epugh-sequel 0.0.0

data/lib/sequel/adapters/jdbc/h2.rb

@@ -0,0 +1,62 @@
+Sequel.require %w'date_format unsupported', 'adapters/utils'
+
+module Sequel
+  module JDBC
+    # Database and Dataset support for H2 databases accessed via JDBC.
+    module H2
+      # Instance methods for H2 Database objects accessed via JDBC.
+      module DatabaseMethods
+        # H2 needs to add a primary key column as a constraint
+        def alter_table_sql(table, op)
+          case op[:op]
+          when :add_column
+            if op.delete(:primary_key)
+              sql = super(table, op)
+              [sql, "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})"]
+            else
+              super(table, op)
+            end
+          else
+            super(table, op)
+          end
+        end
+      
+        # Return Sequel::JDBC::H2::Dataset object with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::H2::Dataset.new(self, opts)
+        end
+        
+        # H2 uses an IDENTITY type
+        def serial_primary_key_options
+          {:primary_key => true, :type => :identity}
+        end
+        
+        private
+        
+        # Use IDENTITY() to get the last inserted id.
+        def last_insert_id(conn, opts={})
+          stmt = conn.createStatement
+          begin
+            rs = stmt.executeQuery('SELECT IDENTITY();')
+            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:h2:mem:' ? o.merge(:max_connections=>1) : o
+        end
+      end
+      
+      # Dataset class for H2 datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Dataset::SQLStandardDateFormat
+        include Dataset::UnsupportedIsTrue
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+Sequel.require '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
+        
+        # Use execute_insert to execute the replace_sql.
+        def replace(*args)
+          execute_insert(replace_sql(*args))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+Sequel.require '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/adapters/jdbc/postgresql.rb

@@ -0,0 +1,101 @@
+Sequel.require '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
+        
+        # Literalize strings similar to the native postgres adapter
+        def literal_string(v)
+          db.synchronize{|c| "'#{c.escape_string(v)}'"}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+Sequel.require '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

data/lib/sequel/adapters/mysql.rb

@@ -0,0 +1,370 @@
+require 'mysql'
+Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
+
+module Sequel
+  # Module for holding all MySQL-related classes and modules for Sequel.
+  module MySQL
+    # Mapping of type numbers to conversion procs
+    MYSQL_TYPES = {}
+
+    # Use only a single proc for each type to save on memory
+    MYSQL_TYPE_PROCS = {
+      [0, 246]  => lambda{|v| BigDecimal.new(v)},                   # decimal
+      [1, 2, 3, 8, 9, 13, 247, 248]  => lambda{|v| v.to_i},         # integer
+      [4, 5]  => lambda{|v| v.to_f},                                # float
+      [10, 14]  => lambda{|v| @zero_date_time_behavior_convert_to_null ? trap_bad_date_time(v) : Sequel.string_to_date(v)},                # date
+      [7, 12] => lambda{|v| @zero_date_time_behavior_convert_to_null ? trap_bad_date_time(v) : Sequel.string_to_datetime(v)},          # datetime
+      [11]  => lambda{|v| @zero_date_time_behavior_convert_to_null ? trap_bad_date_time(v) : Sequel.string_to_time(v)},                # time
+      [249, 250, 251, 252]  => lambda{|v| Sequel::SQL::Blob.new(v)} # blob
+    }
+    MYSQL_TYPE_PROCS.each do |k,v|
+      k.each{|n| MYSQL_TYPES[n] = v}
+    end
+    
+    @zero_date_time_behavior_convert_to_null = false
+
+    class << self
+      # Similar to the JDBC parameter zeroDateTimeBehavior=convertToNull, handles 
+      # dates 0000-00-00 and times like 00:00:00 and converts to null
+      attr_accessor :zero_date_time_behavior_convert_to_null
+
+      def trap_bad_date_time(v)
+        result = nil
+        begin
+          result = Sequel.string_to_date(v)
+        rescue Sequel::Error::InvalidValue
+        end
+        result
+      end
+    end    
+  
+    # Database class for MySQL databases used with Sequel.
+    class Database < Sequel::Database
+      include Sequel::MySQL::DatabaseMethods
+      
+      set_adapter_scheme :mysql
+      
+      # Support stored procedures on MySQL
+      def call_sproc(name, opts={}, &block)
+        args = opts[:args] || [] 
+        execute("CALL #{name}#{args.empty? ? '()' : literal(args)}", opts.merge(:sproc=>false), &block)
+      end
+      
+      # Connect to the database.  In addition to the usual database options,
+      # the following options have effect:
+      #
+      # * :auto_is_null - Set to true to use MySQL default behavior of having
+      #   a filter for an autoincrement column equals NULL to return the last
+      #   inserted row.
+      # * :charset - Same as :encoding (:encoding takes precendence)
+      # * :compress - Set to false to not compress results from the server
+      # * :encoding - Set all the related character sets for this
+      #   connection (connection, client, database, server, and results).
+      # * :socket - Use a unix socket file instead of connecting via TCP/IP.
+      # * :timeout - Set the timeout in seconds before the server will
+      #   disconnect this connection.
+      def connect(server)
+        opts = server_opts(server)
+        conn = Mysql.init
+        conn.options(Mysql::OPT_LOCAL_INFILE, "client")
+        if encoding = opts[:encoding] || opts[:charset]
+          # set charset _before_ the connect. using an option instead of "SET (NAMES|CHARACTER_SET_*)" works across reconnects
+          conn.options(Mysql::SET_CHARSET_NAME, encoding)
+        end
+        conn.real_connect(
+          opts[:host] || 'localhost',
+          opts[:user],
+          opts[:password],
+          opts[:database],
+          opts[:port],
+          opts[:socket],
+          Mysql::CLIENT_MULTI_RESULTS +
+          Mysql::CLIENT_MULTI_STATEMENTS +
+          (opts[:compress] == false ? 0 : Mysql::CLIENT_COMPRESS)
+        )
+
+        # increase timeout so mysql server doesn't disconnect us
+        conn.query("set @@wait_timeout = #{opts[:timeout] || 2592000}")
+
+        # By default, MySQL 'where id is null' selects the last inserted id
+        conn.query("set SQL_AUTO_IS_NULL=0") unless opts[:auto_is_null]
+
+        conn.query_with_result = false
+        class << conn
+          attr_accessor :prepared_statements
+        end
+        conn.prepared_statements = {}
+        conn.reconnect = true
+        conn
+      end
+      
+      # Returns instance of Sequel::MySQL::Dataset with the given options.
+      def dataset(opts = nil)
+        MySQL::Dataset.new(self, opts)
+      end
+      
+      # Executes the given SQL using an available connection, yielding the
+      # connection if the block is given.
+      def execute(sql, opts={}, &block)
+        return call_sproc(sql, opts, &block) if opts[:sproc]
+        return execute_prepared_statement(sql, opts, &block) if Symbol === sql
+        begin
+          synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
+        rescue Mysql::Error => e
+          raise_error(e)
+        end
+      end
+      
+      # Return the version of the MySQL server two which we are connecting.
+      def server_version(server=nil)
+        @server_version ||= (synchronize(server){|conn| conn.server_version if conn.respond_to?(:server_version)} || super)
+      end
+      
+      # Support single level transactions on MySQL.
+      def transaction(opts={})
+        unless opts.is_a?(Hash)
+          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
+          opts = {:server=>opts}
+        end
+        synchronize(opts[:server]) do |conn|
+          return yield(conn) if @transactions.include?(Thread.current)
+          log_info(begin_transaction_sql)
+          conn.query(begin_transaction_sql)
+          begin
+            @transactions << Thread.current
+            yield(conn)
+          rescue ::Exception => e
+            log_info(rollback_transaction_sql)
+            conn.query(rollback_transaction_sql)
+            transaction_error(e, Mysql::Error)
+          ensure
+            unless e
+              log_info(commit_transaction_sql)
+              conn.query(commit_transaction_sql)
+            end
+            @transactions.delete(Thread.current)
+          end
+        end
+      end
+
+      private
+      
+      # Execute the given SQL on the given connection.  If the :type
+      # option is :select, yield the result of the query, otherwise
+      # yield the connection if a block is given.
+      def _execute(conn, sql, opts)
+        log_info(sql)
+        conn.query(sql)
+        if opts[:type] == :select
+          loop do
+            begin
+              r = conn.use_result
+            rescue Mysql::Error
+              nil
+            else
+              begin
+                yield r
+              ensure
+                r.free
+              end
+            end
+            break unless conn.respond_to?(:next_result) && conn.next_result
+          end
+        else
+          yield conn if block_given?
+        end
+      end
+      
+      # MySQL doesn't need the connection pool to convert exceptions.
+      def connection_pool_default_options
+        super.merge(:pool_convert_exceptions=>false)
+      end
+      
+      # The database name when using the native adapter is always stored in
+      # the :database option.
+      def database_name
+        @opts[:database]
+      end
+      
+      # Closes given database connection.
+      def disconnect_connection(c)
+        c.close
+      end
+      
+      # Executes a prepared statement on an available connection.  If the
+      # prepared statement already exists for the connection and has the same
+      # SQL, reuse it, otherwise, prepare the new statement.  Because of the
+      # usual MySQL stupidity, we are forced to name arguments via separate
+      # SET queries.  Use @sequel_arg_N (for N starting at 1) for these
+      # arguments.
+      def execute_prepared_statement(ps_name, opts, &block)
+        args = opts[:arguments]
+        ps = prepared_statements[ps_name]
+        sql = ps.prepared_sql
+        synchronize(opts[:server]) do |conn|
+          unless conn.prepared_statements[ps_name] == sql
+            conn.prepared_statements[ps_name] = sql
+            s = "PREPARE #{ps_name} FROM '#{::Mysql.quote(sql)}'"
+            log_info(s)
+            conn.query(s)
+          end
+          i = 0
+          args.each do |arg|
+            s = "SET @sequel_arg_#{i+=1} = #{literal(arg)}"
+            log_info(s)
+            conn.query(s)
+          end
+          _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
+        end
+      end
+    end
+    
+    # Dataset class for MySQL datasets accessed via the native driver.
+    class Dataset < Sequel::Dataset
+      include Sequel::MySQL::DatasetMethods
+      include StoredProcedures
+      
+      # Methods to add to MySQL prepared statement calls without using a
+      # real database prepared statement and bound variables.
+      module CallableStatementMethods
+        # Extend given dataset with this module so subselects inside subselects in
+        # prepared statements work.
+        def subselect_sql(ds)
+          ps = ds.to_prepared_statement(:select)
+          ps.extend(CallableStatementMethods)
+          ps.prepared_args = prepared_args
+          ps.prepared_sql
+        end
+      end
+      
+      # Methods for MySQL prepared statements using the native driver.
+      module PreparedStatementMethods
+        include Sequel::Dataset::UnnumberedArgumentMapper
+        
+        private
+        
+        # Execute the prepared statement with the bind arguments instead of
+        # the given SQL.
+        def execute(sql, opts={}, &block)
+          super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+        
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_dui(sql, opts={}, &block)
+          super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+      end
+      
+      # Methods for MySQL stored procedures using the native driver.
+      module StoredProcedureMethods
+        include Sequel::Dataset::StoredProcedureMethods
+        
+        private
+        
+        # Execute the database stored procedure with the stored arguments.
+        def execute(sql, opts={}, &block)
+          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
+        end
+        
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_dui(sql, opts={}, &block)
+          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
+        end
+      end
+      
+      # MySQL is different in that it supports prepared statements but not bound
+      # variables outside of prepared statements.  The default implementation
+      # breaks the use of subselects in prepared statements, so extend the
+      # temporary prepared statement that this creates with a module that
+      # fixes it.
+      def call(type, bind_arguments={}, values=nil)
+        ps = to_prepared_statement(type, values)
+        ps.extend(CallableStatementMethods)
+        ps.call(bind_arguments)
+      end
+      
+      # Delete rows matching this dataset
+      def delete(opts = (defarg=true;nil))
+        execute_dui(defarg ? delete_sql : delete_sql(opts)){|c| c.affected_rows}
+      end
+      
+      # Yield all rows matching this dataset
+      def fetch_rows(sql)
+        execute(sql) do |r|
+          column_types = []
+          @columns = r.fetch_fields.map{|f| column_types << f.type; output_identifier(f.name)}
+          while row = r.fetch_row
+            h = {}
+            @columns.each_with_index {|f, i| h[f] = convert_type(row[i], column_types[i])}
+            yield h
+          end
+        end
+        self
+      end
+      
+      # Insert a new value into this dataset
+      def insert(*values)
+        execute_dui(insert_sql(*values)){|c| c.insert_id}
+      end
+      
+      # Store the given type of prepared statement in the associated database
+      # with the given name.
+      def prepare(type, name=nil, values=nil)
+        ps = to_prepared_statement(type, values)
+        ps.extend(PreparedStatementMethods)
+        if name
+          ps.prepared_statement_name = name
+          db.prepared_statements[name] = ps
+        end
+        ps
+      end
+      
+      # Replace (update or insert) the matching row.
+      def replace(*args)
+        execute_dui(replace_sql(*args)){|c| c.insert_id}
+      end
+      
+      # Update the matching rows.
+      def update(values={}, opts=(defarg=true;nil))
+        execute_dui(defarg ? update_sql(values) : update_sql(values, opts)){|c| c.affected_rows}
+      end
+      
+      private
+      
+      # Convert the type of v using the method in MYSQL_TYPES[type].
+      def convert_type(v, type)
+        if v
+          if type == 1 && Sequel.convert_tinyint_to_bool
+            # We special case tinyint here to avoid adding
+            # a method to an ancestor of Fixnum
+            v.to_i == 0 ? false : true
+          else
+            (b = MYSQL_TYPES[type]) ? b.call(v) : v
+          end
+        else
+          nil
+        end
+      end
+      
+      # Set the :type option to :select if it hasn't been set.
+      def execute(sql, opts={}, &block)
+        super(sql, {:type=>:select}.merge(opts), &block)
+      end
+      
+      # Set the :type option to :dui if it hasn't been set.
+      def execute_dui(sql, opts={}, &block)
+        super(sql, {:type=>:dui}.merge(opts), &block)
+      end
+      
+      # Handle correct quoting of strings using ::MySQL.quote.
+      def literal_string(v)
+        "'#{::Mysql.quote(v)}'"
+      end
+      
+      # Extend the dataset with the MySQL stored procedure methods.
+      def prepare_extend_sproc(ds)
+        ds.extend(StoredProcedureMethods)
+      end
+    end
+  end
+end