swift 0.4.1

data/lib/swift.rb

@@ -0,0 +1,48 @@
+# Extension.
+require_relative '../ext/swift'
+require_relative 'swift/adapter'
+require_relative 'swift/attribute'
+require_relative 'swift/db'
+require_relative 'swift/header'
+require_relative 'swift/scheme'
+require_relative 'swift/type'
+
+module Swift
+  class << self
+    def setup name, type, options = {}
+      unless type.kind_of?(Class) && type < Swift::Adapter
+        raise TypeError, "Expected +type+ Swift::Adapter subclass but got #{type.inspect}"
+      end
+      (@repositories ||= {})[name] = type.new(options)
+    end
+
+    def db name = nil, &block
+      # I pilfered the logic from DM but I don't really understand what is/isn't thread safe.
+      scopes     = (Thread.current[:swift_db] ||= [])
+      repository = if name || scopes.empty?
+        @repositories[name || :default] or raise "Unknown db '#{name || :default}', did you forget to #setup?"
+      else
+        scopes.last
+      end
+
+      if block_given?
+        begin
+          scopes.push(repository)
+          block.call(repository)
+        ensure
+          scopes.pop
+        end
+      end
+      repository
+    end
+
+    def schema
+      @schema ||= []
+    end
+
+    def migrate! name = nil
+      db(name){ schema.each(&:migrate!)}
+    end
+  end
+end # Swift
+

data/lib/swift/adapter.rb

@@ -0,0 +1,120 @@
+module Swift
+  #--
+  # TODO: Still not convinced all and first are necessary.
+  class Adapter
+    attr_reader :options
+
+    def identity_map
+      @identity_map ||= IdentityMap.new
+    end
+
+    def get scheme, keys
+      relation = scheme.new(keys)
+      prepare_get(scheme).execute(*relation.tuple.values_at(*scheme.header.keys)).first
+    end
+
+    def all scheme, conditions = '', *binds, &block
+      where = "where #{exchange_names(scheme, conditions)}" unless conditions.empty?
+      prepare(scheme, "select * from #{scheme.store} #{where}").execute(*binds, &block)
+    end
+
+    def first scheme, conditions = '', *binds, &block
+      all(scheme, "#{conditions} limit 1", *binds, &block).first
+    end
+
+    def create scheme, *relations
+      statement = prepare_create(scheme)
+      relations.map do |relation|
+        relation = scheme.new(relation) unless relation.kind_of?(scheme)
+        if statement.execute(*relation.tuple.values_at(*scheme.header.insertable)) && scheme.header.serial
+          relation.tuple[scheme.header.serial] = statement.insert_id
+        end
+        relation
+      end
+    end
+
+    def update scheme, *relations
+      statement = prepare_update(scheme)
+      relations.map do |relation|
+        relation = scheme.new(relation) unless relation.kind_of?(scheme)
+        statement.execute(*relation.tuple.values_at(*scheme.header.updatable, *scheme.header.keys))
+      end
+    end
+
+    def destroy scheme, *relations
+      statement = prepare_destroy(scheme)
+      relations.map do |relation|
+        relation = scheme.new(relation) unless relation.kind_of?(scheme)
+        if result = statement.execute(*relation.tuple.values_at(*scheme.header.keys))
+          relation.freeze
+        end
+        result
+      end
+    end
+
+    def migrate! scheme
+      keys   =  scheme.header.keys
+      fields =  scheme.header.map{|p| field_definition(p)}.join(', ')
+      fields += ", primary key (#{keys.join(', ')})" unless keys.empty?
+
+      execute("drop table if exists #{scheme.store}")
+      execute("create table #{scheme.store} (#{fields})")
+    end
+
+    protected
+      def exchange_names scheme, query
+        query.gsub(/:(\w+)/){ scheme.send($1.to_sym).field }
+      end
+
+      def returning?
+        raise NotImplementedError
+      end
+
+      def prepare_cached scheme, name, &block
+        @prepared               ||= Hash.new{|h,k| h[k] = Hash.new} # Autovivification please Matz!
+        @prepared[scheme][name] ||= prepare(scheme, yield)
+      end
+
+      def prepare_get scheme
+        prepare_cached(scheme, :get) do
+          where = scheme.header.keys.map{|key| "#{key} = ?"}.join(' and ')
+          "select * from #{scheme.store} where #{where} limit 1"
+        end
+      end
+
+      def prepare_create scheme
+        prepare_cached(scheme, :create) do
+          values    = (['?'] * scheme.header.insertable.size).join(', ')
+          returning = "returning #{scheme.header.serial}" if scheme.header.serial and returning?
+          "insert into #{scheme.store} (#{scheme.header.insertable.join(', ')}) values (#{values}) #{returning}"
+        end
+      end
+
+      def prepare_update scheme
+        prepare_cached(scheme, :update) do
+          set   = scheme.header.updatable.map{|field| "#{field} = ?"}.join(', ')
+          where = scheme.header.keys.map{|key| "#{key} = ?"}.join(' and ')
+          "update #{scheme.store} set #{set} where #{where}"
+        end
+      end
+
+      def prepare_destroy scheme
+        prepare_cached(scheme, :destroy) do
+          where = scheme.header.keys.map{|key| "#{key} = ?"}.join(' and ')
+          "delete from #{scheme.store} where #{where}"
+        end
+      end
+
+      def field_definition attribute
+        "#{attribute.field} " + case attribute
+          when Type::String     then 'text'
+          when Type::Integer    then attribute.serial ? 'serial' : 'integer'
+          when Type::Float      then 'float'
+          when Type::BigDecimal then 'numeric'
+          when Type::Time       then 'timestamp'
+          when Type::Boolean    then 'boolean'
+          else 'text'
+        end
+      end
+  end # Adapter
+end # Swift

data/lib/swift/attribute.rb

@@ -0,0 +1,25 @@
+module Swift
+  class Attribute
+    attr_reader :name, :field, :key, :serial
+
+    def initialize scheme, name, options = {}
+      @name      = name
+      @default   = options.fetch(:default, nil)
+      @field     = options.fetch(:field,   name)
+      @key       = options.fetch(:key,     false)
+      @serial    = options.fetch(:serial,  false)
+      define_scheme_methods(scheme)
+    end
+
+    def default
+      @default.respond_to?(:call) ? @default.call : (@default.nil? ? nil : @default.dup)
+    end
+
+    def define_scheme_methods scheme
+      scheme.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{name};        tuple.fetch(:#{field})        end
+        def #{name}= value; tuple.store(:#{field}, value) end
+      RUBY
+    end
+  end # Attribute
+end # Swift

data/lib/swift/db.rb

@@ -0,0 +1,39 @@
+module Swift
+  module DB
+    class Mysql < Adapter
+      def initialize options = {}
+        super options.update(driver: 'mysql')
+        execute('select unix_timestamp() - unix_timestamp(utc_timestamp()) as offset') {|r| @tzoffset = r[:offset] }
+      end
+
+      def timezone *args
+        super(*args)
+        execute('select unix_timestamp() - unix_timestamp(utc_timestamp()) as offset') {|r| @tzoffset = r[:offset] }
+        @tzoffset
+      end
+
+      def returning?
+        false
+      end
+    end # Mysql
+
+    class Postgres < Adapter
+      def initialize options = {}
+        super options.update(driver: 'postgresql')
+        sql = "select extract(epoch from now())::bigint - extract(epoch from now() at time zone 'UTC')::bigint"
+        execute('%s as offset' % sql) {|r| @tzoffset = r[:offset] }
+      end
+
+      def timezone *args
+        super(*args)
+        sql = "select extract(epoch from now())::bigint - extract(epoch from now() at time zone 'UTC')::bigint"
+        execute('%s as offset' % sql) {|r| @tzoffset = r[:offset] }
+        @tzoffset
+      end
+
+      def returning?
+        true
+      end
+    end # Postgres
+  end # DB
+end # Swift

data/lib/swift/header.rb

@@ -0,0 +1,45 @@
+module Swift
+  class Header
+    include Enumerable
+
+    def initialize *attributes
+      @attributes = {}
+      push *attributes unless attributes.empty?
+    end
+
+    def new_tuple
+      Hash[insertable.map{|field| [field, @attributes[field].default]}]
+    end
+
+    def push *attributes
+      @attributes.update Hash[attributes.map{|attribute| [attribute.field, attribute]}]
+    end
+
+    def insertable
+      @insertable ||= all - [serial]
+    end
+
+    def updatable
+      @updatable ||= all - (keys | [serial])
+    end
+
+    def all
+      @all ||= @attributes.keys
+    end
+
+    def serial
+      return @serial if defined? @serial
+      serial  = find(&:serial)
+      @serial = serial ? serial.field : nil
+    end
+
+    def keys
+      @keys ||= select(&:key).map(&:field)
+    end
+
+    def each &block
+      @attributes.values.each{|v| yield v}
+    end
+  end # Header
+end # Swift
+

data/lib/swift/identity_map.rb

@@ -0,0 +1,41 @@
+module Swift
+  # Weak hash set.
+  #--
+  # TODO: Is 'hash set' the real name for a hash where both the keys and values must be unique?
+  class IdentityMap
+    def initialize
+      @cache, @reverse_cache, @finalize = {}, {}, method(:finalize)
+    end
+
+    def get key
+      value_id = @cache[key]
+      return ObjectSpace._id2ref(value_id) unless value_id.nil?
+      nil
+    end
+
+    #--
+    # TODO: Barf if the value.object_id already exists in the cache.
+    def set key, value
+      @reverse_cache[value.object_id] = key
+      @cache[key]                     = value.object_id
+      ObjectSpace.define_finalizer(value, @finalize)
+    end
+
+    private
+      def finalize value_id
+        @cache.delete @reverse_cache.delete value_id
+      end
+  end # IdentityMap
+
+  class Scheme
+    def self.load tuple
+      im = [self, *tuple.values_at(*header.keys)]
+      unless scheme = Swift.db.identity_map.get(im)
+        scheme       = allocate
+        scheme.tuple = tuple
+        Swift.db.identity_map.set(im, scheme)
+      end
+      scheme
+    end
+  end # Scheme
+end # Swift

data/lib/swift/pool.rb

@@ -0,0 +1,74 @@
+require 'eventmachine'
+
+module Swift
+  class Pool
+    module Handler
+      def initialize request, pool
+        @request, @pool = request, pool
+      end
+
+      def socket
+        @request.socket
+      end
+
+      def notify_readable
+        if @request.process
+          detach
+          @pool.detach self
+        end
+      end
+    end # Handler
+
+    def initialize size, options
+      @pool         = Swift::ConnectionPool.new size, options
+      @stop_reactor = EM.reactor_running? ? false : true
+      @pending      = {}
+      @queue        = []
+    end
+
+    def attach c
+      @pending[c] = true
+    end
+
+    def detach c
+      @pending.delete(c)
+      if @queue.empty?
+        EM.stop if @stop_reactor && @pending.empty?
+      else
+        sql, bind, callback = @queue.shift
+        execute(sql, *bind, &callback)
+      end
+    end
+
+    def attached? fd
+      @pending.keys.select{|c| c.socket == fd}.length > 0
+    end
+
+    def execute sql, *bind, &callback
+      request = @pool.execute sql, *bind, &callback
+      # TODO EM throws exceptions in C++ land which are not trapped in the extension.
+      #      This is somehow causing everything to unravel and result in a segfault which
+      #      I cannot track down. I'll buy a beer for someone who can get this fixed :)
+      #      Oh, here it throws an exception if we try to attach same fd twice.
+      if request && !attached?(request.socket)
+        EM.watch(request.socket, Handler, request, self) do |c|
+          attach c
+          c.notify_writable = false
+          c.notify_readable = true
+        end
+      else
+        @queue << [ sql, bind, callback ]
+      end
+    end
+
+    def run &block
+      EM.run{ yield self }
+    end
+  end # Pool
+
+  def self.pool size, name = :default, &block
+    pool = Pool.new(size, Swift.db(name).options)
+    pool.run(&block) if block_given?
+    pool
+  end
+end # Swift

data/lib/swift/scheme.rb

@@ -0,0 +1,70 @@
+module Swift
+  class Scheme
+    attr_accessor :tuple
+    alias_method :scheme, :class
+
+    def initialize options = {}
+      @tuple = scheme.header.new_tuple
+      options.each{|k, v| send(:"#{k}=", v)}
+    end
+
+    def update options = {}
+      options.each{|k, v| send(:"#{k}=", v)}
+      Swift.db.update(scheme, self)
+    end
+
+    def destroy
+      Swift.db.destroy(scheme, self)
+    end
+
+    class << self
+      attr_accessor :header
+
+      def inherited klass
+        klass.header = Header.new
+        klass.header.push(*header) if header
+        Swift.schema.push(klass)   if klass.name
+      end
+
+      def load tuple
+        scheme       = allocate
+        scheme.tuple = tuple
+        scheme
+      end
+
+      def attribute name, type, options = {}
+        header.push(attribute = type.new(self, name, options))
+        (class << self; self end).send(:define_method, name, lambda{ attribute })
+      end
+
+      def store name = nil
+        name ? @store = name : @store
+      end
+
+      def migration &migration
+        (class << self; self end).send(:define_method, :migrate!, lambda{ Swift.db.instance_eval(&migration) })
+      end
+
+      def migrate!
+        Swift.db.migrate!(self)
+      end
+
+      def create options = {}
+        Swift.db.create(self, options)
+      end
+
+      def get keys
+        Swift.db.get(self, keys)
+      end
+
+      def all conditions = '', *binds, &block
+        Swift.db.all(self, conditions, *binds, &block)
+      end
+
+      def first conditions = '', *binds, &block
+        Swift.db.first(self, conditions, *binds, &block)
+      end
+    end
+  end # Scheme
+end # Swift
+