colincasey-sequel 2.10.0 → 2.10.1

data/lib/sequel_core/adapters/jdbc/mysql.rb

@@ -0,0 +1,66 @@
+require 'sequel_core/adapters/shared/mysql'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for MySQL specific
+    # support via JDBC.
+    module MySQL
+      # Database instance methods for MySQL databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::MySQL::DatabaseMethods
+        
+        # Return instance of Sequel::JDBC::MySQL::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::MySQL::Dataset.new(self, opts)
+        end
+        
+        private
+        
+        # The database name for the given database.  Need to parse it out
+        # of the connection string, since the JDBC does no parsing on the
+        # given connection string by default.
+        def database_name
+          u = URI.parse(uri.sub(/\Ajdbc:/, ''))
+          (m = /\/(.*)/.match(u.path)) && m[1]
+        end
+        
+        # Get the last inserted id using LAST_INSERT_ID().
+        def last_insert_id(conn, opts={})
+          stmt = conn.createStatement
+          begin
+            rs = stmt.executeQuery('SELECT LAST_INSERT_ID()')
+            rs.next
+            rs.getInt(1)
+          ensure
+            stmt.close
+          end
+        end
+      end
+      
+      # Dataset class for MySQL datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::MySQL::DatasetMethods
+        
+        # Use execute_insert to execute the insert_sql.
+        def insert(*values)
+          execute_insert(insert_sql(*values))
+        end
+        
+        # Handle time types correctly
+        def literal(v)
+          case v
+          when Time, DateTime
+            v.strftime("'%Y-%m-%d %H:%M:%S'")
+          else
+            super
+          end
+        end
+        
+        # Use execute_insert to execute the replace_sql.
+        def replace(*args)
+          execute_insert(replace_sql(*args))
+        end
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/jdbc/oracle.rb

@@ -0,0 +1,23 @@
+require 'sequel_core/adapters/shared/oracle'
+
+module Sequel
+  module JDBC
+    # Database and Dataset support for Oracle databases accessed via JDBC.
+    module Oracle
+      # Instance methods for Oracle Database objects accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::Oracle::DatabaseMethods
+        
+        # Return Sequel::JDBC::Oracle::Dataset object with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::Oracle::Dataset.new(self, opts)
+        end
+      end
+      
+      # Dataset class for Oracle datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::Oracle::DatasetMethods
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/jdbc/postgresql.rb

@@ -0,0 +1,113 @@
+require 'sequel_core/adapters/shared/postgres'
+
+module Sequel
+  Postgres::CONVERTED_EXCEPTIONS << NativeException
+  
+  module JDBC
+    # Adapter, Database, and Dataset support for accessing a PostgreSQL
+    # database via JDBC.
+    module Postgres
+      # Methods to add to the JDBC adapter/connection to allow it to work
+      # with the shared PostgreSQL code.
+      module AdapterMethods
+        include Sequel::Postgres::AdapterMethods
+        
+        # Give the JDBC adapter a direct execute method, which creates
+        # a statement with the given sql and executes it.
+        def execute(sql, args=nil)
+          method = block_given? ? :executeQuery : :execute
+          stmt = createStatement
+          begin
+            rows = stmt.send(method, sql)
+            yield(rows) if block_given?
+          rescue NativeException => e
+            raise_error(e)
+          ensure
+            stmt.close
+          end
+        end
+        
+        private
+        
+        # JDBC specific method of getting specific values from a result set.
+        def single_value(r)
+          unless r.nil?
+            r.next
+            r.getString(1) unless r.getRow == 0
+          end
+        end
+      end
+    
+      # Methods to add to Database instances that access PostgreSQL via
+      # JDBC.
+      module DatabaseMethods
+        include Sequel::Postgres::DatabaseMethods
+        
+        # Add the primary_keys and primary_key_sequences instance variables,
+        # so we can get the correct return values for inserted rows.
+        def self.extended(db)
+          db.instance_eval do
+            @primary_keys = {}
+            @primary_key_sequences = {}
+          end
+        end
+        
+        # Return instance of Sequel::JDBC::Postgres::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::Postgres::Dataset.new(self, opts)
+        end
+        
+        # Run the INSERT sql on the database and return the primary key
+        # for the record.
+        def execute_insert(sql, opts={})
+          super(sql, {:type=>:insert}.merge(opts))
+        end
+        
+        private
+        
+        # Extend the adapter with the JDBC PostgreSQL AdapterMethods
+        def setup_connection(conn)
+          conn = super(conn)
+          conn.extend(Sequel::JDBC::Postgres::AdapterMethods)
+          conn.db = self
+          conn.apply_connection_settings
+          conn
+        end
+        
+        # Call insert_result with the table and values specified in the opts.
+        def last_insert_id(conn, opts)
+          insert_result(conn, opts[:table], opts[:values])
+        end
+      end
+      
+      # Dataset subclass used for datasets that connect to PostgreSQL via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::Postgres::DatasetMethods
+
+        # Add the shared PostgreSQL prepared statement methods
+        def prepare(*args)
+          ps = super
+          ps.extend(::Sequel::Postgres::DatasetMethods::PreparedStatementMethods)
+          ps
+        end
+        
+        # Convert Java::JavaSql::Timestamps correctly, and handle Strings
+        # similar to the native postgres adapter.
+        def literal(v)
+          case v
+          when LiteralString
+            v
+          when SQL::Blob
+            super
+          when String
+            db.synchronize{|c| "'#{c.escape_string(v)}'"}
+          when Java::JavaSql::Timestamp
+            "TIMESTAMP #{literal(v.to_s)}"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/jdbc/sqlite.rb

@@ -0,0 +1,43 @@
+require 'sequel_core/adapters/shared/sqlite'
+
+module Sequel
+  module JDBC
+    # Database and Dataset support for SQLite databases accessed via JDBC.
+    module SQLite
+      # Instance methods for SQLite Database objects accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::SQLite::DatabaseMethods
+        
+        # Return Sequel::JDBC::SQLite::Dataset object with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::SQLite::Dataset.new(self, opts)
+        end
+        
+        private
+        
+        # Use last_insert_rowid() to get the last inserted id.
+        def last_insert_id(conn, opts={})
+          stmt = conn.createStatement
+          begin
+            rs = stmt.executeQuery('SELECT last_insert_rowid()')
+            rs.next
+            rs.getInt(1)
+          ensure
+            stmt.close
+          end
+        end
+        
+        # Default to a single connection for a memory database.
+        def connection_pool_default_options
+          o = super
+          uri == 'jdbc:sqlite::memory:' ? o.merge(:max_connections=>1) : o
+        end
+      end
+      
+      # Dataset class for SQLite datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::SQLite::DatasetMethods
+      end
+    end
+  end
+end