ibm_db 0.7.5 → 0.8.0

data/ext/ibm_db.c

@@ -10,7 +10,7 @@
   +----------------------------------------------------------------------+
 */
 
-#define MODULE_RELEASE "0.6.0"
+#define MODULE_RELEASE "0.7.0"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -30,7 +30,7 @@ static void _ruby_ibm_db_assign_options( void* handle, int type, long opt_key, V
 static void _ruby_ibm_db_clear_conn_err_cache();
 static void _ruby_ibm_db_clear_stmt_err_cache();
 static char * _ruby_ibm_db_instance_name;
-static int is_systemi;		/* 1 == TRUE; 0 == FALSE; */
+static int is_systemi, is_informix;		/* 1 == TRUE; 0 == FALSE; */
 
 /* Defines a linked list structure for caching param data */
 typedef struct _param_cache_node {
@@ -187,6 +187,7 @@ void Init_ibm_db(void) {
   rb_define_module_function(mDB, "setoption", ibm_db_set_option, -1);
   rb_define_module_function(mDB, "get_option", ibm_db_get_option, -1);
   rb_define_module_function(mDB, "getoption", ibm_db_get_option, -1);
+  rb_define_module_function(mDB, "get_last_serial_value", ibm_db_get_last_serial_value, -1);
   rb_define_module_function(mDB, "fetch_object", ibm_db_fetch_object, -1);
   rb_define_module_function(mDB, "server_info", ibm_db_server_info, -1);
   rb_define_module_function(mDB, "client_info", ibm_db_client_info, -1);
@@ -244,6 +245,7 @@ void Init_ibm_db(void) {
   RUBY_FALIAS(setoption, set_option)
   RUBY_FE(get_option)
   RUBY_FALIAS(getoption, get_option)
+  RUBY_FE(get_last_serial_value)
   RUBY_FE(fetch_object)
   RUBY_FE(server_info)
   RUBY_FE(client_info)
@@ -1081,7 +1083,7 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
   do {
     /* Check if we already have a connection for this userID & database combination */
     if (isPersistent) {
-      hKeyLen = strlen(database) + strlen(uid) + strlen(password) + 9;
+      hKeyLen = strlen(database) + strlen(uid) + strlen(password) + 12;
       hKey = ALLOC_N(char, hKeyLen);
 
       sprintf(hKey, "__ibm_db_%s.%s.%s", uid, database, password);
@@ -1154,19 +1156,6 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
     }
 #endif
 
-    /* Set SQL_ATTR_REPLACE_QUOTED_LITERALS connection attribute to
-     * enable CLI numeric literal feature. This is equivalent to
-     * PATCH2=71 in the db2cli.ini file
-     */
-#ifndef PASE
-    rc = SQLSetConnectAttr((SQLHDBC)conn_res->hdbc, SQL_ATTR_REPLACE_QUOTED_LITERALS, (SQLPOINTER)(enable_numeric_literals), SQL_IS_INTEGER);
-#else
-    rc = SQLSetConnectAttr((SQLHDBC)conn_res->hdbc, SQL_ATTR_REPLACE_QUOTED_LITERALS, (SQLPOINTER)(&enable_numeric_literals), SQL_IS_INTEGER);
-#endif
-    if (rc != SQL_SUCCESS) {
-        _ruby_ibm_db_check_sql_errors(conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1);
-    }
-
     conn_res->c_bin_mode = IBM_DB_G(bin_mode);
     conn_res->c_case_mode = CASE_NATURAL;
     conn_res->c_cursor_type = SQL_SCROLL_FORWARD_ONLY;
@@ -1208,6 +1197,26 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
       memset(server, 0, sizeof(server));
       rc = SQLGetInfo(conn_res->hdbc, SQL_DBMS_NAME, (SQLPOINTER)server, 2048, NULL);
       if (!strcmp(server, "AS")) is_systemi = 1;
+      if (!strncmp(server, "IDS", 3)) is_informix = 1;
+
+    /* Set SQL_ATTR_REPLACE_QUOTED_LITERALS connection attribute to
+     * enable CLI numeric literal feature. This is equivalent to
+     * PATCH2=71 in the db2cli.ini file
+     */
+#ifndef PASE
+      /* Only enable this feature if we are not connected to an Informix data server */
+      if (!is_informix) {
+        rc = SQLSetConnectAttr((SQLHDBC)conn_res->hdbc, SQL_ATTR_REPLACE_QUOTED_LITERALS, (SQLPOINTER)(enable_numeric_literals), SQL_IS_INTEGER);
+      }
+#else
+      /* Only enable this feature if we are not connected to an Informix data server */
+      if (!is_informix) {
+        rc = SQLSetConnectAttr((SQLHDBC)conn_res->hdbc, SQL_ATTR_REPLACE_QUOTED_LITERALS, (SQLPOINTER)(&enable_numeric_literals), SQL_IS_INTEGER);
+      }
+#endif
+      if (rc != SQL_SUCCESS) {
+          _ruby_ibm_db_check_sql_errors(conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1);
+      }
     }
     conn_res->handle_active = 1;
   } while (0);
@@ -3257,7 +3266,7 @@ static int _ruby_ibm_db_bind_data( stmt_handle *stmt_res, param_node *curr, VALU
           if (curr->param_type == SQL_PARAM_OUTPUT || curr->param_type == SQL_PARAM_INPUT_OUTPUT) {
             curr->bind_indicator = curr->ivalue;
             valueType = SQL_C_CHAR;
-            paramValuePtr = (SQLPOINTER)curr;
+            paramValuePtr = (SQLPOINTER)curr->svalue;
           } else {
             curr->bind_indicator = SQL_DATA_AT_EXEC;
             valueType = SQL_C_CHAR;
@@ -6292,6 +6301,55 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
   }
 }
 
+
+/*
+ * IBM_DB::get_last_serial_value --  Gets the last inserted serial value from IDS
+ *
+ * ===Description
+ * string IBM_DB::get_last_serial_value ( resource stmt )
+ *
+ * Returns a string, that is the last inserted value for a serial column for IDS. 
+ * The last inserted value could be auto-generated or entered explicitly by the user
+ * This function is valid for IDS (Informix Dynamic Server only)
+ *
+ * ===Parameters
+ *
+ * stmt
+ *     A valid statement resource.
+ *
+ * ===Return Values
+ *
+ * Returns a string representation of last inserted serial value on a successful call. 
+ * Returns FALSE on failure.
+ */
+VALUE ibm_db_get_last_serial_value(int argc, VALUE *argv, VALUE self)
+{
+  VALUE stmt = Qnil;
+  SQLCHAR *value = NULL;
+  stmt_handle *stmt_res;
+  int rc = 0;
+  
+  rb_scan_args(argc, argv, "1", &stmt);
+
+  if (!NIL_P(stmt)) {
+    Data_Get_Struct(stmt, stmt_handle, stmt_res);
+
+    /* We allocate a buffer of size 31 as per recommendations from the CLI IDS team */
+    value = ALLOC_N(char, 31);
+    rc = SQLGetStmtAttr((SQLHSTMT)stmt_res->hstmt, SQL_ATTR_GET_GENERATED_VALUE, (SQLPOINTER)value, 31, NULL);
+    if ( rc == SQL_ERROR ) {
+      _ruby_ibm_db_check_sql_errors( (SQLHSTMT)stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1);
+      return Qfalse;
+    }
+    return INT2NUM(atoi(value));
+  }
+  else {
+    rb_throw("Supplied statement handle is invalid", Qnil);
+    return Qfalse;
+  }
+}
+
+
 /*
  * Local variables:
  * tab-width: 4

data/ext/ruby_ibm_db.h

@@ -25,6 +25,14 @@
 #define SQL_ATTR_REPLACE_QUOTED_LITERALS 116
 #endif
 
+/* If using a DB2 CLI version which doesn't support this functionality, explicitly
+ * define this. We will rely on DB2 CLI to throw an error when SQLGetStmtAttr is 
+ * called.
+ */
+#ifndef SQL_ATTR_GET_GENERATED_VALUE 
+#define SQL_ATTR_GET_GENERATED_VALUE 2578
+#endif
+
 #ifdef _WIN32
 #define RUBY_IBM_DB_API __declspec(dllexport)
 #else
@@ -125,6 +133,7 @@ VALUE ibm_db_free_result(int argc, VALUE *argv, VALUE self);
 VALUE ibm_db_set_option(int argc, VALUE *argv, VALUE self);
 VALUE ibm_db_setoption(int argc, VALUE *argv, VALUE self);
 VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self);
+VALUE ibm_db_get_last_serial_value(int argc, VALUE *argv, VALUE self);
 VALUE ibm_db_getoption(int argc, VALUE *argv, VALUE self);
 VALUE ibm_db_fetch_object(int argc, VALUE *argv, VALUE self);
 VALUE ibm_db_server_info(int argc, VALUE *argv, VALUE self);

data/lib/active_record/connection_adapters/ibm_db_adapter.rb

@@ -20,7 +20,8 @@ module ActiveRecord
         # Checks that the insert or update had at least a BLOB, CLOB or XML field
         if connection.sql =~ /BLOB\('(.*)'\)/i || 
            connection.sql =~ /@@@IBMTEXT@@@/i || 
-           connection.sql =~ /@@@IBMXML@@@/i
+           connection.sql =~ /@@@IBMXML@@@/i ||
+           connection.sql =~ /@@@IBMBINARY@@@/i 
           update_query = "UPDATE #{self.class.table_name} SET ("
           counter = 0
           values = []
@@ -208,6 +209,8 @@ requires credentials: username and password"
             :string
           when /boolean/i
             :boolean
+          when /serial/i
+            :serial
           when /rowid/i  # rowid is a supported datatype on z/OS and i/5
             :rowid
         end
@@ -277,7 +280,7 @@ requires credentials: username and password"
     # When schema is not specified, the username value is used instead.
     # 
     class IBM_DBAdapter < AbstractAdapter
-      attr_reader :connection
+      attr_reader :connection, :servertype
       attr_accessor :sql
       attr_reader :schema, :app_user, :account, :application, :workstation
 
@@ -325,8 +328,11 @@ requires credentials: username and password"
               end
             when /AS/i                # DB2 for i5 (iSeries)
               @servertype = IBM_DB2_I5.new(self)
+            when /IDS/i               # Informix Dynamic Server
+              @servertype = IBM_IDS.new(self)
           end
         end
+
         # Executes the +set schema+ statement using the schema identifier provided
         @servertype.set_schema(@schema) if @schema && @schema != @username
       end
@@ -495,7 +501,7 @@ requires credentials: username and password"
         if stmt = execute(sql, name)
           begin
             @sql = sql
-            return id_value || @servertype.last_generated_id
+            return id_value || @servertype.last_generated_id(stmt)
             # Ensures to free the resources associated with the statement
           ensure
             IBM_DB::free_result(stmt)
@@ -586,27 +592,19 @@ requires credentials: username and password"
           if limit == 0
             # Returns a query that will always generate zero records
             # (e.g. WHERE sys_row_num BETWEEN 1 and 0)
-            sql = query_offset_limit(sql, 0, limit)
+            sql = @servertype.query_offset_limit(sql, 0, limit)
           # If there is a non-zero limit
           else
             offset = options[:offset]
             # If an offset is specified builds the query with offset and limit,
             # otherwise retrieves only the first +limit+ rows
-            offset ? sql = query_offset_limit(sql, offset, limit) \
-                   : sql << " FETCH FIRST #{limit} ROWS ONLY"
+            sql = @servertype.query_offset_limit(sql, offset, limit)
           end
         end
         # Returns the sql query in any case
         sql
       end # method add_limit_offset!
 
-      # Private method used by +add_limit_offset!+ to create a
-      # sql query given an offset and a limit
-      def query_offset_limit(sql, offset, limit)
-        @servertype.query_offset_limit(sql, offset, limit)
-      end
-      private :query_offset_limit
-
       def default_sequence_name(table, column) # :nodoc:
         "#{table}_#{column}_seq"
       end
@@ -632,30 +630,30 @@ requires credentials: username and password"
               value.to_s
             end
           when String, ActiveSupport::Multibyte::Chars
-            if column && column.type == :binary
-              # If quoting is required for the insert/update of a BLOB
+          if column && column.type == :binary
+            # If quoting is required for the insert/update of a BLOB
+            unless caller[0] =~ /add_column_options/i
+              # Invokes a convertion from string to binary
+                @servertype.set_binary_value
+            else
+              # Quoting required for the default value of a column
+                @servertype.set_binary_default(value)
+              end
+          elsif column && column.type == :text
               unless caller[0] =~ /add_column_options/i
-                # Invokes a convertion from string to binary
-                "BLOB('?')"
+                "'@@@IBMTEXT@@@'"
               else
-                # Quoting required for the default value of a column
-                @servertype.set_blob_default(value)
+                @servertype.set_text_default(value)
               end
-            elsif column && column.type == :text
-                unless caller[0] =~ /add_column_options/i
-                  "'@@@IBMTEXT@@@'"
-                else
-                  "#{value}"
-                end
-            elsif column && column.type == :xml
-                unless caller[0] =~ /add_column_options/i
-                  "'<ibm>@@@IBMXML@@@</ibm>'"
-                else
-                  "#{value}"
-                end
-            else
-              "'#{quote_string(value)}'"
-            end
+          elsif column && column.type == :xml
+              unless caller[0] =~ /add_column_options/i
+                "'<ibm>@@@IBMXML@@@</ibm>'"
+              else
+                "#{value}"
+              end
+          else
+            "'#{quote_string(value)}'"
+          end
           when TrueClass then quoted_true    # return '1' for true
           when FalseClass then quoted_false  # return '0' for false
           when NilClass
@@ -701,9 +699,9 @@ requires credentials: username and password"
           :text        => { :name => "clob" },
           :integer     => { :name => "integer" },
           :float       => { :name => "float" },
-          :datetime    => { :name => "timestamp" },
-          :timestamp   => { :name => "timestamp" },
-          :time        => { :name => "time" },
+          :datetime    => { :name => @servertype.get_datetime_mapping },
+          :timestamp   => { :name => @servertype.get_datetime_mapping },
+          :time        => { :name => @servertype.get_time_mapping },
           :date        => { :name => "date" },
           :binary      => { :name => "blob" },
 
@@ -713,7 +711,8 @@ requires credentials: username and password"
           :boolean     => { :name => "smallint"},
           :xml         => { :name => "xml"},
           :decimal     => { :name => "decimal" },
-          :rowid       => { :name => "rowid" } # rowid is a supported datatype on z/OS and i/5
+          :rowid       => { :name => "rowid" }, # rowid is a supported datatype on z/OS and i/5
+          :serial      => { :name => "serial" } # rowid is a supported datatype on Informix Dynamic Server
         }
       end
 
@@ -743,7 +742,9 @@ requires credentials: username and password"
         # Initializes the tables array
         tables = []
         # Returns a IBM_DB::Statement used to retrieve the tables
-        if stmt = IBM_DB::tables(@connection, nil, @schema.upcase)
+        if stmt = IBM_DB::tables(@connection, 
+                                 nil, 
+                                 @servertype.set_case(@schema))
           # Fetches all the records available
           while tab = IBM_DB::fetch_assoc(stmt)
             # Adds the lowercase table name to the array
@@ -769,7 +770,11 @@ requires credentials: username and password"
         # "NON_UNIQUE:   #{index_stats[3]}"
         # "INDEX_NAME:   #{index_stats[5]}"
         # "COLUMN_NAME:  #{index_stats[8]}"
-        stmt = IBM_DB::statistics( @connection, nil, @schema.upcase, table_name.upcase, 1)
+        stmt = IBM_DB::statistics( @connection, 
+                                   nil, 
+                                   @servertype.set_case(@schema), 
+                                   @servertype.set_case(table_name), 
+                                   1)
         while ( index_stats = IBM_DB::fetch_array(stmt) )
           if index_stats[5]                                          # INDEX_NAME
             index_name = index_stats[5].downcase
@@ -792,14 +797,17 @@ requires credentials: username and password"
       # 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.
-        table_name = table_name.to_s.upcase
+        table_name = @servertype.set_case(table_name.to_s)
         # Checks if a blank table name has been given.
         # If so it returns an empty array
         return [] if table_name.strip.empty?
         # +columns+ will contain the resulting array
         columns = []
         # Statement required to access all the columns information
-        if stmt = IBM_DB::columns(@connection, nil, @schema.upcase, table_name.upcase)
+        if stmt = IBM_DB::columns(@connection, 
+                                  nil, 
+                                  @servertype.set_case(@schema), 
+                                  @servertype.set_case(table_name))
           begin
             # Fetches all the columns and assigns them to col.
             # +col+ is an hash with keys/value pairs for a column
@@ -974,13 +982,13 @@ requires credentials: username and password"
 
     end # class IBM_DBAdapter
 
-    # This class contains common code across DB's (DB2 LUW, zOS and i5)
+    # This class contains common code across DB's (DB2 LUW, zOS, i5 and IDS)
     class IBM_DataServer
       def initialize(adapter)
         @adapter = adapter
       end
 
-      def last_generated_id 
+      def last_generated_id(stmt)
       end
 
       def create_index_after_table (table_name)
@@ -1014,18 +1022,59 @@ To remove the column, the table must be dropped and recreated without the #{colu
         end
       end
 
-      def set_schema(schema)
-        @adapter.execute("SET SCHEMA #{schema}")
+      def select_all(sql, name, stmt, results)
+        # Fetches all the results available. IBM_DB::fetch_assoc(stmt) returns
+        # an hash for each single record.
+        # The loop stops when there aren't any more valid records to fetch
+        while single_hash = IBM_DB::fetch_assoc(stmt)
+          # Add the record to the +results+ array
+          results <<  single_hash
+        end
       end
 
-      def select_all(sql, name, stmt, results)
+      def execute(sql, name = nil)
+        begin
+          if stmt = IBM_DB::exec(@adapter.connection, sql)
+            stmt   # Return the statement object
+          else
+            raise StatementInvalid, IBM_DB::stmt_errormsg
+          end
+        rescue StandardError
+          error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+          if error_msg && !error_msg.empty?
+            raise "Failed to execute statement due to error: #{error_msg}"
+          else
+            raise
+          end
+        end
+      end
+
+      def set_schema(schema)
+        @adapter.execute("SET SCHEMA #{schema}")
       end
 
       def query_offset_limit(sql, offset, limit)
       end
       
-      def set_blob_default(value)
-        "BLOB('#{value}')"
+      def get_datetime_mapping
+      end
+
+      def get_time_mapping
+      end
+
+      def change_column_default(table_name, column_name, default)
+      end
+
+      def set_binary_default(value)
+      end
+
+      def set_binary_value
+      end
+
+      def set_text_default
+      end
+
+      def set_case(value)
       end
     end # class IBM_DataServer
 
@@ -1040,7 +1089,8 @@ To remove the column, the table must be dropped and recreated without the #{colu
 
       # Returns the last automatically generated ID.
       # This method is required by the +insert+ method
-      def last_generated_id
+      # The "stmt" parameter is ignored for DB2 but used for IDS
+      def last_generated_id(stmt)
         # Queries the db to obtain the last ID that was automatically generated
         sql = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1"
         stmt = IBM_DB::exec(@adapter.connection, sql)
@@ -1069,6 +1119,7 @@ The column datatype change to [#{data_type}] is not supported by this data serve
         end
       end
 
+      # DB2 specific ALTER TABLE statement to add a default clause
       def change_column_default(table_name, column_name, default)
         # SQL statement which alters column's default value
         change_column_sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} \
@@ -1078,6 +1129,18 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
           IBM_DB::free_result stmt if stmt
       end
 
+      # This method returns the DB2 SQL type corresponding to the Rails
+      # datetime/timestamp type
+      def get_datetime_mapping
+        return "timestamp"
+      end
+
+      # This method returns the DB2 SQL type corresponding to the Rails
+      # time type
+      def get_time_mapping
+        return "time"
+      end
+
       # Fetches all the results available. IBM_DB::fetch_assoc(stmt) returns
       # an hash for each single record.
       # The loop stops when there aren't any more valid records to fetch
@@ -1086,6 +1149,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
           # We know at this point that there is an offset and/or a limit
           # Check if the cursor type is set correctly
           cursor_type = IBM_DB::get_option stmt, IBM_DB::SQL_ATTR_CURSOR_TYPE, 0
+          @offset = 0 if @offset.nil?
           if (cursor_type == IBM_DB::SQL_CURSOR_STATIC)
             index = 0
             # Get @limit rows starting at @offset
@@ -1176,6 +1240,32 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       def query_offset_limit(sql, offset, limit)
         @limit = limit
         @offset = offset
+        if (offset.nil?)
+           sql << " FETCH FIRST #{limit} ROWS ONLY"
+        end
+      end
+
+      # This method generates the default blob value specified for 
+      # DB2 Dataservers
+      def set_binary_default(value)
+        "BLOB('#{value}')"
+      end
+
+      # This method generates the blob value specified for DB2 Dataservers
+      def set_binary_value
+        "BLOB('?')"       
+      end
+
+      # This method generates the default clob value specified for 
+      # DB2 Dataservers
+      def set_text_default(value)
+        "#{value}"
+      end
+
+      # For DB2 Dataservers , the arguments to the meta-data functions
+      # need to be in upper-case
+      def set_case(value)
+        value.upcase
       end
     end # class IBM_DB2
 
@@ -1185,34 +1275,10 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
         execute("CALL ADMIN_CMD('REORG TABLE #{table_name}')")
       end
 
-      def select_all(sql, name, stmt, results)
-        # Fetches all the results available. IBM_DB::fetch_assoc(stmt) returns
-        # an hash for each single record.
-        # The loop stops when there aren't any more valid records to fetch
-        while single_hash = IBM_DB::fetch_assoc(stmt)
-          # Add the record to the +results+ array
-          results <<  single_hash
-        end
-      end
-
-      def execute(sql, name = nil)
-        begin
-          if stmt = IBM_DB::exec(@adapter.connection, sql)
-            stmt   # Return the statement object
-          else
-            raise StatementInvalid, IBM_DB::stmt_errormsg
-          end
-        rescue StandardError
-          error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
-          if error_msg && !error_msg.empty?
-            raise "Failed to execute statement due to error: #{error_msg}"
-          else
-            raise
-          end
-        end
-      end
-
       def query_offset_limit(sql, offset, limit)
+        if (offset.nil?)
+           return sql << " FETCH FIRST #{limit} ROWS ONLY"
+        end
         # Defines what will be the last record
         last_record = offset + limit
         # Transforms the SELECT query in order to retrieve/fetch only
@@ -1257,7 +1323,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
 
       # DB2 z/OS only allows NULL or "" (empty) string as DEFAULT value for a BLOB column. 
       # For non-empty string and non-NULL values, the server returns error
-      def set_blob_default(value)
+      def set_binary_default(value)
         "#{value}"
       end
 
@@ -1297,5 +1363,119 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       include HostedDataServer
     end # class IBM_DB2_I5
 
+    class IBM_IDS < IBM_DataServer
+      # IDS does not support the SET SCHEMA syntax
+      def set_schema(schema)
+      end
+
+      def rename_column(table_name, column_name, new_column_name)
+        execute "RENAME COLUMN #{table_name}.#{column_name} TO #{new_column_name}"
+      end
+
+      def primary_key
+        return "SERIAL(100) PRIMARY KEY"
+      end
+
+      def change_column(table_name, column_name, type, options)
+        execute "ALTER TABLE #{table_name} MODIFY #{column_name} #{@adapter.type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        if !options[:default].nil?
+           change_column_default(table_name, column_name, options[:default])
+        end
+        reorg_table(table_name)
+      end
+
+      # IDS specific ALTER TABLE statement to add a default clause
+      # IDS requires the data type to be explicitly specified when adding the 
+      # DEFAULT clause
+      def change_column_default(table_name, column_name, default)
+        sql_type = nil
+        @adapter.columns(table_name).select do |col| 
+           if (col.name == column_name)
+              sql_type =  @adapter.type_to_sql(col.type, col.limit, col.precision, col.scale)
+           end
+        end
+        # SQL statement which alters column's default value
+        change_column_sql = "ALTER TABLE #{table_name} MODIFY #{column_name} #{sql_type} DEFAULT #{@adapter.quote(default)}"
+        stmt = execute(change_column_sql)
+        # Ensures to free the resources associated with the statement
+        ensure
+          IBM_DB::free_result stmt if stmt
+      end
+
+      # Reorganizes the table for column changes
+      def reorg_table(table_name)
+        execute("UPDATE STATISTICS FOR TABLE #{table_name}")
+      end
+
+      # This method returns the IDS SQL type corresponding to the Rails
+      # datetime/timestamp type
+      def get_datetime_mapping
+        return "datetime year to fraction(5)"
+      end
+
+      # This method returns the IDS SQL type corresponding to the Rails
+      # time type
+      def get_time_mapping
+        return "datetime hour to second"
+      end
+
+      # Handling offset/limit as per Informix requirements
+      def query_offset_limit(sql, offset, limit)
+        if limit != 0
+          if !offset.nil?
+            # Modifying the SQL to utilize the skip and limit amounts
+            sql.gsub!(/SELECT/i,"SELECT SKIP #{offset} LIMIT #{limit}")
+          else
+            # Modifying the SQL to retrieve only the first #{limit} rows
+            sql = sql.gsub!("SELECT","SELECT FIRST #{limit}")
+          end
+        else
+          # Modifying the SQL to ensure that no rows will be returned
+          sql.gsub!(/SELECT/i,"SELECT * FROM (SELECT")
+          sql << ") WHERE 0 = 1"
+        end
+      end
+
+      # Method that returns the last automatically generated ID
+      # on the given +@connection+. This method is required by the +insert+ 
+      # method. IDS returns the last generated serial value in the SQLCA unlike 
+      # DB2 where the generated value has to be retrieved using the 
+      # IDENTITY_VAL_LOCAL function. We used the "stmt" parameter to identify 
+      # the statement resource from which to get the last generated value
+      def last_generated_id(stmt)
+        IBM_DB::get_last_serial_value(stmt)
+      end
+
+      # This method throws an error when trying to create a default value on a 
+      # BLOB/CLOB column for IDS. The documentation states: "if the column is a 
+      # BLOB or CLOB datatype, NULL is the only valid default value."
+      def set_binary_default(value)
+        unless (value == 'NULL')
+          raise "Informix Dynamic Server only allows NULL as a valid default value for a BLOB data type"
+        end
+      end
+
+      # For Informix Dynamic Server, we treat binary value same as we treat a 
+      # text value. We support literals by converting the insert into a dummy 
+      # insert and an update (See handle_lobs method above)
+      def set_binary_value
+        "'@@@IBMBINARY@@@'"
+      end
+
+      # This method throws an error when trying to create a default value on a 
+      # BLOB/CLOB column for IDS.  The documentation states: "if the column is 
+      # a BLOB or CLOB datatype, NULL is the only valid default value."
+      def set_text_default(value)
+        unless (value == 'NULL')
+          raise "Informix Dynamic Server only allows NULL as a valid default value for a CLOB data type"
+        end
+      end
+
+      # For Informix Dynamic Server, the arguments to the meta-data functions
+      # need to be in lower-case
+      def set_case(value)
+        value.downcase
+      end
+    end # class IBM_IDS
   end # module ConnectionAdapters
 end # module ActiveRecord