activerecord-sqlanywhere-adapter 0.1.0

data/CHANGELOG

@@ -0,0 +1,5 @@
+=CHANGE LOG
+
+=====0.1.0 -- 2008/10/15
+- Initial Release
+

data/LICENSE

@@ -0,0 +1,23 @@
+/*====================================================
+*
+*   Copyright 2008 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.
+* You may obtain a copy of the License at
+*                                                                               
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+* While not a requirement of the license, if you do modify this file, we
+* would appreciate hearing about it.   Please email sqlany_interfaces@sybase.com
+*
+*
+*====================================================*/

data/README

@@ -0,0 +1,71 @@
+=SQL Anywhere ActiveRecord Driver
+
+This is a SQL Anywhere driver for Ruby ActiveRecord. This driver requires the
+native SQL Anywhere Ruby driver. To get the native driver, use:
+
+   gem install sqlanywhere
+
+This driver is designed for use with ActiveRecord 2.0.2 and greater.
+
+This driver is licensed under the Apache License, Version 2.
+
+==Making a Connection
+
+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
+  }
+
+==Running the ActiveRecord Unit Test Suite
+
+1. Open <tt><ACTIVERECORD_INSTALL_DIR>/rakefile</tt> and modify the line:
+
+      for adapter in %w( mysql postgresql sqlite sqlite3 firebird db2 oracle sybase openbase frontbase )
+
+   to include <tt>sqlanywhere</tt>. It should now look like:
+
+      for adapter in %w( mysql postgresql sqlite sqlite3 firebird db2 oracle sybase openbase frontbase sqlanywhere )
+
+2. Create directory to hold the connection definition:
+   
+      mkdir <ACTIVERECORD_INSTALL_DIR>/test/connections/native_sqlanywhere
+
+3. Copy <tt>test/connection.rb</tt> into the newly created directory.
+
+   NOTE: If using ActiveRecord 2.0.2, change the second line of the file from:
+  
+      require_dependency 'models/course'
+
+   to:
+
+      require_dependency 'fixtures/course'
+
+4. Create the two test datbases. These can be created in any directory.
+
+      dbinit arunit
+      dbinit 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].
+
+5. If you are using ActiveRecord 2.0.2, you must load the test tables. 
+
+      dbisql -c "eng=arunit;dbn=arunit;uid=dba;pwd=sql" sqlanywhere.sql
+      dbisql -c "eng=arunit;dbn=arunit2;uid=dba;pwd=sql" sqlanywhere2.sql
+
+   If you are using a newer version of ActiveRecord, this schema is automatically
+   migrated for you.
+
+6. Run the unit test suite from the ActiveRecord install directory:
+
+      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].

data/lib/active_record/connection_adapters/sqlanywhere_adapter.rb

@@ -0,0 +1,510 @@
+#====================================================
+#
+#    Copyright 2008 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.
+# You may obtain a copy of the License at
+#                                                                               
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# While not a requirement of the license, if you do modify this file, we
+# would appreciate hearing about it.   Please email sqlany_interfaces@sybase.com
+#
+#
+#====================================================
+
+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
+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
+
+      end
+
+
+      class SQLAnywhereAdapter < AbstractAdapter
+	 def adapter_name #:nodoc:
+	   'SQLAnywhere'
+	 end
+
+	 def supports_migrations? #:nodoc:
+	   true
+	 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
+
+      
+	 # 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
+
+	 # 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
+	 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")
+            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
+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
+end
+
+

data/test/connection.rb

@@ -0,0 +1,25 @@
+print "Using native SQLAnywhere Interface\n"
+require_dependency 'models/course'
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+ActiveRecord::Base.configurations = {
+  'arunit' => {
+    :adapter  => 'sqlanywhere',
+    :database => 'arunit',
+    :server   => 'arunit',
+    :username => 'dba',
+    :password => 'sql'
+  },
+  'arunit2' => {
+    :adapter  => 'sqlanywhere',
+    :database => 'arunit2',
+    :server   => 'arunit',
+    :username => 'dba',
+    :password => 'sql'
+  }
+}
+
+ActiveRecord::Base.establish_connection 'arunit'
+Course.establish_connection 'arunit2'

data/test/sqlanywhere.drop.sql

@@ -0,0 +1,35 @@
+DROP TABLE accounts
+DROP TABLE funny_jokes
+DROP TABLE companies
+DROP TABLE topics
+DROP TABLE developers
+DROP TABLE projects
+DROP TABLE developers_projects
+DROP TABLE customers
+DROP TABLE orders
+DROP TABLE movies
+DROP TABLE subscribers
+DROP TABLE booleantests
+DROP TABLE auto_id_tests
+DROP TABLE entrants
+DROP TABLE colnametests
+DROP TABLE mixins
+DROP TABLE people
+DROP TABLE readers
+DROP TABLE binaries
+DROP TABLE computers
+DROP TABLE tasks
+DROP TABLE posts
+DROP TABLE comments
+DROP TABLE authors
+DROP TABLE categories
+DROP TABLE categories_posts
+DROP TABLE fk_test_has_fk
+DROP TABLE fk_test_has_pk
+DROP TABLE keyboards
+DROP TABLE legacy_things
+DROP TABLE numeric_data
+DROP TABLE mixed_case_monkeys
+DROP TABLE minimalistics
+DROP TABLE schema_info
+go

data/test/sqlanywhere.sql

@@ -0,0 +1,222 @@
+CREATE TABLE accounts (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  firm_id int NULL,
+  credit_limit int NULL
+)
+
+CREATE TABLE funny_jokes (
+id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  name varchar(50) NULL
+)
+
+CREATE TABLE companies (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  type varchar(50) NULL,
+  ruby_type varchar(50) NULL,
+  firm_id int NULL,
+  name varchar(50) NULL,
+  client_of int NULL,
+  rating int default 1
+)
+
+
+CREATE TABLE topics (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  title varchar(255) NULL,
+  author_name varchar(255) NULL,
+  author_email_address varchar(255) NULL,
+  written_on datetime NULL,
+  bonus_time time NULL,
+  last_read date NULL,
+  content varchar(255) NULL,
+  approved tinyint default 1,
+  replies_count int default 0,
+  parent_id int NULL,
+  type varchar(50) NULL
+)
+
+CREATE TABLE developers (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  name varchar(100) NULL,
+  salary int default 70000,
+  created_at datetime NULL,
+  updated_at datetime NULL
+)
+
+CREATE TABLE projects (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  name varchar(100) NULL,
+  type varchar(255) NULL
+)
+
+CREATE TABLE developers_projects (
+  developer_id int NOT NULL,
+  project_id int NOT NULL,
+  joined_on datetime NULL,
+  access_level smallint default 1
+)
+
+CREATE TABLE orders (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  name varchar(100) NULL,
+  billing_customer_id int NULL,
+  shipping_customer_id int NULL
+)
+
+CREATE TABLE customers (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  name varchar(100) NULL,
+  balance int default 0,
+  address_street varchar(100) NULL,
+  address_city varchar(100) NULL,
+  address_country varchar(100) NULL,
+  gps_location varchar(100) NULL
+)
+
+CREATE TABLE movies (
+  movieid integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  name varchar(100) NULL
+)
+
+CREATE TABLE subscribers (
+  nick varchar(100) PRIMARY KEY,
+  name varchar(100) NULL
+)
+
+CREATE TABLE booleantests (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  value int NULL
+)
+
+CREATE TABLE auto_id_tests (
+  auto_id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  value int NULL
+)
+
+CREATE TABLE entrants (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  name varchar(255) NOT NULL,
+  course_id int NOT NULL
+)
+
+CREATE TABLE colnametests (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  [references] int NOT NULL
+)
+
+CREATE TABLE mixins (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  parent_id int NULL,
+  pos int NULL,
+  created_at datetime NULL,
+  updated_at datetime NULL,
+  lft int NULL,
+  rgt int NULL,
+  root_id int NULL,
+  type varchar(40) NULL
+)
+
+CREATE TABLE people (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  first_name varchar(40) NULL,
+  lock_version int DEFAULT 0
+)
+
+CREATE TABLE readers (
+    id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+    post_id int NOT NULL,
+    person_id int NOT NULL
+)
+
+CREATE TABLE binaries (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  data long binary NULL
+)
+
+CREATE TABLE computers (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  developer int NOT NULL,
+  extendedWarranty int NOT NULL
+)
+
+CREATE TABLE posts (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  author_id int NULL,
+  title varchar(255) NOT NULL,
+  body varchar(2048) NOT NULL,
+  type varchar(255) DEFAULT NULL
+)
+
+CREATE TABLE comments (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  post_id int NOT NULL,
+  body varchar(2048) NOT NULL,
+  type varchar(255) NOT NULL
+)
+
+CREATE TABLE authors (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  name varchar(255) NOT NULL
+)
+
+CREATE TABLE tasks (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  starting datetime NULL,
+  ending datetime NULL
+)
+
+CREATE TABLE categories (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  name varchar(255) NOT NULL,
+  type varchar(255) NOT NULL
+)
+
+CREATE TABLE categories_posts (
+  category_id int NOT NULL,
+  post_id int NOT NULL
+)
+
+CREATE TABLE fk_test_has_pk (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY
+)
+
+CREATE TABLE fk_test_has_fk (
+  id    integer PRIMARY KEY,
+  fk_id integer NOT NULL,
+
+  FOREIGN KEY (fk_id) REFERENCES fk_test_has_pk(id)
+)
+
+
+CREATE TABLE keyboards (
+  key_number integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  name varchar(50) NULL
+)
+
+--This table has an altered lock_version column name.
+CREATE TABLE legacy_things (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  tps_report_number int default NULL,
+  version int default 0
+)
+
+
+CREATE TABLE numeric_data (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  bank_balance numeric(10,2),
+  big_bank_balance numeric(15,2),
+  world_population numeric(10),
+  my_house_population numeric(2),
+  decimal_number_with_default numeric(3,2) DEFAULT 2.78
+)
+
+CREATE TABLE mixed_case_monkeys (
+  monkeyID integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY,
+  fleaCount integer
+);
+
+CREATE TABLE minimalistics (
+  id integer DEFAULT AUTOINCREMENT NOT NULL PRIMARY KEY
+);
+
+go

data/test/sqlanywhere2.drop.sql

@@ -0,0 +1,4 @@
+DROP TABLE courses
+go
+
+

data/test/sqlanywhere2.sql

@@ -0,0 +1,5 @@
+CREATE TABLE courses (
+ id int NOT NULL PRIMARY KEY,
+ name varchar(255) NOT NULL
+)
+go

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: activerecord-sqlanywhere-adapter
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2008-11-03 00:00:00 -05:00
+summary: ActiveRecord driver for SQL Anywhere
+require_paths: 
+- lib
+email: eric.farrar@ianywhere.com
+homepage: http://sqlanywhere.rubyforge.org
+rubyforge_project: sqlanywhere
+description: ActiveRecord driver for SQL Anywhere
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Eric Farrar
+files: 
+- lib/active_record/connection_adapters/sqlanywhere_adapter.rb
+- test/connection.rb
+- test/sqlanywhere.drop.sql
+- test/sqlanywhere.sql
+- test/sqlanywhere2.drop.sql
+- test/sqlanywhere2.sql
+- README
+- CHANGELOG
+- LICENSE
+test_files: []
+
+rdoc_options: 
+- --title
+- ActiveRecord Driver for SQL Anywhere
+- --main
+- README
+- --line-numbers
+extra_rdoc_files: 
+- README
+- CHANGELOG
+- LICENSE
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sqlanywhere
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.2
+    version: