janko 0.0.2

data/lib/janko/flag.rb

@@ -0,0 +1,26 @@
+module Janko
+    class Flag
+        attr_reader :value
+
+        def initialize(value)
+            @value = value
+        end
+
+        def |(other)
+            self.class.new(value | other.value)
+        end
+
+        def eql?(other)
+            return unless other.is_a?(self.class)
+            (value & other.value) != 0
+        end
+
+        def ==(other)
+            eql?(other)
+        end
+
+        def ===(other)
+            eql?(other)
+        end
+    end
+end

data/lib/janko/import.rb

@@ -0,0 +1,80 @@
+require "agrippa/mutable_hash"
+require "janko/connection"
+require "janko/column_list"
+require "janko/copy_importer"
+require "janko/insert_importer"
+require "janko/constants"
+
+# http://starfighter.ngrok.io/
+
+# delegate :start, :stop, :push, to: :delegate
+# set(table:, columns:)
+#
+# connect(connection)
+# builder => self
+
+module Janko
+    class Import
+        include Agrippa::MutableHash
+
+        state_reader :connection
+
+        state_writer :table, prefix: false
+
+        def default_state
+            { columns: Janko::ALL, importer: Janko::CopyImporter }
+        end
+
+        def connect(connection)
+            @state[:connection] = Connection.build(connection)
+            self
+        end
+
+        def use(importer)
+            @state[:importer] = importer
+            self
+        end
+
+        def columns(*columns)
+            @state[:columns] = columns.flatten
+            self
+        end
+
+        def start
+            @state[:started] = true
+            delegate.start
+            self
+        end
+
+        def push(values)
+            raise("Call #start before #push") unless @state[:started]
+            delegate.push(values)
+            self
+        end
+
+        def stop
+            raise("Call #start before #stop") unless @state[:started]
+            delegate.stop
+            @state[:started] = false
+            self
+        end
+
+        private
+
+        def preserve_state_if_started
+            return(self) unless @state[:started]
+            raise("Call #stop before changing import options.")
+        end
+
+        def delegate
+            @delegate ||= @state[:importer].new(delegate_options)
+        end
+
+        def delegate_options
+            raise("No table specified.") unless @state[:table]
+            column_list = ColumnList.build(@state[:columns])
+            raise("No columns specified.") if column_list.empty?
+            @state.merge(columns: column_list)
+        end
+    end
+end

data/lib/janko/insert_importer.rb

@@ -0,0 +1,32 @@
+require "agrippa/mutable"
+
+module Janko
+    class InsertImporter
+        include Agrippa::Mutable
+
+        state_reader :connection, :table, :columns
+
+        def start
+            query = sprintf("INSERT INTO %s(%s) VALUES(%s)", table,
+                columns.to_list, columns.to_binds)
+            connection.prepare(statement_name, query)
+            self
+        end
+
+        def push(values)
+            connection.exec_prepared(statement_name, columns.pack(values))
+            self
+        end
+
+        def stop
+            connection.exec("DEALLOCATE \"#{statement_name}\"")
+            self
+        end
+
+        private
+
+        def statement_name
+            @statement_name ||= "import-#{SecureRandom.hex(8)}"
+        end
+    end
+end

data/lib/janko/merge.rb

@@ -0,0 +1,167 @@
+require "agrippa/mutable_hash"
+require "agrippa/delegation"
+require "janko/connection"
+require "janko/column_list"
+require "janko/single_merge"
+require "janko/bulk_merge"
+
+module Janko
+    class Merge
+        include Agrippa::MutableHash
+
+        include Agrippa::Delegation
+
+        state_writer :table, :locking, :transaction, :collector
+
+        state_reader :table, :connection
+
+        delegate :exec, to: "connection"
+
+        delegate :result, to: "delegate"
+
+        def default_state
+            { strategy: Janko::BulkMerge, connection: Connection.default }
+        end
+
+        def connect(connection)
+            @state[:connection] = Connection.build(connection)
+            self
+        end
+
+        def use(strategy)
+            @state[:strategy] = strategy
+            self
+        end
+
+        def returning(returning)
+            returning = returning.to_s
+            raise("Merge can return inserted, updated, all, or none.") \
+                unless %w(inserted updated all none).include?(returning)
+            chain(returning: returning)
+        end
+
+        def key(*list)
+            preserve_state_if_started
+            columns.tag("key", *list)
+            self
+        end
+
+        def update(*list)
+            preserve_state_if_started
+            columns.tag("update", *list)
+            self
+        end
+
+        def insert(*list)
+            preserve_state_if_started
+            columns.tag("insert", *list)
+            self
+        end
+
+        def select(*list)
+            preserve_state_if_started
+            columns.tag("select", *list)
+            self
+        end
+
+        def alter(*list, &block)
+            preserve_state_if_started
+            columns.alter(*list, &block)
+            self
+        end
+
+        def start
+            @state[:started] = true
+            reset_delegate
+            begin_transaction and lock_table
+            rollback_on_error { delegate.start }
+            self
+        end
+
+        def push(*args)
+            raise("Call #start before #push") unless @state[:started]
+            rollback_on_error { delegate.push(*args) }
+            self
+        end
+
+        def stop
+            raise("Call #start before #stop") unless @state[:started]
+            rollback_on_error { delegate.stop }
+            @state[:started] = false
+            self
+        end
+
+        def columns
+            @state[:columns] ||= begin
+                raise("Connect before setting merge parameters.") \
+                    unless connected?
+                default_column_list
+            end
+        end
+
+        private
+
+        def connected?
+            @state.has_key?(:connection)
+        end
+
+        def default_column_list
+            ColumnList.new(parent: self)
+                .tag(:key, :id)
+                .tag(:select, Janko::ALL)
+                .tag(:insert, Janko::ALL).untag(:insert, :id)
+                .tag(:update, Janko::ALL).untag(:update, :id)
+        end
+
+        def rollback_on_error
+            begin
+                yield
+            rescue
+                raise
+            ensure
+                commit_or_rollback_transaction
+            end
+        end
+
+        def begin_transaction
+            return(self) if connection.in_transaction?
+            return(self) if (@state[:transaction] == false)
+            @state[:our_transaction] == true
+            exec("BEGIN")
+            self
+        end
+
+        def commit_or_rollback_transaction
+            return(self) unless connection.in_transaction?
+            return(self) unless @state.delete(:our_transaction)
+            exec(connection.failed? ? "ROLLBACK" : "COMMIT")
+            self
+        end
+
+        def lock_table
+            return(self) unless connection.in_transaction?
+            return(self) if (@state[:locking] == false)
+            exec("LOCK TABLE #{table} IN SHARE ROW EXCLUSIVE MODE;")
+            self
+        end
+
+        def preserve_state_if_started
+            return(self) unless @state[:started]
+            raise("Call #stop before changing import options.")
+        end
+
+        def delegate
+            @delegate ||= begin
+                strategy_class = @state[:strategy]
+                strategy_class || raise("Set strategy before merging.")
+                strategy_class.new(@state.slice(:connection, :table, 
+                    :returning, :collector).merge(columns: columns))
+            end
+        end
+
+        def reset_delegate
+            @delegate = nil
+            self
+        end
+    end
+end

data/lib/janko/merge_result.rb

@@ -0,0 +1,37 @@
+module Janko
+    class MergeResult
+        include Enumerable
+
+        attr_reader :count
+
+        def initialize
+            @tuples = Hash.new { |h, k| h[k] = [] }
+            @count = 0
+        end
+
+        def push(tag, tuple)
+            @tuples[tag.to_s].push(tuple)
+            @count += 1
+            self
+        end
+
+        def inserted
+            @tuples["inserted"]
+        end
+
+        def updated
+            @tuples["updated"]
+        end
+
+        def clear
+            @tuples.clear
+            self
+        end
+
+        def each(&block)
+            inserted.each(&block)
+            updated.each(&block)
+            self
+        end
+    end
+end

data/lib/janko/single_merge.rb

@@ -0,0 +1,33 @@
+require "janko/merge_result"
+require "janko/upsert"
+
+module Janko
+    class SingleMerge
+        attr_reader :upsert
+
+        def initialize(options = {})
+            @upsert = Upsert.new(options)
+            @options = options
+        end
+
+        def start
+            upsert.result.clear
+            upsert.prepare if @options[:use_prepared_query]
+            self
+        end
+
+        def push(*values)
+            upsert.push(*values)
+            self
+        end
+
+        def stop
+            upsert.cleanup
+            self
+        end
+
+        def result
+            upsert.result
+        end
+    end
+end

data/lib/janko/tagged_column.rb

@@ -0,0 +1,133 @@
+require "janko/constants"
+require "agrippa/state"
+require "agrippa/mutable"
+require "agrippa/delegation"
+
+module Janko
+    include Constants
+
+    class TaggedColumn
+        include Agrippa::Delegation
+
+        include Agrippa::Mutable
+
+        state_reader :tags, :name, :parent
+
+        state_writer :wrap, :default, :on_update, prefix: false
+
+        delegate :table, :connection, to: :parent
+
+        def default_state
+            { tags: {} }
+        end
+
+        def set(updates)
+            chain(updates)
+        end
+
+        def tag(tag)
+            tag = tag.to_s
+            tags.merge!(tag => true) unless (tag == "")
+            self
+        end
+
+        def untag(tag)
+            tag = tag.to_s
+            tags.reject! { |k| k == tag } unless (tag == "")
+            self
+        end
+
+        def has_tag?(tag)
+            tags.has_key?(tag.to_s)
+        end
+
+        def tagged?
+            not tags.empty?
+        end
+
+        def to_s
+            tags.keys.join(" ")
+        end
+
+        def type
+            connection.column_type(table, name)
+        end
+
+        # FIXME: Quoting
+        def quoted(prefix = nil)
+            prefix.nil? ? "\"#{name}\"" : "\"#{prefix}\".\"#{name}\""
+        end
+
+        def to_condition(left, right)
+            "#{quoted(left)} = #{quoted(right)}"
+        end
+
+        def to_setter(left, right)
+            "#{quoted} = #{maybe_on_update(left, right)}"
+        end
+
+        def to_value(prefix = nil)
+            maybe_wrap(nil, prefix)
+        end
+
+        def to_bind(position)
+            "$#{position}"
+        end
+
+        def to_typecast_bind(position)
+            "$#{position}::#{type}"
+        end
+
+        def inspect
+            children = "(#{tags.keys.join(" ")})"
+            "#<#{self.class}:0x#{self.__id__.to_s(16)} #{name}#{children}>"
+        end
+
+        private
+
+        def maybe_wrap(left, right)
+            inner = maybe_default(left, right)
+            return(inner) unless @wrap
+            @wrap.gsub(/\$NEW/i) { inner }
+        end
+
+        def maybe_on_update(left, right)
+            inner = maybe_wrap(left, right)
+            return(inner) unless @on_update
+            output = Agrippa::State.new(@on_update, :gsub)
+            output.gsub(/\$NEW/i) { inner }
+            output.gsub(/\$OLD/i) { quoted(left) }
+            output._value
+        end
+
+        def maybe_default(left, right)
+            values = [ quoted(right) ]
+            values.push(keep_existing_value(left))
+            values.push(column_default_value)
+            values.compact!
+            return(values.first) if (values.length == 1)
+            "COALESCE(#{values.join(", ")})"
+        end
+
+        def keep_existing_value(prefix)
+            return if prefix.nil?
+            return unless (value = @default)
+            return unless (value == Janko::KEEP)
+            quoted(prefix)
+        end
+
+        def column_default_value
+            @column_default_value ||= begin
+                return unless (value = @default)
+                return(value) unless value.is_a?(Flag)
+                return unless (value == Janko::DEFAULT)
+                connection.column_default(table, name)
+            end
+        end
+
+        def flagged(value, flag)
+            return(false) unless value.is_a?(Fixnum)
+            (value & flag) == value
+        end
+    end
+end