em-postgres 0.0.1 → 0.0.2

data/README

@@ -1,9 +1,8 @@
 Async PostgreSQL driver for Ruby/EventMachine
-  based off Aman Gupta's mysql driver
-
 
 Requires pg
 
+To run the specs, you will need rspec, run "rspec spec/postgres_spec.rb"
 
 
 TODOS:

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/lib/em-postgres/connection.rb

@@ -83,7 +83,7 @@ module EventMachine
 
     def notify_readable
       if item = @current
-        sql, cblk, eblk, retries = item
+        sql,params, cblk, eblk, retries = item
         #results = []
         #result = nil
         #@postgres.get_result{|r| result = r}
@@ -100,7 +100,6 @@ module EventMachine
           end
           #puts "\n\nQuery result:\n%p\n" % [ result.values ]
         end
-        
         unless @postgres.error_message == ""
           #TODO this is wrong
           eb = (eblk || @opts[:on_error])
@@ -130,7 +129,7 @@ module EventMachine
         next_query
 
       elsif DisconnectErrors.include? e.message
-        @queue << [sql, cblk, eblk, retries + 1]
+        @queue << [sql,params, cblk, eblk, retries + 1]
         return #close
 
       elsif cb = (eblk || @opts[:on_error])
@@ -158,7 +157,6 @@ module EventMachine
     end
     
     def reconnect
-      puts "DDDDD"
       @processing = false
       @postgres = @conn.connect_socket(@opts)
       @fd = @postgres.socket
@@ -173,35 +171,41 @@ module EventMachine
       EM.add_timer(1) { reconnect }
     end
 
-
-    def execute(sql, cblk = nil, eblk = nil, retries = 0)
-      
+    def execute(sql,params=nil, cblk = nil, eblk = nil, retries = 0)
       begin
         if not @processing or not @connected
         #if !@processing || !@connected
           @processing = true
-
-          @postgres.send_query(sql)          
+            
+          if sql =~ /\s+/
+            @postgres.send_query(sql,params)
+          else
+            @postgres.send_query_prepared(sql,params)
+          end
         else          
-          @queue << [sql, cblk, eblk, retries]
+          @queue << [sql,params, cblk, eblk, retries]
           return
         end
 
       rescue Exception => e
         puts "error in execute #{e}"
         if DisconnectErrors.include? e.message
-          @queue << [sql, cblk, eblk, retries]
+          @queue << [sql,params, cblk, eblk, retries]
           return #close
         else
           raise e
         end
       end
-      @current = [sql, cblk, eblk, retries]
+      @current = [sql,params, cblk, eblk, retries]
     end
 
     # act like the pg driver
     def method_missing(method, *args, &blk)
-      @postgres.send(method, *args, &blk) if @postres.respond_to? method
+      if @postgres.respond_to? method
+        @postgres.send(method, *args, &blk) 
+      else
+        super
+      end
     end
 
     def close
@@ -215,8 +219,8 @@ module EventMachine
 
       def next_query
         if @connected and !@processing and pending = @queue.shift
-          sql, cblk, eblk = pending
-          execute(sql, cblk, eblk)
+          sql, params, cblk, eblk = pending
+          execute(sql, params, cblk, eblk)
         end
       end
 

data/lib/em-postgres/postgres.rb

@@ -56,13 +56,12 @@ module EventMachine
       @connection.close
     end
 
-    def query(sql, &blk)
+    def query(sql,params=[], &blk)
       df = EventMachine::DefaultDeferrable.new
       cb = blk || Proc.new { |r| df.succeed(r) }
       eb = Proc.new { |r| df.fail(r) }
-
-      @connection.execute(sql, cb, eb)
-
+      
+      @connection.execute(sql,params,cb,eb)
       df
     end
     alias :real_query :query

data/lib/sequel/async.rb

@@ -0,0 +1,184 @@
+# async sequel extensions, for use with em-mysql
+#
+#   require 'em/mysql'
+#   DB = Sequel.connect(:adapter => 'mysql', :user => 'root', :database => 'test', ...)
+#   EventedMysql.settings.update(..., :on_error => proc{|e| log 'error', e })
+#
+#   def log *args
+#     p [Time.now, *args]
+#   end
+#
+#   DB[:table].where(:id < 100).async_update(:field => 'new value') do |num_updated|
+#     log "done updating #{num_updated} rows"
+#   end
+#
+#   DB[:table].async_insert(:field => 'value') do |insert_id|
+#     log "inserted row #{insert_id}"
+#   end
+#
+#   DB[:table].async_multi_insert([:field], [ ['one'], ['two'], ['three'] ]) do
+#     log "done inserting 3 rows"
+#   end
+#
+#   DB[:table].limit(10).async_each do |row|
+#     log "got a row", row
+#   end; log "this will be printed before the query returns"
+#
+#   DB[:table].async_all do |rows|
+#     DB[:table].async_multi_insert([:field], rows.map{|r| "new_#{r[:field]}" })
+#   end
+#
+#   DB[:table].async_all do |rows|
+#     num = rows.size
+#
+#     rows.each{ |r|
+#       DB[:table].where(:id => r[:id]).async_update(:field => rand(10000).to_s) do
+#         num = num-1
+#         if num == 0
+#           log "last update completed"
+#         end
+#       end
+#     }
+#   end
+#
+#   DB[:table].async_count do |num_rows|
+#     log "table has #{num_rows} rows"
+#   end
+
+require 'sequel'
+raise 'need Sequel >= 3.2.0' unless Sequel::MAJOR == 3 and Sequel::MINOR >= 2
+
+module Sequel
+  class Dataset
+    def async_insert *args, &cb
+      EventedMysql.insert insert_sql(*args), &cb
+      nil
+    end
+
+    def async_insert_ignore *args, &cb
+      EventedMysql.insert insert_ignore.insert_sql(*args), &cb
+      nil
+    end
+
+    def async_update *args, &cb
+      EventedMysql.update update_sql(*args), &cb
+      nil
+    end
+
+    def async_delete &cb
+      EventedMysql.execute delete_sql, &cb
+      nil
+    end
+
+    def async_multi_insert *args, &cb
+      EventedMysql.execute multi_insert_sql(*args).first, &cb
+      nil
+    end
+
+    def async_multi_insert_ignore *args, &cb
+      EventedMysql.execute insert_ignore.multi_insert_sql(*args).first, &cb
+      nil
+    end
+
+    def async_fetch_rows sql, iter = :each
+      EventedMysql.raw(sql) do |m|
+        r = m.result
+
+        i = -1
+        cols = r.fetch_fields.map{|f| [output_identifier(f.name), Sequel::MySQL::MYSQL_TYPES[f.type], i+=1]}
+        @columns = cols.map{|c| c.first}
+        rows = []
+        while row = r.fetch_row
+          h = {}
+          cols.each{|n, p, i| v = row[i]; h[n] = (v && p) ? p.call(v) : v}
+          if iter == :each
+            yield h
+          else
+            rows << h
+          end
+        end
+        yield rows if iter == :all
+      end
+      nil
+    end
+
+    def async_each
+      async_fetch_rows(select_sql, :each) do |r|
+        if row_proc = @row_proc
+          yield row_proc.call(r)
+        else
+          yield r
+        end
+      end
+      nil
+    end
+
+    def async_all
+      async_fetch_rows(sql, :all) do |rows|
+        if row_proc = @row_proc
+          yield(rows.map{|r| row_proc.call(r) })
+        else
+          yield(rows)
+        end
+      end
+      nil
+    end
+
+    def async_count &cb
+      if options_overlap(COUNT_FROM_SELF_OPTS)
+        from_self.async_count(&cb)
+      else
+        clone(STOCK_COUNT_OPTS).async_each{|r|
+          yield r.is_a?(Hash) ? r.values.first.to_i : r.values.values.first.to_i
+        }
+      end
+      nil
+    end
+  end
+
+  class Model
+    def async_update *args, &cb
+      this.async_update(*args, &cb)
+      set(*args)
+      self
+    end
+
+    def async_delete &cb
+      this.async_delete(&cb)
+      nil
+    end
+
+    class << self
+      [ :async_insert,
+        :async_insert_ignore,
+        :async_multi_insert,
+        :async_multi_insert_ignore,
+        :async_each,
+        :async_all,
+        :async_update,
+        :async_count ].each do |method|
+        class_eval %[
+          def #{method} *args, &cb
+            dataset.#{method}(*args, &cb)
+          end
+        ]
+      end
+
+      # async version of Model#[]
+      def async_lookup args
+        unless Hash === args
+          args = primary_key_hash(args)
+        end
+
+        dataset.where(args).limit(1).async_all{ |rows|
+          if rows.any?
+            yield rows.first
+          else
+            yield nil
+          end
+        }
+        nil
+      end
+    end
+  end
+end

data/spec/helper.rb

@@ -3,4 +3,4 @@ require "rubygems"
 require "eventmachine"
 require "rspec"
 require "em-postgres"
-require "ruby-debug"
+#require "ruby-debug"

data/spec/postgres_spec.rb

@@ -1,6 +1,5 @@
 $LOAD_PATH << File.join(File.dirname(__FILE__))
 require "helper"
-require "ruby-debug"
 describe EventMachine::Postgres do
   
   it "should be true" do
@@ -54,7 +53,17 @@ describe EventMachine::Postgres do
     }
   end
 
-
+  it "should accept paramaters" do
+    EventMachine.run {
+      conn = EventMachine::Postgres.new(:database => 'test')
+      conn.execute("select $1::int AS first,$2::int AS second,$3::varchar AS third;",[1,nil,'']) { |res|        
+        res.first["first"].should == "1"
+        res.first["second"].should == nil
+        res.first["third"].should == ""
+        EventMachine.stop
+      }
+    }
+  end
 
   it "allow custom error callbacks for each query" do
     EventMachine.run {
@@ -75,11 +84,9 @@ describe EventMachine::Postgres do
       conn = EventMachine::Postgres.new(:database => 'test')
 
       results = []
-      #debugger
       conn.execute("select 1 AS x;") {|res| puts res.inspect; results.push(res.first["x"].to_i)}
       conn.execute("select 2 AS x;") {|res| puts res.inspect;results.push(res.first["x"].to_i)}
       conn.execute("select 3 AS x;") {|res| puts res.inspect;results.push(res.first["x"].to_i)}
-      #debugger
       EventMachine.add_timer(0.05) {
         results.should == [1,2,3]
         #conn.connection_pool.first.close
@@ -124,6 +131,35 @@ describe EventMachine::Postgres do
     }
   end
 
+  it "should work with bind parameters" do
+    EventMachine.run {
+      conn = EventMachine::Postgres.new(:database=> 'test')
+      conn.execute("select $1::int as bind1;",[4]){|r|
+        r.first["bind1"].to_i.should == 4
+      }
+      conn.execute("select $1::text as bind1;",['four']){|r|
+        r.first["bind1"].should == 'four'
+        EventMachine.stop
+      }
+      
+    }
+  end
+  
+  it "should allow the creation of a prepare statement" do
+    EventMachine.run {
+      conn = EventMachine::Postgres.new(:database=> 'test')
+      prepare_name = "random#{rand(69)}"
+      i = rand(69)
+      conn.prepare(prepare_name,"select #{i};")
+      conn.execute(prepare_name){|r|
+        r.first["?column?"].to_i.should == i
+        EventMachine.stop
+      }      
+    }
+  end
+  
+  
+
 =begin
   it "should work with synchronous commands" do
     EventMachine.run {

data/test.rb

@@ -0,0 +1,59 @@
+require 'lib/em/postgres'
+
+# EM.kqueue
+# EM.epoll
+EM.run{
+  EM.start_server '127.0.0.1', 12345 do |c|
+    def c.receive_data data
+      p 'sending http response'
+      send_data "hello"
+      close_connection_after_writing
+    end
+  end
+
+  SQL = EventedPostgres
+  def SQL(query, &blk) SQL.select(query, &blk) end
+
+  if true
+
+    SQL.settings.update :logging => true,
+                        :database => 'test',
+                        :connections => 1
+
+    SQL.execute('select 1+2')
+
+    EM.add_timer(1){
+      3.times do SQL.select('select sleep(0.5)+1'){|r| p(r) } end
+    }
+
+  elsif false
+
+    SQL.settings.update :logging => true,
+                        :database => 'test',
+                        :connections => 10
+
+    EM.add_timer(2.5){ SQL.all('use test') }
+
+  else
+
+    SQL.settings.update :logging => true,
+                        :database => 'test',
+                        :connections => 10,
+                        :timeout => 1
+
+    n = 0
+
+    SQL.execute('drop table if exists testingabc'){
+      SQL.execute('create table testingabc (a int, b int, c int)'){
+        EM.add_periodic_timer(0.2) do
+          cur_num = n+=1
+          SQL.execute("insert into testingabc values (1,2,#{cur_num})"){
+            SQL("select * from testingabc where c = #{cur_num} limit 1"){ |res| puts;puts }
+          }
+        end
+      }
+    }
+
+  end
+
+}

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: em-postgres
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 1
-  version: 0.0.1
+  prerelease: 
+  version: 0.0.2
 platform: ruby
 authors: 
 - Jason Toy
@@ -14,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-25 00:00:00 -07:00
-default_executable: 
+date: 2012-01-20 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: eventmachine
@@ -25,31 +20,29 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 12
-        - 9
         version: 0.12.9
   type: :runtime
   version_requirements: *id001
-description: Async PostgreSQL client API for Ruby/EventMachine
+description: Async PostgreSQL driver for Ruby/Eventmachine
 email: jtoy@jtoy.net
 executables: []
 
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- README
 files: 
 - README
 - Rakefile
+- VERSION
 - em-postgres.gemspec
-- lib/em-postgres/postgres.rb
-- lib/em-postgres/connection.rb
 - lib/em-postgres.rb
+- lib/em-postgres/connection.rb
+- lib/em-postgres/postgres.rb
+- lib/sequel/async.rb
 - spec/helper.rb
 - spec/postgres_spec.rb
-has_rdoc: true
+- test.rb
 homepage: http://github.com/jtoy/em-postgres
 licenses: []
 
@@ -63,23 +56,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.3.7
+rubyforge_project: em-postgres
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: Async PostgreSQL client API for Ruby/EventMachine
+summary: Async PostgreSQL driver for Ruby/Eventmachine
 test_files: []