activerecord-sqlanywhere-adapter 0.1.1 → 0.1.2

data/CHANGELOG

@@ -1,5 +1,17 @@
 =CHANGE LOG
 
+=====0.1.2 -- 2008/12/30
+- Fixed bug in ActiveRecord::ConnectionAdapters::SQLAnywhereAdapter#table_structure SQL (Paul Smith)
+- Added options for :commlinks and :connection_name to database.yml configuration (Paul Smith)
+- Fixed ActiveRecord::ConnectionAdapters::SQLAnywhereColumn.string_to_binary and binary_to_string  (Paul Smith)
+- Added :time as a native datatype  (Paul Smith)
+- Override SQLAnywhereAdapter#active? to prevent stale connections  (Paul Smith)
+- 'Fixed' coding style to match Rails standards  (Paul Smith)
+- Added temporary option for timestamp_format
+- Fixed bug to let migrations drop columns with indexes
+- Formatted code
+- Fixed bug to raise proper exceptions when a query with a bad column in executed
+
 =====0.1.1 -- 2008/11/06
 - Changed file permissions on archives
 - Changed archives to be specific to platform (.zip on windows, .tar.gz

data/LICENSE

@@ -1,6 +1,6 @@
 /*====================================================
 *
-*   Copyright 2008 iAnywhere Solutions, Inc.
+*   Copyright 2008-2009 iAnywhere Solutions, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.

data/README

@@ -16,10 +16,12 @@ The following code is a sample database configuration object.
   ActiveRecord::Base.configurations = {
     'arunit' => {
       :adapter  => 'sqlanywhere', 
-      :database => 'arunit',      #equivalent to the "dbn" parameter
-      :server   => 'arunit',      #equivalent to the "eng" parameter
-      :username => 'dba',         #equivalent to the "uid" parameter
-      :password => 'sql'          #equivalent to the "pwd" parameter
+      :database => 'arunit',      #equivalent to the "DatabaseName" parameter
+      :server   => 'arunit',      #equivalent to the "ServerName" parameter
+      :username => 'dba',         #equivalent to the "UserID" parameter
+      :password => 'sql',         #equivalent to the "Password" parameter
+      :commlinks => 'TCPIP()',    #equivalent to the "Commlinks" parameter
+      :connection_name => 'Rails' #equivalent to the "ConnectionName" parameter
   }
 
 ==Running the ActiveRecord Unit Test Suite
@@ -48,12 +50,11 @@ The following code is a sample database configuration object.
 
 4. Create the two test databases. These can be created in any directory.
 
-      dbinit arunit
-      dbinit arunit2
+      dbinit -c arunit
+      dbinit -c arunit2
       dbsrv11 arunit arunit2
 
-   <b>If the commands cannot be found, make sure you have set up the SQL Anywhere environment variables correctly.</b> For more information
-   review the online documentation here[http://dcx.sybase.com/index.php#http%3A%2F%2Fdcx.sybase.com%2F1100en%2Fdbadmin_en11%2Fda-envvar-sect1-3672410.html].
+   <b>If the commands cannot be found, make sure you have set up the SQL Anywhere environment variables correctly.</b> For more information review the online documentation here[http://dcx.sybase.com/index.php#http%3A%2F%2Fdcx.sybase.com%2F1100en%2Fdbadmin_en11%2Fda-envvar-sect1-3672410.html].
 
 5. If you are using ActiveRecord 2.0.2, you must load the test tables. 
 
@@ -67,5 +68,58 @@ The following code is a sample database configuration object.
 
       rake test_sqlanywhere
 
-   <b>If the migration tests fail, make sure you have set up the SQL Anywhere environment variables correctly.</b> For more information
-   review the online documentation here[http://dcx.sybase.com/index.php#http%3A%2F%2Fdcx.sybase.com%2F1100en%2Fdbadmin_en11%2Fda-envvar-sect1-3672410.html].
+   <b>If the migration tests fail, make sure you have set up the SQL Anywhere environment variables correctly.</b> For more information review the online documentation here[http://dcx.sybase.com/index.php#http%3A%2F%2Fdcx.sybase.com%2F1100en%2Fdbadmin_en11%2Fda-envvar-sect1-3672410.html].
+
+==Explaination of Test Results
+
+As of ActiveRecord 2.2.2., it is expected that 6 tests will fail. The failed tests, along with an explaination, are identified below:
+
+1. (CalculationsTest) - test_should_sum_expression
+
+   Explaination: Appears to be an error in the test.
+   
+   This tests checks the results of the following statement:
+   
+      assert_equal '636', Account.sum("2 * credit_limit")
+   
+   According to the ActiveRecord documentation, the summation of a column should return a value of the same type as the column. In this case, <tt>credit_limit</tt> is an integer, and so the result should be a number type, not a string.
+   
+2. (MigrationTest) - test_add_table_with_decimals
+
+   Explaination: Requires special case.
+
+   From the comments regarding this test:
+
+      # This one is fun. The 'value_of_e' field is defined as 'DECIMAL' with
+      # precision/scale explicitly left out.  By the SQL standard, numbers
+      # assigned to this field should be truncated but that's seldom respected.
+   
+   There are already three special cases of this test. SQL Anywhere would require another special case to pass this test.
+
+3. (NamedScopeTest) - test_should_use_where_in_query_for_named_scope
+
+   Explaination: Appears to be an error in the test.
+
+   This test issues a query that returns two rows. Because there is no ORDER BY in the query, the order that that rows are returned in is non-deterministic. SQL Anywhere returns the correct rows, but in a different order.
+
+4. (QueryCacheTest) - test_cache_does_not_wrap_string_results_in_arrays
+
+   Explaination: Appears to be an error in the test.
+
+   This tests checks that the cached value of the following query is a string:
+
+      SELECT count(*) AS count_all FROM tasks
+
+   However, SQL Anywhere treats the values of a <tt>COUNT(*)</tt> opration as a fixnum, not a string. It would appear that the real intent of this test is to test that the value is NOT an array, rather than testing that the value is a string.
+
+5. (SchemaDumperTest) - test_schema_dump_includes_limit_constraint_for_integer_columns
+
+   Explaination: SQL Anywhere does not have a 'limitless' integer type.
+
+   Any integer type will be given an implicit limit when instantiated. It would be possible to use another type such as <tt>NUMERIC</tt> to mimic this type, however this seems like a bad idea.
+
+6. (ValidationsTest) - test_validate_case_sensitive_uniqueness
+
+   Explaination: By default, SQL Anywhere is case insensitive.
+
+   If a case sensitive database is required (as in this test), ensure the database is created with the <tt>-c</tt> switch to make it case sensitive.

data/lib/active_record/connection_adapters/sqlanywhere_adapter.rb

@@ -1,6 +1,6 @@
 #====================================================
 #
-#    Copyright 2008 iAnywhere Solutions, Inc.
+#    Copyright 2008-2009 iAnywhere Solutions, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -26,485 +26,545 @@ require 'active_record/connection_adapters/abstract_adapter'
 
 # Singleton class to hold a valid instance of the SQLAnywhereInterface across all connections
 class SA
-   include Singleton
-   attr_accessor :api
-
-   def initialize
-	 unless defined? SQLAnywhere
-           require_library_or_gem 'sqlanywhere'
-	 end
-
-	 @api = SQLAnywhere::SQLAnywhereInterface.new()
-	 result = SQLAnywhere::API.sqlany_initialize_interface(@api)
-	 if result == 0
-	     raise LoadError, "Could not load SQLAnywhere adapter DLL" 
-	 end
-	 result = @api.sqlany_init()
-	 if result == 0
-	     raise LoadError, "Could not initialize SQLAnywhere adapter DLL" 
-	 end
-   end
+  include Singleton
+  attr_accessor :api
+
+  def initialize
+    require_library_or_gem 'sqlanywhere' unless defined? SQLAnywhere
+    @api = SQLAnywhere::SQLAnywhereInterface.new()
+    raise LoadError, "Could not load SQLAnywhere DBCAPI library" if SQLAnywhere::API.sqlany_initialize_interface(@api) == 0 
+    raise LoadError, "Could not initialize SQLAnywhere DBCAPI library" if @api.sqlany_init() == 0 
+  end
 end
 
 module ActiveRecord
-   class Base
-      # Main connection function to SQL Anywhere
-      # Connection Adapter takes four parameters:
-      # * :database (required, no default). Corresponds to "ENG=" in connection string
-      # * :server (optional, defaults to :databse). Corresponds to "DBN=" in connection string 
-      # * :username (optional, default to 'dba')
-      # * :password (optioanl, deafult to 'sql')
-      def self.sqlanywhere_connection(config)
-
-         if config.has_key?(:database)
-           database = config[:database]
-         else
-           raise ArgumentError, "No database name was given. Please add a :database option."
-         end
-
-	 database = config[:database]
-	 server   = config[:server] ? config[:server].to_s : database
-	 username = config[:username] ? config[:username].to_s : 'dba'
-	 password = config[:password] ? config[:password].to_s : 'sql'
-
-	 db = SA.instance.api.sqlany_new_connection()
-	 SA.instance.api.sqlany_connect(db, "eng=#{server};dbn=#{database};uid=#{username};pwd=#{password}")
-	 SA.instance.api.sqlany_execute_immediate(db, "SET OPTION non_keywords = 'LOGIN'")
-	 ConnectionAdapters::SQLAnywhereAdapter.new(db, logger)
-      end
-   end
-
-   module ConnectionAdapters
-      class SQLAnywhereColumn < Column
-	   private
-	      # Overridden to handle SQL Anywhere integer, varchar, binary, and timestamp types
-	      def simplified_type(field_type)
-		return :boolean if field_type =~ /tinyint/i
-		return :string if field_type =~ /varchar/i
-		return :binary if field_type =~ /long binary/i
-	        return :datetime if field_type =~ /timestamp/i
-		return :integer if field_type =~ /smallint|bigint/i
-		super
-	      end
-
-	      def extract_limit(sql_type)
-	        case sql_type
-                  when /^tinyint/i:  1
-	          when /^smallint/i: 2
-	          when /^integer/i:  4		  
-	          when /^bigint/i:   8	
-	          else super
-	        end
-	      end
-
-           protected
-	      # Handles the encoding of a binary object into SQL Anywhere
-	      # SQL Anywhere requires that binary values be encoded as \xHH, where HH is a hexadecimal number
-	      # This function encodes the binary string in this format
-	      def self.string_to_binary(value)
-	        if value
-                  result = ''
-                  value.each_byte do |c|
-		     res = sprintf('\x%x', c)
-		     res.insert(2, '0') if res.length == 3
-		     result << res
-		  end
-                  result
-                end
-	      end
-	      
-	      def self.binary_to_string(value)
-		 %Q/#{value}/
-              end
+  class Base
+    DEFAULT_CONFIG = { :username => 'dba', :password => 'sql' }
+    # Main connection function to SQL Anywhere
+    # Connection Adapter takes four parameters:
+    # * :database (required, no default). Corresponds to "DatabaseName=" in connection string
+    # * :server (optional, defaults to :databse). Corresponds to "ServerName=" in connection string 
+    # * :username (optional, default to 'dba')
+    # * :password (optional, deafult to 'sql')
+    # * :commlinks (optional). Corresponds to "CommLinks=" in connection string
+    # * :connection_name (optional). Corresponds to "ConnectionName=" in connection string
+    
+    def self.sqlanywhere_connection(config)
+
+      config = DEFAULT_CONFIG.merge(config)
+
+      raise ArgumentError, "No database name was given. Please add a :database option." unless config.has_key?(:database)
+
+      connection_string = "ServerName=#{(config[:server] || config[:database])};DatabaseName=#{config[:database]};UserID=#{config[:username]};Password=#{config[:password]};"
+      connection_string += "CommLinks=#{config[:commlinks]};" unless config[:commlinks].nil?
+      connection_string += "ConnectionName=#{config[:connection_name]};" unless config[:connection_name].nil?
+      connection_string += "Idle=0" # Prevent the server from disconnecting us if we're idle for >240mins (by default)
 
+      db = SA.instance.api.sqlany_new_connection()
+      
+      ConnectionAdapters::SQLAnywhereAdapter.new(db, logger, connection_string)
+    end
+  end
+
+  module ConnectionAdapters
+    class SQLAnywhereColumn < Column
+      private
+        # Overridden to handle SQL Anywhere integer, varchar, binary, and timestamp types
+        def simplified_type(field_type)
+          return :boolean if field_type =~ /tinyint/i
+          return :string if field_type =~ /varchar/i
+          return :binary if field_type =~ /long binary/i
+          return :datetime if field_type =~ /timestamp/i
+          return :integer if field_type =~ /smallint|bigint/i
+          super
+        end
+
+        def extract_limit(sql_type)
+          case sql_type
+            when /^tinyint/i:  1
+            when /^smallint/i: 2
+            when /^integer/i:  4            
+            when /^bigint/i:   8  
+            else super
+          end
+        end
+
+      protected
+        # Handles the encoding of a binary object into SQL Anywhere
+        # SQL Anywhere requires that binary values be encoded as \xHH, where HH is a hexadecimal number
+        # This function encodes the binary string in this format
+        def self.string_to_binary(value)
+          "\\x" + value.unpack("H*")[0].scan(/../).join("\\x")
+        end
+        
+        def self.binary_to_string(value)
+          value.gsub(/\\x[0-9]{2}/) { |byte| byte[2..3].hex }
+        end
+    end
+
+    class SQLAnywhereAdapter < AbstractAdapter
+      def initialize( connection, logger = nil, connection_string = "") #:nodoc:
+        super(connection, logger)
+        @auto_commit = true
+        @affected_rows = 0
+        @connection_string = connection_string
+        connect!
       end
 
+      def adapter_name #:nodoc:
+        'SQLAnywhere'
+      end
 
-      class SQLAnywhereAdapter < AbstractAdapter
-	 def adapter_name #:nodoc:
-	   'SQLAnywhere'
-	 end
+      def supports_migrations? #:nodoc:
+        true
+      end
 
-	 def supports_migrations? #:nodoc:
-	   true
-	 end
+      def requires_reloading?
+        false
+      end
+   
+      def active?
+        # The liveness variable is used a low-cost "no-op" to test liveness
+        SA.instance.api.sqlany_execute_immediate(@connection, "SET liveness = 1") == 1
+      rescue
+        false
+      end
 
-	 def requires_reloading?
-	   false
-	 end
-    
-	 def disconnect!
-	   SA.instance.api.sqlany_disconnect( @connection ) rescue nil
-	   SA.instance.api.sqlany_free_connection( @connection ) rescue nil
-	   super
-	 end
-
-	 def supports_count_distinct? #:nodoc:
-	   true
-	 end
-
-	 def supports_autoincrement? #:nodoc:
-	   true
-	 end
-
-	 # Maps native ActiveRecord/Ruby types into SQLAnywhere types
-	 # TINYINTs are treated as the default boolean value
-	 # ActiveRecord allows NULLs in boolean columns, and the SQL Anywhere BIT type does not
-	 # As a result, TINYINT must be used. All TINYINT columns will be assumed to be boolean and
-	 # should not be used as single-byte integer columns. This restriction is similar to other ActiveRecord database drivers
-	 def native_database_types #:nodoc:
-	   {
-	     :primary_key => 'INTEGER PRIMARY KEY DEFAULT AUTOINCREMENT NOT NULL',
-	     :string      => { :name => "varchar", :limit => 255 },
-	     :text        => { :name => "long varchar" },
-	     :integer     => { :name => "integer" },
-	     :float       => { :name => "float" },
-	     :decimal     => { :name => "decimal" },
-	     :datetime    => { :name => "datetime" },
-	     :timestamp   => { :name => "datetime" },
-	     :time        => { :name => "datetime" },
-	     :date        => { :name => "date" },
-	     :binary      => { :name => "long binary" },
-	     :boolean     => { :name => "tinyint"}
-	   }
-	 end
-
-	 # QUOTING ==================================================
-
-	 # Applies quotations around column names in generated queries
-	 def quote_column_name(name) #:nodoc:
-	   %Q("#{name}")
-	 end
-
-	 # Handles special quoting of binary columns. Binary columns will be treated as strings inside of ActiveRecord.
-	 # ActiveRecord requires that any strings it inserts into databases must escape the backslash (\).
-	 # Since in the binary case, the (\x) is significant to SQL Anywhere, it cannot be escaped.
-	 def quote(value, column = nil)
-	    case value
-	       when String, ActiveSupport::Multibyte::Chars
-		  value_S = value.to_s
-		  if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
-		     "#{quoted_string_prefix}'#{column.class.string_to_binary(value_S)}'"
-		  else
-		     super(value, column)
-		  end
-	       else
-		  super(value, column)
-	    end
-	 end
-
-	 def quoted_true
-	   '1'
-	 end
-
-	 def quoted_false
-	   '0'
-	 end
+      def disconnect!
+        result = SA.instance.api.sqlany_disconnect( @connection )
+	super
+      end
 
-      
-	 # SQL Anywhere, in accordance with the SQL Standard, does not allow a column to appear in the ORDER BY list
-	 # that is not also in the SELECT with when obtaining DISTINCT rows beacuse the actual semantics of this query
-	 # are unclear. The following functions create a query that mimics the way that SQLite and MySQL handle this query.
-	 #
-	 # This function (distinct) is based on the Oracle ActiveRecord driver created by Graham Jenkins (2005)
-	 # (http://svn.rubyonrails.org/rails/adapters/oracle/lib/active_record/connection_adapters/oracle_adapter.rb)
-         def distinct(columns, order_by)
-          return "DISTINCT #{columns}" if order_by.blank?
-          order_columns = order_by.split(',').map { |s| s.strip }.reject(&:blank?)
-          order_columns = order_columns.zip((0...order_columns.size).to_a).map do |c, i|
-            "FIRST_VALUE(#{c.split.first}) OVER (PARTITION BY #{columns} ORDER BY #{c}) AS alias_#{i}__"
+      def reconnect!
+        disconnect!
+        connect!
+      end
+
+      def supports_count_distinct? #:nodoc:
+        true
+      end
+
+      def supports_autoincrement? #:nodoc:
+        true
+      end
+
+      # Maps native ActiveRecord/Ruby types into SQLAnywhere types
+      # TINYINTs are treated as the default boolean value
+      # ActiveRecord allows NULLs in boolean columns, and the SQL Anywhere BIT type does not
+      # As a result, TINYINT must be used. All TINYINT columns will be assumed to be boolean and
+      # should not be used as single-byte integer columns. This restriction is similar to other ActiveRecord database drivers
+      def native_database_types #:nodoc:
+        {
+          :primary_key => 'INTEGER PRIMARY KEY DEFAULT AUTOINCREMENT NOT NULL',
+          :string      => { :name => "varchar", :limit => 255 },
+          :text        => { :name => "long varchar" },
+          :integer     => { :name => "integer" },
+          :float       => { :name => "float" },
+          :decimal     => { :name => "decimal" },
+          :datetime    => { :name => "datetime" },
+          :timestamp   => { :name => "datetime" },
+          :time        => { :name => "time" },
+          :date        => { :name => "date" },
+          :binary      => { :name => "long binary" },
+          :boolean     => { :name => "tinyint"}
+        }
+      end
+
+      # QUOTING ==================================================
+
+      # Applies quotations around column names in generated queries
+      def quote_column_name(name) #:nodoc:
+        %Q("#{name}")
+      end
+
+      # Handles special quoting of binary columns. Binary columns will be treated as strings inside of ActiveRecord.
+      # ActiveRecord requires that any strings it inserts into databases must escape the backslash (\).
+      # Since in the binary case, the (\x) is significant to SQL Anywhere, it cannot be escaped.
+      def quote(value, column = nil)
+        case value
+          when String, ActiveSupport::Multibyte::Chars
+            value_S = value.to_s
+            if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+              "#{quoted_string_prefix}'#{column.class.string_to_binary(value_S)}'"
+            else
+               super(value, column)
+            end
+          else
+            super(value, column)
+        end
+      end
+
+      def quoted_true
+        '1'
+      end
+
+      def quoted_false
+        '0'
+      end
+
+     
+      # SQL Anywhere, in accordance with the SQL Standard, does not allow a column to appear in the ORDER BY list
+      # that is not also in the SELECT with when obtaining DISTINCT rows beacuse the actual semantics of this query
+      # are unclear. The following functions create a query that mimics the way that SQLite and MySQL handle this query.
+      #
+      # This function (distinct) is based on the Oracle ActiveRecord driver created by Graham Jenkins (2005)
+      # (http://svn.rubyonrails.org/rails/adapters/oracle/lib/active_record/connection_adapters/oracle_adapter.rb)
+      def distinct(columns, order_by)
+        return "DISTINCT #{columns}" if order_by.blank?
+        order_columns = order_by.split(',').map { |s| s.strip }.reject(&:blank?)
+        order_columns = order_columns.zip((0...order_columns.size).to_a).map do |c, i|
+          "FIRST_VALUE(#{c.split.first}) OVER (PARTITION BY #{columns} ORDER BY #{c}) AS alias_#{i}__"
+        end
+        sql = "DISTINCT #{columns}, "
+        sql << order_columns * ", "
+      end      
+
+      # This function (add_order_by_for_association_limiting) is based on the Oracle ActiveRecord driver created by Graham Jenkins (2005)
+      # (http://svn.rubyonrails.org/rails/adapters/oracle/lib/active_record/connection_adapters/oracle_adapter.rb)    
+      def add_order_by_for_association_limiting!(sql, options)
+        return sql if options[:order].blank?
+
+        order = options[:order].split(',').collect { |s| s.strip }.reject(&:blank?)
+        order.map! {|s| $1 if s =~ / (.*)/}
+        order = order.zip((0...order.size).to_a).map { |s,i| "alias_#{i}__ #{s}" }.join(', ')
+
+        sql << " ORDER BY #{order}"
+      end
+
+      # The database execution function
+      def execute(sql, name = nil) #:nodoc:
+        return if sql.nil?
+        sql = modify_limit_offset(sql)
+
+        # ActiveRecord allows a query to return TOP 0. SQL Anywhere requires that the TOP value is a positive integer.
+        return Array.new() if sql =~ /TOP 0/i
+           
+        # Executes the query, iterates through the results, and builds an array of hashes.
+        rs = SA.instance.api.sqlany_execute_direct(@connection, sql)
+        if rs.nil?
+          error = SA.instance.api.sqlany_error(@connection)
+          case error[0].to_i
+          when -143
+            if sql =~ /^SELECT/i then
+              raise ActiveRecord::StatementInvalid.new("#{error}:#{sql}")
+            else
+              raise ActiveRecord::ActiveRecordError.new("#{error}:#{sql}")
+            end
+          else
+            raise ActiveRecord::StatementInvalid.new("#{error}:#{sql}")
           end
-          sql = "DISTINCT #{columns}, "
-          sql << order_columns * ", "
-
-	 end	  
-
-	 # This function (add_order_by_for_association_limiting) is based on the Oracle ActiveRecord driver created by Graham Jenkins (2005)
-	 # (http://svn.rubyonrails.org/rails/adapters/oracle/lib/active_record/connection_adapters/oracle_adapter.rb)	 
-         def add_order_by_for_association_limiting!(sql, options)
-          return sql if options[:order].blank?
-
-          order = options[:order].split(',').collect { |s| s.strip }.reject(&:blank?)
-          order.map! {|s| $1 if s =~ / (.*)/}
-          order = order.zip((0...order.size).to_a).map { |s,i| "alias_#{i}__ #{s}" }.join(', ')
-
-          sql << " ORDER BY #{order}"
-         end
-
-	 # By default, ActiveRecord attempts to use the MySQL/SQLite syntax of limit and offset. That is, adding LIMIT XX OFFSET XX
-	 # at the end of the query. SQL Anywhere uses TOP XX START XX to handle this, adding immediatly following SELECT or SELECT DISTINCT.
-	 # This function adds the limit and offset to the appropriate place in the query.
-	 def add_limit_offset!(sql, options)
-	    temp_sql = ''
-	    if limit = options[:limit]
-	       temp_sql << " TOP #{self.respond_to?('sanitize_limit') ? sanitize_limit(limit) : limit} "	       
-	       if offset = options[:offset]
-	          temp_sql << " START AT #{offset + 1}"
-	       end
-	       if sql =~ /^select distinct.*/i
-		  sql.insert(15, temp_sql);
-	       elsif sql =~ /^select.*/i
-		  sql.insert(6, temp_sql);
-	       else
-		  sql = temp_sql;
-	       end
-	    end   
-	    sql
-	 end
-
-	 # The database execution function
-	 def execute(sql, name = nil) #:nodoc:
-	    return if sql.nil?
-
-	    # ActiveRecord allows a query to return TOP 0. SQL Anywhere requires that the TOP value is a positive integer.
-	    if sql =~ /TOP 0/i
-	       return Array.new()
-	    end
-	    
-	    # Executes the query, iterates through the results, and builds an array of hashes.
-            rs = SA.instance.api.sqlany_execute_direct(@connection, sql)
-	    raise ActiveRecord::StatementInvalid.new("#{SA.instance.api.sqlany_error(@connection)}:#{sql}") if rs.nil?
-	    record = []
-	    while SA.instance.api.sqlany_fetch_next(rs) == 1
-	      max_cols = SA.instance.api.sqlany_num_cols(rs)
- 	      result = Hash.new()
-	      max_cols.times do |cols|
-	        result[SA.instance.api.sqlany_get_column_info(rs, cols)[2]] = SA.instance.api.sqlany_get_column(rs, cols)[1]
-	      end
-	    record << result
-	    end
-    	    SA.instance.api.sqlany_free_stmt(rs)
-	    return record
-	 end
-
-	 # The database update function.	 
-	 def update_sql(sql, name = nil)
-		rs = SA.instance.api.sqlany_execute_direct(@connection, sql)
-		raise ActiveRecord::StatementInvalid.new("#{SA.instance.api.sqlany_error(@connection)}:#{sql}") if rs.nil?
-		retVal = SA.instance.api.sqlany_affected_rows(rs)
-		SA.instance.api.sqlany_free_stmt(rs)
-		execute (nil) # test suite counts number of executions. Dummy execution needed to pass tests.
-		return retVal
-	 end
-
-	 # The database delete function.
-	 def delete_sql(sql, name = nil) #:nodoc:
-		rs = SA.instance.api.sqlany_execute_direct(@connection, sql)
-		raise ActiveRecord::StatementInvalid.new("#{SA.instance.api.sqlany_error(@connection)}:#{sql}") if rs.nil?
-		retVal = SA.instance.api.sqlany_affected_rows(rs)
-		SA.instance.api.sqlany_free_stmt(rs)
-		execute (nil) # test suite counts number of executions. Dummy execution needed to pass tests.
-		return retVal
-	 end
-
-	 # The database insert function.
-	 # ActiveRecord requires that insert_sql returns the primary key of the row just inserted. In most cases, this can be accomplished
-	 # by immediatly querying the @@identity property. If the @@identity property is 0, then passed id_value is used
-	 def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-	     retval = 0
-	     rs = SA.instance.api.sqlany_execute_direct(@connection, sql)
-	     raise ActiveRecord::StatementInvalid.new("#{SA.instance.api.sqlany_error(@connection)}:#{sql}") if rs.nil?
-	     identity = SA.instance.api.sqlany_execute_direct(@connection, 'SELECT @@identity')
-	     raise ActiveRecord::StatementInvalid.new("#{SA.instance.api.sqlany_error(@connection)}:#{sql}") if identity.nil?
-	     SA.instance.api.sqlany_fetch_next(identity)
-	     retval = SA.instance.api.sqlany_get_column(identity, 0)[1]
-	     SA.instance.api.sqlany_free_stmt(identity)
-	     SA.instance.api.sqlany_free_stmt(rs)
-	     retval = id_value if retval == 0
-	     execute (nil) # test suite counts number of executions. Dummy execution needed to pass tests.
-	     return retval
-	 end
-	 
-	 # Returns a query as an array of arrays
-	 def select_rows(sql, name = nil)
-	     rs = SA.instance.api.sqlany_execute_direct(@connection, sql)
-	     raise ActiveRecord::StatementInvalid.new("#{SA.instance.api.sqlany_error(@connection)}:#{sql}") if rs.nil?
-	     record = []
-	     while SA.instance.api.sqlany_fetch_next(rs) == 1
-	       max_cols = SA.instance.api.sqlany_num_cols(rs)
-	       result = Array.new(max_cols)
-	       max_cols.times do |cols|
-		  result[cols] = SA.instance.api.sqlany_get_column(rs, cols)[1]
-	       end
-		record << result
-	      end
-    	      SA.instance.api.sqlany_free_stmt(rs)
-	      return record
-	 end
-
-	 def begin_db_transaction #:nodoc:   
-	 end
-
-	 def commit_db_transaction #:nodoc:
-	   SA.instance.api.sqlany_commit(@connection)
-	 end
-
-	 def rollback_db_transaction #:nodoc:
-	   SA.instance.api.sqlany_rollback(@connection)
-	 end
-
-	 def add_lock!(sql, options) #:nodoc:
- 	    sql
-	 end
-
-	 # SQL Anywhere does not support sizing of integers based on the sytax INTEGER(size). Integer sizes
-	 # must be captured when generating the SQL and replaced with the appropriate size.
-	 def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
-	    if native = native_database_types[type]
-	       if type == :integer
-	        case limit
-		 when 1
-		  column_type_sql = 'tinyint'
-		 when 2
-		  column_type_sql = 'smallint'	
-	         when 3..4
-	       	  column_type_sql = 'integer'
-		 when 5..8
-	       	  column_type_sql = 'bigint'
-	         else
-	       	  column_type_sql = 'integer'
-	         end
-	         column_type_sql
-	       else
-		  super(type, limit, precision, scale)
-	       end
-	    else
-	       super(type, limit, precision, scale)
-	    end
-	 end
-
-	 # Do not return SYS-owned or DBO-owned tables
-	 def tables(name = nil) #:nodoc:
- 	   sql = <<-SQL
-	     SELECT table_name
-	     FROM systable
-	     WHERE creator not in (0,3)
-	   SQL
-
-	   select(sql, name).map do |row|
-	     row["table_name"]
-	   end
-	 end
-
-	 def columns(table_name, name = nil) #:nodoc:
-	   table_structure(table_name).map do |field|
-	     field['default'] = field['default'][1..-2] if (!field['default'].nil? and field['default'][0].chr == "'")
-	     SQLAnywhereColumn.new(field['name'], field['default'], field['domain'], (field['nulls'] == 1))
-	   end
-	 end
-
-	 def indexes(table_name, name = nil) #:nodoc:
-
-	    sql = <<-SQL	    
-SELECT index_name, "unique"
-FROM systable join (sysidxcol join sysidx)
-WHERE  table_name = '#{table_name}' and index_category > 2
-SQL
-	    select(sql, name).map do |row|
-              index = IndexDefinition.new(table_name, row['index_name'])
-              index.unique = row['unique'] == 1
-	      sql = <<-SQL	    
-SELECT column_name
-FROM (systable join systabcol) join (sysidxcol join sysidx)
-WHERE  table_name = '#{table_name}' and index_name = '#{row['index_name']}'
-SQL
-	      index.columns = select(sql).map { |col| col['column_name'] }
-              index
+        end
+        
+        record = []
+        if( SA.instance.api.sqlany_num_cols(rs) > 0 ) 
+          while SA.instance.api.sqlany_fetch_next(rs) == 1
+            max_cols = SA.instance.api.sqlany_num_cols(rs)
+            result = Hash.new()
+            max_cols.times do |cols|
+              result[SA.instance.api.sqlany_get_column_info(rs, cols)[2]] = SA.instance.api.sqlany_get_column(rs, cols)[1]
             end
-	 end
+            record << result
+          end
+          @affected_rows = 0
+        else
+          @affected_rows = SA.instance.api.sqlany_affected_rows(rs)
+        end 
+        SA.instance.api.sqlany_free_stmt(rs)
+
+        SA.instance.api.sqlany_commit(@connection) if @auto_commit
+        return record
+      end
 
-	 def primary_key(table_name) #:nodoc:
-	    sql = <<-SQL	    
-SELECT systabcol.column_name
-FROM (systable join systabcol ) left outer join (sysidxcol join sysidx)
-WHERE  table_name = '#{table_name}' AND sysidxcol.sequence = 0
-SQL
-	    rs = select(sql)
-	    if !rs.nil? and !rs[0].nil?
-	       rs[0]['column_name']
-	    else
-	       nil
-	    end
-	 end
-
-	 def remove_index(table_name, options={}) #:nodoc:
-	    execute "DROP INDEX #{table_name}.#{quote_column_name(index_name(table_name, options))}"
-	 end
-
-	 def rename_table(name, new_name)
-	   execute "ALTER TABLE #{quote_table_name(name)} RENAME #{quote_table_name(new_name)}"
-	 end
-
-	 def remove_column(table_name, column_name) #:nodoc:
-	    execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}"
-	 end
-
-	 def change_column_default(table_name, column_name, default) #:nodoc:
-	    execute "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} DEFAULT #{quote(default)}"
-	 end
-
-         def change_column_null(table_name, column_name, null, default = nil)
-            unless null || default.nil?
-               execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+      # The database update function.         
+      def update_sql(sql, name = nil)
+        execute( sql, name )
+        return @affected_rows
+      end
+
+      # The database delete function.
+      def delete_sql(sql, name = nil) #:nodoc:
+        execute( sql, name )
+        return @affected_rows
+      end
+
+      # The database insert function.
+      # ActiveRecord requires that insert_sql returns the primary key of the row just inserted. In most cases, this can be accomplished
+      # by immediatly querying the @@identity property. If the @@identity property is 0, then passed id_value is used
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+        execute(sql, name)
+        
+        identity = SA.instance.api.sqlany_execute_direct(@connection, 'SELECT @@identity')
+        raise ActiveRecord::StatementInvalid.new("#{SA.instance.api.sqlany_error(@connection)}:#{sql}") if identity.nil?
+        SA.instance.api.sqlany_fetch_next(identity)
+        retval = SA.instance.api.sqlany_get_column(identity, 0)[1]
+        SA.instance.api.sqlany_free_stmt(identity)
+
+        retval = id_value if retval == 0
+        return retval
+      end
+      
+      # Returns a query as an array of arrays
+      def select_rows(sql, name = nil)
+        rs = SA.instance.api.sqlany_execute_direct(@connection, sql)
+        raise ActiveRecord::StatementInvalid.new("#{SA.instance.api.sqlany_error(@connection)}:#{sql}") if rs.nil?
+        record = []
+        while SA.instance.api.sqlany_fetch_next(rs) == 1
+          max_cols = SA.instance.api.sqlany_num_cols(rs)
+          result = Array.new(max_cols)
+          max_cols.times do |cols|
+            result[cols] = SA.instance.api.sqlany_get_column(rs, cols)[1]
+          end
+          record << result
+        end
+        SA.instance.api.sqlany_free_stmt(rs)
+        return record
+      end
+
+      def begin_db_transaction #:nodoc:   
+        @auto_commit = false;
+      end
+
+      def commit_db_transaction #:nodoc:
+        SA.instance.api.sqlany_commit(@connection)
+        @auto_commit = true;
+      end
+
+      def rollback_db_transaction #:nodoc:
+        SA.instance.api.sqlany_rollback(@connection)
+        @auto_commit = true;
+      end
+
+      def add_lock!(sql, options) #:nodoc:
+        sql
+      end
+
+      # SQL Anywhere does not support sizing of integers based on the sytax INTEGER(size). Integer sizes
+      # must be captured when generating the SQL and replaced with the appropriate size.
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+        if native = native_database_types[type]
+          if type == :integer
+            case limit
+              when 1
+                column_type_sql = 'tinyint'
+              when 2
+                column_type_sql = 'smallint'  
+              when 3..4
+                column_type_sql = 'integer'
+              when 5..8
+                column_type_sql = 'bigint'
+              else
+                column_type_sql = 'integer'
+              end
+               column_type_sql
+            else
+              super(type, limit, precision, scale)
+          end
+        else
+          super(type, limit, precision, scale)
+        end
+      end
+
+      # Do not return SYS-owned or DBO-owned tables
+      def tables(name = nil) #:nodoc:
+          sql = "SELECT table_name FROM systable WHERE creator not in (0,3)"
+          select(sql, name).map { |row| row["table_name"] }
+      end
+
+      def columns(table_name, name = nil) #:nodoc:
+        table_structure(table_name).map do |field|
+          field['default'] = field['default'][1..-2] if (!field['default'].nil? and field['default'][0].chr == "'")
+          SQLAnywhereColumn.new(field['name'], field['default'], field['domain'], (field['nulls'] == 1))
+        end
+      end
+
+      def indexes(table_name, name = nil) #:nodoc:
+        sql = "SELECT DISTINCT index_name, \"unique\" FROM sys.systable INNER JOIN sys.sysidxcol ON sys.systable.table_id = sys.sysidxcol.table_id INNER JOIN sys.sysidx ON sys.systable.table_id = sys.sysidx.table_id AND sys.sysidxcol.index_id = sys.sysidx.index_id WHERE table_name = '#{table_name}' AND index_category > 2"
+        select(sql, name).map do |row|
+          index = IndexDefinition.new(table_name, row['index_name'])
+          index.unique = row['unique'] == 1
+          sql = "SELECT column_name FROM sys.sysidx INNER JOIN sys.sysidxcol ON sys.sysidxcol.table_id = sys.sysidx.table_id AND sys.sysidxcol.index_id = sys.sysidx.index_id INNER JOIN sys.syscolumn ON sys.syscolumn.table_id = sys.sysidxcol.table_id AND sys.syscolumn.column_id = sys.sysidxcol.column_id WHERE index_name = '#{row['index_name']}'"	
+          index.columns = select(sql).map { |col| col['column_name'] }
+          index
+        end
+      end
+
+      def primary_key(table_name) #:nodoc:
+        sql = "SELECT sys.systabcol.column_name FROM (sys.systable JOIN sys.systabcol) LEFT OUTER JOIN (sys.sysidxcol JOIN sys.sysidx) WHERE table_name = '#{table_name}' AND sys.sysidxcol.sequence = 0"
+        rs = select(sql)
+        if !rs.nil? and !rs[0].nil?
+          rs[0]['column_name']
+        else
+          nil
+        end
+      end
+
+      def remove_index(table_name, options={}) #:nodoc:
+        execute "DROP INDEX #{table_name}.#{quote_column_name(index_name(table_name, options))}"
+      end
+
+      def rename_table(name, new_name)
+        execute "ALTER TABLE #{quote_table_name(name)} RENAME #{quote_table_name(new_name)}"
+      end
+
+      def remove_column(table_name, column_name) #:nodoc:
+        execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}"
+      end
+
+      def change_column_default(table_name, column_name, default) #:nodoc:
+        execute "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} DEFAULT #{quote(default)}"
+      end
+
+      def change_column_null(table_name, column_name, null, default = nil)
+        unless null || default.nil?
+          execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+        end
+        execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} #{null ? '' : 'NOT'} NULL")
+      end             
+
+      def change_column(table_name, column_name, type, options = {}) #:nodoc:         
+        add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        add_column_options!(add_column_sql, options)
+        add_column_sql << ' NULL' if options[:null]
+        execute(add_column_sql)
+      end
+       
+      def rename_column(table_name, column_name, new_column_name) #:nodoc:
+        execute "ALTER TABLE #{quote_table_name(table_name)} RENAME #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
+      end
+
+      def remove_column(table_name, column_name)
+        sql = "SELECT \"index_name\" FROM SYS.SYSTAB join SYS.SYSTABCOL join SYS.SYSIDXCOL join SYS.SYSIDX WHERE \"column_name\" = '#{column_name}' AND \"table_name\" = '#{table_name}'"
+        select(sql, nil).map do |row|
+          execute "DROP INDEX \"#{table_name}\".\"#{row['index_name']}\""      
+        end
+        execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}"
+      end
+         
+      protected
+        def select(sql, name = nil) #:nodoc:
+          return execute(sql, name)
+        end
+
+        # ActiveRecord uses the OFFSET/LIMIT keywords at the end of query to limit the number of items in the result set.
+        # This syntax is NOT supported by SQL Anywhere. In previous versions of this adapter this adapter simply
+        # overrode the add_limit_offset function and added the appropriate TOP/START AT keywords to the start of the query.
+        # However, this will not work for cases where add_limit_offset is being used in a subquery since add_limit_offset
+        # is called with the WHERE clause. 
+        #
+        # As a result, the following function must be called before every SELECT statement against the database. It
+        # recursivly walks through all subqueries in the SQL statment and replaces the instances of OFFSET/LIMIT with the
+        # corresponding TOP/START AT. It was my intent to do the entire thing using regular expressions, but it would seem
+        # that it is not possible given that it must count levels of nested brackets.
+        def modify_limit_offset(sql)
+          modified_sql = ""
+          subquery_sql = ""
+          in_single_quote = false
+          in_double_quote = false
+          nesting_level = 0
+          if sql =~ /(OFFSET|LIMIT)/xmi then
+            if sql =~ /\(/ then
+              sql.split(//).each_with_index do |x, i|
+                case x[0]
+                  when 40  # left brace - (
+                    modified_sql << x if nesting_level == 0
+                    subquery_sql << x if nesting_level > 0
+                    nesting_level = nesting_level + 1 unless in_double_quote || in_single_quote
+                  when 41  # right brace - )
+                    nesting_level = nesting_level - 1 unless in_double_quote || in_single_quote
+                    if nesting_level == 0 and !in_double_quote and !in_single_quote then
+                      modified_sql << modify_limit_offset(subquery_sql)
+                      subquery_sql = ""
+                    end
+                    modified_sql << x if nesting_level == 0
+                    subquery_sql << x if nesting_level > 0                         
+                  when 39  # single quote - '
+                    in_single_quote = in_single_quote ^ true unless in_double_quote
+                    modified_sql << x if nesting_level == 0
+                    subquery_sql << x if nesting_level > 0    
+                  when 34  # double quote - "
+                    in_double_quote = in_double_quote ^ true unless in_single_quote
+                    modified_sql << x if nesting_level == 0
+                    subquery_sql << x if nesting_level > 0
+                  else
+                    modified_sql << x if nesting_level == 0
+                    subquery_sql << x if nesting_level > 0
+                end
+                raise ActiveRecord::StatementInvalid.new("Braces do not match: #{sql}") if nesting_level < 0
+              end
+            else
+              modified_sql = sql
             end
-            execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} #{null ? '' : 'NOT'} NULL")
-         end	 	 
-
-	 def change_column(table_name, column_name, type, options = {}) #:nodoc:         
-	   add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-           add_column_options!(add_column_sql, options)
-	   add_column_sql << ' NULL' if options[:null]
-	   execute(add_column_sql)
-	 end
-	 
-	 def rename_column(table_name, column_name, new_column_name) #:nodoc:
-	    execute "ALTER TABLE #{quote_table_name(table_name)} RENAME #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
-	 end
-
-	 def drop_column(table_name, column_name)
-	    execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}"
-	 end
-	 
-
-	 protected
-	    def select(sql, name = nil) #:nodoc:
-	      return execute(sql, name)
-	    end
-
-	    # Queries the structure of a table including the columns names, defaults, type, and nullability 
-	    # ActiveRecord uses the type to parse scale and precision information out of the types. As a result,
-	    # chars, varchars, binary, nchars, nvarchars must all be returned in the form <i>type</i>(<i>width</i>)
-	    # numeric and decimal must be returned in the form <i>type</i>(<i>width</i>, <i>scale</i>)
-	    # Nullability is returned as 0 (no nulls allowed) or 1 (nulls allowed)
-	    # Alos, ActiveRecord expects an autoincrement column to have default value of NULL
-
-	    def table_structure(table_name)
-	       sql = <<-SQL
-SELECT syscolumn.column_name as name, 
-       (IF syscolumn."default" = 'autoincrement' then null else syscolumn."default" endif) as "default",
-       (IF syscolumn.domain_id IN (7,8,9,11,33,34,35,3,27) THEN
-           (IF syscolumn.domain_id IN (3, 27)
-             THEN sysdomain.domain_name || '(' || syscolumn.width || ',' || syscolumn.scale || ')'
-             ELSE sysdomain.domain_name || '(' || syscolumn.width || ')'
-            END IF)
-         ELSE sysdomain.domain_name endif) as domain, 
-       (if syscolumn.nulls = 'Y' then 1 else 0 endif) as nulls
-FROM syscolumn, systable, sysdomain 
-WHERE syscolumn.table_id = systable.table_id AND 
-      table_name = '#{table_name}' AND
-      syscolumn.domain_id = sysdomain.domain_id
+            raise ActiveRecord::StatementInvalid.new("Quotes do not match: #{sql}") if in_double_quote or in_single_quote
+            return "" if modified_sql.nil?
+            select_components = modified_sql.scan(/\ASELECT\s+(DISTINCT)?(.*?)(?:\s+LIMIT\s+(.*?))?(?:\s+OFFSET\s+(.*?))?\Z/xmi)
+            return modified_sql if select_components[0].nil?
+            final_sql = "SELECT #{select_components[0][0]} "
+            final_sql << "TOP #{select_components[0][2]} " unless select_components[0][2].nil?
+            final_sql << "START AT #{(select_components[0][3].to_i + 1).to_s} " unless select_components[0][3].nil?
+            final_sql << "#{select_components[0][1]}"
+            return final_sql
+          else
+            return sql
+          end
+        end
+
+        # Queries the structure of a table including the columns names, defaults, type, and nullability 
+        # ActiveRecord uses the type to parse scale and precision information out of the types. As a result,
+        # chars, varchars, binary, nchars, nvarchars must all be returned in the form <i>type</i>(<i>width</i>)
+        # numeric and decimal must be returned in the form <i>type</i>(<i>width</i>, <i>scale</i>)
+        # Nullability is returned as 0 (no nulls allowed) or 1 (nulls allowed)
+        # Alos, ActiveRecord expects an autoincrement column to have default value of NULL
+
+        def table_structure(table_name)
+          sql = <<-SQL
+SELECT sys.syscolumn.column_name AS name, 
+  NULLIF(sys.syscolumn."default", 'autoincrement') AS "default",
+  IF sys.syscolumn.domain_id IN (7,8,9,11,33,34,35,3,27) THEN
+    IF sys.syscolumn.domain_id IN (3,27) THEN
+      sys.sysdomain.domain_name || '(' || sys.syscolumn.width || ',' || sys.syscolumn.scale || ')'
+    ELSE
+      sys.sysdomain.domain_name || '(' || sys.syscolumn.width || ')'
+    ENDIF
+  ELSE
+    sys.sysdomain.domain_name 
+  ENDIF AS domain, 
+  IF sys.syscolumn.nulls = 'Y' THEN 1 ELSE 0 ENDIF AS nulls
+FROM 
+  sys.syscolumn 
+  INNER JOIN sys.systable ON sys.syscolumn.table_id = sys.systable.table_id 
+  INNER JOIN sys.sysdomain ON sys.syscolumn.domain_id = sys.sysdomain.domain_id
+WHERE
+  table_name = '#{table_name}'
 SQL
-	       returning structure = select(sql) do       
-		  raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if false
-	       end
-	    end
-    
-	    # Required to prevent DEFAULT NULL being added to primary keys
-	    def options_include_default?(options)
-               options.include?(:default) && !(options[:null] == false && options[:default].nil?)
-	    end
-      end
-   end
+          returning structure = select(sql) do       
+            raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if false
+          end
+        end
+        
+        # Required to prevent DEFAULT NULL being added to primary keys
+        def options_include_default?(options)
+          options.include?(:default) && !(options[:null] == false && options[:default].nil?)
+        end
+
+      private
+
+        def connect!
+          result = SA.instance.api.sqlany_connect(@connection, @connection_string)
+          if result == 1 then
+            set_connection_options
+          else
+            error = SA.instance.api.sqlany_error(@connection)
+            raise ActiveRecord::ActiveRecordError.new("#{error}: Cannot Establish Connection")
+          end
+        end
+
+        def set_connection_options
+          SA.instance.api.sqlany_execute_immediate(@connection, "SET TEMPORARY OPTION non_keywords = 'LOGIN'") rescue nil
+          SA.instance.api.sqlany_execute_immediate(@connection, "SET TEMPORARY OPTION timestamp_format = 'YYYY-MM-DD HH:NN:SS'") rescue nil
+          # The liveness variable is used a low-cost "no-op" to test liveness
+          SA.instance.api.sqlany_execute_immediate(@connection, "CREATE VARIABLE liveness INT") rescue nil
+        end
+    end
+  end
 end
 
-

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: activerecord-sqlanywhere-adapter
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2008-11-07 00:00:00 -05:00
+  version: 0.1.2
+date: 2008-12-31 00:00:00 -05:00
 summary: ActiveRecord driver for SQL Anywhere
 require_paths: 
 - lib