class Ag::Adapters::SequelPullCompact

Adapter that uses the minimum amount of writes while still allowing full historic assembly of timelines. This comes at the cost of slower reads.

Public Class Methods

dehydrate(object) click to toggle source
# File lib/ag/adapters/sequel_pull_compact.rb, line 8
def self.dehydrate(object)
  [object.type, object.id].join(":")
end
hydrate(id) click to toggle source
# File lib/ag/adapters/sequel_pull_compact.rb, line 12
def self.hydrate(id)
  Ag::Object.new(*id.split(":"))
end
new(db) click to toggle source
# File lib/ag/adapters/sequel_pull_compact.rb, line 16
def initialize(db)
  @db = db
end

Public Instance Methods

connect(consumer, producer) click to toggle source
# File lib/ag/adapters/sequel_pull_compact.rb, line 20
def connect(consumer, producer)
  created_at = Time.now.utc
  id = @db[:connections].insert({
    consumer_id: self.class.dehydrate(consumer),
    producer_id: self.class.dehydrate(producer),
    created_at: created_at,
  })

  Connection.new({
    id: id,
    created_at: created_at,
    consumer: consumer,
    producer: producer,
  })
end
connected?(consumer, producer) click to toggle source
# File lib/ag/adapters/sequel_pull_compact.rb, line 54
      def connected?(consumer, producer)
        statement = <<-SQL
          SELECT
            1
          FROM
            connections
          WHERE
            consumer_id = :consumer_id AND
            producer_id = :producer_id
          LIMIT 1
        SQL

        binds = {
          consumer_id: self.class.dehydrate(consumer),
          producer_id: self.class.dehydrate(producer),
        }

        !@db[statement, binds].first.nil?
      end
consumers(producer, options = {}) click to toggle source
# File lib/ag/adapters/sequel_pull_compact.rb, line 74
      def consumers(producer, options = {})
        statement = <<-SQL
          SELECT
            id, created_at, consumer_id, producer_id
          FROM
            connections
          WHERE
            producer_id = :producer_id
          ORDER BY
            id DESC
          LIMIT :limit
          OFFSET :offset
        SQL

        binds = {
          producer_id: self.class.dehydrate(producer),
          limit: options.fetch(:limit, 30),
          offset: options.fetch(:offset, 0),
        }

        @db[statement, binds].to_a.map { |row|
          Connection.new({
            id: row[:id],
            created_at: row[:created_at],
            consumer: self.class.hydrate(row[:consumer_id]),
            producer: self.class.hydrate(row[:producer_id]),
          })
        }
      end
produce(event) click to toggle source
# File lib/ag/adapters/sequel_pull_compact.rb, line 36
def produce(event)
  created_at = event.created_at || Time.now.utc
  id = @db[:events].insert({
    producer_id: self.class.dehydrate(event.producer),
    object_id: self.class.dehydrate(event.object),
    verb: event.verb,
    created_at: created_at,
  })

  Ag::Event.new({
    id: id,
    created_at: created_at,
    producer: event.producer,
    object: event.object,
    verb: event.verb,
  })
end
producers(consumer, options = {}) click to toggle source
# File lib/ag/adapters/sequel_pull_compact.rb, line 104
      def producers(consumer, options = {})
        statement = <<-SQL
          SELECT
            id, created_at, consumer_id, producer_id
          FROM
            connections
          WHERE
            consumer_id = :consumer_id
          ORDER BY
            id DESC
          LIMIT :limit
          OFFSET :offset
        SQL

        binds = {
          consumer_id: self.class.dehydrate(consumer),
          limit: options.fetch(:limit, 30),
          offset: options.fetch(:offset, 0),
        }

        @db[statement, binds].to_a.map { |row|
          Connection.new({
            id: row[:id],
            created_at: row[:created_at],
            consumer: self.class.hydrate(row[:consumer_id]),
            producer: self.class.hydrate(row[:producer_id]),
          })
        }
      end
timeline(consumer, options = {}) click to toggle source
# File lib/ag/adapters/sequel_pull_compact.rb, line 134
      def timeline(consumer, options = {})
        statement = <<-SQL
          SELECT
            e.*
          FROM
            events e
          INNER JOIN
            connections c ON
              e.producer_id = c.producer_id
          WHERE
            c.consumer_id = :consumer_id
          ORDER BY
            e.created_at DESC
          LIMIT :limit
          OFFSET :offset
        SQL

        binds = {
          consumer_id: self.class.dehydrate(consumer),
          limit: options.fetch(:limit, 30),
          offset: options.fetch(:offset, 0),
        }

        @db[statement, binds].to_a.map { |row|
          Ag::Event.new({
            id: row[:id],
            created_at: row[:created_at],
            producer: self.class.hydrate(row[:producer_id]),
            object: self.class.hydrate(row[:object_id]),
            verb: row[:verb],
          })
        }
      end