activerecord-sqlanywhere-jdbc-in4systems-adapter 1.0.12-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 754ffa261c7b9d3bfc68476c8463161b11fb7fbc
+  data.tar.gz: ba39ec75ea5143074d62966c70a608255bb89205
+SHA512:
+  metadata.gz: 3cbf49e0b0bc3657d7ca89e9fc378551c693c0b6104946650799245af164a05bbf3d623e813bd9cfe475fa6a052345882df555c399034ab25e8f0212a26f135a
+  data.tar.gz: 6cca0835a18ce4e7cbbbfde53ea4bfac99b322bb8a4d83295f1a4da6e842a1374d922ebb5d13931d92b35167dbd29dde2aeb67bf9b2a16d72aff7de74bb8f277

data/CHANGELOG

@@ -0,0 +1,33 @@
+=CHANGE LOG
+
+=====0.2.0 -- 2010/12/02
+- Added support for Rails 3.0.3
+- Added support for Arel 2
+- Removed test instructions for ActiveRecord 2.2.2
+- Updated license to 2010
+
+=====0.1.3 -- 2010/02/01
+- Added :encoding option to connection string
+- Fixed bug associated with dangling connections in development mode (http://groups.google.com/group/sql-anywhere-web-development/browse_thread/thread/79fa81bdfcf84c13/e29074e5b8b7ad6a?lnk=gst&q=activerecord#e29074e5b8b7ad6a)
+
+=====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
+otherwise)
+- Removed the default rake task
+
+=====0.1.0 -- 2008/10/15
+- Initial Release
+

data/LICENSE

@@ -0,0 +1,23 @@
+/*====================================================
+*
+*   Copyright 2008-2010 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,56 @@
+=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 3.0.3 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 "DatabaseName" parameter
+      :server   => 'arunit',       #equivalent to the "ServerName" parameter
+      :username => 'dba',          #equivalent to the "UserID" parameter
+      :password => 'sql',          #equivalent to the "Password" parameter
+      :encoding => 'Windows-1252', #equivalent to the "CharSet" parameter
+      :commlinks => 'TCPIP()',     #equivalent to the "Commlinks" parameter
+      :connection_name => 'Rails'  #equivalent to the "ConnectionName" 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.
+
+4. Create the two test databases. These can be created in any directory.
+
+      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].
+
+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_jdbc_in4systems_adapter.rb

@@ -0,0 +1,492 @@
+#encoding: utf-8
+#====================================================
+#
+#    Copyright 2008-2010 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'
+require 'activerecord-jdbc-adapter'
+
+require 'active_record/connection_adapters/abstract_adapter'
+require 'arel/visitors/sqlanywhere.rb'
+require 'pathname'
+
+module ActiveRecord
+  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')
+    # * :encoding (optional, defaults to charset of OS)
+    # * :commlinks (optional). Corresponds to "CommLinks=" in connection string
+    # * :connection_name (optional). Corresponds to "ConnectionName=" in connection string
+
+    def self.sqlanywhere_jdbc_in4systems_connection(config)
+
+      if config[:connection_string]
+        connection_string = config[:connection_string]
+      else
+        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 += "CharSet=#{config[:encoding]};" unless config[:encoding].nil?
+        connection_string += "Idle=0" # Prevent the server from disconnecting us if we're idle for >240mins (by default)
+      end
+
+      url = 'jdbc:sqlanywhere:' + connection_string
+
+      if ENV['SQLANY16']
+        $CLASSPATH << 'sajdbc4.jar'
+        $CLASSPATH << Pathname.new(ENV['SQLANY16']).join('java').join('sajdbc4.jar').to_s
+        driver = 'sybase.jdbc4.sqlanywhere.IDriver'
+      elsif ENV['SQLANY12']
+        $CLASSPATH << 'sajdbc4.jar'
+        $CLASSPATH << Pathname.new(ENV['SQLANY12']).join('java').join('sajdbc4.jar').to_s
+        driver = 'sybase.jdbc4.sqlanywhere.IDriver'
+      elsif ENV['SQLANY11']
+        $CLASSPATH << 'sajdbc.jar'
+        $CLASSPATH << Pathname.new(ENV['SQLANY11']).join('java').join('sajdbc.jar').to_s
+        driver = 'sybase.jdbc.sqlanywhere.IDriver'
+      else
+        raise "Cannot find SqlAnywhere installation directory"
+      end
+
+      conn = ActiveRecord::Base.jdbc_connection({adapter: 'jdbc', driver: driver, url: url})
+
+      ConnectionAdapters::SQLAnywhereJdbcIn4systemsAdapter.new( conn, logger, connection_string)
+    end
+  end
+
+  module ConnectionAdapters
+    class JdbcTypeConverter
+      AR_TO_JDBC_TYPES[:text] << lambda {|r| r['type_name'] =~ /^long varchar$/i}
+    end
+
+    class SQLAnywhereException < StandardError
+      attr_reader :errno
+      attr_reader :sql
+
+      def initialize(message, errno, sql)
+        super(message)
+        @errno = errno
+        @sql = sql
+      end
+    end
+
+    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 :boolean if field_type =~ /bit/i
+          return :text if field_type =~ /long varchar/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
+          return :text if field_type =~ /xml/i
+          return :integer if field_type =~ /uniqueidentifier/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
+
+		# Should override the time column values.
+		# Sybase doesn't like the time zones.
+
+    end
+
+    class SQLAnywhereJdbcIn4systemsAdapter < AbstractAdapter
+      delegate :select, :select_rows, :execute, to: :conn
+
+      attr_reader :conn
+      def initialize( conn, logger, connection_string = "") #:nodoc:
+        super
+        @visitor = Arel::Visitors::SQLAnywhere.new self
+        @conn = conn
+      end
+
+      def self.visitor_for(pool)
+        config = pool.spec.config
+
+        if config.fetch(:prepared_statements) {true}
+          Arel::Visitors::SQLAnywhere.new pool
+        else
+          BindSubstitution.new pool
+        end
+      end
+
+      def adapter_name #:nodoc:
+        'SQLAnywhere'
+      end
+
+      def supports_migrations? #:nodoc:
+        true
+      end
+
+      def requires_reloading?
+        true
+      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 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", :limit => 4 },
+          :float       => { :name => "float" },
+          :decimal     => { :name => "decimal" },
+          :datetime    => { :name => "datetime" },
+          :timestamp   => { :name => "datetime" },
+          :time        => { :name => "time" },
+          :date        => { :name => "date" },
+          :binary      => { :name => "binary" },
+          :boolean     => { :name => "tinyint", :limit => 1}
+        }
+      end
+
+      # QUOTING ==================================================
+
+      # Applies quotations around column names in generated queries
+      def quote_column_name(name) #:nodoc:
+        %Q("#{name}")
+      end
+
+      def quote_table_name(name)
+        owner, table = name.to_s.split('.', 2)
+        if table == nil
+          table = owner
+          owner = :dba
+        end
+        "#{quote_column_name(owner)}.#{quote_column_name(table)}"
+      end
+
+      def quote_table_alias_name(name)
+        quote_column_name 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)
+              "'#{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 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:
+        type = type.to_sym
+        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
+          elsif type == :string and !limit.nil?
+             "varchar (#{limit})"
+          elsif type == :boolean
+            column_type_sql = 'tinyint'
+          else
+            super(type, limit, precision, scale)
+          end
+        else
+          super(type, limit, precision, scale)
+        end
+      end
+
+      def viewed_tables(name = nil)
+        list_of_tables(['view'], name)
+      end
+
+      def base_tables(name = nil)
+        list_of_tables(['base'], name)
+      end
+
+      # Do not return SYS-owned or DBO-owned tables or RS_systabgroup-owned
+      def tables(name = nil) #:nodoc:
+        list_of_tables(['base', 'view'])
+      end
+
+      def columns(table_name, name = nil) #:nodoc:
+        table_structure(table_name).map do |field|
+          default = field['default']
+          if default == nil # Nil is the usual case
+          elsif default.starts_with?("'") # If string, remove first and last quotes and the last \n character
+            default = default[1..-2]
+          elsif default =~ /^-?\d+(\.\d+)?$/ # If a number string, leave as it is
+          else # Otherwise, it's probably something (LAST USER, CURRENT TIMESTAMP, etc) that wouldn't work in Rails, so return nil
+            default = nil
+          end
+          SQLAnywhereColumn.new(field['name'], 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 cname from SYS.SYSCOLUMNS where tname = '#{table_name}' and in_primary_key = 'Y'"
+        rs = exec_query(sql)
+        if !rs.nil? and !rs.first.nil?
+          rs.first['cname']
+        else
+          nil
+        end
+      end
+
+      def remove_index(table_name, options={}) #:nodoc:
+        execute "DROP INDEX #{quote_table_name(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 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:
+        if column_name.downcase == new_column_name.downcase
+          whine = "if_the_only_change_is_case_sqlanywhere_doesnt_rename_the_column"
+          rename_column table_name, column_name, "#{new_column_name}#{whine}"
+          rename_column table_name, "#{new_column_name}#{whine}", new_column_name
+        else
+          execute "ALTER TABLE #{quote_table_name(table_name)} RENAME #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
+        end
+      end
+
+      def remove_column(table_name, *column_names)
+        column_names = column_names.flatten
+        column_names.zip(columns_for_remove(table_name, *column_names)).each do |unquoted_column_name, column_name|
+          sql = <<-SQL
+            SELECT "index_name" FROM SYS.SYSTAB join SYS.SYSTABCOL join SYS.SYSIDXCOL join SYS.SYSIDX
+            WHERE "column_name" = '#{unquoted_column_name}' AND "table_name" = '#{table_name}'
+          SQL
+          select(sql, nil).each do |row|
+            execute "DROP INDEX \"#{table_name}\".\"#{row['index_name']}\""
+          end
+          execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{column_name}"
+        end
+      end
+
+      def exec_query(sql, name = 'SQL', binds = [])
+        binds.map! do |column, value|
+          type = column.type
+          if value != nil
+            case type
+            when :boolean
+              [column, value ? 1 : 0]
+            else
+              [column, value]
+            end
+          else
+            [column, value]
+          end
+        end
+        conn.exec_query(sql, name, binds)
+      end
+
+      def last_inserted_id(result)
+        select_value('SELECT @@identity')
+      end
+
+      def select_user(cache=true)
+        @user_id = (cache && @user_id) || select_value('SELECT USER')
+      end
+
+      # Set the database user to be user_id.
+      # If a block is given, then after running the block, the previous user_id is restored.
+      def set_user(user_id)
+        previous_user_id = select_user(true)
+        if previous_user_id != user_id
+          execute("SETUSER #{quote_column_name(user_id)}")
+          @user_id = user_id
+        end
+        if block_given?
+          begin
+            yield
+          ensure
+            set_user(previous_user_id)
+          end
+        end
+      end
+
+      protected
+
+        def list_of_tables(types, name = nil)
+          sql = "SELECT table_name FROM SYS.SYSTABLE WHERE table_type in (#{types.map{|t| quote(t)}.join(', ')}) and creator NOT IN (0,3,5)"
+          select(sql, name).map { |row| row["table_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 SYS.SYSCOLUMN.column_name AS name,
+  "default" 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
+ INNER JOIN sys.sysUser ON sys.systable.creator = sys.sysuser.user_id AND sys.sysuser.user_name = 'dba'
+WHERE
+  table_name = '#{table_name}'
+SQL
+          structure = exec_query(sql, :skip_logging)
+          raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure == false
+          structure
+        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 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
+          #SA.instance.api.sqlany_execute_immediate(@connection, "SET OPTION reserved_keywords = 'LIMIT'") 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
+

data/lib/arel/visitors/sqlanywhere.rb

@@ -0,0 +1,159 @@
+module Arel
+  module Visitors
+    class SQLAnywhere < Arel::Visitors::ToSql
+      def initialize connection
+        super
+        @quoted_table_aliases = {}
+      end
+
+      private
+        def visit_Arel_Nodes_SelectStatement o
+    o = order_hacks(o)
+
+    is_distinct = using_distinct?(o)
+
+    o.limit = 1000000 if (o.offset && !o.limit)
+    o.limit = o.limit.expr if(o.limit.is_a?(Arel::Nodes::Limit))
+    o.limit = o.limit if(o.limit.is_a?(Fixnum))
+
+    [
+      "SELECT",
+      ("DISTINCT" if is_distinct),
+      ("TOP #{o.limit}" if o.limit),
+      (visit_Arel_Nodes_Offset(o.offset) if o.offset),
+      o.cores.map { |x| visit_Arel_Nodes_SelectCore x }.join,
+      ("ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?),
+            #("LIMIT #{o.limit}" if o.limit),
+            #(visit(o.offset) if o.offset),
+      (visit(o.lock) if o.lock),
+    ].compact.join ' '
+  end
+
+      def visit_Arel_Nodes_SelectCore o
+        [
+          "#{o.projections.map { |x| visit x }.join ', '}",
+          ("FROM #{visit o.source}" if o.source), # Joins
+          ("WHERE #{o.wheres.map { |x| visit x }.join ' AND ' }" unless o.wheres.empty?),
+          ("GROUP BY #{o.groups.map { |x| visit x }.join ', ' }" unless o.groups.empty?),
+          (visit(o.having) if o.having),
+        ].compact.join ' '
+      end
+
+      def visit_Arel_Nodes_Group o
+        expr = o.expr.clone
+        if expr.class == Arel::Nodes::NamedFunction
+          expr.alias = nil
+        end
+        visit expr
+      end
+
+      def visit_Arel_Nodes_Offset o
+        "START AT #{visit(o.expr) + 1}"
+      end
+
+      def visit_Arel_Nodes_True o
+        "1=1"
+      end
+
+      def visit_Arel_Nodes_False o
+        "1=0"
+      end
+
+      def visit_Arel_Nodes_Matches o
+        # The version in arel cannot like integer columns
+        left = visit o.left # This method sets last column
+        # If last column was left, visit o.right would return 0
+        self.last_column = nil
+        "#{left} LIKE #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_TableAlias o
+        "#{visit o.relation} #{quote_table_alias_name o.name}"
+      end
+
+      def visit_Arel_Table o, a=nil
+        if o.table_alias
+          "#{quote_table_name o.name} #{quote_table_alias_name o.table_alias}"
+        else
+          quote_table_name o.name
+        end
+      end
+
+      def visit_Arel_Attributes_Attribute o, a=nil
+        if o.relation.table_alias
+          join_name = o.relation.table_alias
+          "#{quote_table_alias_name join_name}.#{quote_column_name o.name}"
+        else
+          join_name = o.relation.name
+          "#{quote_table_name join_name}.#{quote_column_name o.name}"
+        end
+      end
+
+      def quote_table_alias_name name
+        return name if Arel::Nodes::SqlLiteral === name
+        @quoted_table_aliases[name] ||= @connection.quote_table_alias_name(name)
+      end
+
+
+
+
+
+  def using_distinct?(o)
+    o.cores.any? do |core|
+      core.set_quantifier.class == Arel::Nodes::Distinct
+    end
+  end
+
+      # The functions (order_hacks, split_order_string) are based on the Oracle Enhacned ActiveRecord driver maintained by Raimonds Simanovskis (2010)
+      # (https://github.com/rsim/oracle-enhanced)
+
+      ###
+      # Hacks for the order clauses
+      def order_hacks o
+        return o if o.orders.empty?
+        return o unless o.cores.any? do |core|
+          core.projections.any? do |projection|
+            /DISTINCT.*FIRST_VALUE/ === projection
+          end
+        end
+        # Previous version with join and split broke ORDER BY clause
+        # if it contained functions with several arguments (separated by ',').
+        #
+        # orders   = o.orders.map { |x| visit x }.join(', ').split(',')
+        orders   = o.orders.map do |x|
+          string = visit x
+          if string.include?(',')
+            split_order_string(string)
+          else
+            string
+          end
+        end.flatten
+        o.orders = []
+        orders.each_with_index do |order, i|
+          o.orders <<
+            Nodes::SqlLiteral.new("alias_#{i}__#{' DESC' if /\bdesc$/i === order}")
+        end
+        o
+      end
+
+      # Split string by commas but count opening and closing brackets
+      # and ignore commas inside brackets.
+      def split_order_string(string)
+        array = []
+        i = 0
+        string.split(',').each do |part|
+          if array[i]
+            array[i] << ',' << part
+          else
+            # to ensure that array[i] will be String and not Arel::Nodes::SqlLiteral
+            array[i] = '' << part
+          end
+          i += 1 if array[i].count('(') == array[i].count(')')
+        end
+        array
+      end
+    end
+  end
+end
+
+Arel::Visitors::VISITORS['sqlanywhere'] = Arel::Visitors::SQLAnywhere

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'

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-sqlanywhere-jdbc-in4systems-adapter
+version: !ruby/object:Gem::Version
+  version: 1.0.12
+platform: java
+authors:
+- Eric Farar
+- Sri Kalai
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord-jdbc-adapter
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.3
+  prerelease: false
+  type: :runtime
+description: ActiveRecord JDBC driver for SQL Anywhere customized for in4systems
+email: chris.couzens@in4systems.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG
+- LICENSE
+- README
+- lib/active_record/connection_adapters/sqlanywhere_jdbc_in4systems_adapter.rb
+- lib/arel/visitors/sqlanywhere.rb
+- test/connection.rb
+homepage: https://github.com/in4systems/activerecord-sqlanywhere-adapter
+licenses:
+- Apache License Version 2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.2.2
+signing_key:
+specification_version: 4
+summary: ActiveRecord driver for SQL Anywhere
+test_files: []