pod4 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9c0490f9b2e4082a0d36fde99281b5ec3b18dc06
-  data.tar.gz: 5338ef5d4695a2b0385a0093e43f4e4658c580c6
+  metadata.gz: 14459fc92264f22a30f5fc92078d2de5343102b0
+  data.tar.gz: 8595eb150b4615d49ba9447972a1dc25bca60406
 SHA512:
-  metadata.gz: 21795d227c37d1a80d6d60a0a74f9c5111818cd80dcc696e2fc77641bbcbba9d1f089ab5ec44302825861d5aff0a6e8a3111e8c218cfd7beba5d07753ca9f7ed
-  data.tar.gz: ec96c28be57e17385efef6725cf83e402399eeacaa55be1f089139a1a8f6b889e547f5da36f77b255c2b770a4796948698f25fbbda4d9a918951b08dcebfb308
+  metadata.gz: 0002b34674f809b1320cb0d47b05f8c1514eb91d2993639d5210c2ac4b9be08d57d08c7edc47112f657c326204be4301977037a2363772108a21e602a09fbde6
+  data.tar.gz: e983618952a89b09f28514bcf7bf299cf261f3e33347444b9a0a0a14444ce69fedde0e3c30c7972e254486471162285b34ebc33dfdd70de29e7a3aa9a15bf0c5

data/.hgignore

@@ -16,3 +16,4 @@ mkmf.log
 .ruby-gemset
 .rbenv-gemsets
 .Project
+.project

data/.hgtags

@@ -19,3 +19,4 @@ dc22541876279b47dd366ddb44d262775ccdb933 0.6.1
 4a0e392be3499d9edc9cde66dd3b8d37136a0816 0.6.2
 e41769b310f2eaab5f37d285ce9ad8658b689916 0.7.1
 2c28b064a96d4760d124da3f1842242f52f4cc69 0.7.2
+ccb4a8711560725e358f7fb87c76f4787eac5ed5 0.8.0

data/Gemfile

@@ -24,7 +24,9 @@ group :development, :test do
 
   platforms :jruby do
     gem "jruby-lint"
-    gem "pg_jruby"
+    gem "jeremyevans-postgres-pr"
+    gem 'jdbc-mssqlserver'
+    gem 'jdbc-postgres', '9.4.1200'
   end
 
 

data/Rakefile

@@ -1,8 +1,3 @@
-#require "bundler/gem_tasks"
-#require "rspec/core/rake_task"
-
-#RSpec::Core::RakeTask.new(:spec)
-
 desc "Push doc to HARS"
 task :hars do
   sh "rsync -aP --delete doc/ /home/hars/hars/public/pod4"
@@ -13,6 +8,7 @@ task :retag do
   sh "ripper-tags -R"
 end
 
+
 namespace :rspec do
 
   desc "run tests (mri)"
@@ -25,4 +21,20 @@ namespace :rspec do
     sh "rspec spec/common spec/jruby"
   end
 
+  desc "run one test (pass as parameter)"
+  task :one do |task, args|
+
+    if args.extras.count > 0 # rake rspec[path/to/file]
+      sh "rspec #{args.extras.first}"
+
+    elsif ARGV.count == 2 && File.exist?(ARGV[1])  # rake rspec path/to/file
+      sh "rspec #{ARGV[1]}"
+
+    else
+      raise "You need to specify a test"
+    end
+
+  end
+
 end
+

data/lib/pod4/pg_interface.rb

@@ -5,6 +5,7 @@ require 'bigdecimal'
 
 require_relative 'interface'
 require_relative 'errors'
+require_relative 'sql_helper'
 
 
 module Pod4
@@ -23,6 +24,7 @@ module Pod4
   #     end
   #
   class PgInterface < Interface
+    include SQLHelper
 
     attr_reader :id_fld
 
@@ -91,29 +93,15 @@ module Pod4
     def table;  self.class.table;  end
     def id_fld; self.class.id_fld; end
 
-    def quoted_table
-      schema ? %Q|"#{schema}"."#{table}"| : %Q|"#{table}"|
-    end
-
 
     ##
-    # Selection is whatever Sequel's `where` supports.
     #
     def list(selection=nil)
       raise(ArgumentError, 'selection parameter is not a hash') \
         unless selection.nil? || selection.respond_to?(:keys)
 
-      if selection
-        sel = selection.map {|k,v| %Q|"#{k}" = #{quote v}| }.join(" and ")
-        sql = %Q|select * 
-                     from #{quoted_table}
-                     where #{sel};|
-
-      else
-        sql = %Q|select * from #{quoted_table};|
-      end
-
-      select(sql) {|r| Octothorpe.new(r) }
+      sql, vals = sql_select(nil, selection)
+      selectp(sql, *vals) {|r| Octothorpe.new(r) }
 
     rescue => e
       handle_error(e)
@@ -130,15 +118,8 @@ module Pod4
       raise(ArgumentError, "Bad type for record parameter") \
         unless record.kind_of?(Hash) || record.kind_of?(Octothorpe)
 
-      ks = record.keys.map   {|k| %Q|"#{k}"| }.join(',')
-      vs = record.values.map {|v| quote v }.join(',')
-
-      sql = %Q|insert into #{quoted_table}
-                   ( #{ks} )
-                   values( #{vs} )
-                   returning "#{id_fld}";| 
-
-      x = select(sql)
+      sql, vals = sql_insert(record) 
+      x = selectp(sql, *vals)
       x.first[id_fld]
 
     rescue => e
@@ -152,11 +133,9 @@ module Pod4
     def read(id)
       raise(ArgumentError, "ID parameter is nil") if id.nil?
 
-      sql = %Q|select * 
-                   from #{quoted_table} 
-                   where "#{id_fld}" = #{quote id};|
-
-      Octothorpe.new( select(sql).first )
+      sql, vals = sql_select(nil, id_fld => id) 
+      rows = selectp(sql, *vals)
+      Octothorpe.new(rows.first)
 
     rescue => e
       # Select has already wrapped the error in a Pod4Error, but in this case we want to catch
@@ -177,13 +156,9 @@ module Pod4
         unless record.kind_of?(Hash) || record.kind_of?(Octothorpe)
 
       read_or_die(id)
-      sets = record.map {|k,v| %Q| "#{k}" = #{quote v}| }.join(',')
 
-      sql = %Q|update #{quoted_table} set
-                   #{sets}
-                   where "#{id_fld}" = #{quote id};|
-
-      execute(sql)
+      sql, vals = sql_update(record, id_fld => id)
+      executep(sql, *vals)
 
       self
 
@@ -197,7 +172,9 @@ module Pod4
     #
     def delete(id)
       read_or_die(id)
-      execute( %Q|delete from #{quoted_table} where "#{id_fld}" = #{quote id};| )
+
+      sql, vals = sql_delete(id_fld => id)
+      executep(sql, *vals)
 
       self
 
@@ -250,6 +227,44 @@ module Pod4
     end
 
 
+    ##
+    # Run SQL code on the server as per select() but with parameter insertion.
+    #
+    # Placeholders in the SQL string should all be %s as per sql_helper methods.
+    # Values should be as returned by sql_helper methods.
+    #
+    def selectp(sql, *vals)
+      raise(ArgumentError, "Bad SQL parameter") unless sql.kind_of?(String)
+
+      ensure_connection
+
+      Pod4.logger.debug(__FILE__){ "select: #{sql} #{vals.inspect}" }
+
+      rows = []
+      @client.exec_params( *parse_for_params(sql, vals) ) do |query|
+        oids = make_oid_hash(query)
+
+        query.each do |r| 
+          row = cast_row_fudge(r, oids)
+
+          if block_given? 
+            rows << yield(row)
+          else
+            rows << row
+          end
+
+        end
+      end
+
+      @client.cancel 
+
+      rows
+
+    rescue => e
+      handle_error(e)
+    end
+
+
     ##
     # Run SQL code on the server; return true or false for success or failure
     #
@@ -266,6 +281,25 @@ module Pod4
     end
 
 
+    ##
+    # Run SQL code on the server as per execute() but with parameter insertion.
+    #
+    # Placeholders in the SQL string should all be %s as per sql_helper methods.
+    # Values should be as returned by sql_helper methods.
+    #
+    def executep(sql, *vals)
+      raise(ArgumentError, "Bad SQL parameter") unless sql.kind_of?(String)
+
+      ensure_connection
+
+      Pod4.logger.debug(__FILE__){ "parameterised execute: #{sql}" }
+      @client.exec_params( *parse_for_params(sql, vals) )
+
+    rescue => e
+      handle_error(e)
+    end
+
+
     protected
 
 
@@ -369,26 +403,6 @@ module Pod4
     end
 
 
-    def quote(fld)
-
-      case fld
-        when Date, Time
-          "'#{fld}'" 
-        when String
-          "'#{fld.gsub("'", "''")}'" 
-        when Symbol
-          "'#{fld.to_s.gsub("'", "''")}'" 
-        when BigDecimal
-          fld.to_f
-        when nil
-          'NULL'
-        else 
-          fld
-      end
-
-    end
-    
-
     private
 
 
@@ -404,6 +418,7 @@ module Pod4
     end
 
 
+
     ##
     # Cast a query row
     #
@@ -449,6 +464,15 @@ module Pod4
       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 ? quote(v, nil).to_s : nil }
+      
+      [ sql_subst(sql, *new_params), new_vals ]
+    end
+
+
   end
 
 

data/lib/pod4/sequel_interface.rb

@@ -83,6 +83,14 @@ module Pod4
       @table  = db[schema ? "#{schema}__#{table}".to_sym : table]
       @id_fld = self.class.id_fld
 
+      # 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.new s[1..-1] rescue nil}
+        Sequel::JDBC::Postgres::Dataset::PG_SPECIFIC_TYPES << Java::JavaSQL::Types::DOUBLE
+      end
+
     rescue => e
       handle_error(e)
     end
@@ -118,16 +126,25 @@ module Pod4
     ##
     # Record is a hash 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)
 
       Pod4.logger.debug(__FILE__) { "Creating #{self.class.table}: #{record.inspect}" }
 
-      @table.insert( sanitise_hash(record.to_h) )
+      id = @table.insert( sanitise_hash(record.to_h) )
+
+      # 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...)
+
+      id_val = record[id_fld] || record[id_fld.to_s]
+
+      if (id.kind_of?(Fixnum) || id.nil?) && id_val && !id_val.kind_of?(Fixnum)
+        id_val
+      else
+        id
+      end
 
     rescue => e
       handle_error(e) 
@@ -191,27 +208,65 @@ module Pod4
     #
     def execute(sql)
       raise(ArgumentError, "Bad sql parameter") unless sql.kind_of?(String)
-
       Pod4.logger.debug(__FILE__) { "Execute SQL: #{sql}" }
+
       @db.run(sql)
     rescue => e
       handle_error(e)
     end
 
 
+    ##
+    # Bonus method: execute SQL as per execute(), but parameterised.
+    #
+    # Use ? as a placeholder in the SQL
+    # mode is either :insert :update or :delete
+    # Please quote values for yourself, we don't.
+    #
+    # "update and delete should return the number of rows affected, and insert should return the
+    # autogenerated primary integer key for the row inserted (if any)"
+    #
+    def executep(sql, mode, *values)
+      raise(ArgumentError, "Bad sql parameter")    unless sql.kind_of?(String)
+      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)
+    rescue => e
+      handle_error(e)
+    end
+
+
+
     ## 
     # Bonus method: execute arbitrary SQL and return the resulting dataset as a Hash.
     #
     def select(sql)
       raise(ArgumentError, "Bad sql parameter") unless sql.kind_of?(String)
-
       Pod4.logger.debug(__FILE__) { "Select SQL: #{sql}" }
+
       @db[sql].all
     rescue => e
       handle_error(e)
     end
 
 
+    ##
+    # Bonus method: execute arbitrary SQL as per select(), but parameterised.
+    #
+    # Use ? as a placeholder in the SQL
+    # Please quote values for yourself, we don't.
+    #
+    def selectp(sql, *values)
+      raise(ArgumentError, "Bad sql parameter")    unless sql.kind_of?(String)
+      Pod4.logger.debug(__FILE__) { "Parameterised select SQL: #{sql}" }
+
+      @db.fetch(sql, *values).all
+    rescue => e
+      handle_error(e)
+    end
+
+
     protected
 
 

data/lib/pod4/sql_helper.rb

@@ -0,0 +1,229 @@
+module Pod4
+
+
+  ##
+  # A mixin to help interfaces that need to generate SQL
+  #
+  # Most of these methods return two things: an sql string with %s where each value should be; and
+  # an array of values to insert.
+  #
+  # You can override placeholder() to change %s to something else. You can override quote() to
+  # change how values are quoted and quote_fld() to change how column names are quoted. Of course
+  # the SQL here won't be suitable for all data source libraries even then, but, it gives us some
+  # common ground to start with.
+  #
+  # You can call sql_subst() to turn the SQL and the values array into actual SQL -- but don't do
+  # that; you should call the parameterised query routines for the data source library instead.
+  #
+  module SQLHelper
+    
+   
+    ##
+    # Return the name of the table quoted as for inclusion in SQL. Might include the name of the
+    # schema, too, if you have set one.
+    #
+    # table() is mandatory for an Interface, and if we have a schema it will be schema().
+    #
+    def quoted_table
+      defined?(schema) && schema ? %Q|"#{schema}"."#{table}"| : %Q|"#{table}"|
+    end
+
+
+    private
+
+
+    ##
+    # Given a list of fields and a selection hash, return an SQL string and an array of values 
+    # for an SQL SELECT.
+    #
+    def sql_select(fields, selection)
+      flds = fields ? Array(fields).flatten.map{|f| quote_field f} : ["*"]
+
+      wsql, wvals = sql_where(selection)
+
+      sql = %Q|select #{flds.join ','}
+                 from #{quoted_table}
+                 #{wsql};|
+
+      [sql, wvals]
+    end
+
+
+    ##
+    # Given a column:value hash, return an SQL string and an array of values for an SQL INSERT.
+    #
+    # Note that we get the table ID field from id_fld, which is mandatory for an Interface.
+    #
+    def sql_insert(fldsValues)
+      raise ArgumentError, "Needs a field:value hash" if fldsValues.nil? || fldsValues.empty?
+
+      flds, vals = parse_fldsvalues(fldsValues)
+      ph = Array(placeholder).flatten * flds.count
+
+      sql = %Q|insert into #{quoted_table}
+                 ( #{flds.join ','} )
+                 values( #{ph.join ','} )
+                 returning #{quote_field id_fld};| 
+
+      [sql, vals]
+    end
+
+
+    ##
+    # Given a column:value hash and a selection hash, return an SQL string and an array of values 
+    # for an SQL UPDATE.
+    #
+    def sql_update(fldsValues, selection)
+      raise ArgumentError, "Needs a field:value hash" if fldsValues.nil? || fldsValues.empty?
+
+      flds, vals = parse_fldsvalues(fldsValues)
+      sets = flds.map {|f| %Q| #{f} = #{placeholder}| }
+
+      wsql, wvals = sql_where(selection)
+
+      sql = %Q|update #{quoted_table}
+                 set #{sets.join ','}
+                 #{wsql};|
+                 
+      [sql, vals + wvals]
+    end
+
+
+    ##
+    # Given a selection hash, return an SQL string and an array of values for an SQL DELETE.
+    #
+    def sql_delete(selection)
+      wsql, wval = sql_where(selection)
+      [ %Q|delete from #{quoted_table} #{wsql};|, 
+        wval ]
+    end
+
+
+    ##
+    # Given a selection hash, return an SQL string and an array of values 
+    # for an SQL where clause.
+    #
+    # This is used internally; you probably don't need it unless you are trying to override
+    # sql_select(), sql_update() etc.
+    #
+    def sql_where(selection)
+      return ["", []] if (selection.nil? || selection == {})
+
+      flds, vals = parse_fldsvalues(selection)
+
+      [ "where " + flds.map {|f| %Q|#{f} = #{placeholder}| }.join(" and "),
+        vals ]
+
+    end
+
+
+    ##
+    # Given a string which is supposedly the name of a column, return a string with the column name
+    # quoted for inclusion to SQL.
+    #
+    # Defaults to SQL standard double quotes. If you want something else, pass the new quote
+    # character as the optional second parameter, and/or override the method.
+    #
+    def quote_field(fld, qc=%q|"|)
+      raise ArgumentError, "bad field name" unless fld.kind_of?(String) || fld.kind_of?(Symbol)
+      %Q|#{qc}#{fld}#{qc}|
+    end
+
+
+    ##
+    # Given some value, quote it for inclusion in SQL.
+    #
+    # Tries to follow the generic SQL standard -- single quotes for strings, NULL for nil, etc.
+    # If you want something else, pass a different quote character as the second parameter, and/or 
+    # override the method.
+    #
+    # Note that this also turns 'O'Claire' into 'O''Claire', as required by SQL.
+    #
+    def quote(fld, qc=%q|'|)
+
+      case fld
+        when Date, Time
+          %Q|#{qc}#{fld}#{qc}|
+        when String
+          %Q|#{qc}#{fld.gsub("#{qc}", "#{qc}#{qc}")}#{qc}|
+        when Symbol
+          %Q|#{qc}#{fld.to_s.gsub("#{qc}", "#{qc}#{qc}")}#{qc}|
+        when BigDecimal
+          fld.to_f
+        when nil
+          "NULL"
+        else 
+          fld
+      end
+
+    end
+    
+
+    ##
+    # Return the placeholder to use in place of values when we return SQL.  Defaults to the
+    # Ruby-friendly %s. Override it if you want everything else.
+    #
+    def placeholder
+      "%s"
+    end
+
+
+    ##
+    # Given a string (SQL) with %s placeholders and one or more values -- substitute the values for
+    # the placeholders.
+    #
+    #     sql_subst("foo %s bar %s", "$1", "$2") #-> "foo $1 bar $2"
+    #     sql_subst("foo %s bar %s", "$$"]     ) #-> "foo $$ bar $$"
+    #
+    # You can use this to configure your SQL ready for the parameterised query routine that comes
+    # with your data library. Note: this does not work if you redefine placeholder().
+    #
+    # You could also use it to turn a sql-with-placeholders string into valid SQL, by passing the
+    # (quoted) values array that you got from sql_select, etc.:
+    #
+    #     sql, vals =  sql_select(nil, id => 4)
+    #     validSQL = sql_subst( sql, *vals.map{|v| quote v} )
+    #
+    # Note: Don't do this. Dreadful idea. 
+    # If at all possible you should instead get the data source library to combine these two
+    # things. This will protect you against SQL injection (or if not, the library has screwed up).
+    #
+    def sql_subst(sql, *args)
+      raise ArgumentError, "bad SQL"     unless sql.kind_of? String
+      raise ArgumentError, "missing SQL" if sql.empty?
+
+      vals = args.map(&:to_s)
+
+      case 
+        when vals.empty?    then sql
+        when vals.size == 1 then sql.gsub("%s", vals.first) 
+        else 
+          raise ArgumentError, "wrong number of values" unless sql.scan("%s").count == vals.count
+          sql % args
+      end
+    end
+
+
+    ##
+    # Helper routine: given a hash, quote the keys as column names and keep the values as they are
+    # (since we don't know whether your parameterised query routine in your data source library
+    # does that for you).
+    #
+    # Return the hash as two arrays, to ensure the ordering is consistent.
+    #
+    def parse_fldsvalues(hash)
+      flds = []; vals = []
+
+      hash.each do|f, v|
+        flds << quote_field(f.to_s)
+        vals << v
+      end
+
+      [flds, vals]
+    end
+
+  end
+
+
+end
+