pod4 0.10.6 → 1.0.0

data/lib/pod4/pg_interface.rb

@@ -1,16 +1,17 @@
-require 'octothorpe'
-require 'date'
-require 'time'
-require 'bigdecimal'
+require "octothorpe"
+require "date"
+require "time"
+require "bigdecimal"
 
-require_relative 'interface'
-require_relative 'errors'
-require_relative 'sql_helper'
+require_relative "interface"
+require_relative "connection_pool"
+require_relative "errors"
+require_relative "sql_helper"
 
 
 module Pod4
 
-
+  
   ##
   # Pod4 Interface for requests on a SQL table via pg, the PostgresQL adapter.
   #
@@ -20,7 +21,7 @@ module Pod4
   #     class CustomerInterface < SwingShift::PgInterface
   #       set_schema :public    # optional
   #       set_table  :customer
-  #       set_id_fld :id
+  #       set_id_fld :id, autoincrement: true
   #     end
   #
   class PgInterface < Interface
@@ -28,7 +29,6 @@ module Pod4
 
     attr_reader :id_fld
 
-
     class << self
       #--
       # These are set in the class because it keeps the model code cleaner: the definition of the
@@ -60,42 +60,48 @@ module Pod4
       ##
       # Set the name of the column that holds the unique id for the table.
       #
-      def set_id_fld(idFld)
+      def set_id_fld(idFld, opts={})
+        ai = opts.fetch(:autoincrement) { true }
         define_class_method(:id_fld) {idFld.to_s.to_sym}
+        define_class_method(:id_ai)  {!!ai}
       end
 
       def id_fld
         raise Pod4Error, "You need to use set_id_fld to set the ID column"
       end
 
-    end
-    ##
+      def id_ai
+        raise Pod4Error, "You need to use set_id_fld to set the ID column"
+      end
 
+    end # of class << self
 
     ##
-    # Initialise the interface by passing it a Pg connection hash. For testing ONLY you can also
-    # pass an object which pretends to be a Pg client, in which case the hash is pretty much
-    # ignored.
+    # Initialise the interface by passing it a Pg connection hash, or a Pod4::ConnectionPool
+    # object.
     #
-    def initialize(connectHash, testClient=nil)
-      raise(ArgumentError, 'invalid connection hash') unless connectHash.kind_of?(Hash)
+    def initialize(arg)
+      case arg
+        when Hash
+          @connection = ConnectionPool.new(interface: self.class)
+          @connection.data_layer_options = arg
 
-      @connect_hash = connectHash.dup
-      @test_client  = testClient 
-      @client       = nil
+        when ConnectionPool
+          @connection = arg
+
+        else
+          raise ArgumentError, "Bad argument"
+      end
 
     rescue => e
       handle_error(e)
     end
 
-
     def schema; self.class.schema; end
     def table;  self.class.table;  end
     def id_fld; self.class.id_fld; end
+    def id_ai;  self.class.id_ai;  end
 
-
-    ##
-    #
     def list(selection=nil)
       raise(ArgumentError, 'selection parameter is not a hash') \
         unless selection.nil? || selection.respond_to?(:keys)
@@ -107,26 +113,32 @@ module Pod4
       handle_error(e)
     end
 
-
     ##
-    # Record is a hash of field: value
+    # Record is a hash or octothorpe of field: value
     #
     # By a happy coincidence, insert returns the unique ID for the record, which is just what we
     # want to do, too.
     #
     def create(record)
-      raise(ArgumentError, "Bad type for record parameter") \
-        unless record.kind_of?(Hash) || record.kind_of?(Octothorpe)
+      raise Octothorpe::BadHash if record.nil?
+      ot = Octothorpe.new(record)
+
+      if id_ai
+        ot = ot.reject{|k,_| k == id_fld}
+      else
+        raise(ArgumentError, "ID field missing from record") if ot[id_fld].nil?
+      end
 
-      sql, vals = sql_insert(record) 
+      sql, vals = sql_insert(ot) 
       x = selectp(sql, *vals)
       x.first[id_fld]
 
-    rescue => e
-      handle_error(e)
+    rescue Octothorpe::BadHash
+      raise ArgumentError, "Bad type for record parameter"
+    rescue
+      handle_error $!
     end
 
-
     ##
     # ID corresponds to whatever you set in set_id_fld
     #
@@ -146,9 +158,8 @@ module Pod4
       handle_error(e)
     end
 
-
     ##
-    # ID is whatever you set in the interface using set_id_fld record should be a Hash or
+    # ID is whatever you set in the interface using set_id_fld; record should be a Hash or
     # Octothorpe.
     #
     def update(id, record)
@@ -166,7 +177,6 @@ module Pod4
       handle_error(e)
     end
 
-
     ##
     # ID is whatever you set in the interface using set_id_fld
     #
@@ -182,7 +192,6 @@ module Pod4
       handle_error(e)
     end
 
-
     ##
     # Run SQL code on the server. Return the results.
     #
@@ -198,12 +207,11 @@ module Pod4
     def select(sql)
       raise(ArgumentError, "Bad SQL parameter") unless sql.kind_of?(String)
 
-      ensure_connection
-
+      client = ensure_connection
       Pod4.logger.debug(__FILE__){ "select: #{sql}" }
 
       rows = []
-      @client.exec(sql) do |query|
+      client.exec(sql) do |query|
         oids = make_oid_hash(query)
 
         query.each do |r| 
@@ -218,15 +226,13 @@ module Pod4
         end
       end
 
-      @client.cancel 
-
+      client.cancel 
       rows
 
     rescue => e
       handle_error(e)
     end
 
-
     ##
     # Run SQL code on the server as per select() but with parameter insertion.
     #
@@ -236,12 +242,11 @@ module Pod4
     def selectp(sql, *vals)
       raise(ArgumentError, "Bad SQL parameter") unless sql.kind_of?(String)
 
-      ensure_connection
-
+      client = ensure_connection
       Pod4.logger.debug(__FILE__){ "select: #{sql} #{vals.inspect}" }
 
       rows = []
-      @client.exec_params( *parse_for_params(sql, vals) ) do |query|
+      client.exec_params( *parse_for_params(sql, vals) ) do |query|
         oids = make_oid_hash(query)
 
         query.each do |r| 
@@ -256,30 +261,27 @@ module Pod4
         end
       end
 
-      @client.cancel 
+      client.cancel 
       rows
 
     rescue => e
       handle_error(e)
     end
 
-
     ##
     # Run SQL code on the server; return true or false for success or failure
     #
     def execute(sql)
       raise(ArgumentError, "Bad SQL parameter") unless sql.kind_of?(String)
 
-      ensure_connection
-
+      client = ensure_connection
       Pod4.logger.debug(__FILE__){ "execute: #{sql}" }
-      @client.exec(sql)
+      client.exec(sql)
 
     rescue => e
       handle_error(e)
     end
 
-
     ##
     # Run SQL code on the server as per execute() but with parameter insertion.
     #
@@ -289,105 +291,90 @@ module Pod4
     def executep(sql, *vals)
       raise(ArgumentError, "Bad SQL parameter") unless sql.kind_of?(String)
 
-      ensure_connection
-
+      client = ensure_connection
       Pod4.logger.debug(__FILE__){ "parameterised execute: #{sql}" }
-      @client.exec_params( *parse_for_params(sql, vals) )
+      client.exec_params( *parse_for_params(sql, vals) )
 
     rescue => e
       handle_error(e)
     end
 
-
-    private
-
-
     ##
     # Open the connection to the database.
     #
-    # No parameters are needed: the option hash has everything we need.
+    # This is called from a Connection Object.
     #
-    def open
+    def new_connection(params)
       Pod4.logger.info(__FILE__){ "Connecting to DB" }
 
-      client = @test_Client || PG.connect(@connect_hash)
-      raise DataBaseError, "Bad Connection" \
-        unless client.status == PG::CONNECTION_OK
+      client = PG.connect(params)
+      raise DataBaseError, "Bad Connection" unless client.status == PG::CONNECTION_OK
 
-      # This gives us type mapping for integers, floats, booleans, and dates -- but annoyingly the
-      # PostgreSQL types 'numeric' and 'money' remain as strings... we fudge that elsewhere.
-      #
-      # NOTE we now deal with ALL mapping elsewhere, since pg_jruby does not support type mapping.
-      # Also: no annoying error messages, and it seems to be a hell of a lot faster now...
-      # 
-      #     if defined?(PG::BasicTypeMapForQueries)
-      #       client.type_map_for_queries = PG::BasicTypeMapForQueries.new(client)
-      #     end
-      #
-      #     if defined?(PG::BasicTypeMapForResults)
-      #       client.type_map_for_results = PG::BasicTypeMapForResults.new(client)
-      #     end
-
-      @client = client
-      self
+      client
 
     rescue => e
       handle_error(e)
     end
 
-
     ##
     # Close the connection to the database.
     #
-    # We don't actually use this, but it's here for completeness. Maybe a caller will find it
-    # useful.
+    # Pod4 itself doesn't use this(?)
     #
-    def close
+    def close_connection(conn)
       Pod4.logger.info(__FILE__){ "Closing connection to DB" }
-      @client.finish unless @client.nil?
+      conn.finish unless conn.nil?
 
     rescue => e
       handle_error(e)
     end
 
+    ##
+    # Expose @connection, for testing only.
+    #
+    def _connection
+      @connection
+    end
+
+    private
 
     ##
     # True if we are connected to a database
     #
-    def connected?
-      return false if @client.nil?
-      return false if @client.status != PG::CONNECTION_OK
+    def connected?(conn)
+      return false if conn.nil?
+      return false if conn.status != PG::CONNECTION_OK
 
       # pg's own examples suggest we poke the database rather than trust
       # @client.status, so...
-      @client.exec('select 1;')
+      conn.exec('select 1;')
       true
     rescue PG::Error
       return false
     end
 
-
     ##
+    # Return a client from the connection pool and check it is open.
     # Since pg gives us @client.reset to reconnect, we should use it rather than just call open
     #
     def ensure_connection
+      client = @connection.client(self)
 
-      if @client.nil?
+      if client.nil?
         open
-      elsif ! connected?
-        @client.reset
+      elsif ! connected?(client)
+        client.reset
       end
 
+      client
     end
 
-
     def handle_error(err, kaller=nil)
       kaller ||= caller[1..-1]
 
       Pod4.logger.error(__FILE__){ err.message }
 
       case err
-
         when ArgumentError, Pod4::Pod4Error, Pod4::CantContinue
           raise err.class, err.message, kaller
 
@@ -396,12 +383,10 @@ module Pod4
 
         else
           raise Pod4::Pod4Error, err.message, kaller
-
       end
 
     end
 
-
     ##
     # build a hash of column -> oid
     #
@@ -413,11 +398,10 @@ module Pod4
 
     end
 
-
     ##
     # Cast a query row
     #
-    # This is to step around problems with pg type mapping There is definitely a way to tell pg to
+    # This is to step around problems with pg type mapping. There is definitely a way to tell pg to
     # cast money and numeric as BigDecimal, but, it's not documented...
     #
     # Also, for the pg_jruby gem, type mapping doesn't work at all?
@@ -452,7 +436,6 @@ module Pod4
       end
 
     end
-
     
     ##
     # Given a value from the database which supposedly represents a boolean ... return one.
@@ -470,12 +453,10 @@ module Pod4
       end
     end
 
-
     def read_or_die(id)
       raise CantContinue, "'No record found with ID '#{id}'" if read(id).empty?
     end
 
-
     def parse_for_params(sql, vals)
       new_params = sql.scan("%s").map.with_index{|e,i| "$#{i + 1}" }
       new_vals   = vals.map{|v| v.nil? ? nil : quote(v, nil).to_s }
@@ -483,8 +464,7 @@ module Pod4
       [ sql_subst(sql, *new_params), new_vals ]
     end
 
-
-  end
+  end # of PgInterface
 
 
 end

data/lib/pod4/sequel_interface.rb

@@ -1,7 +1,8 @@
-require 'octothorpe'
+require "octothorpe"
 
-require_relative 'interface'
-require_relative 'errors'
+require_relative "interface"
+require_relative "errors"
+require_relative "connection"
 
 
 module Pod4
@@ -22,18 +23,21 @@ module Pod4
   # appropriate -- but it also depends on the underlying adapter.  TinyTds maps dates to strings,
   # for example. 
   #
+  # Connections: Because the Sequel client -- the "DB" object -- has its own connection pool and
+  # does most of the heavy lifting for us, the only reason we use the Connection class is to defer
+  # creating the DB object until the first time we need it. Most of what Connection does, we don't
+  # need, so our interactions with Connection are a little strange.
+  #
   class SequelInterface < Interface
 
     attr_reader :id_fld
 
-
     class << self
       #---
       # These are set in the class because it keeps the model code cleaner: the definition of the
       # interface stays in the interface, and doesn't leak out into the model.
       #+++
 
-
       ##
       # Use this to set the schema name (optional)
       #
@@ -43,7 +47,6 @@ module Pod4
 
       def schema; nil; end
 
-
       ##
       # Set the table name. 
       #
@@ -55,82 +58,71 @@ module Pod4
         raise Pod4Error, "You need to use set_table to set the table name"
       end
 
-
       ##
       # Set the unique id field on the table.
       #
-      def set_id_fld(idFld)
+      def set_id_fld(idFld, opts={})
+        ai = opts.fetch(:autoincrement) { true }
         define_class_method(:id_fld) {idFld.to_s.to_sym}
+        define_class_method(:id_ai)  {!!ai}
       end
 
       def id_fld
         raise Pod4Error, "You need to use set_id_fld to set the ID column name"
       end
 
-    end
-    ##
+      def id_ai
+        raise Pod4Error, "You need to use set_id_fld to set the ID column name"
+      end
 
+    end # of class << self
 
     ##
-    # Initialise the interface by passing it the Sequel DB object.
+    # Initialise the interface by passing it the Sequel DB object. Or a Sequel
+    # connection string. Or a Pod4::Connection object. 
     #
-    def initialize(db)
-      raise(ArgumentError, "Bad database") unless db.kind_of? Sequel::Database
+    def initialize(arg)
       raise(Pod4Error, 'no call to set_table in the interface definition') if self.class.table.nil?
       raise(Pod4Error, 'no call to set_id_fld in the interface definition') if self.class.id_fld.nil?
 
-      @sequel_version = Sequel.respond_to?(:qualify) ? 5 : 4
-      @db             = db # reference to the db object
-      @id_fld         = self.class.id_fld
+      case arg
+        when Sequel::Database
+          @connection = Connection.new(interface: self.class)
+          @connection.data_layer_options = arg 
 
-      @table  = 
-        if schema
-          if @sequel_version == 5
-            db[ Sequel[schema][table] ]
-          else
-            db[ "#{schema}__#{table}".to_sym ]
-          end
-        else
-          db[table]
-        end
-          
-      # Work around a problem with jdbc-postgresql where it throws an exception whenever it sees
-      # the money type. This workaround actually allows us to return a BigDecimal, so it's better
-      # than using postgres_pr when under jRuby!
-      if @db.uri =~ /jdbc:postgresql/
-        @db.conversion_procs[790] = ->(s){BigDecimal(s[1..-1]) rescue nil}
-        c = Sequel::JDBC::Postgres::Dataset
+        when Hash, String
+          @connection = Connection.new(interface: self.class)
+          @connection.data_layer_options = Sequel.connect(arg)
+
+        when Connection
+          @connection = arg
 
-        if @sequel_version >= 5
-          # In Sequel 5 everything is frozen, so some hacking is required.
-          # See https://github.com/jeremyevans/sequel/issues/1458
-          vals = c::PG_SPECIFIC_TYPES + [Java::JavaSQL::Types::DOUBLE] 
-          c.send(:remove_const, :PG_SPECIFIC_TYPES) # We can probably get away with just const_set, but.
-          c.send(:const_set,    :PG_SPECIFIC_TYPES, vals.freeze)
         else
-          c::PG_SPECIFIC_TYPES << Java::JavaSQL::Types::DOUBLE
-        end
+          raise ArgumentError, "Bad argument"
+
       end
 
+      @sequel_version = Sequel.respond_to?(:qualify) ? 5 : 4
+      @id_fld         = self.class.id_fld
+      @db             = nil
+
     rescue => e
       handle_error(e)
     end
 
-
     def schema; self.class.schema; end
     def table;  self.class.table;  end
     def id_fld; self.class.id_fld; end
+    def id_ai;  self.class.id_ai;  end
 
     def quoted_table
       if schema 
-        %Q|#{@db.quote_identifier schema}.#{@db.quote_identifier table}|
+        %Q|#{db.quote_identifier schema}.#{db.quote_identifier table}|
       else
-        @db.quote_identifier(table)
+        db.quote_identifier(table)
       end
     end
 
-
-
     ##
     # Selection is whatever Sequel's `where` supports.
     #
@@ -138,40 +130,42 @@ module Pod4
       sel = sanitise_hash(selection)
       Pod4.logger.debug(__FILE__) { "Listing #{self.class.table}: #{sel.inspect}" }
 
-      (sel ? @table.where(sel) : @table.all).map {|x| Octothorpe.new(x) }
+      (sel ? db_table.where(sel) : db_table.all).map {|x| Octothorpe.new(x) }
     rescue => e
       handle_error(e)
     end
 
-
     ##
-    # Record is a hash of field: value
+    # Record is a Hash or Octothorpe of field: value
     #
     def create(record)
-      raise(ArgumentError, "Bad type for record parameter") \
-        unless record.kind_of?(Hash) || record.kind_of?(Octothorpe)
-
-      Pod4.logger.debug(__FILE__) { "Creating #{self.class.table}: #{record.inspect}" }
+      raise Octothorpe::BadHash if record.nil?
+      ot = Octothorpe.new(record)
 
-      id = @table.insert( sanitise_hash(record.to_h) )
+      if id_ai
+        ot = ot.reject{|k,_| k == id_fld}
+      else
+        raise(ArgumentError, "ID field missing from record") if ot[id_fld].nil?
+      end
 
-      # Sequel doesn't return the key unless it is an autoincrement; otherwise it turns a row
-      # number regardless.  It probably doesn' t matter, but try to catch that anyway.
-      # (bamf: If your non-incrementing key happens to be an integer, this won't work...)
+      Pod4.logger.debug(__FILE__) { "Creating #{self.class.table}: #{ot.inspect}" }
 
-      id_val = record[id_fld] || record[id_fld.to_s]
+      id = db_table.insert( sanitise_hash(ot.to_h) )
 
-      if (id.kind_of?(Fixnum) || id.nil?) && id_val && !id_val.kind_of?(Fixnum)
-        id_val
-      else
+      # Sequel doesn't return the key unless it is an autoincrement; otherwise it turns a row
+      # number, which isn't much use to us. We always return the key.
+      if id_ai
         id
+      else
+        ot[id_fld]
       end
-
-    rescue => e
-      handle_error(e) 
+    
+    rescue Octothorpe::BadHash
+      raise ArgumentError, "Bad type for record parameter"
+    rescue
+      handle_error $!
     end
 
-
     ##
     # ID corresponds to whatever you set in set_id_fld
     #
@@ -179,7 +173,7 @@ module Pod4
       raise(ArgumentError, "ID parameter is nil") if id.nil?
       Pod4.logger.debug(__FILE__) { "Reading #{self.class.table} where #{@id_fld}=#{id}" }
 
-      Octothorpe.new( @table[@id_fld => id] )
+      Octothorpe.new( db_table[@id_fld => id] )
 
     rescue Sequel::DatabaseError
       raise CantContinue, "Problem reading record. Is '#{id}' really an ID?"
@@ -188,7 +182,6 @@ module Pod4
       handle_error(e)
     end
 
-
     ##
     # ID is whatever you set in the interface using set_id_fld record should be a Hash or
     # Octothorpe.
@@ -200,13 +193,12 @@ module Pod4
         "Updating #{self.class.table} where #{@id_fld}=#{id}: #{record.inspect}"
       end
 
-      @table.where(@id_fld => id).update( sanitise_hash(record.to_h) )
+      db_table.where(@id_fld => id).update( sanitise_hash(record.to_h) )
       self
     rescue => e
       handle_error(e)
     end
 
-
     ##
     # ID is whatever you set in the interface using set_id_fld
     #
@@ -217,13 +209,12 @@ module Pod4
         "Deleting #{self.class.table} where #{@id_fld}=#{id}"
       end
 
-      @table.where(@id_fld => id).delete
+      db_table.where(@id_fld => id).delete
       self
     rescue => e
       handle_error(e)
     end
 
-
     ##
     # Bonus method: execute arbitrary SQL. Returns nil.
     #
@@ -231,12 +222,13 @@ module Pod4
       raise(ArgumentError, "Bad sql parameter") unless sql.kind_of?(String)
       Pod4.logger.debug(__FILE__) { "Execute SQL: #{sql}" }
 
-      @db.run(sql)
+      c = @connection.client(self)
+      c.run(sql)
+
     rescue => e
       handle_error(e)
     end
 
-
     ##
     # Bonus method: execute SQL as per execute(), but parameterised.
     #
@@ -252,13 +244,11 @@ module Pod4
       raise(ArgumentError, "Bad mode parameter")   unless %i|insert delete update|.include?(mode)
       Pod4.logger.debug(__FILE__) { "Parameterised execute #{mode} SQL: #{sql}" }
 
-      @db[sql, *values].send(mode)
+      @connection.client(self)[sql, *values].send(mode)
     rescue => e
       handle_error(e)
     end
 
-
-
     ## 
     # Bonus method: execute arbitrary SQL and return the resulting dataset as a Hash.
     #
@@ -266,12 +256,11 @@ module Pod4
       raise(ArgumentError, "Bad sql parameter") unless sql.kind_of?(String)
       Pod4.logger.debug(__FILE__) { "Select SQL: #{sql}" }
 
-      @db[sql].all
+      @connection.client(self)[sql].all
     rescue => e
       handle_error(e)
     end
 
-
     ##
     # Bonus method: execute arbitrary SQL as per select(), but parameterised.
     #
@@ -282,14 +271,38 @@ module Pod4
       raise(ArgumentError, "Bad sql parameter")    unless sql.kind_of?(String)
       Pod4.logger.debug(__FILE__) { "Parameterised select SQL: #{sql}" }
 
-      @db.fetch(sql, *values).all
+      @connection.client(self).fetch(sql, *values).all
+
     rescue => e
       handle_error(e)
     end
 
+    ## 
+    # Called by @connection to get the DB object.
+    # Never called internally. Given the way Sequel works -- the data layer option object passed
+    # to Connection actually is the client object -- we do something a bit weird here.
+    #
+    def new_connection(options)
+      options
+    end
 
-    private
+    ###
+    # Called by @connection to "close" the DB object.
+    # Never called internally, and given the way Sequel works, we implement this as a dummy
+    # operation
+    #
+    def close_connection
+      self
+    end
+
+    ##
+    # Return the connection object, for testing purposes only
+    #
+    def _connection
+      @connection
+    end
 
+    private
 
     ##
     # Helper routine to handle or re-raise the right exception.
@@ -329,7 +342,28 @@ module Pod4
       end
 
     end
+    
+    def sequel_fudges(db)
+      # Work around a problem with jdbc-postgresql where it throws an exception whenever it sees
+      # the money type. This workaround actually allows us to return a BigDecimal, so it's better
+      # than using postgres_pr when under jRuby!
+      if db.uri =~ /jdbc:postgresql/
+        db.conversion_procs[790] = ->(s){BigDecimal(s[1..-1]) rescue nil}
+        c = Sequel::JDBC::Postgres::Dataset
 
+        if @sequel_version >= 5
+          # In Sequel 5 everything is frozen, so some hacking is required.
+          # See https://github.com/jeremyevans/sequel/issues/1458
+          vals = c::PG_SPECIFIC_TYPES + [Java::JavaSQL::Types::DOUBLE] 
+          c.send(:remove_const, :PG_SPECIFIC_TYPES) # We can probably get away with just const_set, but.
+          c.send(:const_set,    :PG_SPECIFIC_TYPES, vals.freeze)
+        else
+          c::PG_SPECIFIC_TYPES << Java::JavaSQL::Types::DOUBLE
+        end
+      end
+
+      db
+    end
 
     ##
     # Sequel behaves VERY oddly if you pass a symbol as a value to the hash you give to a
@@ -354,12 +388,34 @@ module Pod4
 
     end
 
-
     def read_or_die(id)
       raise CantContinue, "'No record found with ID '#{id}'" if read(id).empty?
     end
 
-  end
+    def db
+      if @db
+        @db
+      else
+        @db = @connection.client(self)
+        sequel_fudges(@db)
+      end
+    end
+
+    def db_table
+
+      if schema
+        if @sequel_version == 5
+          db[ Sequel[schema][table] ]
+        else
+          db[ "#{schema}__#{table}".to_sym ]
+        end
+      else
+        db[table]
+      end
+
+    end
+
+  end # of SequelInterface
 
 
 end