evt-event_source-postgres 0.12.1.1 → 0.13.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4b46187f05253e8212ff186ad05a8abbc3dca713
-  data.tar.gz: d2f17eddaf8845b2480b026bb7f10fe28c4dda7d
+  metadata.gz: bcc6eb15d8ed107da6ccd448e0be92c6f93d1cc7
+  data.tar.gz: bf794d6b3d1ffe7c8f514fec02d38e7cca63645d
 SHA512:
-  metadata.gz: f78fb4d3182f54385e4a9356d3c2f3d235c16f45f843fc471761c20a6367cbd0d79c7af0cbe5231af4b38649422b9e184fe74abe2eddf112798bdc961b357c54
-  data.tar.gz: 5b58dcaf4cde0d8b5831cd0c0d64567c9572b05e02f7bb43af24f5d40075463075861f861a984e466cf79349671e2eb34d2bc4359ba39a07bccd2fa53c2a6d21
+  metadata.gz: 22637fcf20e69a19a7b933adec20b0ffc6626abd1319507bbf68f70ba125553beed71ce1f295798e8f0aa1ef22eaff42ac4dd53173a6a54375be08880421c069
+  data.tar.gz: 215c302408bab981a768fec5a3baf8511e3fbec22346dfbf7bcab5be31b7acd0672c322d7651d17bff1357a269d03b57c7c091b247014cced6b71282719b8242

data/lib/event_source/postgres/get.rb

@@ -1,21 +1,21 @@
 module EventSource
   module Postgres
     class Get
-      include Log::Dependency
+      include EventSource::Get
 
-      initializer :batch_size, :precedence
+      initializer :batch_size
 
       dependency :session, Session
 
-      def self.build(batch_size: nil, precedence: nil, session: nil)
-        new(batch_size, precedence).tap do |instance|
+      def self.build(batch_size: nil, session: nil)
+        new(batch_size).tap do |instance|
           instance.configure(session: session)
         end
       end
 
-      def self.configure(receiver, attr_name: nil, position: nil, batch_size: nil, precedence: nil, session: nil)
+      def self.configure(receiver, attr_name: nil, position: nil, batch_size: nil, session: nil)
         attr_name ||= :get
-        instance = build(batch_size: batch_size, precedence: precedence, session: session)
+        instance = build(batch_size: batch_size, session: session)
         receiver.public_send "#{attr_name}=", instance
       end
 
@@ -23,32 +23,32 @@ module EventSource
         Session.configure self, session: session
       end
 
-      def self.call(stream_name, position: nil, batch_size: nil, precedence: nil, session: nil)
-        instance = build(batch_size: batch_size, precedence: precedence, session: session)
+      def self.call(stream_name, position: nil, batch_size: nil, session: nil)
+        instance = build(batch_size: batch_size, session: session)
         instance.(stream_name, position: position)
       end
 
       def call(stream_name, position: nil)
-        logger.trace { "Getting event data (Position: #{position.inspect}, Stream Name: #{stream_name}, Batch Size: #{batch_size.inspect}, Precedence: #{precedence.inspect})" }
+        logger.trace { "Getting event data (Position: #{position.inspect}, Stream Name: #{stream_name}, Batch Size: #{batch_size.inspect})" }
 
         records = get_records(stream_name, position)
 
         events = convert(records)
 
-        logger.info { "Finished getting event data (Count: #{events.length}, Position: #{position.inspect}, Stream Name: #{stream_name}, Batch Size: #{batch_size.inspect}, Precedence: #{precedence.inspect})" }
+        logger.info { "Finished getting event data (Count: #{events.length}, Position: #{position.inspect}, Stream Name: #{stream_name}, Batch Size: #{batch_size.inspect})" }
         logger.info(tags: [:data, :event_data]) { events.pretty_inspect }
 
         events
       end
 
       def get_records(stream_name, position)
-        logger.trace { "Getting records (Stream: #{stream_name}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect}, Precedence: #{precedence.inspect})" }
+        logger.trace { "Getting records (Stream: #{stream_name}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect})" }
 
-        select_statement = SelectStatement.build(stream_name, offset: position, batch_size: batch_size, precedence: precedence)
+        select_statement = SelectStatement.build(stream_name, position: position, batch_size: batch_size)
 
         records = session.execute(select_statement.sql)
 
-        logger.debug { "Finished getting records (Count: #{records.ntuples}, Stream: #{stream_name}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect}, Precedence: #{precedence.inspect})" }
+        logger.debug { "Finished getting records (Count: #{records.ntuples}, Stream: #{stream_name}, Position: #{position.inspect}, Batch Size: #{batch_size.inspect})" }
 
         records
       end

data/lib/event_source/postgres/get/select_statement.rb

@@ -4,20 +4,16 @@ module EventSource
       class SelectStatement
         include Log::Dependency
 
-        initializer :stream, w(:offset), w(:batch_size), w(:precedence)
+        initializer :stream, w(:position), w(:batch_size)
 
-        def offset
-          @offset ||= Defaults.offset
+        def position
+          @position ||= Defaults.position
         end
 
         def batch_size
           @batch_size ||= Defaults.batch_size
         end
 
-        def precedence
-          @precedence ||= Defaults.precedence
-        end
-
         def stream_name
           stream.name
         end
@@ -26,13 +22,13 @@ module EventSource
           stream.type
         end
 
-        def self.build(stream_name, offset: nil, batch_size: nil, precedence: nil)
+        def self.build(stream_name, position: nil, batch_size: nil)
           stream = Stream.new(stream_name)
-          new(stream, offset, batch_size, precedence)
+          new(stream, position, batch_size)
         end
 
         def sql
-          logger.trace(tag: :sql) { "Composing select statement (Stream: #{stream_name}, Category: #{stream.category?}, Type: #{stream_type}, Position: #{offset}, Batch Size: #{batch_size}, Precedence: #{precedence})" }
+          logger.trace(tag: :sql) { "Composing select statement (Stream: #{stream_name}, Category: #{stream.category?}, Type: #{stream_type}, Position: #{position}, Batch Size: #{batch_size})" }
 
           statement = <<-SQL
             SELECT
@@ -47,17 +43,16 @@ module EventSource
             FROM
               events
             WHERE
-              #{where_clause_field} = '#{stream_name}'
+              #{where_clause_field} = '#{stream_name}' AND
+              #{position_field} >= #{position}
             ORDER BY
-              global_position #{precedence.to_s.upcase}
+              #{position_field} ASC
             LIMIT
               #{batch_size}
-            OFFSET
-              #{offset}
             ;
           SQL
 
-          logger.debug(tag: :sql) { "Composed select statement (Stream: #{stream_name}, Category: #{stream.category?}, Type: #{stream_type}, Position: #{offset}, Batch Size: #{batch_size}, Precedence: #{precedence})" }
+          logger.debug(tag: :sql) { "Composed select statement (Stream: #{stream_name}, Category: #{stream.category?}, Type: #{stream_type}, Position: #{position}, Batch Size: #{batch_size})" }
           logger.debug(tags: [:data, :sql]) { "Statement: #{statement}" }
 
           statement
@@ -71,18 +66,22 @@ module EventSource
           end
         end
 
+        def position_field
+          unless stream.category?
+            'position'
+          else
+            'global_position'
+          end
+        end
+
         module Defaults
-          def self.offset
+          def self.position
             0
           end
 
           def self.batch_size
             1000
           end
-
-          def self.precedence
-            :asc
-          end
         end
       end
     end

data/lib/event_source/postgres/read.rb

@@ -3,8 +3,8 @@ module EventSource
     class Read
       include EventSource::Read
 
-      def configure(batch_size: nil, precedence: nil, session: nil)
-        Get.configure(self, batch_size: batch_size, precedence: precedence, session: session)
+      def configure(batch_size: nil, session: nil)
+        Get.configure(self, batch_size: batch_size, session: session)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evt-event_source-postgres
 version: !ruby/object:Gem::Version
-  version: 0.12.1.1
+  version: 0.13.0.0
 platform: ruby
 authors:
 - The Eventide Project
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-25 00:00:00.000000000 Z
+date: 2017-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: evt-event_source