Sequel для ценителей Postgres

1. Когда возможностей
ActiveRecord недостаточно
Sequel: ORM для ценителей Postgres

2. О чем пойдет речь
Почему возможностей AR может не хватать
Основные отличия Sequel
Составные типы данных (hstore, jsonb, array)
Использование специальных функций Postgres и
примеры

3. Есть же AR! У нас все отлично работает!
Слабая поддержка:
Составных типов данных
CTE
Join, group
Распределенных БД
Подзапросов
Master Slave
Операций на стороне бд
Sequel
Sequel это [паттерн] ActiveRecord
Во многом похож на AR
Превосходит AR по функциональности
Поддерживает большее число СУБД
Поддерживает ree 1.8, jruby
Имеет модульную архитектуру
Поддерживает то, что написано слева

4. Где работает плохо и почему
Model.select(“COALESCE(ABS(SUM(amount * (courses ->
users.currency)::numeric)), 0)”)
SELECT COALESCE(ABS(SUM(amount * (courses ->
users.currency)::numeric)), 0) FROM "models"
Model.select { coalesce(abs(sum(:amount *
:courses.hstore[:users__currency].cast(:numeric))), 0) }
SELECT coalesce(abs(sum(("amount" * CAST(("courses" ->
"users"."currency") AS numeric)))), 0) FROM "models"

5. ActiveRecord vs Sequel (функциональность)
1. pg_loose_count
2. pg_static_cache_updater
3. single_table_inheritance
4. timestamps
5. association_proxies
6. optimistic_locking
Feature AR Sequel
Where OR 2016 2008
Left joins 2015 2008
Concurrently indexing 2013(5) 2012
Bulk loading 2010 2009
where.not 2012 2007
rewhere 2013 2008

6. Arel
users = Arel::Table.new(:users) # Users.arel_table
orders = Arel::Table.new(:orders)
User.find_by_sql(users.project(Arel.star).join(orders,
Arel::Nodes::OuterJoin).on(users[:id].eq(orders[:user_id])))
User.left_join(:orders, user_id: :id).all
User.find_by_sql(users.project(Arel.star).where(
orders.where(users[:id].eq(orders[:user_id])).exists.not ))
User.exclude { exists(DB[:orders].where(user_id: users__id)) }.all

7. Arel сложные условия и оконные функции
users.project(Arel.star).where(users[:id].eq(23).or(users[:status_id].gteq(42)
)).to_sql
User.where(id: 23).or(User.where("status_id >= ?", 42)).to_sql
User.where { { id: 23 } | (status_id >= 42) }.sql
SELECT * FROM "users" WHERE (("id" = 23) OR ("status_id" >= 42))
users.project([users[:id].sum.over(Arel::Nodes::Window.new.partition(users[:st
atus_id])), users[:id], users[:status_id]]).to_sql
User.select{ [sum(id).over(partition: :users__status_id), status_id] }.sql
SELECT sum("id") OVER (PARTITION BY "users"."status_id"), "status_id" FROM "users"

8. Sequel::Model & Sequel::Dataset
class Model < Sequel::Model(:models)
many_to_one :category
subset(:expensive){ price > 500000 }
dataset_module do
def by_category(category_id)
where(category_id: category_id)
end
end
End
Model.by_category(1).all
Model.expensive.all
Model.qualify
.join(:categories, id: :category_id)
.select_append(
:categories__title___cat_title
)
.group(:models__id)
.group_append(:categories__id)
SELECT "models".*,
"categories"."title" AS
"cat_title"
FROM "models"
INNER JOIN "categories" ON
("categories"."id" =
"models"."category_id")
GROUP BY "models"."id",
"categories"."id"

9. Массивы
Model.where{ :values.pg_array.contains([4, 5]) }
SELECT * FROM "models" WHERE ("values" @> ARRAY[4,5])
Model.select{
[:array1.pg_array.concat(array2).overlaps(:array3).as(:result
), :id] }.all
SELECT (("array1" || "array2") && "array3") AS "result", "id"
FROM "models"
ia.contains(:other_int_array_column) # @>
ia.contained_by(:other_int_array_column) # <@
ia.overlaps(:other_int_array_column) # &&
ia.concat(:other_int_array_column) # ||
ia.push(1) # int_array_column || 1
ia.unshift(1) # 1 || int_array_column

10. Hstore
Model.select{ :properties.hstore[:enabled] }
SELECT ("properties" -> "enabled") FROM "models"
Model.select{ :properties.hstore.key?(:enabled) }
SELECT ("properties" ? "enabled") FROM "models"
Model.where( :properties.hstore.key?(:enabled))
SELECT * FROM "models" WHERE ("properties" ? "enabled")
DB[:tab].update(:h=>Sequel.hstore_op(:h).concat('c'=>3))
UPDATE "tab" SET "h" = ("h" || '"c"=>"3"'::hstore)

11. JSON(B) вложенные структуры
DB[:jsonb].insert(jsonb: '{"array":[1], "object": {}}' )
DB[:jsonb].where( :prefs.pg_jsonb.contains('{"object":{}}') &
{ :prefs.pg_jsonb[['array', '0']] => '1' } ).all
SELECT * FROM "jsonb" WHERE (("prefs" @> '{"object":{}}') AND
(("prefs" #> ARRAY['array','0']) = '1'))
DB[:jsonb].update(prefs: :prefs.pg_jsonb.set(['array', '1'],
'5'))
UPDATE "jsonb" SET "prefs" = jsonb_set("prefs",
ARRAY['array','1'], '5', true)

12. Использование вложенных типов данных
DB.create_table(:address, temp: true) { String :street; String :city; }
CREATE TEMPORARY TABLE "address" ("street" text, "city" text)
DB.create_table(:test, temp: true) { primary_key :id; address :address; }
CREATE TEMPORARY TABLE "test" ("id" serial PRIMARY KEY, "address" address)
DB[:test].insert(:address=>DB.row_type(:address, street: '123 Sesame St.',
city: 'Some City'))
INSERT INTO "test" ("address") VALUES (ROW('123 Sesame St.', 'Some
City')::"address") RETURNING "id"
DB[:test].first[:address]
=> {:street=>"123 Sesame St.", :city=>"Some City"}

13. Полнотекстовый поиск
DB.alter_table(:texts) {add_full_text_index([:text],
language: 'english')
CREATE INDEX "texts_text_index" ON "texts" USING gin
(to_tsvector('english'::regconfig, (COALESCE("text", ''))))
DB[:texts].full_text_search(:text, %w[match tes:*], language:
'english')
SELECT * FROM "texts" WHERE (to_tsvector(CAST('english' AS
regconfig), (COALESCE("text", ''))) @@
to_tsquery(CAST('english' AS regconfig), 'match | tes:*'))
[{:id=>1, :text=>"test test"}, {:id=>3, :text=>"exact match"}]

14. CTE
Перемещение данных в другую
таблицу
WITH deleted_items AS (
DELETE FROM #{table}
WHERE #{where}
RETURNING *
)
INSERT INTO #{table}_archive
SELECT * FROM deleted_items
admins = User.where(role: 'admin')
User.with(:admins,
admins).from(:admins)
.where(login: /a/)
WITH "admins" AS (SELECT * FROM
"users" WHERE ("role" = 'admin'))
SELECT * FROM "admins" WHERE ("login"
~ 'a')
DB[:"#{table}_archive"].with(:deleted_items,
DB[table].returning.with_sql(:delete_sql)).insert(DB[:deleted_items])
WITH "d" AS (DELETE FROM "users" RETURNING *) INSERT INTO "users_archive" SELECT * FROM
"d" RETURNING NULL

15. Recursive CTE
DB[:t].with_recursive(:t,
DB.select(Sequel.lit('1').as(:val)),
DB[:t].select(:t__val +
1).where(Sequel.expr(:t__val) < 10),
:args=>[:val]).all
WITH recursive "t"("val") AS (
SELECT 1 AS "val"
UNION ALL (
SELECT ("t"."val" + 1)
FROM "t"
WHERE (
"t"."val" < 10
)
)
)
SELECT *
FROM "t"

16. Полезные RCTE
Инициализация
db[table].where(id: [db[table].min(key),
db[table].max(key)]).select(
sequel_function(:min, key),
sequel_function(:max, key),
as(:target.cast(pg_type), :target_col),
as(:target.cast(pg_type), :value_col)
).group(:target_col)
Тело рекурсии
db[:t].join(table, Sequel.qualify(table, :id)=> mid)
.where(expr(:max) >= :min)
.select(
as(Sequel.case(
{ (:t__target_col >= Sequel.qualify(table, column)) => mid },
:min), :min),
as(Sequel.case(
{ (:t__target_col < Sequel.qualify(table, column)) => mid },
:max), :max),
:target_col,
as(Sequel.qualify(table, column), :value_col)
)
def mid
(:min + :max) / 2
end

17. RCTE binary search (Окончание)
def find_nearest(table, column, target, options={})
key = options.fetch(:key, :id)
pg_type = options.fetch(:pg_type, :text)
db.dataset.with_recursive(:t,
initial_query(table, key, target, pg_type),
recursive_query(table, column),
union_all: false
).from(:t)
end

18. Деревья
Node.first.descendants
WITH RECURSIVE "t" AS (SELECT * FROM "tree" WHERE
("parent_id" = 1) UNION ALL (SELECT "tree".* FROM "tree"
INNER JOIN "t" ON ("t"."id" = "tree"."parent_id"))) SELECT *
FROM "t" AS "tree"
=> [#<Node @values={:id=>2, :parent_id=>1}>,
#<Node @values={:id=>4, :parent_id=>1}>,
#<Node @values={:id=>3, :parent_id=>2}>,
#<Node @values={:id=>5, :parent_id=>4}>]

19. Insert conflict & rollup
DB[:texts].insert_conflict(:target=>:id, :update=>{:text=>:excluded__text}).insert(id: 2,
text: 'exact match updated')
INSERT INTO "texts" ("id", "text") VALUES (2, 'exact match updated') ON CONFLICT ("id") DO
UPDATE SET "text" = "excluded"."text" RETURNING "id"
User.select { [role, sum(balance).cast(:integer)] }.group(:role).group_rollup.all
SELECT "role", CAST(sum("balance") AS integer) FROM "users" GROUP BY ROLLUP("role")
=> [#<User @values={:role=>"admin", :sum=>210933700}>,
#<User @values={:role=>"client", :sum=>344305}>,
#<User @values={:role=>nil, :sum=>211278005}>]

20. DO statements & copy
DB.do(:language=>:plpgsql) <<-SQL
BEGIN
raise 'exception';
END;
SQL
DB.create_function(:set_updated_at, “
BEGIN
NEW.updated_at := CURRENT_TIMESTAMP;
RETURN NEW;
END;", :language=>:plpgsql,
:returns=>:trigger)
DB.copy_table(DB[:jsonb], :format=>:csv)
COPY (SELECT * FROM "jsonb") TO STDOUT
(FORMAT csv)
=> 1,"{""array"": [7, ""4""],
""object"": {}}"
2,"{""array"": [7, ""4""], ""object"":
{}}"

21. Шардинг и master/slave
DB=Sequel.connect('postgres://master_server/database',
:servers=>{:read_only=>{:host=>'slave_server'}})
# Force the SELECT to run on the master
DB[:users].server(:default).all
# Force the SELECT to run on the read-only slave
DB[:users].server(:read_only).all
DB.transaction(:prepare=>'some_transaction_id_string') do
DB[:foo].insert(1) # INSERT
end
DB.commit_prepared_transaction('some_transaction_id_string') # or
DB.rollback_prepared_transaction('some_transaction_id_string')

22. Итоги
Вопросы? Q&A!
Ссылка о производительности