sequel 3.39.0 → 3.40.0

data/CHANGELOG

@@ -1,3 +1,33 @@
+=== 3.40.0 (2012-09-26)
+
+* Add a cubrid adapter for accessing CUBRID databases via the cubrid gem (jeremyevans)
+
+* Add a jdbc/cubrid adapter for accessing CUBRID databases via JDBC on JRuby (jeremyevans)
+
+* Return OCI8::CLOB values as ruby Strings in the Oracle adapter (jeremyevans)
+
+* Use clob for String :text=>true types on Oracle, DB2, HSQLDB, and Derby (jeremyevans) (#555)
+
+* Allowing marshalling of Sequel::Postgres::HStore (jeremyevans) (#556)
+
+* Quote channel identifier names when using LISTEN/NOTIFY on PostgreSQL (jeremyevans)
+
+* Handle nil values when formatting bound variable arguments in the pg_row extension (jeremyevans) (#548)
+
+* Handle nil values when parsing composite types in the pg_row extension (jeremyevans) (#548)
+
+* Add :disconnect=>:retry option to Database#transaction, for automatically retrying the transaction on disconnect (jeremyevans)
+
+* Greatly improved support on Microsoft Access (jeremyevans)
+
+* Support Database#{schema,tables,views,indexes,foreign_key_list} when using ado/access adapter (ericgj) (#545, #546)
+
+* Add ado/access adapter for accessing Microsoft Access via the ado adapter (jeremyevans)
+
+* Combine disconnect error detection for mysql and mysql2 adapters (jeremyevans)
+
+* Update the association_pks plugin to handle composite primary keys (chanks, jeremyevans) (#544)
+
 === 3.39.0 (2012-09-01)
 
 * Fix defaults_setter to set false default values (jeremyevans)

data/README.rdoc

@@ -11,9 +11,10 @@ toolkit for Ruby.
   statements, bound variables, stored procedures, savepoints,
   two-phase commit, transaction isolation, master/slave
   configurations, and database sharding.
-* Sequel currently has adapters for ADO, Amalgalite, DataObjects,
-  DB2, DBI, Firebird, IBM_DB, Informix, JDBC, MySQL, Mysql2, ODBC,
-  OpenBase, Oracle, PostgreSQL, SQLite3, Swift, and TinyTDS.
+* Sequel currently has adapters for ADO, Amalgalite, CUBRID,
+  DataObjects, DB2, DBI, Firebird, IBM_DB, Informix, JDBC, MySQL,
+  Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, Swift, and
+  TinyTDS.
 
 == Resources
 

data/doc/active_record.rdoc

@@ -456,7 +456,7 @@ This part of the guide will list Sequel equivalents for ActiveRecord methods, ho
 
 ==== +abstract_class+, <tt>abstract_class=</tt>, <tt>abstract_class?</tt>
 
-With Sequel, these methods don't exist because it doesn't default to using single table inheritance in subclasses.  ActiveRecord assumes that subclasses of Model classes use single table inheritance, and you have to set <tt>abstract_class = true</tt> to use an abstract class.  In Sequel, you must use the +single_table_inheritance+ or +class_tabble_inheritance+ plugin to configure inheritance in the database.
+With Sequel, these methods don't exist because it doesn't default to using single table inheritance in subclasses.  ActiveRecord assumes that subclasses of Model classes use single table inheritance, and you have to set <tt>abstract_class = true</tt> to use an abstract class.  In Sequel, you must use the +single_table_inheritance+ or +class_table_inheritance+ plugin to configure inheritance in the database.
 
 ==== +all+
 

data/doc/opening_databases.rdoc

@@ -148,6 +148,12 @@ Without a database argument, assumes a memory database, so you can do:
 Handles paths in the connection string similar to the SQLite adapter, so see
 the sqlite section below for details.
 
+=== cubrid
+
+cubrid is a ruby extension for accessing a CUBRID database.  Currently,
+the ruby cubrid gem is in fairly rough state, with broken transaction
+support and some other issues, but most things work.
+
 === db2 
 
 Requires: db2/db2cli
@@ -266,6 +272,7 @@ Example connection strings:
   jdbc:db2://localhost:3700/database:user=user;password=password;
   jdbc:firebirdsql:localhost/3050:/path/to/database.fdb
   jdbc:jdbcprogress:T:hostname:port:database
+  jdbc:cubrid:hostname:port:database:::
 
 You can also use JNDI connection strings:
 

data/doc/release_notes/3.40.0.txt

@@ -0,0 +1,73 @@
+= New Features
+
+* Sequel now has vastly improved support for Microsoft Access.
+
+* Sequel now supports the CUBRID database, with a cubrid adapter
+  that uses the cubrid gem, and a jdbc/cubrid adapter for accessing
+  CUBRID via JDBC on JRuby.
+
+* The association_pks plugin now supports composite keys.
+
+* Database#transaction now accepts a :disconnect=>:retry option,
+  in which case it will automatically retry the block if it
+  detects a disconnection.  This is potentially dangerous, and
+  should only be used if the entire block is idempotent.  There
+  is also no checking against an infinite retry loop.
+
+* SQL::CaseExpression#with_merged_expression has been added, for
+  converting a CaseExpression with an associated expression to
+  one without an associated expression, by merging the expression
+  into each condition.
+
+= Other Improvements
+
+* Sequel now quotes arguments/columns in common table expressions.
+
+* Sequel now handles nil values correctly in the pg_row extension.
+
+* Sequel::Postgres::HStore instances can now be marshalled.
+
+* Sequel now uses clob for String :text=>true types on databases that
+  don't support a text type.
+
+* On PostgreSQL, Sequel now quotes channel identifier names when using
+  LISTEN/NOTIFY.
+
+* On PostgreSQL, Sequel now correctly handles the case where named
+  type conversion procs have been added before the Database object is
+  instantiated.
+
+* On DB2, Sequel now explicitly sets NOT NULL for unique constraint
+  columns instead of foreign key columns.  DB2 does not allow columns
+  in unique constraints to be NULL, but does allow foreign key columns
+  to be NULL.
+
+* In the oracle adapter, clob values are now returned as ruby strings
+  upon retrieval.
+
+* Sequel now detects more types of disconnections in the postgres,
+  mysql, and mysql2 adapters.
+
+* If a database provides a default column value that isn't a ruby
+  string, it is used directly as the ruby default, instead of causing
+  the schema parsing to fail.
+
+= Backwards Compatibility
+
+* Code using Sequel's oracle adapter that expected clob values to be
+  returned as OCI8::CLOB instances needs to be modified to work with
+  ruby strings.
+
+* Because Sequel now quotes column names in common table expressions,
+  those names are now case sensitive, which could break certain poorly
+  coded queries.  Similar issues exist with the quoting of channel
+  identifier names in LISTEN/NOTIFY on PostgreSQL.
+
+* The private Database#requires_return_generated_keys? method
+  has been removed from the jdbc adapter.  Custom jdbc subadapters
+  relying on this method should override the private
+  Database#execute_statement_insert method instead to ensure that
+  RETURN_GENERATED_KEYS is used for insert statements.
+
+* The private Dataset#argument_list and #argument_list_append methods
+  have been removed.

data/lib/sequel/adapters/ado.rb

@@ -12,9 +12,9 @@ module Sequel
         super
         case @opts[:conn_string]
         when /Microsoft\.(Jet|ACE)\.OLEDB/io
-          Sequel.ts_require 'adapters/shared/access'
-          extend Sequel::Access::DatabaseMethods
-          extend_datasets(Sequel::Access::DatasetMethods)
+          Sequel.ts_require 'adapters/ado/access'
+          extend Sequel::ADO::Access::DatabaseMethods
+          @dataset_class = ADO::Access::Dataset
         else
           @opts[:driver] ||= 'SQL Server'
           case @opts[:driver]
@@ -57,6 +57,32 @@ module Sequel
         handle
       end
       
+      # Just execute so it doesn't attempt to return the number of rows modified.
+      def execute_ddl(sql, opts={})
+        execute(sql, opts)
+      end
+
+      # Just execute so it doesn't attempt to return the number of rows modified.
+      def execute_insert(sql, opts={})
+        execute(sql, opts)
+      end
+      
+      # Use pass by reference in WIN32OLE to get the number of affected rows,
+      # unless is a provider is in use (since some providers don't seem to
+      # return the number of affected rows, but the default provider appears
+      # to).
+      def execute_dui(sql, opts={})
+        return super if opts[:provider]
+        synchronize(opts[:server]) do |conn|
+          begin
+            log_yield(sql){conn.Execute(sql, 1)}
+            WIN32OLE::ARGV[1]
+          rescue ::WIN32OLERuntimeError => e
+            raise_error(e)
+          end
+        end
+      end
+
       def execute(sql, opts={})
         synchronize(opts[:server]) do |conn|
           begin

data/lib/sequel/adapters/ado/access.rb

@@ -0,0 +1,334 @@
+Sequel.require 'adapters/shared/access'
+Sequel.require 'adapters/utils/split_alter_table'
+
+module Sequel
+  module ADO
+    # Database and Dataset instance methods for Access specific
+    # support via ADO.
+    module Access
+      class AdoSchema
+        QUERY_TYPE = {
+          :columns => 4,
+          :indexes => 12,
+          :tables  => 20,
+          :views   => 23,
+          :foreign_keys => 27
+        }
+        
+        attr_reader :type, :criteria
+
+        def initialize(type, crit)
+          @type     = QUERY_TYPE[type]
+          @criteria = Array(crit)
+        end
+        
+        class Column
+          DATA_TYPE = {
+            2   => "SMALLINT",
+            3   => "INTEGER",
+            4   => "REAL",
+            5   => "DOUBLE",
+            6   => "MONEY",
+            7   => "DATETIME",
+            11  => "BIT",
+            14  => "DECIMAL",
+            16  => "TINYINT",
+            17  => "BYTE",
+            72  => "GUID",
+            128 => "BINARY",
+            130 => "TEXT",
+            131 => "DECIMAL",
+            201 => "TEXT",
+            205 => "IMAGE"
+          }
+          
+          def initialize(row)
+            @row = row
+          end
+          
+          def [](col)
+            @row[col]
+          end
+          
+          def allow_null
+            self["IS_NULLABLE"]
+          end
+          
+          def default
+            self["COLUMN_DEFAULT"]
+          end
+          
+          def db_type
+            t = DATA_TYPE[self["DATA_TYPE"]]
+            if t == "DECIMAL" && precision
+              t + "(#{precision.to_i},#{(scale || 0).to_i})"
+            elsif t == "TEXT" && maximum_length && maximum_length > 0
+              t + "(#{maximum_length.to_i})"
+            else
+              t
+            end
+          end
+          
+          def precision
+            self["NUMERIC_PRECISION"]
+          end
+          
+          def scale
+            self["NUMERIC_SCALE"]
+          end
+          
+          def maximum_length
+            self["CHARACTER_MAXIMUM_LENGTH"]
+          end
+        end
+      end      
+
+      module DatabaseMethods
+        include Sequel::Access::DatabaseMethods
+        include Sequel::Database::SplitAlterTable
+    
+        DECIMAL_TYPE_RE = /decimal/io
+        LAST_INSERT_ID = "SELECT @@IDENTITY".freeze
+
+        # Remove cached schema after altering a table, since otherwise it can be cached
+        # incorrectly in the rename column case.
+        def alter_table(name, *)
+          super
+          remove_cached_schema(name)
+          nil
+        end
+
+        # Access doesn't let you disconnect if inside a transaction, so
+        # try rolling back an existing transaction first.
+        def disconnect_connection(conn)
+          conn.RollbackTrans rescue nil
+          super
+        end
+
+        def execute_insert(sql, opts={})
+          synchronize(opts[:server]) do |conn|
+            begin
+              r = log_yield(sql){conn.Execute(sql)}
+              res = log_yield(LAST_INSERT_ID){conn.Execute(LAST_INSERT_ID)}
+              res.getRows.transpose.each{|r| return r.shift}
+            rescue ::WIN32OLERuntimeError => e
+              raise_error(e)
+            end
+          end
+          nil
+        end
+
+        def tables(opts={})
+          m = output_identifier_meth
+          ado_schema_tables.map {|tbl| m.call(tbl['TABLE_NAME'])}
+        end
+
+        def views(opts={})
+          m = output_identifier_meth
+          ado_schema_views.map {|tbl| m.call(tbl['TABLE_NAME'])}
+        end
+        
+        # Note OpenSchema returns compound indexes as multiple rows
+        def indexes(table_name,opts={})
+          m = output_identifier_meth
+          idxs = ado_schema_indexes(table_name).inject({}) do |memo, idx|
+            unless idx["PRIMARY_KEY"]
+              index = memo[m.call(idx["INDEX_NAME"])] ||= {
+                :columns=>[], :unique=>idx["UNIQUE"]
+              }
+              index[:columns] << m.call(idx["COLUMN_NAME"])
+            end
+            memo
+          end
+          idxs
+        end
+
+        # Note OpenSchema returns compound foreign key relationships as multiple rows
+        def foreign_key_list(table, opts={})
+          m = output_identifier_meth
+          fks = ado_schema_foreign_keys(table).inject({}) do |memo, fk|
+            name = m.call(fk['FK_NAME'])
+            specs = memo[name] ||= {
+              :columns => [],
+              :table   => m.call(fk['PK_TABLE_NAME']),
+              :key     => [],
+              :deferrable => fk['DEFERRABILITY'],
+              :name    => name,
+              :on_delete => fk['DELETE_RULE'],
+              :on_update => fk['UPDATE_RULE']
+            }
+            specs[:columns] << m.call(fk['FK_COLUMN_NAME'])
+            specs[:key]     << m.call(fk['PK_COLUMN_NAME'])
+            memo
+          end
+          fks.values
+        end
+                
+        private
+
+        # Emulate rename_column by adding the column, copying data from the old
+        # column, and dropping the old column.
+        def alter_table_sql(table, op)
+          case op[:op]
+          when :rename_column
+            unless sch = op[:schema]
+              raise(Error, "can't find existing schema entry for #{op[:name]}") unless sch = op[:schema] || schema(table).find{|c| c.first == op[:name]}
+              sch = sch.last
+            end
+            [
+              alter_table_sql(table, :op=>:add_column, :name=>op[:new_name], :default=>sch[:ruby_default], :type=>sch[:db_type], :null=>sch[:allow_null]),
+              from(table).update_sql(op[:new_name]=>op[:name]),
+              alter_table_sql(table, :op=>:drop_column, :name=>op[:name])
+            ]
+          when :set_column_null, :set_column_default
+            raise(Error, "can't find existing schema entry for #{op[:name]}") unless sch = op[:schema] || schema(table).find{|c| c.first == op[:name]}
+            sch = sch.last
+
+            sch = if op[:op] == :set_column_null
+              sch.merge(:allow_null=>op[:null])
+            else
+              sch.merge(:ruby_default=>op[:default])
+            end
+
+            [
+              alter_table_sql(table, :op=>:rename_column, :name=>op[:name], :new_name=>:sequel_access_backup_column, :schema=>sch),
+              alter_table_sql(table, :op=>:rename_column, :new_name=>op[:name], :name=>:sequel_access_backup_column, :schema=>sch)
+            ]
+          else
+            super
+          end
+        end
+
+        def begin_transaction(conn, opts={})
+          log_yield('Transaction.begin'){conn.BeginTrans}
+        end
+          
+        def commit_transaction(conn, opts={})
+          log_yield('Transaction.commit'){conn.CommitTrans}
+        end
+          
+        def rollback_transaction(conn, opts={})
+          log_yield('Transaction.rollback'){conn.RollbackTrans}
+        end
+          
+        def schema_column_type(db_type)
+          case db_type.downcase
+          when 'bit'
+            :boolean
+          when 'byte', 'guid'
+            :integer
+          when 'image'
+            :blob
+          else
+            super
+          end
+        end
+        
+        def schema_parse_table(table_name, opts)
+          m = output_identifier_meth(opts[:dataset])
+          m2 = input_identifier_meth(opts[:dataset])
+          tn = m2.call(table_name.to_s)
+          idxs = ado_schema_indexes(tn)
+          ado_schema_columns(tn).map {|row|
+            specs = { 
+              :allow_null => row.allow_null,
+              :db_type => row.db_type,
+              :default => row.default,
+              :primary_key => !!idxs.find {|idx| 
+                                idx["COLUMN_NAME"] == row["COLUMN_NAME"] &&
+                                idx["PRIMARY_KEY"]
+                              },
+              :type =>  if row.db_type =~ DECIMAL_TYPE_RE && row.scale == 0
+                          :integer
+                        else
+                          schema_column_type(row.db_type)
+                        end,
+              :ado_type => row["DATA_TYPE"]
+            }
+            specs[:default] = nil if blank_object?(specs[:default])
+            specs[:allow_null] = specs[:allow_null] && !specs[:primary_key]
+            [ m.call(row["COLUMN_NAME"]), specs ]
+          }
+        end
+
+        def ado_schema_tables
+          rows=[]
+          fetch_ado_schema(:tables, [nil,nil,nil,'TABLE']) do |row|
+            rows << row
+          end
+          rows
+        end
+
+        def ado_schema_views
+          rows=[]
+          fetch_ado_schema(:views, [nil,nil,nil]) do |row|
+            rows << row
+          end
+          rows
+        end
+        
+        def ado_schema_indexes(table_name)
+          rows=[]
+          fetch_ado_schema(:indexes, [nil,nil,nil,nil,table_name.to_s]) do |row|
+            rows << row
+          end
+          rows
+        end
+        
+        def ado_schema_columns(table_name)
+          rows=[]
+          fetch_ado_schema(:columns, [nil,nil,table_name.to_s,nil]) do |row| 
+            rows << AdoSchema::Column.new(row)
+          end
+          rows.sort!{|a,b| a["ORDINAL_POSITION"] <=> b["ORDINAL_POSITION"]}
+        end
+        
+        def ado_schema_foreign_keys(table_name)
+          rows=[]
+          fetch_ado_schema(:foreign_keys, [nil,nil,nil,nil,nil,table_name.to_s]) do |row| 
+            rows << row
+          end
+          rows.sort!{|a,b| a["ORDINAL"] <=> b["ORDINAL"]}
+        end
+        
+        def fetch_ado_schema(type, criteria=[])
+          execute_open_ado_schema(type, criteria) do |s|
+            cols = s.Fields.extend(Enumerable).map {|c| c.Name}
+            s.getRows.transpose.each do |r|
+              row = {}
+              cols.each{|c| row[c] = r.shift}
+              yield row
+            end unless s.eof
+          end
+        end
+             
+        # This is like execute() in that it yields an ADO RecordSet, except
+        # instead of an SQL interface there's this OpenSchema call
+        # cf. http://msdn.microsoft.com/en-us/library/ee275721(v=bts.10)
+        #
+        def execute_open_ado_schema(type, criteria=[])
+          ado_schema = AdoSchema.new(type, criteria)
+          synchronize(opts[:server]) do |conn|
+            begin
+              r = log_yield("OpenSchema #{type.inspect}, #{criteria.inspect}") { 
+                if ado_schema.criteria.empty?
+                  conn.OpenSchema(ado_schema.type) 
+                else
+                  conn.OpenSchema(ado_schema.type, ado_schema.criteria) 
+                end
+              }
+              yield(r) if block_given?
+            rescue ::WIN32OLERuntimeError => e
+              raise_error(e)
+            end
+          end
+          nil
+        end
+      end
+      
+      class Dataset < ADO::Dataset
+        include Sequel::Access::DatasetMethods
+      end
+    end
+  end
+end