ibm_db 0.9.3 → 0.9.4

data/CHANGES

@@ -1,5 +1,10 @@
 Change Log
 ==============
+2008/04/28 (IBM_DB adapter 0.9.4, driver 0.9.4):
+  - Fixed bug [#19679]--> invalid values being returned for blank or null in fetch_assoc
+  - Fixed bug [#19223] and [#19224]--> handling of composite and unique indexes incorrect
+  - Support for the Rails2.0 type of migrations for columns of type xml [t.xml :xml_col1,:xml_col2]
+   
 2008/03/10 (IBM_DB adapter 0.9.3, driver 0.9.3):
   - Resolved the issue of truncation of output when stored procedure was called
   

data/ext/ibm_db.c

@@ -10,7 +10,7 @@
   +----------------------------------------------------------------------+
 */
 
-#define MODULE_RELEASE "0.9.3"
+#define MODULE_RELEASE "0.9.4"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -4703,6 +4703,24 @@ static RETCODE _ruby_ibm_db_get_data2(stmt_handle *stmt_res, SQLUSMALLINT col_nu
 
   return rc;
 }
+
+/*Function to check if the value of the LOB in the column is null or not*/
+int isNullLOB(VALUE *return_value,int i,stmt_handle *stmt_res,int op)
+{
+	if (stmt_res->column_info[i].loc_ind == SQL_NULL_DATA) {
+		if ( op & FETCH_ASSOC ) {
+		  rb_hash_aset(*return_value, rb_str_new2((char*)stmt_res->column_info[i].name), Qnil);
+		}
+		if ( op == FETCH_INDEX ) {
+		  rb_ary_store(*return_value, i, Qnil);
+		} else if ( op == FETCH_BOTH ) {
+		  rb_hash_aset(*return_value, INT2NUM(i), Qnil);
+		}
+		  return 1;
+	}
+		return 0;
+}
+
 /* }}} */
 
 /*
@@ -4829,6 +4847,7 @@ VALUE ibm_db_result(int argc, VALUE *argv, VALUE self)
         break;
 
       case SQL_CLOB:
+
         rc = _ruby_ibm_db_get_length(stmt_res, col_num+1, &in_length);
         if ( rc == SQL_ERROR ) {
           return Qfalse;
@@ -4855,6 +4874,7 @@ VALUE ibm_db_result(int argc, VALUE *argv, VALUE self)
       case SQL_LONGVARBINARY:
 #endif /* PASE */
       case SQL_VARBINARY:
+
         rc = _ruby_ibm_db_get_length(stmt_res, col_num+1, &in_length);
         if ( rc == SQL_ERROR ) {
           return Qfalse;
@@ -4891,6 +4911,7 @@ VALUE ibm_db_result(int argc, VALUE *argv, VALUE self)
         break;
 
       case SQL_XML:
+
         rc = _ruby_ibm_db_get_length(stmt_res, col_num+1, &in_length);
         if ( rc == SQL_ERROR ) {
           return Qfalse;
@@ -5152,6 +5173,13 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(int argc, VALUE *argv, int op)
           break;
 
         case SQL_BLOB:
+        
+        /*Check if the data value in the column is null*/
+        
+        if(isNullLOB(&return_value,i,stmt_res,op))
+		{
+			break;
+		}
           out_ptr = NULL;
           rc=_ruby_ibm_db_get_length(stmt_res, i+1, &tmp_length);
 
@@ -5208,6 +5236,14 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(int argc, VALUE *argv, int op)
           break;
 
         case SQL_XML:
+        
+		/*Check if the data value in the column is null*/
+
+		  if(isNullLOB(&return_value,i,stmt_res,op))
+		  {
+			break;
+		  }
+
           out_ptr = NULL;
           rc = _ruby_ibm_db_get_data(stmt_res, i+1, SQL_C_BINARY, NULL, 0, (SQLINTEGER *)&tmp_length);
           if ( rc == SQL_ERROR ) {
@@ -5250,6 +5286,13 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(int argc, VALUE *argv, int op)
           break;
 
         case SQL_CLOB:
+        
+		/*Check if the data value in the column is null*/
+
+		  if(isNullLOB(&return_value,i,stmt_res,op))
+		  {
+		    	break;
+		  }
           out_ptr = NULL;
           rc = _ruby_ibm_db_get_length(stmt_res, i+1, &tmp_length);
 

data/lib/active_record/connection_adapters/ibm_db_adapter.rb

@@ -227,8 +227,21 @@ requires credentials: username and password"
      end #class IBM_DBColumn
 
     class TableDefinition
+      
+      #Method to support the new syntax of rails 2.0 migrations for columns of type xml 
+      def xml(*args )
+        options = {}
+        if args.last.is_a?(Hash) 
+          options = args.delete_at(args.length-1)
+        end
+        args.each do | name | 
+          column(name,'xml',options)
+        end # end args.each
+        return self
+      end
+      
       # Overrides the abstract adapter in order to handle
-      # the DEFAULT option for the native XML datat type
+      # the DEFAULT option for the native XML datatype
       def column(name, type, options ={})
         # construct a column definition where @base is adaptor instance
         column = ColumnDefinition.new(@base, name, type)
@@ -776,38 +789,86 @@ requires credentials: username and password"
 
       # Returns an array of non-primary key indexes for a specified table name
       def indexes(table_name, name = nil)
-        # to_s required because +table_name+ may be a symbol.
+                # to_s required because +table_name+ may be a symbol.
         table_name = table_name.to_s
         # Checks if a blank table name has been given.
         # If so it returns an empty array of columns.
         return [] if table_name.strip.empty?
 
-        # +indexes+ will contain the resulting array
+        # +index_array+ will contain the resulting array
         indexes = []
+        index_array = []
+        pk_index = nil
+        index_schema = []
+        
+        #fetch the primary keys of the table using function primary_keys
+        #TABLE_SCHEM:: pk_index[1]
+        #TABLE_NAME:: pk_index[2]
+        #COLUMN_NAME:: pk_index[3]
+        #PK_NAME:: pk_index[5]
+        if stmt = IBM_DB::primary_keys( @connection, nil, 
+                                      @servertype.set_case(@schema), 
+                                      @servertype.set_case(table_name))
+          begin
+            while ( pk_index_row = IBM_DB::fetch_array(stmt) )
+               pk_index_name = pk_index_row[5].downcase
+               pk_index_columns = pk_index_row[3].map{|c| c.downcase}           # COLUMN_NAME
+               if pk_index 
+                   pk_index.columns = "#{pk_index.columns} , #{pk_index_columns}"
+               else
+                    pk_index = IndexDefinition.new(table_name, pk_index_name, true, pk_index_columns)
+                   
+                end
+            end
+          ensure  # Free resources associated with the statement
+            IBM_DB::free_result(stmt) if stmt
+          end
+        else  # Handle driver execution errors
+          error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+          if error_msg && !error_msg.empty?
+            raise "Failed to retrieve primary key metadata due to error: #{error_msg}"
+          else
+            raise StandardError('Unexpected error during primary key retrieval')
+          end
+        end
+        
+        
         # Query table statistics for all indexes on the table
         # "TABLE_NAME:   #{index_stats[2]}"
         # "NON_UNIQUE:   #{index_stats[3]}"
         # "INDEX_NAME:   #{index_stats[5]}"
         # "COLUMN_NAME:  #{index_stats[8]}"
-        if stmt = IBM_DB::statistics( @connection, nil, 
+      if stmt = IBM_DB::statistics( @connection, nil, 
                                       @servertype.set_case(@schema), 
                                       @servertype.set_case(table_name), 1 )
-          begin
-            while ( index_stats = IBM_DB::fetch_array(stmt) )
-              if index_stats[5]                                          # INDEX_NAME
-                index_name = index_stats[5].downcase
-                # Non-unique index type (not the primary key)
-                unless index_stats[3] == 0                               # NON_UNIQUE
-                  index_unique = (index_stats[3] == 0)
-                  index_columns = index_stats[8].map{|c| c.downcase}     # COLUMN_NAME
-                  # Create an IndexDefinition object and add to the indexes array
-                  indexes << IndexDefinition.new(table_name, index_name, index_unique, index_columns)
-                end
-              end
+      begin
+        while ( index_stats = IBM_DB::fetch_array(stmt) )
+          is_composite = false
+          if index_stats[5]             # INDEX_NAME
+            index_name = index_stats[5].downcase
+            index_unique = (index_stats[3] == 0)
+            index_columns = index_stats[8].map{|c| c.downcase}     # COLUMN_NAME
+            index_qualifier = index_stats[4]             #Index_Qualifier
+            # Create an IndexDefinition object and add to the indexes array
+            i = 0;
+            indexes.each do |index|
+              if index.name == index_name && index_schema[i] == index_qualifier
+                index.columns = "#{index.columns} , #{index_columns}"
+                is_composite = true
+              end 
+              i = i+1
             end
-          ensure  # Free resources associated with the statement
-            IBM_DB::free_result(stmt) if stmt
+              
+            unless is_composite 
+              indexes << IndexDefinition.new(table_name, index_name, index_unique, index_columns)
+              index_schema << index_qualifier.downcase
+            end 
+            
           end
+        end
+      ensure  # Free resources associated with the statement
+        IBM_DB::free_result(stmt) if stmt
+      end
         else  # Handle driver execution errors
           error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
           if error_msg && !error_msg.empty?
@@ -816,10 +877,21 @@ requires credentials: username and password"
             raise StandardError('Unexpected error during index retrieval')
           end
         end
+    
+    # remove the primary key index entry.... shouldnt be dumped by the dumper
+    
+      i = 0
+      indexes.each do |index|
+        unless index.columns == pk_index.columns
+          index.name = "#{index_schema[i]}.#{index.name}"
+          index_array << index
+        end
+          i = i+1
+      end 
         # Returns the indexes array
-        return indexes
+        return index_array
       end
-
+      
       # Returns an array of Column objects for the table specified by +table_name+
       def columns(table_name, name = nil)
         # to_s required because it may be a symbol.

data/test/adapter_test.rb

@@ -62,7 +62,7 @@ class AdapterTest < Test::Unit::TestCase
   end
 
   def test_indexes
-    idx_name = "accounts_idx"
+    idx_name = "#{ActiveRecord::Base.connection.schema}.accounts_idx"
       
     if @connection.respond_to?(:indexes)
       indexes = @connection.indexes("accounts")

data/test/migration_test.rb

@@ -152,6 +152,20 @@ if ActiveRecord::Base.connection.supports_migrations?
       ensure
         clasz.connection.drop_table(clasz.table_name) rescue nil
       end
+      
+      def test_new_xml_migrations
+        clasz = Class.new(ActiveRecord::Base)
+        clasz.table_name = 'test_new_xml_migrations'
+        assert_nothing_raised do
+          clasz.connection.create_table clasz.table_name do |t|
+                t.xml     :xml_col,:xml_col1,:xml_col2
+                t.string  :varchar_col
+                t.integer :int_col
+          end
+        end
+      ensure
+        clasz.connection.drop_table(clasz.table_name) rescue nil
+      end
     end
 
     def test_create_table_with_limits

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ibm_db
 version: !ruby/object:Gem::Version 
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors: 
 - IBM
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-03-20 00:00:00 -07:00
+date: 2008-04-30 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency