pod4 0.10.6 → 1.0.0

data/lib/pod4/tds_interface.rb

@@ -1,11 +1,12 @@
-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
@@ -30,14 +31,12 @@ 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
       # interface stays in the interface, and doesn't leak out into the model.
       #++
 
-
       ##
       # Use this to set the database name.
       #
@@ -49,7 +48,6 @@ module Pod4
         raise Pod4Error, "You need to use set_db to set the database name"
       end
 
-
       ##
       # Use this to set the schema name (optional)
       #
@@ -59,7 +57,6 @@ module Pod4
 
       def schema; nil; end
 
-
       ##
       # Use this to set the name of the table
       #
@@ -71,37 +68,41 @@ module Pod4
         raise Pod4Error, "You need to use set_table to set the table name"
       end
 
-
       ##
       # This sets 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_table to set the table name"
       end
 
-    end
-    ##
-
+    end # of class << self
 
     ##
-    # Initialise the interface by passing it a TinyTds connection hash.# For testing ONLY you can
-    # also pass an object which pretends to be a TinyTds client, in which case the hash is pretty
-    # much ignored.
+    # Initialise the interface by passing it a TinyTds connection hash OR a ConnectionPool object.
     #
-    def initialize(connectHash, testClient=nil)
+    def initialize(args)
+      case args
+        when Hash
+          @connection = ConnectionPool.new(interface: self.class)
+          @connection.data_layer_options = args
+
+        when ConnectionPool
+          @connection = args
+
+        else
+          raise ArgumentError, "Bad Argument"
+      end
+
       sc = self.class
       raise(Pod4Error, 'no call to set_db in the interface definition')     if sc.db.nil?
       raise(Pod4Error, 'no call to set_table in the interface definition')  if sc.table.nil?
       raise(Pod4Error, 'no call to set_id_fld in the interface definition') if sc.id_fld.nil?
-      raise(ArgumentError, 'invalid connection hash') unless connectHash.kind_of?(Hash)
-
-      @connect_hash = connectHash.dup
-      @test_client  = testClient 
-      @client       = nil
 
       TinyTds::Client.default_query_options[:as] = :hash
       TinyTds::Client.default_query_options[:symbolize_keys] = true
@@ -110,11 +111,11 @@ module Pod4
       handle_error(e)
     end
 
-
     def db;     self.class.db;     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
       schema ? %Q|[#{schema}].[#{table}]| : %Q|[#{table}]|
@@ -124,13 +125,11 @@ module Pod4
       "[#{super(fld, nil)}]"
     end
 
-
     ##
     # Selection is a hash or something like it: keys should be field names. We return any records
     # where the given fields equal the given values.
     #
     def list(selection=nil)
-
       raise(Pod4::DatabaseError, 'selection parameter is not a hash') \
         unless selection.nil? || selection.respond_to?(:keys)
 
@@ -141,24 +140,29 @@ module Pod4
       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)
+      raise Octothorpe::BadHash if record.nil?
+      ot = Octothorpe.new(record)
 
-      sql, vals = sql_insert(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(ot)
       x = select sql_subst(sql, *vals.map{|v| quote v})
       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
     #
@@ -178,11 +182,9 @@ module Pod4
         && e.cause.class   == TinyTds::Error \
         && e.cause.message =~ /conversion failed/i
 
-
       handle_error(e)
     end
 
-
     ##
     # ID is whatever you set in the interface using set_id_fld record should be a Hash or
     # Octothorpe.
@@ -202,7 +204,6 @@ module Pod4
       handle_error(e)
     end
 
-
     ##
     # ID is whatever you set in the interface using set_id_fld
     #
@@ -218,7 +219,6 @@ module Pod4
       handle_error(e)
     end
 
-
     ##
     # Override the sql_insert method in sql_helper since our SQL is rather different
     #
@@ -234,7 +234,6 @@ module Pod4
       [sql, vals]
     end
 
-
     ##
     # Run SQL code on the server. Return the results.
     #
@@ -250,10 +249,10 @@ module Pod4
     def select(sql)
       raise(ArgumentError, "Bad sql parameter") unless sql.kind_of?(String)
 
-      open unless connected?
+      client = ensure_connected
 
       Pod4.logger.debug(__FILE__){ "select: #{sql}" }
-      query = @client.execute(sql)
+      query = client.execute(sql)
 
       rows = []
       query.each do |r| 
@@ -273,17 +272,16 @@ module Pod4
       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)
 
-      open unless connected?
+      client = ensure_connected
 
       Pod4.logger.debug(__FILE__){ "execute: #{sql}" }
-      r = @client.execute(sql)
+      r = client.execute(sql)
 
       r.do
       r
@@ -292,62 +290,79 @@ module Pod4
       handle_error(e)
     end
 
-
     ##
     # Wrapper for the data source library escape routine, which is all we can offer in terms of SQL
     # injection protection. (Its not much.)
     #
     def escape(thing)
-      open unless connected?
-      thing.kind_of?(String) ? @client.escape(thing) : thing
+      client = ensure_connected
+      thing.kind_of?(String) ? client.escape(thing) : thing
     end
 
-
-    private
-
-
     ##
     # Open the connection to the database.
     #
-    # No parameters are needed: the option hash has everything we need.
+    # This is called by ConnectionPool.
     #
-    def open
+    def new_connection(params)
       Pod4.logger.info(__FILE__){ "Connecting to DB" }
-      client = @test_Client || TinyTds::Client.new(@connect_hash)
+      client = TinyTds::Client.new(params)
       raise "Bad Connection" unless client.active?
 
-      @client = client
-      execute("use [#{self.class.db}]")
+      client.execute("use [#{self.class.db}]").do
 
-      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.
+    # We don't actually use this.  Theoretically it would be called by ConnectionPool, but we
+    # don't.  I've left it in for completeness.
     #
-    def close
+    def close_connection(conn)
       Pod4.logger.info(__FILE__){ "Closing connection to DB" }
-      @client.close unless @client.nil?
+      conn.close unless conn.nil?
 
     rescue => e
       handle_error(e)
     end
 
+    ##
+    # Expose @connection for test purposes only
+    #
+    def _connection
+      @connection
+    end
+
+    private
 
     ##
-    # True if we are connected to a database
+    # Return an open client connection from the Connection Pool, or else raise an error
     #
-    def connected?
-      @client && @client.active?
+    def ensure_connected
+      client = @connection.client(self)
+      
+      # If this connection has expired somehow, try to get another one.
+      unless connected?(client)
+        @connection.drop(self)
+        client = @connection.client(self)
+      end
+
+      fail "Bad Connection" unless connected?(client)
+
+      client
     end
 
+    ##
+    # True if we are connected to a database
+    #
+    def connected?(conn)
+      conn && conn.active?
+    end
 
     def handle_error(err, kaller=nil)
       kaller ||= caller[1..-1]
@@ -369,7 +384,6 @@ module Pod4
 
     end
 
-
     ##
     # Overrride the quote routine in sql_helper.
     #
@@ -390,12 +404,11 @@ module Pod4
 
     end
 
-
     def read_or_die(id)
       raise CantContinue, "'No record found with ID '#{id}'" if read(id).empty?
     end
 
-  end
+  end # of TdsInterface
 
 
 end

data/lib/pod4/tweaking.rb

@@ -0,0 +1,105 @@
+require 'pod4/errors'
+require 'pod4/metaxing'
+
+
+module Pod4
+
+
+  ##
+  # A mixin that extends the model DSL to simplify use of custom interface methods.
+  #
+  # We add one command to the model DSL: set_custom_list. It's optional.
+  #
+  #
+  # set_custom_list
+  # ---------------
+  #
+  #     class Bar < Pod4::Model
+  #       include Pod4::Tweaking
+  # 
+  #       class Interface < Pod4::PgInterface
+  #         set table :bar
+  #         set_id_field :id, autoincrement: true
+  # 
+  #         # Example custom interface method
+  #         def list_paged(drop=0, limit=15)
+  #           execute %Q|select * from bar offset #{drop} rows fetch next #{limit} rows only;|
+  #         end
+  #       end # of Interface
+  # 
+  #       set_interface   Interface.new($conn)
+  #       set_custom_list :list_paged
+  #     end
+  #
+  # Use this when you want to make a special version of the List action.  It takes one parameter:
+  # the name of a custom method you have defined on the Interface. A corresponding method will be
+  # created on the model. Any parameters you pass to the model method will be passed on to your
+  # custom interface method.
+  #
+  # Your custom interface method should return an array of Octothorpes or Hashes; the
+  # corresponding model method will return an array of instances of the model, just as #list does.
+  #
+  # Obviously this means that the keys in your array of Hash/Octothorpe must match the column
+  # attributes in the model.  Any missing attributes will be set to nil; any extra attributes will
+  # be ignored.  But the ID field must be present as a key, or else an exception will be raised. if
+  # you want to indicate that no records were found, you must return an empty Array and not nil.
+  #
+  # Just as with List proper, the array of model instances have not had validation run against
+  # them, and are all status :empty.
+  #
+  module Tweaking
+
+    ##
+    # A little bit of magic, for which I apologise. 
+    #
+    # When you include this module it actually adds the methods in ClassMethods to the class as if
+    # you had called `extend TypeCasting:ClassMethds` *AND* (theoretically, in this case) adds the
+    # methods in InstanceMethods as if you had written `prepend TypeCasting::InstanceMethods`.  
+    #
+    # In my defence: I didn't want to have to make you remember to do that...
+    #
+    def self.included(base)
+      base.extend ClassMethods
+#     base.send(:prepend, InstanceMethods)
+    end
+
+
+    module ClassMethods
+      include Metaxing
+
+      def set_custom_list(method)
+        raise ArgumentError, "Bad custom interface method" unless interface.respond_to?(method)
+        raise ArgumentError, "Method already exists on the model" \
+          if (self.instance_methods - self.class.instance_methods).include?(method)
+
+        define_class_method(method) do |*args|
+          mname = "#{interface.class.name}.#{method}"
+          rows  = interface.send(method, *args)
+
+          raise Pod4Error, "#{mname} did not return an array" unless rows.is_a? Array
+          raise Pod4Error, "#{mname} did not return an array of records" \
+            unless rows.all?{|r| r.is_a?(Hash) || r.is_a?(Octothorpe) }
+
+          raise Pod4Error, "#{mname} returned some records with no ID" \
+            unless rows.all?{|r| r.has_key? interface.id_fld }
+
+          rows.map do |r|
+            rec = self.new r[interface.id_fld] 
+            rec.map_to_model r 
+            rec
+          end
+        end
+
+      end
+
+    end # of ClassMethods
+
+
+#   module InstanceMethods
+#   end # of InstanceMethods
+
+  end # of Tweaking
+
+
+end
+