janko 0.0.2

data/lib/janko/upsert.rb

@@ -0,0 +1,193 @@
+require "securerandom"
+require "agrippa/mutable"
+
+module Janko
+    # http://dba.stackexchange.com/questions/13468/most-idiomatic-way-to-implement-upsert-in-postgresql-nowadays
+    # http://stackoverflow.com/questions/1109061/insert-on-duplicate-update-in-postgresql/8702291#8702291
+    # http://stackoverflow.com/questions/17575489/postgresql-cte-upsert-returning-modified-rows
+    class Upsert
+        include Agrippa::Mutable
+
+        state_reader :connection, :table, :columns, :collector, :returning
+
+        def default_state
+            { collector: MergeResult.new }
+        end
+
+        def result
+            collector
+        end
+
+        def prepare
+            return(self) if prepared?
+            @prepared = "upsert_#{SecureRandom.hex(8)}"
+            connection.prepare(@prepared, query)
+            self
+        end
+
+        def push(*values)
+            raise(RuntimeError, "Can't #push when reading from a table.") \
+                if read_from_table?
+            collect_result(exec_query(columns.pack(*values)))
+            self
+        end
+
+        def process
+            raise(RuntimeError, "Can't #process without from_table") \
+                unless read_from_table?
+            result.clear
+            collect_result(exec_query)
+            self
+        end
+
+        def cleanup
+            return unless prepared?
+            connection.exec("DEALLOCATE \"#{@prepared}\"")
+            @prepared = nil
+            self
+        end
+
+        private
+
+        def result_type_column
+            "__type"
+        end
+
+        def collect_result(tuples)
+            return(self) if (tuples.count == 0)
+            tuples.each { |t| result.push(t.delete(result_type_column), t) }
+        end
+
+        def read_from_table?
+            not @from_table.nil?
+        end
+
+        def prepared?
+            not @prepared.nil?
+        end
+
+        def exec_query(*binds)
+            return(connection.exec(query, *binds)) unless prepared?
+            connection.exec_prepared(@prepared, *binds)
+        end
+
+        def key_columns
+            @key_columns ||= columns.tagged(:key)
+        end
+
+        def update_columns
+            @update_columns ||= columns.tagged(:update).not_tagged(:key)
+        end
+
+        def insert_columns
+            @insert_columns ||= columns.tagged(:insert)
+        end
+
+        def select_columns
+            @select_columns ||= columns.tagged(:select)
+        end
+
+        def insert_columns_with_defaults
+            insert_columns.to_list_with_defaults
+        end
+
+        def columns_to_binds_with_types
+            columns.to_typecast_binds
+        end
+
+        def update_clause
+            update_columns.to_setters("upsert_updates", source_table)
+        end
+
+        def update_key_clause
+            key_columns.to_conditions("upsert_updates", source_table)
+        end
+
+        def insert_key_clause
+            key_columns.to_conditions("upsert", source_table)
+        end
+
+        def query
+            return(query_returning_nothing) if select_columns.empty?
+            return(query_returning_all) if (returning == "all")
+            return(query_returning_inserts) if (returning == "inserted")
+            return(query_returning_updates) if (returning == "updated")
+            query_returning_nothing
+        end
+
+        def source_table
+            @from_table || "upsert_data"
+        end
+
+        def source_fragment
+            return if read_from_table?
+            return(<<-END)
+                #{source_table} (#{columns.to_list}) AS (VALUES
+                    (#{columns_to_binds_with_types})),
+            END
+        end
+
+        def upsert_fragment
+            return(<<-END)
+                UPDATE #{table} upsert_updates
+                SET #{update_clause} FROM #{source_table}
+                WHERE (#{update_key_clause})
+                RETURNING upsert_updates.*
+            END
+        end
+
+        def insert_fragment
+            return(<<-END)
+                INSERT INTO #{table} (#{insert_columns.to_list})
+                SELECT #{insert_columns_with_defaults} FROM #{source_table}
+                WHERE NOT EXISTS (SELECT 1 FROM upsert
+                    WHERE #{insert_key_clause})
+            END
+        end
+
+        def query_returning_nothing
+            return(<<-END)
+                WITH #{source_fragment} upsert AS (#{upsert_fragment})
+                #{insert_fragment}
+            END
+        end
+
+        def query_with_returnable_tuples
+            return(<<-END)
+                WITH #{source_fragment} upsert AS (#{upsert_fragment}), 
+                inserted AS (#{insert_fragment} RETURNING #{table}.*)
+            END
+        end
+
+        def query_returning_inserts
+            return(<<-END)
+                #{query_with_returnable_tuples}
+                SELECT 'inserted'
+                    AS #{result_type_column}, #{select_columns.to_list}
+                    FROM inserted
+            END
+        end
+
+        def query_returning_updates
+            return(<<-END)
+                #{query_with_returnable_tuples}
+                SELECT 'updated'
+                    AS #{result_type_column}, #{select_columns.to_list}
+                    FROM upsert
+            END
+        end
+
+        def query_returning_all
+            return(<<-END)
+                #{query_with_returnable_tuples}
+                SELECT 'inserted'
+                    AS #{result_type_column}, #{select_columns.to_list}
+                    FROM inserted
+                UNION ALL
+                SELECT 'updated'
+                    AS #{result_type_column}, #{select_columns.to_list}
+                    FROM upsert
+            END
+        end
+    end
+end

data/lib/janko/version.rb

@@ -0,0 +1,3 @@
+module Janko
+    VERSION = "0.0.2"
+end

data/spec/column_list_spec.rb

@@ -0,0 +1,164 @@
+require "spec_helper"
+require "janko/column_list"
+
+RSpec.describe Janko::ColumnList do
+    let(:subject) { Janko::ColumnList.new.builder }
+
+    it "#empty?" do
+        expect(subject.empty?).to eq(true)
+        expect(subject.add(:a).empty?).to eq(false)
+    end
+
+    it "#columns" do
+        expect(subject.add(:a, "b", :c).columns).to eq(%w(a b c))
+    end
+    
+    describe "#tagged" do
+        it "filters" do
+            subject.tag(:red, :a).tag(:blue, :b)
+            expect(subject.tagged(:red).columns).to eq(%w(a))
+        end
+
+        it "symbols or strings" do
+            subject.tag(:red, :a)
+            expect(subject.tagged("red").columns).to eq(%w(a))
+            subject.tag("red", :b)
+            expect(subject.tagged("red").columns).to eq(%w(b))
+        end
+
+        it "preserves column order" do
+            subject.add(:a, :b, :c)
+            subject.tag(:red, :c, :b)
+            expect(subject.tagged(:red).columns).to eq(%w(b c))
+        end
+
+        it "all tagged columns" do
+            subject.add(:a, :b, :c)
+            subject.tag(:red, :a).tag(:green, :c)
+            expect(subject.tagged.columns).to eq(%w(a c))
+        end
+    end
+
+    describe "#pack" do
+        it "maintains order" do
+            subject.add(:a, :b, :c)
+            expect(subject.pack(b: "2", a: "1", c: "3")).to eq(%w(1 2 3))
+        end
+
+        it "null-fills fewer columns" do
+            subject.add(:a, :b, :c)
+            expect(subject.pack(a: 1, c: 3)).to eq([1, nil, 3])
+        end
+
+        it "unknown columns" do
+            subject.add(:a, :b)
+            expect(lambda { subject.pack(b: 2, a: 1, c: 3) }).to \
+                raise_error(ArgumentError)
+        end
+
+        it "indifferent access" do
+            subject.add(:a, "b")
+            expect(subject.pack("a" => "1", b: "2")).to eq(%w(1 2))
+        end
+    end
+
+    describe "#add" do
+        it "multiple times" do
+            subject.add(:a).add(:b, :c)
+            expect(subject.pack(b: "2", a: "1", c: "3")).to eq(%w(1 2 3))
+        end
+
+        it "duplicate columns" do
+            subject.add(:a).add(:a, :b, :c)
+            expect(subject.pack(b: "2", a: "1", c: "3")).to eq(%w(1 2 3))
+        end
+    end
+
+    describe "#alter" do
+        before(:each) { subject.add(:a) }
+
+        it "modifies a column" do
+            subject.alter(:a) { |f| f.tag(:altered) }
+            expect(subject.tagged(:altered).columns).to eq(%w(a))
+        end
+
+        it "modifies multiple columns" do
+            subject.add(:b)
+            subject.alter(:a, :b) { |f| f.tag(:altered) }
+            expect(subject.tagged(:altered).columns).to eq(%w(a b))
+        end
+
+        it "preserves name and parent" do
+            parent = double
+            connection = double
+            expect(parent).to receive(:connection).and_return(connection)
+            subject.set(parent: parent)
+            subject.alter(:a) { |f| Janko::TaggedColumn.new }
+            expect(subject.columns).to eq(%w(a))
+            expect(subject).to be_all { |_, c| c.connection == connection }
+        end
+
+        it "only works on existing columns" do
+            expect(lambda { subject.alter(:b) { |f| f.tag(:b) } }) \
+                .to raise_error(RuntimeError)
+        end
+    end
+
+    it "Janko::ALL" do
+        parent = double
+        connection = double
+        expect(parent).to receive(:table)
+        expect(parent).to receive(:connection).and_return(connection)
+        expect(connection).to receive(:column_list) \
+            .and_return(%w(id a b c))
+        subject.set(parent: parent)
+        subject.add(Janko::ALL)
+        expect(subject.columns).to eq(%w(id a b c))
+    end
+
+    it "Janko::DEFAULT" do
+        parent = double
+        connection = double
+        expect(parent).to receive(:table)
+        expect(parent).to receive(:connection).and_return(connection)
+        expect(connection).to receive(:column_list) \
+            .and_return(%w(id a b c))
+        subject.set(parent: parent)
+        subject.add(Janko::DEFAULT)
+        expect(subject.columns).to eq(%w(a b c))
+    end
+
+    it "all columns except" do
+        parent = double
+        connection = double
+        expect(parent).to receive(:table)
+        expect(parent).to receive(:connection).and_return(connection)
+        expect(connection).to receive(:column_list) \
+            .and_return(%w(id a b c))
+        subject.set(parent: parent)
+        subject.add(except: "b")
+        expect(subject.columns).to eq(%w(id a c))
+    end
+
+    it "#remove" do
+        subject.add(:a, :b, :c).remove("b")
+        expect(subject.columns).to eq(%w(a c))
+    end
+
+    it "#to_list" do
+        subject.add(:a, :b, :c)
+        expect(subject.to_list).to eq("\"a\",\"b\",\"c\"")
+    end
+
+    it "#to_binds" do
+        subject.add(:a, :b, :c)
+        expect(subject.to_binds).to eq("$1,$2,$3")
+    end
+
+    it "#inspect includes children" do
+        subject.add(:foo, :bar).tag("blue", :bar)
+        expect(subject.inspect).to match(/foo/)
+        expect(subject.inspect).to match(/bar/)
+        expect(subject.inspect).to match(/blue/)
+    end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+require "janko/connection"
+
+RSpec.describe Janko::Connection do
+    describe ".build" do
+        it "PG::Connection" do
+            backend = ActiveRecord::Base.connection.raw_connection
+            connection = Janko::Connection.build(backend)
+            expect(connection.backend).to be(backend)
+        end
+
+        it "ActiveRecord::Base.connection" do
+            backend = ActiveRecord::Base.connection
+            connection = Janko::Connection.build(backend)
+            raw_connection = backend.raw_connection
+            expect(connection.backend).to be(raw_connection)
+        end
+
+        it "ActiveRecord::Base" do
+            backend = ActiveRecord::Base
+            connection = Janko::Connection.build(backend)
+            raw_connection = backend.connection.raw_connection
+            expect(connection.backend).to be(raw_connection)
+        end
+    end
+end
+

data/spec/flag_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+require "janko/flag"
+
+RSpec.describe Janko::Flag do
+    def flag(value)
+        Janko::Flag.new(value)
+    end
+
+    it { expect(flag(2 ** 0)).to_not eq(2 ** 0) }
+
+    it { expect(flag(2 ** 0)).to eq(flag(2 ** 0)) }
+
+    it { expect(flag(2 ** 0)).to eq(flag(2 ** 0) | flag(2 ** 1)) }
+
+    it { expect(flag(2 ** 0)).to_not eq(flag(2 ** 2) | flag(2 ** 1)) }
+end

data/spec/import_spec.rb

@@ -0,0 +1,112 @@
+require "spec_helper"
+require "janko/import"
+require "pg"
+
+RSpec.shared_examples_for "an importer" do
+    describe "insert" do
+        let(:subject) { importer.connect(connection) }
+
+        around :each do |example|
+            begin
+                subject.table("import_test").columns(:id, :value)
+                connection.exec(<<-END)
+                    BEGIN; CREATE TEMP TABLE import_test(
+                        id integer not null, value text)
+                        WITHOUT OIDS ON COMMIT DROP;
+                    CREATE UNIQUE INDEX index_import_test_id
+                        ON import_test(id);
+                END
+                example.run
+            rescue
+                raise
+            ensure
+                connection.exec("ROLLBACK")
+            end
+        end
+
+        def result
+            output = connection.exec(<<-END)
+                SELECT id, value FROM import_test ORDER BY id asc
+            END
+            output.values.map { |v| v.join(",") }.join(";")
+        end
+ 
+        it "single row" do
+            subject.start.push(id: 1, value: "fish").stop
+            expect(result).to eq("1,fish")
+        end
+
+        it "multiple rows" do
+            subject.start
+            subject.push(id: 1, value: "fish")
+            subject.push(id: 2, value: "fish")
+            subject.stop
+            expect(result).to eq("1,fish;2,fish")
+        end
+
+        it "nullable column" do
+            subject.start.push(id: "1").stop
+            expect(result).to eq("1,")
+        end
+
+        it "violates not-null constraint" do
+            subject.start
+            row = { value: "fish" }
+            expect(lambda { subject.push(row).stop })
+                .to raise_error(PG::NotNullViolation)
+            connection.exec("ROLLBACK")
+        end
+
+        it "integer overflow" do
+            subject.start
+            row = { id: 2**32, value: "fish" }
+            expect(lambda { subject.push(row).stop })
+                .to raise_error(PG::NumericValueOutOfRange)
+            connection.exec("ROLLBACK")
+        end
+
+        it "violate uniqueness constraint" do
+            subject.start
+            row = { id: 1, value: "fish" }
+            subject.push(row)
+            expect(lambda { subject.push(row).stop })
+                .to raise_error(PG::UniqueViolation)
+            connection.exec("ROLLBACK")
+        end
+
+        it "violate uniqueness constraint (async errors)" do
+            subject.start
+            a = { id: 1, value: "fish" }
+            b = { id: 2, value: "fish" }
+            c = { id: 3, value: "fish" }
+            subject.push(b)
+            copy = lambda { subject.push(a).push(b).push(c).stop }
+            expect(copy).to raise_error(PG::UniqueViolation)
+            connection.exec("ROLLBACK")
+        end
+
+        it "too many columns" do
+            subject.start
+            row = [ 1, "fish", "woah" ]
+            expect(lambda { subject.push(*row).stop })
+                .to raise_error(ArgumentError)
+            connection.exec("ROLLBACK")
+        end
+    end
+end
+
+RSpec.describe Janko::Import do
+    let(:connection) { ActiveRecord::Base.connection.raw_connection }
+
+    describe "#strategy insert" do
+        let(:importer) { Janko::Import.new.use(Janko::InsertImporter) }
+
+        it_behaves_like "an importer"
+    end
+
+    describe "#strategy copy" do
+        let(:importer) { Janko::Import.new.use(Janko::CopyImporter) }
+
+        it_behaves_like "an importer"
+    end
+end