pg_partitioning 0.0.1

data/spec/dummy/log/development.log

@@ -0,0 +1,3421 @@
+   (165.8ms)  CREATE TABLE "schema_migrations" ("version" character varying NOT NULL) 
+   (110.3ms)  CREATE UNIQUE INDEX  "unique_schema_migrations" ON "schema_migrations"  ("version")
+  ActiveRecord::SchemaMigration Load (1.9ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+Migrating to CreateGangs (20160306173540)
+   (0.4ms)  BEGIN
+   (276.8ms)  CREATE TABLE "gangs" ("id" serial primary key, "title" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+  SQL (0.8ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306173540"]]
+   (59.1ms)  COMMIT
+Migrating to CreateBandits (20160306174017)
+   (0.5ms)  BEGIN
+   (152.2ms)  CREATE TABLE "bandits" ("id" serial primary key, "name" character varying, "specialization" character varying, "gang_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (91.9ms)  CREATE  INDEX  "index_bandits_on_gang_id" ON "bandits"  ("gang_id")
+   (11.5ms)  ALTER TABLE "bandits" ADD CONSTRAINT "fk_rails_7411a14fb1"
+FOREIGN KEY ("gang_id")
+  REFERENCES "gangs" ("id")
+
+  SQL (0.7ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174017"]]
+   (57.5ms)  COMMIT
+Migrating to CreateCrimes (20160306174042)
+   (0.6ms)  BEGIN
+   (92.2ms)  CREATE TABLE "crimes" ("id" serial primary key, "title" character varying, "bandit_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (69.5ms)  CREATE  INDEX  "index_crimes_on_bandit_id" ON "crimes"  ("bandit_id")
+   (4.6ms)  ALTER TABLE "crimes" ADD CONSTRAINT "fk_rails_ca9866c40c"
+FOREIGN KEY ("bandit_id")
+  REFERENCES "bandits" ("id")
+
+  SQL (0.6ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174042"]]
+   (13.4ms)  COMMIT
+  ActiveRecord::SchemaMigration Load (0.5ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+   (6.4ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'bandits'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (7.6ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'crimes'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (6.0ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'gangs'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (337.6ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := ‘specialization’;
+                   colval  text := NEW."specialization";
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE ' || tblname || '(check (' || quote_ident(colname) || '=' || quote_literal(colval) || ')) INHERITS (' || TG_RELNAME || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NULL;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (88.4ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := ‘specialization’;
+                   colval  text := NEW."specialization";
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE ' || tblname || '(check (' || quote_ident(colname) || '=' || quote_literal(colval) || ')) INHERITS (' || TG_RELNAME || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NULL;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (96.8ms)  CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_trigger();
+   (21.1ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := ‘specialization’;
+                   colval  text := NEW."specialization";
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE ' || tblname || '(check (' || quote_ident(colname) || '=' || quote_literal(colval) || ')) INHERITS (' || TG_RELNAME || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NULL;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (66.6ms)  CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (0.2ms)  BEGIN
+  SQL (139.1ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al"], ["specialization", "killer"], ["created_at", "2016-03-06 18:16:50.203953"], ["updated_at", "2016-03-06 18:16:50.203953"]]
+   (0.7ms)  ROLLBACK
+   (17.2ms)  BEGIN
+  SQL (9.3ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al"], ["specialization", "killer"], ["created_at", "2016-03-06 18:18:42.617682"], ["updated_at", "2016-03-06 18:18:42.617682"]]
+   (2.9ms)  ROLLBACK
+  Bandit Load (43.6ms)  SELECT "bandits".* FROM "bandits"
+   (5.5ms)  BEGIN
+  SQL (26.0ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al"], ["specialization", "killer"], ["created_at", "2016-03-06 18:22:30.695935"], ["updated_at", "2016-03-06 18:22:30.695935"]]
+   (0.2ms)  ROLLBACK
+   (138.3ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := specialization;
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE ' || tblname || '(check (' || quote_ident(colname) || '=' || quote_literal(colval) || ')) INHERITS (' || TG_RELNAME || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NULL;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (58.9ms)  CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (38.2ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := specialization;
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE ' || tblname || '(check (' || quote_ident(colname) || '=' || quote_literal(colval) || ')) INHERITS (' || TG_RELNAME || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NULL;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (16.1ms)  CREATE OR REPLACE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (55.5ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := specialization;
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE ' || tblname || '(check (' || quote_ident(colname) || '=' || quote_literal(colval) || ')) INHERITS (' || TG_RELNAME || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NULL;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (35.9ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE OR REPLACE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (91.0ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := specialization;
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE ' || tblname || '(check (' || quote_ident(colname) || '=' || quote_literal(colval) || ')) INHERITS (' || TG_RELNAME || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NULL;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (156.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (0.3ms)  BEGIN
+  SQL (28.7ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al"], ["specialization", "killer"], ["created_at", "2016-03-06 18:36:57.517077"], ["updated_at", "2016-03-06 18:36:57.517077"]]
+   (0.2ms)  ROLLBACK
+   (153.7ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := specialization;
+                   colval  text := NEW."specialization";
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE ' || tblname || '(check (' || quote_ident(colname) || '=' || quote_literal(colval) || ')) INHERITS (' || TG_RELNAME || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NULL;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (29.4ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (0.5ms)  BEGIN
+  SQL (156.8ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al"], ["specialization", "killer"], ["created_at", "2016-03-06 18:51:32.134070"], ["updated_at", "2016-03-06 18:51:32.134070"]]
+   (0.4ms)  ROLLBACK
+   (159.1ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := specialization;
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE ' || tblname || '(check (' || quote_ident(colname) || '=' || quote_literal(colval) || ')) INHERITS (' || TG_RELNAME || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NULL;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (65.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (0.2ms)  BEGIN
+  SQL (5.4ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al"], ["specialization", "killer"], ["created_at", "2016-03-06 18:54:21.292659"], ["updated_at", "2016-03-06 18:54:21.292659"]]
+   (0.2ms)  ROLLBACK
+   (34.3ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := specialization;
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE ' || tblname || '(check (' || quote_ident(colname) || '=' || quote_literal(colval) || ')) INHERITS (' || TG_RELNAME || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NULL;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (0.2ms)  BEGIN
+  SQL (4.4ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al"], ["specialization", "killer"], ["created_at", "2016-03-06 18:56:24.906340"], ["updated_at", "2016-03-06 18:56:24.906340"]]
+   (0.3ms)  ROLLBACK
+   (26.3ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE ' || tblname || '(check (' || quote_ident(colname) || '=' || quote_literal(colval) || ')) INHERITS (' || TG_RELNAME || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NULL;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (11.5ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (0.2ms)  BEGIN
+  SQL (417.6ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al"], ["specialization", "killer"], ["created_at", "2016-03-06 18:59:09.972726"], ["updated_at", "2016-03-06 18:59:09.972726"]]
+   (26.5ms)  COMMIT
+  Bandit Load (24.4ms)  SELECT "bandits".* FROM "bandits"
+   (3.1ms)  BEGIN
+  SQL (1.2ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "AlCop"], ["specialization", "killer"], ["created_at", "2016-03-06 18:59:58.928003"], ["updated_at", "2016-03-06 18:59:58.928003"]]
+   (81.1ms)  COMMIT
+  Bandit Load (2.3ms)  SELECT "bandits".* FROM "bandits"
+   (0.4ms)  BEGIN
+  SQL (212.8ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "AlCop"], ["specialization", "killer"], ["created_at", "2016-03-08 09:18:14.136427"], ["updated_at", "2016-03-08 09:18:14.136427"]]
+   (79.1ms)  COMMIT
+   (0.4ms)  BEGIN
+  SQL (6.5ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "AlCop"], ["specialization", "killer"], ["created_at", "2016-03-08 09:19:17.711315"], ["updated_at", "2016-03-08 09:19:17.711315"]]
+   (18.2ms)  COMMIT
+  Bandit Load (138.1ms)  SELECT "bandits".* FROM "bandits"
+   (160.7ms)  CREATE TABLE "schema_migrations" ("version" character varying NOT NULL) 
+   (150.1ms)  CREATE UNIQUE INDEX  "unique_schema_migrations" ON "schema_migrations"  ("version")
+  ActiveRecord::SchemaMigration Load (1.6ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+Migrating to CreateGangs (20160306173540)
+   (0.4ms)  BEGIN
+   (187.6ms)  CREATE TABLE "gangs" ("id" serial primary key, "title" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+  SQL (0.7ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306173540"]]
+   (51.0ms)  COMMIT
+Migrating to CreateBandits (20160306174017)
+   (0.5ms)  BEGIN
+   (128.7ms)  CREATE TABLE "bandits" ("id" serial primary key, "name" character varying, "specialization" character varying, "gang_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (97.4ms)  CREATE  INDEX  "index_bandits_on_gang_id" ON "bandits"  ("gang_id")
+   (6.5ms)  ALTER TABLE "bandits" ADD CONSTRAINT "fk_rails_7411a14fb1"
+FOREIGN KEY ("gang_id")
+  REFERENCES "gangs" ("id")
+
+  SQL (0.7ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174017"]]
+   (34.1ms)  COMMIT
+Migrating to CreateCrimes (20160306174042)
+   (2.1ms)  BEGIN
+   (169.2ms)  CREATE TABLE "crimes" ("id" serial primary key, "title" character varying, "bandit_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (79.9ms)  CREATE  INDEX  "index_crimes_on_bandit_id" ON "crimes"  ("bandit_id")
+   (13.6ms)  ALTER TABLE "crimes" ADD CONSTRAINT "fk_rails_ca9866c40c"
+FOREIGN KEY ("bandit_id")
+  REFERENCES "bandits" ("id")
+
+  SQL (0.7ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174042"]]
+   (51.6ms)  COMMIT
+  ActiveRecord::SchemaMigration Load (1.0ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+   (6.5ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'bandits'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (7.3ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'crimes'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (6.1ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'gangs'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (87.2ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NULL;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.9ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (30.9ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (25.8ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NULL;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.6ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (11.0ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.7ms)  CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.4ms)  BEGIN
+  SQL (59.3ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al Cap"], ["specialization", "bootlegger"], ["created_at", "2016-03-08 10:23:46.014823"], ["updated_at", "2016-03-08 10:23:46.014823"]]
+   (16.3ms)  COMMIT
+   (39.9ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.3ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.8ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (0.9ms)  CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (33.3ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (11.4ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.9ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (11.4ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.2ms)  BEGIN
+  SQL (102.4ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al Cap"], ["specialization", "bootlegger"], ["created_at", "2016-03-08 10:27:22.638917"], ["updated_at", "2016-03-08 10:27:22.638917"]]
+   (20.7ms)  COMMIT
+  Bandit Load (274.3ms)  SELECT "bandits".* FROM "bandits"
+  SQL (110.3ms)  DELETE FROM "bandits"
+  Bandit Load (1.4ms)  SELECT "bandits".* FROM "bandits"
+   (0.4ms)  BEGIN
+  SQL (208.6ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al Cap"], ["specialization", "bootlegger"], ["created_at", "2016-03-09 17:37:29.355906"], ["updated_at", "2016-03-09 17:37:29.355906"]]
+   (23.9ms)  COMMIT
+  Bandit Load (1.9ms)  SELECT "bandits".* FROM "bandits"
+  SQL (21.0ms)  DELETE FROM "bandits"
+   (0.4ms)  BEGIN
+  SQL (26.0ms)  INSERT INTO "gangs" ("title", "created_at", "updated_at") VALUES ($1, $2, $3) RETURNING "id"  [["title", "Mocha"], ["created_at", "2016-03-09 17:38:21.061823"], ["updated_at", "2016-03-09 17:38:21.061823"]]
+   (16.9ms)  COMMIT
+  Gang Load (2.4ms)  SELECT  "gangs".* FROM "gangs"  ORDER BY "gangs"."id" ASC LIMIT 1
+  Gang Load (1.4ms)  SELECT  "gangs".* FROM "gangs"  ORDER BY "gangs"."id" ASC LIMIT 1
+  Gang Load (2.1ms)  SELECT  "gangs".* FROM "gangs"  ORDER BY "gangs"."id" ASC LIMIT 1
+  Gang Load (1.3ms)  SELECT  "gangs".* FROM "gangs"  ORDER BY "gangs"."id" ASC LIMIT 1
+   (0.2ms)  BEGIN
+  SQL (4.0ms)  INSERT INTO "bandits" ("name", "specialization", "gang_id", "created_at", "updated_at") VALUES ($1, $2, $3, $4, $5) RETURNING "id"  [["name", "Al Cap"], ["specialization", "bootlegger"], ["gang_id", 1], ["created_at", "2016-03-09 17:43:32.602947"], ["updated_at", "2016-03-09 17:43:32.602947"]]
+   (20.7ms)  COMMIT
+  Bandit Load (2.0ms)  SELECT "bandits".* FROM "bandits"
+  Gang Load (2.0ms)  SELECT  "gangs".* FROM "gangs"  ORDER BY "gangs"."id" ASC LIMIT 1
+  Bandit Load (1.9ms)  SELECT "bandits".* FROM "bandits" WHERE "bandits"."gang_id" = $1  [["gang_id", 1]]
+  Gang Load (1.4ms)  SELECT  "gangs".* FROM "gangs"  ORDER BY "gangs"."id" ASC LIMIT 1
+  Bandit Load (15.5ms)  SELECT  "bandits".* FROM "bandits" WHERE "bandits"."gang_id" = $1  ORDER BY "bandits"."id" ASC LIMIT 1  [["gang_id", 1]]
+   (0.4ms)  BEGIN
+  SQL (47.4ms)  INSERT INTO "crimes" ("title", "bandit_id", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["title", "bla"], ["bandit_id", 4], ["created_at", "2016-03-09 17:45:00.577595"], ["updated_at", "2016-03-09 17:45:00.577595"]]
+   (0.3ms)  ROLLBACK
+   (0.8ms)  SHOW constraint_exclusion;
+   (1.9ms)  SHOW constraint_exclusion;
+   (2.3ms)  SHOW constraint_exclusion;
+   (1.3ms)  SHOW constraint_exclusion;
+   (1.7ms)  SHOW constraint_exclusion;
+   (1.1ms)  SHOW constraint_exclusion;
+   (2.1ms)  SHOW constraint_exclusion;
+   (2.3ms)  SHOW constraint_exclusion;
+   (318.8ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'speciafication';
+                   colval  text := NEW.speciafication;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (242.9ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.6ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (9.8ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.5ms)  SHOW constraint_exclusion;
+   (47.0ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (23.0ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (13.3ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (12.2ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (1.2ms)  SHOW constraint_exclusion;
+   (21.9ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.4ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.7ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.4ms)  SHOW constraint_exclusion;
+   (72.8ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specializtion';
+                   colval  text := NEW.specializtion;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (11.0ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (11.2ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.6ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (1.9ms)  SHOW constraint_exclusion;
+   (106.8ms)  CREATE OR REPLACE FUNCTION bandit_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandit_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (29.9ms)  DROP TRIGGER IF EXISTS insert_bandit_trigger ON bandit;
+                 CREATE TRIGGER insert_bandit_trigger
+                 BEFORE INSERT ON bandit
+                 FOR EACH ROW EXECUTE PROCEDURE bandit_insert_master();
+   (15.1ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.9ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.8ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.4ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.3ms)  SHOW constraint_exclusion;
+   (73.1ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.8ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (11.0ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.3ms)  SHOW constraint_exclusion;
+   (33.3ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.8ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.8ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.2ms)  SHOW constraint_exclusion;
+   (31.0ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (11.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (11.0ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.8ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.2ms)  SHOW constraint_exclusion;
+   (13.9ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.9ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.5ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (11.2ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (1.4ms)  SHOW constraint_exclusion;
+   (31.8ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (15.4ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (5.9ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (11.2ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.3ms)  SHOW constraint_exclusion;
+   (41.1ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specialization';
+                   colval  text := NEW.specialization;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.1ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.9ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (11.0ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.3ms)  SHOW constraint_exclusion;
+   (59.4ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'spec';
+                   colval  text := NEW.spec;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (14.9ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (7.6ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (9.2ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.5ms)  SHOW constraint_exclusion;
+   (37.1ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'spec';
+                   colval  text := NEW.spec;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (14.2ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (8.4ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.8ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.3ms)  SHOW constraint_exclusion;
+   (20.4ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'spec';
+                   colval  text := NEW.spec;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.6ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.8ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.7ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.3ms)  SHOW constraint_exclusion;
+   (57.3ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'spec';
+                   colval  text := NEW.spec;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (14.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (7.8ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (11.6ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (0.3ms)  SHOW constraint_exclusion;
+   (342.6ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specification';
+                   colval  text := NEW.specification;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (366.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (32.6ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.6ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (22.9ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specifications';
+                   colval  text := NEW.specifications;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (65.9ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (14.6ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (7.0ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (419.6ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                        ccu.table_name AS foreign_table_name,
+                        ccu.column_name AS foreign_column_name 
+                 FROM   information_schema.table_constraints AS tc 
+                 JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                 JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                 WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.8ms)  SHOW constraint_exclusion;
+   (35.6ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specifications';
+                   colval  text := NEW.specifications;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (13.4ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (7.7ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (14.9ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (24.2ms)  S
+   (19.9ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specifications';
+                   colval  text := NEW.specifications;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (13.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (7.7ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (13.1ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (37.6ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                        ccu.table_name AS foreign_table_name,
+                        ccu.column_name AS foreign_column_name 
+                 FROM   information_schema.table_constraints AS tc 
+                 JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                 JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                 WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.5ms)  SHOW constraint_exclusion;
+   (80.9ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specifications';
+                   colval  text := NEW.specifications;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (14.3ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (20.2ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (9.8ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (71.2ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                        ccu.table_name AS foreign_table_name,
+                        ccu.column_name AS foreign_column_name 
+                 FROM   information_schema.table_constraints AS tc 
+                 JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                 JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                 WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (114.9ms)  ALTER TABLE crimes DROP CONSTRAINT fk_rails_ca9866c40c;
+   (0.4ms)  SHOW constraint_exclusion;
+   (38.1ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specifications';
+                   colval  text := NEW.specifications;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (14.2ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (6.9ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.8ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (37.0ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                        ccu.table_name AS foreign_table_name,
+                        ccu.column_name AS foreign_column_name 
+                 FROM   information_schema.table_constraints AS tc 
+                 JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                 JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                 WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.5ms)  SHOW constraint_exclusion;
+   (218.8ms)  CREATE TABLE "schema_migrations" ("version" character varying NOT NULL) 
+   (76.6ms)  CREATE UNIQUE INDEX  "unique_schema_migrations" ON "schema_migrations"  ("version")
+  ActiveRecord::SchemaMigration Load (1.6ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+Migrating to CreateGangs (20160306173540)
+   (0.4ms)  BEGIN
+   (157.8ms)  CREATE TABLE "gangs" ("id" serial primary key, "title" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+  SQL (59.8ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306173540"]]
+   (122.5ms)  COMMIT
+Migrating to CreateBandits (20160306174017)
+   (0.5ms)  BEGIN
+   (109.1ms)  CREATE TABLE "bandits" ("id" serial primary key, "name" character varying, "specialization" character varying, "gang_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (55.7ms)  CREATE  INDEX  "index_bandits_on_gang_id" ON "bandits"  ("gang_id")
+   (5.8ms)  ALTER TABLE "bandits" ADD CONSTRAINT "fk_rails_7411a14fb1"
+FOREIGN KEY ("gang_id")
+  REFERENCES "gangs" ("id")
+
+  SQL (26.9ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174017"]]
+   (22.0ms)  COMMIT
+Migrating to CreateCrimes (20160306174042)
+   (0.8ms)  BEGIN
+   (94.3ms)  CREATE TABLE "crimes" ("id" serial primary key, "title" character varying, "bandit_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (51.5ms)  CREATE  INDEX  "index_crimes_on_bandit_id" ON "crimes"  ("bandit_id")
+   (4.7ms)  ALTER TABLE "crimes" ADD CONSTRAINT "fk_rails_ca9866c40c"
+FOREIGN KEY ("bandit_id")
+  REFERENCES "bandits" ("id")
+
+  SQL (0.7ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174042"]]
+   (20.9ms)  COMMIT
+  ActiveRecord::SchemaMigration Load (0.9ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+   (12.4ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'bandits'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (13.2ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'crimes'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (13.8ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'gangs'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (57.7ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   colname text := 'specifications';
+                   colval  text := NEW.specifications;
+                   tblname text := 'bandits_' || colval;
+                 BEGIN
+                   IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                   EXECUTE 'CREATE TABLE '
+                           || tblname 
+                           || '(check (' 
+                           || quote_ident(colname) 
+                           || '=' 
+                           || quote_literal(colval) 
+                           || ')) INHERITS (' 
+                           || TG_RELNAME 
+                           || ');';
+                   END IF;
+                   EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                   RETURN NEW;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (15.1ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                 CREATE TRIGGER insert_bandits_trigger
+                 BEFORE INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (6.4ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                 DECLARE
+                   row bandits%rowtype;
+                 BEGIN
+                   DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                   RETURN row;
+                 END;
+                 $$ LANGUAGE plpgsql;
+   (10.7ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                 CREATE TRIGGER bandits_after_insert_trigger
+                 AFTER INSERT ON bandits
+                 FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (40.5ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                        ccu.table_name AS foreign_table_name,
+                        ccu.column_name AS foreign_column_name 
+                 FROM   information_schema.table_constraints AS tc 
+                 JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                 JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                 WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (69.2ms)  ALTER TABLE crimes DROP CONSTRAINT fk_rails_ca9866c40c;
+   (0.5ms)  SHOW constraint_exclusion;
+   (163.7ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                   DECLARE
+                     colname text := 'specialization';
+                     colval  text := NEW.specialization;
+                     tblname text := 'bandits_' || colval;
+                   BEGIN
+                     IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                     EXECUTE 'CREATE TABLE '
+                             || tblname 
+                             || '(check (' 
+                             || quote_ident(colname) 
+                             || '=' 
+                             || quote_literal(colval) 
+                             || ')) INHERITS (' 
+                             || TG_RELNAME 
+                             || ');';
+                     END IF;
+                     EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                     RETURN NEW;
+                   END;
+                   $$ LANGUAGE plpgsql;
+   (40.8ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                   CREATE TRIGGER insert_bandits_trigger
+                   BEFORE INSERT ON bandits
+                   FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.0ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                   DECLARE
+                     row bandits%rowtype;
+                   BEGIN
+                     DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                     RETURN row;
+                   END;
+                   $$ LANGUAGE plpgsql;
+   (10.2ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                   CREATE TRIGGER bandits_after_insert_trigger
+                   AFTER INSERT ON bandits
+                   FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (67.4ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                          ccu.table_name AS foreign_table_name,
+                          ccu.column_name AS foreign_column_name 
+                   FROM   information_schema.table_constraints AS tc 
+                   JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                   JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                   WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.4ms)  SHOW constraint_exclusion;
+   (63.6ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                   DECLARE
+                     colname text := 'specialization';
+                     colval  text := NEW.specialization;
+                     tblname text := 'bandits_' || colval;
+                   BEGIN
+                     IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                     EXECUTE 'CREATE TABLE '
+                             || tblname 
+                             || '(check (' 
+                             || quote_ident(colname) 
+                             || '=' 
+                             || quote_literal(colval) 
+                             || ')) INHERITS (' 
+                             || TG_RELNAME 
+                             || ');';
+                     END IF;
+                     EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                     RETURN NEW;
+                   END;
+                   $$ LANGUAGE plpgsql;
+   (31.0ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                   CREATE TRIGGER insert_bandits_trigger
+                   BEFORE INSERT ON bandits
+                   FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.9ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                   DECLARE
+                     row bandits%rowtype;
+                   BEGIN
+                     DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                     RETURN row;
+                   END;
+                   $$ LANGUAGE plpgsql;
+   (10.7ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                   CREATE TRIGGER bandits_after_insert_trigger
+                   AFTER INSERT ON bandits
+                   FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (36.3ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                          ccu.table_name AS foreign_table_name,
+                          ccu.column_name AS foreign_column_name 
+                   FROM   information_schema.table_constraints AS tc 
+                   JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                   JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                   WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.5ms)  SHOW constraint_exclusion;
+   (21.9ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                   DECLARE
+                     colname text := 'specification';
+                     colval  text := NEW.specification;
+                     tblname text := 'bandits_' || colval;
+                   BEGIN
+                     IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                     EXECUTE 'CREATE TABLE '
+                             || tblname 
+                             || '(check (' 
+                             || quote_ident(colname) 
+                             || '=' 
+                             || quote_literal(colval) 
+                             || ')) INHERITS (' 
+                             || TG_RELNAME 
+                             || ');';
+                     END IF;
+                     EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                     RETURN NEW;
+                   END;
+                   $$ LANGUAGE plpgsql;
+   (13.5ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                   CREATE TRIGGER insert_bandits_trigger
+                   BEFORE INSERT ON bandits
+                   FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (64.3ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                   DECLARE
+                     row bandits%rowtype;
+                   BEGIN
+                     DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                     RETURN row;
+                   END;
+                   $$ LANGUAGE plpgsql;
+   (13.3ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                   CREATE TRIGGER bandits_after_insert_trigger
+                   AFTER INSERT ON bandits
+                   FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (419.7ms)  SELECT 1 FROM information_schema.columns WHERE table_name ='bandits' AND column_name = 'idd';
+   (491.5ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'specialization';
+                         colval  text := NEW.specialization;
+                         tblname text := 'bandits_' || colval;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (' 
+                                 || quote_ident(colname) 
+                                 || '=' 
+                                 || quote_literal(colval) 
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (411.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (12.7ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (8.5ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (407.1ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                          ccu.table_name AS foreign_table_name,
+                          ccu.column_name AS foreign_column_name 
+                   FROM   information_schema.table_constraints AS tc 
+                   JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                   JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                   WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.4ms)  SHOW constraint_exclusion;
+   (287.4ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'id';
+                         colval := NEW.id;
+                         step integer := ROUND(colval::integer / '100'::integer);
+                         tblname text := 'bandits_' || step;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (ROUND(' 
+                                 || quote_ident(colname) 
+                                 || '/ 100)=' 
+                                 || step
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (32.1ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'id';
+                         colval integer := NEW.id;
+                         step integer := ROUND(colval / '100'::integer);
+                         tblname text := 'bandits_' || step;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (ROUND(' 
+                                 || quote_ident(colname) 
+                                 || '/ 100)=' 
+                                 || step
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (55.8ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.4ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (10.7ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (63.3ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                          ccu.table_name AS foreign_table_name,
+                          ccu.column_name AS foreign_column_name 
+                   FROM   information_schema.table_constraints AS tc 
+                   JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                   JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                   WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.4ms)  SHOW constraint_exclusion;
+   (0.4ms)  BEGIN
+  SQL (205.9ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al Cap"], ["specialization", "bootlegger"], ["created_at", "2016-03-12 16:00:24.180197"], ["updated_at", "2016-03-12 16:00:24.180197"]]
+   (48.8ms)  COMMIT
+   (0.8ms)  BEGIN
+  SQL (68.1ms)  INSERT INTO "bandits" ("id", "name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4, $5) RETURNING "id"  [["id", 200], ["name", "Al Cap"], ["specialization", "bootlegger"], ["created_at", "2016-03-12 16:00:37.954027"], ["updated_at", "2016-03-12 16:00:37.954027"]]
+   (12.6ms)  COMMIT
+  Bandit Load (3.2ms)  SELECT "bandits".* FROM "bandits"
+   (45.9ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'id';
+                         colval integer := NEW.id;
+                         threshold integer := '10';
+                         step integer := ROUND(colval / threshold);
+                         tblname text := 'bandits_' || step;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (ROUND(' 
+                                 || quote_ident(colname) 
+                                 || '/'
+                                 || threshold 
+                                 || ')=' 
+                                 || step
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (44.2ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (7.8ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (8.9ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (103.0ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                          ccu.table_name AS foreign_table_name,
+                          ccu.column_name AS foreign_column_name 
+                   FROM   information_schema.table_constraints AS tc 
+                   JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                   JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                   WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.4ms)  SHOW constraint_exclusion;
+   (0.2ms)  BEGIN
+  SQL (69.3ms)  INSERT INTO "bandits" ("id", "name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4, $5) RETURNING "id"  [["id", 205], ["name", "Al Cap"], ["specialization", "bootlegger"], ["created_at", "2016-03-12 16:05:59.164453"], ["updated_at", "2016-03-12 16:05:59.164453"]]
+   (23.2ms)  COMMIT
+   (233.0ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text      := 'created_at';
+                         colval  timestamp := NEW.created_at;
+                         pattern text      := 'YYYY';
+                         sample  text      := TO_CHAR(colval, pattern);
+                         tblname text      := 'bandits_' || colval;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (TO_CHAR(' 
+                                 || quote_ident(colname) 
+                                 || ','
+                                 || pattern
+                                 || ')=' 
+                                 || sample
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (128.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (11.0ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (10.6ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (106.0ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                          ccu.table_name AS foreign_table_name,
+                          ccu.column_name AS foreign_column_name 
+                   FROM   information_schema.table_constraints AS tc 
+                   JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                   JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                   WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.5ms)  SHOW constraint_exclusion;
+   (0.4ms)  BEGIN
+  SQL (390.7ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al Cap"], ["specialization", "bootlegger"], ["created_at", "2016-03-12 17:38:15.437632"], ["updated_at", "2016-03-12 17:38:15.437632"]]
+   (0.7ms)  ROLLBACK
+   (150.9ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text      := 'created_at';
+                         colval  timestamp := NEW.created_at;
+                         pattern text      := 'YYYY';
+                         sample  text      := TO_CHAR(colval, pattern);
+                         tblname text      := 'bandits_' || sample;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (TO_CHAR(' 
+                                 || quote_ident(colname) 
+                                 || ','
+                                 || pattern
+                                 || ')=' 
+                                 || sample
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (108.5ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.5ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (10.9ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (69.7ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                          ccu.table_name AS foreign_table_name,
+                          ccu.column_name AS foreign_column_name 
+                   FROM   information_schema.table_constraints AS tc 
+                   JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                   JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                   WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.7ms)  SHOW constraint_exclusion;
+   (0.2ms)  BEGIN
+  SQL (188.8ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al Cap"], ["specialization", "bootlegger"], ["created_at", "2016-03-12 17:39:45.055084"], ["updated_at", "2016-03-12 17:39:45.055084"]]
+   (0.4ms)  ROLLBACK
+   (81.8ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text      := 'created_at';
+                         colval  timestamp := NEW.created_at;
+                         pattern text      := 'YYYY';
+                         sample  text      := TO_CHAR(colval, pattern);
+                         tblname text      := 'bandits_' || sample;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (TO_CHAR(' 
+                                 || quote_ident(colname) 
+                                 || ','
+                                 || quote_literal(pattern)
+                                 || ')=' 
+                                 || quote_literal(sample)
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (89.5ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (14.3ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (7.4ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (87.9ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                          ccu.table_name AS foreign_table_name,
+                          ccu.column_name AS foreign_column_name 
+                   FROM   information_schema.table_constraints AS tc 
+                   JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                   JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                   WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.4ms)  SHOW constraint_exclusion;
+   (0.2ms)  BEGIN
+  SQL (343.6ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Al Cap"], ["specialization", "bootlegger"], ["created_at", "2016-03-12 17:51:02.433456"], ["updated_at", "2016-03-12 17:51:02.433456"]]
+   (37.1ms)  COMMIT
+   (172.9ms)  CREATE TABLE "schema_migrations" ("version" character varying NOT NULL) 
+   (61.5ms)  CREATE UNIQUE INDEX  "unique_schema_migrations" ON "schema_migrations"  ("version")
+  ActiveRecord::SchemaMigration Load (1.6ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+Migrating to CreateGangs (20160306173540)
+   (0.4ms)  BEGIN
+   (204.4ms)  CREATE TABLE "gangs" ("id" serial primary key, "title" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+  SQL (20.9ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306173540"]]
+   (20.7ms)  COMMIT
+Migrating to CreateBandits (20160306174017)
+   (0.3ms)  BEGIN
+   (114.9ms)  CREATE TABLE "bandits" ("id" serial primary key, "name" character varying, "specialization" character varying, "date_of_birth" date, "gang_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (47.2ms)  CREATE  INDEX  "index_bandits_on_gang_id" ON "bandits"  ("gang_id")
+   (28.3ms)  ALTER TABLE "bandits" ADD CONSTRAINT "fk_rails_7411a14fb1"
+FOREIGN KEY ("gang_id")
+  REFERENCES "gangs" ("id")
+
+  SQL (23.6ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174017"]]
+   (19.3ms)  COMMIT
+Migrating to CreateCrimes (20160306174042)
+   (0.6ms)  BEGIN
+   (127.1ms)  CREATE TABLE "crimes" ("id" serial primary key, "title" character varying, "bandit_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (51.8ms)  CREATE  INDEX  "index_crimes_on_bandit_id" ON "crimes"  ("bandit_id")
+   (2.8ms)  ALTER TABLE "crimes" ADD CONSTRAINT "fk_rails_ca9866c40c"
+FOREIGN KEY ("bandit_id")
+  REFERENCES "bandits" ("id")
+
+  SQL (1.2ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174042"]]
+   (11.2ms)  COMMIT
+  ActiveRecord::SchemaMigration Load (0.9ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+   (29.9ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'bandits'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (5.7ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'crimes'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (5.4ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'gangs'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (50.0ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'date_of_birth';
+   (9.0ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'date_of_birth';
+   (141.4ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text      := 'date_of_birth';
+                         colval  timestamp := NEW.date_of_birth;
+                         pattern text      := 'MM';
+                         sample  text      := TO_CHAR(colval, pattern);
+                         tblname text      := 'bandits_' || sample;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (TO_CHAR(' 
+                                 || quote_ident(colname) 
+                                 || ','
+                                 || quote_literal(pattern)
+                                 || ')=' 
+                                 || quote_literal(sample)
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (66.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (9.9ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (10.7ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (50.4ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (3.7ms)  ALTER TABLE crimes DROP CONSTRAINT fk_rails_ca9866c40c;
+   (0.5ms)  SHOW constraint_exclusion;
+   (0.2ms)  BEGIN
+  SQL (69.4ms)  INSERT INTO "bandits" ("name", "specialization", "date_of_birth", "created_at", "updated_at") VALUES ($1, $2, $3, $4, $5) RETURNING "id"  [["name", "Al Cap"], ["specialization", "bootlegger"], ["date_of_birth", "2016-03-11"], ["created_at", "2016-03-12 19:30:19.210861"], ["updated_at", "2016-03-12 19:30:19.210861"]]
+   (17.2ms)  COMMIT
+   (280.7ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'specialization';
+   (228.6ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.9ms)  SHOW constraint_exclusion;
+   (22.5ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'created_at';
+   (487.1ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text      := 'created_at';
+                         colval  timestamp := NEW.created_at;
+                         pattern text      := 'YYYY';
+                         sample  text      := TO_CHAR(colval, pattern);
+                         tblname text      := 'bandits_' || sample;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (TO_CHAR(' 
+                                 || quote_ident(colname) 
+                                 || ','
+                                 || quote_literal(pattern)
+                                 || ')=' 
+                                 || quote_literal(sample)
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (294.0ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.4ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (21.8ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (74.1ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.8ms)  SHOW constraint_exclusion;
+   (566.1ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.6ms)  SHOW constraint_exclusion;
+   (327.1ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='ban' 
+                      AND column_name = 'id';
+   (17.2ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bn' 
+                      AND column_name = 'dd';
+   (9.1ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='ban' 
+                      AND column_name = 'id';
+   (71.7ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (9.8ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (13.4ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (9.1ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (9.1ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (607.2ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname   text    := 'id';
+                         colval    integer := NEW.id;
+                         threshold integer := '30';
+                         step      integer := ROUND(colval / threshold);
+                         tblname   text    := 'bandits_' || step;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (ROUND(' 
+                                 || quote_ident(colname) 
+                                 || '/'
+                                 || threshold 
+                                 || ')=' 
+                                 || step
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (284.8ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.4ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (7.3ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (113.9ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.4ms)  SHOW constraint_exclusion;
+   (11.0ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (185.3ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'id';
+                         colval  text := NEW.id;
+                         tblname text := 'bandits_' || colval;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (' 
+                                 || quote_ident(colname) 
+                                 || '=' 
+                                 || quote_literal(colval) 
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (43.4ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (76.6ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (12.7ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (54.4ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.6ms)  SHOW constraint_exclusion;
+   (8.8ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='ban' 
+                      AND column_name = 'id';
+   (122.7ms)  CREATE OR REPLACE FUNCTION ban_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'id';
+                         colval  text := NEW.id;
+                         tblname text := 'ban_' || colval;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (' 
+                                 || quote_ident(colname) 
+                                 || '=' 
+                                 || quote_literal(colval) 
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (40.8ms)  DROP TRIGGER IF EXISTS insert_ban_trigger ON ban;
+                     CREATE TRIGGER insert_ban_trigger
+                     BEFORE INSERT ON ban
+                     FOR EACH ROW EXECUTE PROCEDURE ban_insert_master();
+   (12.1ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='ban' 
+                      AND column_name = 'id';
+   (19.1ms)  CREATE OR REPLACE FUNCTION ban_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'id';
+                         colval  text := NEW.id;
+                         tblname text := 'ban_' || colval;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (' 
+                                 || quote_ident(colname) 
+                                 || '=' 
+                                 || quote_literal(colval) 
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (0.9ms)  DROP TRIGGER IF EXISTS insert_ban_trigger ON ban;
+                     CREATE TRIGGER insert_ban_trigger
+                     BEFORE INSERT ON ban
+                     FOR EACH ROW EXECUTE PROCEDURE ban_insert_master();
+   (9.2ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='ban' 
+                      AND column_name = 'id';
+   (27.1ms)  CREATE OR REPLACE FUNCTION ban_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'id';
+                         colval  text := NEW.id;
+                         tblname text := 'ban_' || colval;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (' 
+                                 || quote_ident(colname) 
+                                 || '=' 
+                                 || quote_literal(colval) 
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (0.7ms)  DROP TRIGGER IF EXISTS insert_ban_trigger ON ban;
+                     CREATE TRIGGER insert_ban_trigger
+                     BEFORE INSERT ON ban
+                     FOR EACH ROW EXECUTE PROCEDURE ban_insert_master();
+   (9.4ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='ban' 
+                      AND column_name = 'id';
+   (11.9ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'idd';
+   (13.6ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='ban' 
+                      AND column_name = 'id';
+   (8.8ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='band' 
+                      AND column_name = 'id';
+   (8.8ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='band' 
+                      AND column_name = 'id';
+   (9.0ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='band' 
+                      AND column_name = 'id';
+   (9.5ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='band' 
+                      AND column_name = 'id';
+   (25.8ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'created_at';
+   (9.0ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'created_at';
+   (8.8ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='band' 
+                      AND column_name = 'id';
+   (17.3ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'created_at';
+   (9.0ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (150.8ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (365.1ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname   text    := 'id';
+                         colval    integer := NEW.id;
+                         threshold integer := '30';
+                         step      integer := ROUND(colval / threshold);
+                         tblname   text    := 'bandits_' || step;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (ROUND(' 
+                                 || quote_ident(colname) 
+                                 || '/'
+                                 || threshold 
+                                 || ')=' 
+                                 || step
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (142.5ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (14.3ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (7.2ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (201.0ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.4ms)  SHOW constraint_exclusion;
+   (299.4ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (378.3ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname   text    := 'id';
+                         colval    integer := NEW.id;
+                         threshold integer := '7';
+                         step      integer := ROUND(colval / threshold);
+                         tblname   text    := 'bandits_' || step;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (ROUND(' 
+                                 || quote_ident(colname) 
+                                 || '/'
+                                 || threshold 
+                                 || ')=' 
+                                 || step
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (543.3ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.7ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (6.1ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (197.8ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.8ms)  SHOW constraint_exclusion;
+   (9.8ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bjhj' 
+                      AND column_name = 'jkjkj';
+   (153.1ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='klkl' 
+                      AND column_name = 'klk';
+   (8.7ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='sdsdsds' 
+                      AND column_name = 'id';
+   (73.0ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (242.6ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'id';
+                         colval  text := NEW.id;
+                         tblname text := 'bandits_' || colval;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (' 
+                                 || quote_ident(colname) 
+                                 || '=' 
+                                 || quote_literal(colval) 
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (132.0ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (15.3ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (6.4ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (232.1ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.5ms)  SHOW constraint_exclusion;
+  Bandit Count (408.5ms)  SELECT COUNT(*) FROM ONLY bandits
+  Bandit Count (68.1ms)  SELECT COUNT(*) FROM bandits
+  Bandit Count (2.6ms)  SELECT COUNT(*) FROM ONLY bandits
+   (250.5ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'specialization';
+   (135.0ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'specialization';
+                         colval  text := NEW.specialization;
+                         tblname text := 'bandits_' || colval;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (' 
+                                 || quote_ident(colname) 
+                                 || '=' 
+                                 || quote_literal(colval) 
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (110.6ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.6ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (10.2ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (174.6ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.8ms)  SHOW constraint_exclusion;
+   (0.4ms)  BEGIN
+  SQL (406.8ms)  INSERT INTO "bandits" ("specialization", "created_at", "updated_at") VALUES ($1, $2, $3) RETURNING "id"  [["specialization", "killer"], ["created_at", "2016-03-18 17:29:59.157240"], ["updated_at", "2016-03-18 17:29:59.157240"]]
+   (28.0ms)  COMMIT
+  Bandit Load (3.3ms)  select * from bandits_killer
+   (1.1ms)  BEGIN
+  SQL (49.0ms)  INSERT INTO "bandits" ("specialization", "created_at", "updated_at") VALUES ($1, $2, $3) RETURNING "id"  [["specialization", "pol"], ["created_at", "2016-03-18 17:38:03.393164"], ["updated_at", "2016-03-18 17:38:03.393164"]]
+   (21.3ms)  COMMIT
+  Bandit Load (1.1ms)  select * from bandits_pol
+   (23.0ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (55.6ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'id';
+                         colval  text := NEW.id;
+                         tblname text := 'bandits_' || colval;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (' 
+                                 || quote_ident(colname) 
+                                 || '=' 
+                                 || quote_literal(colval) 
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (15.0ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (8.6ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (11.2ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (74.9ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (3.3ms)  SHOW constraint_exclusion;
+   (11.1ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (22.8ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'id';
+                         colval  text := NEW.id;
+                         tblname text := 'bandits_' || colval;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (' 
+                                 || quote_ident(colname) 
+                                 || '=' 
+                                 || quote_literal(colval) 
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (14.7ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (7.8ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (14.8ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (26.0ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.9ms)  SHOW constraint_exclusion;
+   (9.3ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='sdsd' 
+                      AND column_name = 'sdsd';
+   (9.0ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (24.2ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'id';
+                         colval  text := NEW.id;
+                         tblname text := 'bandits_' || colval;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (' 
+                                 || quote_ident(colname) 
+                                 || '=' 
+                                 || quote_literal(colval) 
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (14.1ms)  DROP TRIGGER IF EXISTS insert_bandits_trigger ON bandits;
+                     CREATE TRIGGER insert_bandits_trigger
+                     BEFORE INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (7.3ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                     DECLARE
+                       row bandits%rowtype;
+                     BEGIN
+                       DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                       RETURN row;
+                     END;
+                     $$ LANGUAGE plpgsql;
+   (10.8ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits; 
+                     CREATE TRIGGER bandits_after_insert_trigger
+                     AFTER INSERT ON bandits
+                     FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (29.5ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.5ms)  SHOW constraint_exclusion;
+   (16.9ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bAND' 
+                      AND column_name = 'id';
+   (17.3ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='band' 
+                      AND column_name = 'id';
+   (17.8ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='ban' 
+                      AND column_name = 'id';
+   (8.7ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bdn' 
+                      AND column_name = 'id';
+   (8.7ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='ban' 
+                      AND column_name = 'id';
+   (19.8ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'created_at';
+   (9.5ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='jk' 
+                      AND column_name = 'jk';
+   (9.4ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='kl' 
+                      AND column_name = ';l;';
+   (71.9ms)  CREATE TABLE "schema_migrations" ("version" character varying NOT NULL) 
+   (83.8ms)  CREATE UNIQUE INDEX  "unique_schema_migrations" ON "schema_migrations"  ("version")
+  ActiveRecord::SchemaMigration Load (1.8ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+Migrating to CreateGangs (20160306173540)
+   (0.4ms)  BEGIN
+   (110.3ms)  CREATE TABLE "gangs" ("id" serial primary key, "title" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+  SQL (2.2ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306173540"]]
+   (10.1ms)  COMMIT
+Migrating to CreateBandits (20160306174017)
+   (2.9ms)  BEGIN
+   (89.1ms)  CREATE TABLE "bandits" ("id" serial primary key, "name" character varying, "specialization" character varying, "date_of_birth" date, "gang_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (65.5ms)  CREATE  INDEX  "index_bandits_on_gang_id" ON "bandits"  ("gang_id")
+   (11.1ms)  ALTER TABLE "bandits" ADD CONSTRAINT "fk_rails_7411a14fb1"
+FOREIGN KEY ("gang_id")
+  REFERENCES "gangs" ("id")
+
+  SQL (12.4ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174017"]]
+   (30.6ms)  COMMIT
+Migrating to CreateCrimes (20160306174042)
+   (4.3ms)  BEGIN
+   (102.4ms)  CREATE TABLE "crimes" ("id" serial primary key, "title" character varying, "bandit_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (63.4ms)  CREATE  INDEX  "index_crimes_on_bandit_id" ON "crimes"  ("bandit_id")
+   (2.3ms)  ALTER TABLE "crimes" ADD CONSTRAINT "fk_rails_ca9866c40c"
+FOREIGN KEY ("bandit_id")
+  REFERENCES "bandits" ("id")
+
+  SQL (0.3ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174042"]]
+   (21.3ms)  COMMIT
+  ActiveRecord::SchemaMigration Load (0.8ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+   (7.6ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'bandits'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (6.4ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'crimes'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (14.1ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'gangs'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (324.7ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='fdfd' 
+                      AND column_name = 'dsdsd';
+   (63.0ms)  CREATE TABLE "schema_migrations" ("version" character varying NOT NULL) 
+   (76.0ms)  CREATE UNIQUE INDEX  "unique_schema_migrations" ON "schema_migrations"  ("version")
+  ActiveRecord::SchemaMigration Load (1.5ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+Migrating to CreateGangs (20160306173540)
+   (0.4ms)  BEGIN
+   (112.5ms)  CREATE TABLE "gangs" ("id" serial primary key, "title" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+  SQL (3.3ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306173540"]]
+   (3.9ms)  COMMIT
+Migrating to CreateBandits (20160306174017)
+   (0.4ms)  BEGIN
+   (99.6ms)  CREATE TABLE "bandits" ("id" serial primary key, "name" character varying, "specialization" character varying, "date_of_birth" date, "gang_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (67.4ms)  CREATE  INDEX  "index_bandits_on_gang_id" ON "bandits"  ("gang_id")
+   (7.3ms)  ALTER TABLE "bandits" ADD CONSTRAINT "fk_rails_7411a14fb1"
+FOREIGN KEY ("gang_id")
+  REFERENCES "gangs" ("id")
+
+  SQL (0.7ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174017"]]
+   (5.0ms)  COMMIT
+Migrating to CreateCrimes (20160306174042)
+   (5.6ms)  BEGIN
+   (117.5ms)  CREATE TABLE "crimes" ("id" serial primary key, "title" character varying, "bandit_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (61.8ms)  CREATE  INDEX  "index_crimes_on_bandit_id" ON "crimes"  ("bandit_id")
+   (4.5ms)  ALTER TABLE "crimes" ADD CONSTRAINT "fk_rails_ca9866c40c"
+FOREIGN KEY ("bandit_id")
+  REFERENCES "bandits" ("id")
+
+  SQL (0.6ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174042"]]
+   (9.6ms)  COMMIT
+  ActiveRecord::SchemaMigration Load (0.9ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+   (5.3ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'bandits'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (5.1ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'crimes'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (4.9ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'gangs'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (9.5ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'id';
+   (36.0ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'id';
+                         colval  text := NEW.id;
+                         tblname text := 'bandits_' || colval;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (' 
+                                 || quote_ident(colname) 
+                                 || '=' 
+                                 || quote_literal(colval) 
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (0.6ms)  DROP TRIGGER IF EXISTS bandits_before_insert_trigger ON bandits;
+   (13.0ms)  CREATE TRIGGER bandits_before_insert_trigger
+                      before INSERT ON bandits
+                      FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (7.5ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                      DECLARE
+                        row bandits%rowtype;
+                      BEGIN
+                        DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                        RETURN row;
+                      END;
+                      $$ LANGUAGE plpgsql;
+   (0.4ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits;
+   (10.7ms)  CREATE TRIGGER bandits_after_insert_trigger
+                      after INSERT ON bandits
+                      FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (30.4ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (12.2ms)  ALTER TABLE crimes DROP CONSTRAINT fk_rails_ca9866c40c;
+   (8.5ms)  SHOW constraint_exclusion;
+   (0.2ms)  BEGIN
+  SQL (62.3ms)  INSERT INTO "bandits" ("specialization", "created_at", "updated_at") VALUES ($1, $2, $3) RETURNING "id"  [["specialization", "pol"], ["created_at", "2016-03-20 07:48:16.365726"], ["updated_at", "2016-03-20 07:48:16.365726"]]
+   (17.5ms)  COMMIT
+   (0.7ms)  BEGIN
+  SQL (86.9ms)  INSERT INTO "bandits" ("specialization", "created_at", "updated_at") VALUES ($1, $2, $3) RETURNING "id"  [["specialization", "polit"], ["created_at", "2016-03-20 07:48:26.107704"], ["updated_at", "2016-03-20 07:48:26.107704"]]
+   (15.0ms)  COMMIT
+   (870.2ms)  SELECT data_type FROM information_schema.columns 
+                      WHERE table_name ='bandits' 
+                      AND column_name = 'specialization';
+   (953.9ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname text := 'specialization';
+                         colval  text := NEW.specialization;
+                         tblname text := 'bandits_' || colval;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (' 
+                                 || quote_ident(colname) 
+                                 || '=' 
+                                 || quote_literal(colval) 
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (616.8ms)  DROP TRIGGER IF EXISTS bandits_before_insert_trigger ON bandits;
+   (34.9ms)  CREATE TRIGGER bandits_before_insert_trigger
+                      before INSERT ON bandits
+                      FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (52.2ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                      DECLARE
+                        row bandits%rowtype;
+                      BEGIN
+                        DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                        RETURN row;
+                      END;
+                      $$ LANGUAGE plpgsql;
+   (8.4ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits;
+   (10.3ms)  CREATE TRIGGER bandits_after_insert_trigger
+                      after INSERT ON bandits
+                      FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (647.8ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                             ccu.table_name AS foreign_table_name,
+                             ccu.column_name AS foreign_column_name 
+                      FROM   information_schema.table_constraints AS tc 
+                      JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                      JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                      WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.6ms)  SHOW constraint_exclusion;
+  Bandit Load (129.0ms)  SELECT "bandits".* FROM "bandits"
+   (4.9ms)  BEGIN
+  SQL (288.3ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Yo"], ["specialization", "puk"], ["created_at", "2016-03-21 20:05:09.309204"], ["updated_at", "2016-03-21 20:05:09.309204"]]
+   (38.0ms)  COMMIT
+  Bandit Load (13.8ms)  SELECT  "bandits".* FROM "bandits"  ORDER BY "bandits"."id" DESC LIMIT 1
+   (0.2ms)  BEGIN
+  SQL (53.6ms)  INSERT INTO "crimes" ("title", "bandit_id", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["title", "bla"], ["bandit_id", 3], ["created_at", "2016-03-21 20:05:51.390198"], ["updated_at", "2016-03-21 20:05:51.390198"]]
+   (16.3ms)  COMMIT
+  Crime Load (1.8ms)  SELECT  "crimes".* FROM "crimes"  ORDER BY "crimes"."id" ASC LIMIT 1
+  Crime Load (1.6ms)  SELECT  "crimes".* FROM "crimes"  ORDER BY "crimes"."id" ASC LIMIT 1
+  Bandit Load (2.1ms)  SELECT  "bandits".* FROM "bandits" WHERE "bandits"."id" = $1 LIMIT 1  [["id", 3]]
+  Crime Load (1.2ms)  SELECT  "crimes".* FROM "crimes"  ORDER BY "crimes"."id" ASC LIMIT 1
+  Bandit Load (0.8ms)  SELECT  "bandits".* FROM "bandits" WHERE "bandits"."id" = $1 LIMIT 1  [["id", 3]]
+   (0.9ms)  BEGIN
+  SQL (1.0ms)  INSERT INTO "crimes" ("title", "bandit_id", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["title", "dsdsds"], ["bandit_id", 3], ["created_at", "2016-03-21 20:07:39.673947"], ["updated_at", "2016-03-21 20:07:39.673947"]]
+   (16.6ms)  COMMIT
+  Bandit Load (4.2ms)  SELECT  "bandits".* FROM "bandits"  ORDER BY "bandits"."id" ASC LIMIT 1
+  Crime Load (0.8ms)  SELECT "crimes".* FROM "crimes" WHERE "crimes"."bandit_id" = $1  [["bandit_id", 1]]
+  Bandit Load (3.3ms)  SELECT  "bandits".* FROM "bandits"  ORDER BY "bandits"."id" DESC LIMIT 1
+  Crime Load (1.0ms)  SELECT "crimes".* FROM "crimes" WHERE "crimes"."bandit_id" = $1  [["bandit_id", 3]]
+   (73.4ms)  CREATE TABLE "schema_migrations" ("version" character varying NOT NULL) 
+   (81.9ms)  CREATE UNIQUE INDEX  "unique_schema_migrations" ON "schema_migrations"  ("version")
+  ActiveRecord::SchemaMigration Load (1.5ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+Migrating to CreateGangs (20160306173540)
+   (0.5ms)  BEGIN
+   (143.1ms)  CREATE TABLE "gangs" ("id" serial primary key, "title" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+  SQL (0.7ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306173540"]]
+   (23.6ms)  COMMIT
+Migrating to CreateBandits (20160306174017)
+   (0.3ms)  BEGIN
+   (95.4ms)  CREATE TABLE "bandits" ("id" serial primary key, "name" character varying, "specialization" character varying, "date_of_birth" date, "gang_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (48.0ms)  CREATE  INDEX  "index_bandits_on_gang_id" ON "bandits"  ("gang_id")
+   (6.8ms)  ALTER TABLE "bandits" ADD CONSTRAINT "fk_rails_7411a14fb1"
+FOREIGN KEY ("gang_id")
+  REFERENCES "gangs" ("id")
+
+  SQL (0.7ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174017"]]
+   (16.1ms)  COMMIT
+Migrating to CreateCrimes (20160306174042)
+   (0.6ms)  BEGIN
+   (117.6ms)  CREATE TABLE "crimes" ("id" serial primary key, "title" character varying, "bandit_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (50.9ms)  CREATE  INDEX  "index_crimes_on_bandit_id" ON "crimes"  ("bandit_id")
+   (4.5ms)  ALTER TABLE "crimes" ADD CONSTRAINT "fk_rails_ca9866c40c"
+FOREIGN KEY ("bandit_id")
+  REFERENCES "bandits" ("id")
+
+  SQL (0.6ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174042"]]
+   (20.5ms)  COMMIT
+  ActiveRecord::SchemaMigration Load (0.5ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+   (6.5ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'bandits'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (6.1ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'crimes'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (6.7ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'gangs'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (10.2ms)  SELECT data_type FROM information_schema.columns
+                                          WHERE table_name = 'bandits' AND column_name = 'id';
+   (19.0ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname   text    := 'id';
+                         colval    integer := NEW.id;
+                         threshold integer := '100';
+                         step      integer := ROUND(colval / threshold);
+                         tblname   text    := 'bandits_' || step;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (ROUND(' 
+                                 || quote_ident(colname) 
+                                 || '/'
+                                 || threshold 
+                                 || ')=' 
+                                 || step
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (0.6ms)  DROP TRIGGER IF EXISTS bandits_before_insert_trigger ON bandits;
+   (13.5ms)  CREATE TRIGGER bandits_before_insert_trigger
+                      before INSERT ON bandits
+                      FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (7.1ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                      DECLARE
+                        row bandits%rowtype;
+                      BEGIN
+                        DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                        RETURN row;
+                      END;
+                      $$ LANGUAGE plpgsql;
+   (0.4ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits;
+   (12.8ms)  CREATE TRIGGER bandits_after_insert_trigger
+                      after INSERT ON bandits
+                      FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (26.2ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                           ccu.table_name AS foreign_table_name,
+                           ccu.column_name AS foreign_column_name 
+                    FROM   information_schema.table_constraints AS tc 
+                    JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                    JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                    WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (13.9ms)  ALTER TABLE crimes DROP CONSTRAINT fk_rails_ca9866c40c;
+   (0.5ms)  SHOW constraint_exclusion;
+   (0.2ms)  BEGIN
+  SQL (90.3ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Yo"], ["specialization", "puk"], ["created_at", "2016-03-23 17:58:26.254810"], ["updated_at", "2016-03-23 17:58:26.254810"]]
+   (16.5ms)  COMMIT
+   (10.8ms)  SELECT data_type FROM information_schema.columns
+                                          WHERE table_name = '1 = 1' AND column_name = 'id';
+   (9.3ms)  SELECT data_type FROM information_schema.columns
+                                          WHERE table_name = 'true' AND column_name = 'id';
+   (224.2ms)  SELECT data_type FROM information_schema.columns
+                                          WHERE table_name = 'bandits' AND column_name = 'id';
+   (216.3ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname   text    := 'id';
+                         colval    integer := NEW.id;
+                         threshold integer := '40';
+                         step      integer := ROUND(colval / threshold);
+                         tblname   text    := 'bandits_' || step;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (ROUND(' 
+                                 || quote_ident(colname) 
+                                 || '/'
+                                 || threshold 
+                                 || ')=' 
+                                 || step
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         EXECUTE 'CREATE INDEX ' 
+                                 || quote_ident(tblname || '_idx') 
+                                 || ' ON ' 
+                                 || quote_ident(tblname) 
+                                 || ' (id, '
+                                 || quote_ident(colname)
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (131.0ms)  DROP TRIGGER IF EXISTS bandits_before_insert_trigger ON bandits;
+   (54.9ms)  CREATE TRIGGER bandits_before_insert_trigger
+                      before INSERT ON bandits
+                      FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (9.3ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                      DECLARE
+                        row bandits%rowtype;
+                      BEGIN
+                        DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                        RETURN row;
+                      END;
+                      $$ LANGUAGE plpgsql;
+   (5.9ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits;
+   (13.9ms)  CREATE TRIGGER bandits_after_insert_trigger
+                      after INSERT ON bandits
+                      FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (237.0ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                           ccu.table_name AS foreign_table_name,
+                           ccu.column_name AS foreign_column_name 
+                    FROM   information_schema.table_constraints AS tc 
+                    JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                    JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                    WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (0.9ms)  SHOW constraint_exclusion;
+   (0.2ms)  BEGIN
+  SQL (68.8ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Yo"], ["specialization", "puk"], ["created_at", "2016-03-24 17:40:39.130570"], ["updated_at", "2016-03-24 17:40:39.130570"]]
+   (20.1ms)  COMMIT
+   (137.4ms)  CREATE TABLE "schema_migrations" ("version" character varying NOT NULL) 
+   (67.7ms)  CREATE UNIQUE INDEX  "unique_schema_migrations" ON "schema_migrations"  ("version")
+  ActiveRecord::SchemaMigration Load (1.8ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+Migrating to CreateGangs (20160306173540)
+   (0.4ms)  BEGIN
+   (143.9ms)  CREATE TABLE "gangs" ("id" serial primary key, "title" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+  SQL (22.3ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306173540"]]
+   (14.8ms)  COMMIT
+Migrating to CreateBandits (20160306174017)
+   (0.3ms)  BEGIN
+   (101.0ms)  CREATE TABLE "bandits" ("id" serial primary key, "name" character varying, "specialization" character varying, "date_of_birth" date, "gang_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (48.6ms)  CREATE  INDEX  "index_bandits_on_gang_id" ON "bandits"  ("gang_id")
+   (8.0ms)  ALTER TABLE "bandits" ADD CONSTRAINT "fk_rails_7411a14fb1"
+FOREIGN KEY ("gang_id")
+  REFERENCES "gangs" ("id")
+
+  SQL (0.7ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174017"]]
+   (20.1ms)  COMMIT
+Migrating to CreateCrimes (20160306174042)
+   (0.9ms)  BEGIN
+   (105.0ms)  CREATE TABLE "crimes" ("id" serial primary key, "title" character varying, "bandit_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (63.5ms)  CREATE  INDEX  "index_crimes_on_bandit_id" ON "crimes"  ("bandit_id")
+   (4.6ms)  ALTER TABLE "crimes" ADD CONSTRAINT "fk_rails_ca9866c40c"
+FOREIGN KEY ("bandit_id")
+  REFERENCES "bandits" ("id")
+
+  SQL (0.7ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174042"]]
+   (19.1ms)  COMMIT
+  ActiveRecord::SchemaMigration Load (0.5ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+   (6.5ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'bandits'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (6.1ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'crimes'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (5.9ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'gangs'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (0.2ms)  BEGIN
+  SQL (1.8ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Yo"], ["specialization", "puk"], ["created_at", "2016-03-24 17:44:05.066919"], ["updated_at", "2016-03-24 17:44:05.066919"]]
+   (29.7ms)  COMMIT
+   (109.3ms)  SELECT data_type FROM information_schema.columns
+                                          WHERE table_name = 'bandits' AND column_name = 'id';
+   (162.8ms)  CREATE OR REPLACE FUNCTION bandits_insert_master() RETURNS TRIGGER AS $$
+                       DECLARE
+                         colname   text    := 'id';
+                         colval    integer := NEW.id;
+                         threshold integer := '5';
+                         step      integer := ROUND(colval / threshold);
+                         tblname   text    := 'bandits_' || step;
+                       BEGIN
+                         IF NOT EXISTS(SELECT relname FROM pg_class WHERE relname=tblname) THEN
+                         EXECUTE 'CREATE TABLE '
+                                 || tblname 
+                                 || '(check (ROUND(' 
+                                 || quote_ident(colname) 
+                                 || '/'
+                                 || threshold 
+                                 || ')=' 
+                                 || step
+                                 || ')) INHERITS (' 
+                                 || TG_RELNAME 
+                                 || ');';
+                         EXECUTE 'CREATE INDEX ' 
+                                 || quote_ident(tblname || '_idx') 
+                                 || ' ON ' 
+                                 || quote_ident(tblname) 
+                                 || ' (id, '
+                                 || quote_ident(colname)
+                                 || ');';
+                         END IF;
+                         EXECUTE 'INSERT INTO ' || tblname || ' SELECT ($1).*' USING NEW;
+                         RETURN NEW;
+                       END;
+                       $$ LANGUAGE plpgsql;
+   (9.8ms)  DROP TRIGGER IF EXISTS bandits_before_insert_trigger ON bandits;
+   (17.2ms)  CREATE TRIGGER bandits_before_insert_trigger
+                      before INSERT ON bandits
+                      FOR EACH ROW EXECUTE PROCEDURE bandits_insert_master();
+   (10.3ms)  CREATE OR REPLACE FUNCTION bandits_delete_master() RETURNS TRIGGER AS $$
+                      DECLARE
+                        row bandits%rowtype;
+                      BEGIN
+                        DELETE FROM ONLY bandits WHERE id = NEW.id RETURNING * INTO row;
+                        RETURN row;
+                      END;
+                      $$ LANGUAGE plpgsql;
+   (0.6ms)  DROP TRIGGER IF EXISTS bandits_after_insert_trigger ON bandits;
+   (19.9ms)  CREATE TRIGGER bandits_after_insert_trigger
+                      after INSERT ON bandits
+                      FOR EACH ROW EXECUTE PROCEDURE bandits_delete_master();
+   (108.9ms)  SELECT tc.constraint_name, tc.table_name, kcu.column_name, 
+                           ccu.table_name AS foreign_table_name,
+                           ccu.column_name AS foreign_column_name 
+                    FROM   information_schema.table_constraints AS tc 
+                    JOIN   information_schema.key_column_usage AS kcu ON tc.constraint_name = kcu.constraint_name
+                    JOIN   information_schema.constraint_column_usage AS ccu ON ccu.constraint_name = tc.constraint_name
+                    WHERE  constraint_type = 'FOREIGN KEY' AND ccu.table_name='bandits';
+   (15.3ms)  ALTER TABLE crimes DROP CONSTRAINT fk_rails_ca9866c40c;
+   (0.5ms)  SHOW constraint_exclusion;
+   (0.2ms)  BEGIN
+  SQL (187.7ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Yo"], ["specialization", "puk"], ["created_at", "2016-03-24 17:45:50.965645"], ["updated_at", "2016-03-24 17:45:50.965645"]]
+   (23.8ms)  COMMIT
+   (2.2ms)  BEGIN
+  SQL (12.7ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Yo"], ["specialization", "puk"], ["created_at", "2016-03-24 17:45:54.248710"], ["updated_at", "2016-03-24 17:45:54.248710"]]
+   (23.4ms)  COMMIT
+   (2.5ms)  BEGIN
+  SQL (14.5ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Yo"], ["specialization", "puk"], ["created_at", "2016-03-24 17:45:55.183196"], ["updated_at", "2016-03-24 17:45:55.183196"]]
+   (18.3ms)  COMMIT
+   (2.1ms)  BEGIN
+  SQL (126.0ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Yo"], ["specialization", "puk"], ["created_at", "2016-03-24 17:45:56.083555"], ["updated_at", "2016-03-24 17:45:56.083555"]]
+   (22.7ms)  COMMIT
+   (1.1ms)  BEGIN
+  SQL (8.4ms)  INSERT INTO "bandits" ("name", "specialization", "created_at", "updated_at") VALUES ($1, $2, $3, $4) RETURNING "id"  [["name", "Yo"], ["specialization", "puk"], ["created_at", "2016-03-24 17:45:57.166553"], ["updated_at", "2016-03-24 17:45:57.166553"]]
+   (24.0ms)  COMMIT
+   (364.6ms)  CREATE TABLE "schema_migrations" ("version" character varying NOT NULL) 
+   (244.6ms)  CREATE UNIQUE INDEX  "unique_schema_migrations" ON "schema_migrations"  ("version")
+  ActiveRecord::SchemaMigration Load (2.3ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+Migrating to CreateGangs (20160306173540)
+   (0.2ms)  BEGIN
+   (909.6ms)  CREATE TABLE "gangs" ("id" serial primary key, "title" character varying, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+  SQL (40.3ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306173540"]]
+   (114.2ms)  COMMIT
+Migrating to CreateBandits (20160306174017)
+   (0.3ms)  BEGIN
+   (149.4ms)  CREATE TABLE "bandits" ("id" serial primary key, "name" character varying, "specialization" character varying, "date_of_birth" date, "gang_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (100.8ms)  CREATE  INDEX  "index_bandits_on_gang_id" ON "bandits"  ("gang_id")
+   (115.4ms)  ALTER TABLE "bandits" ADD CONSTRAINT "fk_rails_7411a14fb1"
+FOREIGN KEY ("gang_id")
+  REFERENCES "gangs" ("id")
+
+  SQL (44.0ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174017"]]
+   (81.1ms)  COMMIT
+Migrating to CreateCrimes (20160306174042)
+   (0.3ms)  BEGIN
+   (92.4ms)  CREATE TABLE "crimes" ("id" serial primary key, "title" character varying, "bandit_id" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (66.3ms)  CREATE  INDEX  "index_crimes_on_bandit_id" ON "crimes"  ("bandit_id")
+   (3.2ms)  ALTER TABLE "crimes" ADD CONSTRAINT "fk_rails_ca9866c40c"
+FOREIGN KEY ("bandit_id")
+  REFERENCES "bandits" ("id")
+
+  SQL (0.6ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20160306174042"]]
+   (30.2ms)  COMMIT
+  ActiveRecord::SchemaMigration Load (0.5ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+   (44.2ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'bandits'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (17.1ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'crimes'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+
+   (9.9ms)  SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+FROM pg_constraint c
+JOIN pg_class t1 ON c.conrelid = t1.oid
+JOIN pg_class t2 ON c.confrelid = t2.oid
+JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+JOIN pg_namespace t3 ON c.connamespace = t3.oid
+WHERE c.contype = 'f'
+  AND t1.relname = 'gangs'
+  AND t3.nspname = ANY (current_schemas(false))
+ORDER BY c.conname
+