activerecord-jdbcsqlanywhere-adapter 1.0.0 → 1.0.1

data/.gitignore

@@ -2,3 +2,5 @@ pkg/*
 *.gem
 .bundle
 *.jar
+Gemfile.lock
+.rvmrc

data/Gemfile

@@ -1,4 +1,7 @@
 source :gemcutter
 
+gem 'rails', ENV['AR_VERSION'] if ENV['AR_VERSION']
+gem 'activerecord', ENV['AR_VERSION']
+
 # Specify your gem's dependencies in activerecord-sqlanywhere-adapter.gemspec
 gemspec

data/README.md

@@ -1,5 +1,5 @@
-activerecord-sqlanywhere-adapter
+activerecord-jdbcsqlanywhere-adapter
 ===========================
 
-This is an ActiveRecord adapter for Sybase SQLAnywhere.
+This is an ActiveRecord JDBC adapter for Sybase SQLAnywhere.
 

data/Rakefile

@@ -23,6 +23,14 @@ end
 task :build => [:java_compile, :git_local_check]
 
 require 'rake/testtask'
+
+# overriding the default rake tests loader
+class Rake::TestTask
+  def rake_loader
+    'test/my-minitest-loader.rb'
+  end
+end
+
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
   ar_jdbc = ENV['AR_JDBC'] ||

data/lib/activerecord-jdbcsqlanywhere-adapter.rb

@@ -1,5 +1,5 @@
 module ArJdbc
   module SybaseSQLAnywhere
-    VERSION = "1.0.0"
+    VERSION = "1.0.1"
   end
 end

data/lib/arjdbc/sqlanywhere/adapter.rb

@@ -12,6 +12,152 @@ module ::ArJdbc
       def init_column(name, default, *args)
         @name = name.downcase
       end
+
+      # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
+      def default_value(value)
+        # jdbc returns column default strings with actual single quotes around the value.
+        return $1 if value =~ /^'(.*)'$/
+
+        value
+      end
+
+      def simplified_type(field_type)
+        case field_type
+        when /int|bigint|smallint|tinyint/i                        then :integer
+        when /numeric/i                                            then (@scale.nil? || @scale == 0) ? :integer : :decimal
+        when /float|double|decimal|money|real|smallmoney/i         then :decimal
+        when /datetime|smalldatetime/i                             then :datetime
+        when /timestamp/i                                          then :timestamp
+        when /time/i                                               then :time
+        when /date/i                                               then :date
+        when /text|ntext|xml/i                                     then :text
+        when /binary|image|varbinary/i                             then :binary
+        when /char|nchar|nvarchar|string|varchar/i                 then (@limit == 1073741823 ? (@limit = nil; :text) : :string)
+        when /bit/i                                                then :boolean
+        when /uniqueidentifier/i                                   then :string
+        end
+      end
+
+      def type_cast(value)
+        return nil if value.nil? || value == "(null)" || value == "(NULL)"
+        case type
+        when :primary_key then value == true || value == false ? value == true ? 1 : 0 : value.to_i
+        when :boolean   then value == true or (value =~ /^t(rue)?$/i) == 0 or value=="1"
+        else
+          super
+        end
+      end
+    end
+
+    def quote_column_name(name)
+      "\"#{name}\""
+    end
+
+    def quoted_true
+      quote(1)
+    end
+
+    def quoted_false
+      quote(0)
+    end
+    
+    def sybaseserver_version
+      @sybaseserver_version ||= select_value("select @@version").split('.').map(&:to_i)
+    end
+
+    def last_insert_id
+      Integer(select_value("SELECT @@IDENTITY"))
+    end
+
+    def _execute(sql, name = nil)
+      result = super
+      ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql) ? last_insert_id : result
+    end
+    
+    def modify_types(tp) #:nodoc:
+      tp[:primary_key] = "NUMERIC(22,0) DEFAULT AUTOINCREMENT PRIMARY KEY"
+      tp[:integer][:limit] = nil
+      tp[:boolean] = {:name => "bit"}
+      tp[:binary] = {:name => "image"}
+      tp
+    end
+
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+      limit = nil if %w(text binary).include? type.to_s
+      return 'uniqueidentifier' if (type.to_s == 'uniqueidentifier')
+      return super unless type.to_s == 'integer'
+
+      if limit.nil? || limit == 4
+        'int'
+      elsif limit == 2
+        'smallint'
+      elsif limit == 1
+        'tinyint'
+      else
+        'bigint'
+      end
+    end
+
+    def add_limit_offset!(sql, options)
+      if options[:limit] and options[:offset] and options[:offset] > 0
+        sql.sub!(/^\s*SELECT(\s+DISTINCT)?/i,  "SELECT\\1 TOP #{options[:limit]} START AT #{options[:offset]+1}")
+      elsif sql !~ /^\s*SELECT (@@|COUNT\()/i
+        sql.sub!(/^\s*SELECT(\s+DISTINCT)?/i) do
+          "SELECT#{$1} TOP #{options[:limit]}"
+        end unless options[:limit].nil?
+      end
+    end
+        
+    def add_column_options!(sql, options) #:nodoc:
+      super
+      if options[:null] != false
+        sql << " NULL"
+      end
+    end
+
+    # Adds a new column to the named table.
+    # See TableDefinition#column for details of the options you can use.
+    def add_column(table_name, column_name, type, options = {})
+      add_column_sql = "ALTER TABLE #{table_name} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+      fix_null = false
+      if options[:null] == false
+        fix_null = true
+        options.delete(:null)
+      end
+      add_column_options!(add_column_sql, options)
+      # TODO: Add support to mimic date columns, using constraints to mark them as such in the database
+      # add_column_sql << " CONSTRAINT ck__#{table_name}__#{column_name}__date_only CHECK ( CONVERT(CHAR(12), #{quote_column_name(column_name)}, 14)='00:00:00:000' )" if type == :date
+      execute(add_column_sql)
+      execute("ALTER TABLE #{table_name} MODIFY #{quote_column_name(column_name)} NOT NULL") if fix_null
+    end
+    
+    def remove_column(table_name, column_name)
+      remove_from_primary_key(table_name, column_name)
+      remove_from_index(table_name, column_name)
+      remove_check_constraints(table_name, column_name)
+      execute "ALTER TABLE #{table_name} DROP #{quote_column_name(column_name)}"
+    end
+
+    def remove_from_index(table_name, column_name)
+    end
+
+    def remove_check_constraints(table_name, column_name)
+    end
+    
+    def remove_from_primary_key(table_name, column_name)
+      columns = select "select col.cname from SYS.syscolumns col WHERE col.tname = '#{table_name}' AND in_primary_key = 'Y'"
+      the_column, columns = columns.partition{|c| c['cname'].casecmp(column_name.to_s) == 0 }
+      if the_column.size > 0
+        execute "ALTER TABLE #{table_name} DROP PRIMARY KEY"
+        if columns.size > 0
+          columns.map! {|c| quote_column_name(c['cname'])}
+          execute "ALTER TABLE #{table_name} ADD PRIMARY KEY (#{columns.join(', ')})"
+        end
+      end
+    end
+
+    def remove_index(table_name, options = {})
+      execute "DROP INDEX #{table_name}.#{index_name(table_name, options)}"
     end
   end
 end

data/lib/arjdbc/sqlanywhere/connection_methods.rb

@@ -1,9 +1,15 @@
 class ActiveRecord::Base
   class << self
     def sqlanywhere_connection( config )
+      version4 = true
+      begin
+        Java::com.sybase.jdbc4.jdbc.SybDriver
+      rescue NameError
+        version4 = false
+      end
       config[:port] ||= 2638
-      config[:url] ||= "jdbc:sybase:Tds:#{config[:server]}:#{config[:port]}?serviceName=#{config[:database]}"
-      config[:driver] ||= "com.sybase.jdbc3.jdbc.SybDriver"
+      config[:url] ||= "jdbc:sybase:Tds:#{config[:host]}:#{config[:port]}?serviceName=#{config[:database]}"
+      config[:driver] ||= version4 ? "com.sybase.jdbc4.jdbc.SybDriver" : "com.sybase.jdbc3.jdbc.SybDriver"
       config[:dialect] = "sqlanywhere"
       jdbc_connection(config)
     end

data/src/java/arjdbc/sqlanywhere/SQLAnywhereRubyJdbcConnection.java

@@ -31,6 +31,7 @@ import java.sql.DatabaseMetaData;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
+import java.sql.Connection;
 import java.sql.Types;
 
 import arjdbc.jdbc.RubyJdbcConnection;
@@ -64,18 +65,32 @@ public class SQLAnywhereRubyJdbcConnection extends RubyJdbcConnection {
         }
     };
 
+    protected static IRubyObject booleanToRuby(Ruby runtime, ResultSet resultSet, boolean booleanValue)
+            throws SQLException {
+        if (booleanValue == false && resultSet.wasNull()) return runtime.getNil();
+        return runtime.newBoolean(booleanValue);
+    }
+
     /**
      * Treat LONGVARCHAR as CLOB on Informix for purposes of converting a JDBC value to Ruby.
      */
     @Override
     protected IRubyObject jdbcToRuby(Ruby runtime, int column, int type, ResultSet resultSet)
             throws SQLException {
+        if ( Types.BOOLEAN == type || Types.BIT == type ) {
+          return booleanToRuby(runtime, resultSet, resultSet.getBoolean(column));
+        }
         if (type == Types.LONGVARCHAR) {
             type = Types.CLOB;
         }
         return super.jdbcToRuby(runtime, column, type, resultSet);
     }
     
+    @Override
+    protected IRubyObject unmarshalKeysOrUpdateCount(ThreadContext context, Connection c, Statement stmt) throws SQLException {
+        return context.getRuntime().newFixnum(stmt.getUpdateCount());
+    }
+    
     @Override
     protected IRubyObject unmarshalResults(ThreadContext context, DatabaseMetaData metadata,
                                            Statement stmt, boolean downCase) throws SQLException {

data/test/db/sqlanywhere.rb

@@ -1,9 +1,10 @@
 config = { 
   :username => 'dba',
-  :password => 'weblog',
+  :password => 'sql',
   :adapter  => 'sqlanywhere',
   :host     => ENV[ "SQLANYWHERE_HOST" ] || 'localhost',
-  :database => ENV[ "SQLANYWHERE_NAMESPACE" ] || 'weblog_development'
+  :port     => ENV[ "SQLANYWHERE_PORT" ] || nil,
+  :database => ENV[ "SQLANYWHERE_NAMESPACE" ] || 'ARTest'
 }
 
 ActiveRecord::Base.establish_connection( config )

data/test/my-minitest-loader.rb

@@ -0,0 +1,13 @@
+require 'rake'
+
+# Load the test files from the command line.
+
+ARGV.each do |f|
+  break if f =~ /^-/
+
+  if f =~ /\*/
+    FileList[f].to_a.each { |fn| require File.expand_path(fn) }
+  else
+    require File.expand_path(f)
+  end
+end

data/test/sqlanywhere_limit_offset_test.rb

@@ -0,0 +1,159 @@
+require 'jdbc_common'
+require 'db/sqlanywhere'
+
+ActiveRecord::Schema.verbose = false
+
+class CreateLongShips < ActiveRecord::Migration
+
+  def self.up
+    create_table "long_ships", :force => true do |t|
+      t.string "name", :limit => 50, :null => false
+      t.integer "width", :default => 123
+      t.integer "length", :default => 456
+    end
+  end
+
+  def self.down
+    drop_table "long_ships"
+  end
+
+end
+
+class LongShip < ActiveRecord::Base
+  has_many :vikings
+end
+
+class CreateVikings < ActiveRecord::Migration
+
+  def self.up
+    create_table "vikings", :force => true do |t|
+      t.integer "long_ship_id", :null => false
+      t.string "name", :limit => 50, :default => "Sven"
+    end
+  end
+
+  def self.down
+    drop_table "vikings"
+  end
+
+end
+
+class Viking < ActiveRecord::Base
+  belongs_to :long_ship
+end
+
+
+class CreateNoIdVikings < ActiveRecord::Migration
+  def self.up
+    create_table "no_id_vikings", :force => true do |t|
+      t.string "name", :limit => 50, :default => "Sven"
+    end
+    remove_column "no_id_vikings", "id"
+  end
+
+  def self.down
+    drop_table "no_id_vikings"
+  end
+end
+
+class NoIdViking < ActiveRecord::Base
+end
+
+
+
+class SQLAnywhereLimitOffsetTest < Test::Unit::TestCase
+
+  def setup
+    CreateLongShips.up
+    CreateVikings.up
+    CreateNoIdVikings.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    CreateVikings.down
+    CreateLongShips.down
+    CreateNoIdVikings.down
+    ActiveRecord::Base.clear_active_connections!
+  end
+
+  def test_limit_with_no_id_column_available
+    NoIdViking.create!(:name => 'Erik')
+    assert_nothing_raised(ActiveRecord::StatementInvalid) do 
+      NoIdViking.find(:first)
+    end
+  end
+
+  def test_limit
+    %w(one two three four five six seven eight).each do |name|
+      LongShip.create!(:name => name)
+    end
+    ship_names = LongShip.find(:all, :limit => 3).map(&:name)
+    assert_equal(%w(one two three), ship_names)
+  end
+
+  def test_limit_and_offset
+    return if @connection.sybaseserver_version[0] < 10
+      
+    %w(one two three four five six seven eight).each do |name|
+      LongShip.create!(:name => name)
+    end
+    ship_names = LongShip.find(:all, :offset => 2, :limit => 3).map(&:name)
+    assert_equal(%w(three four five), ship_names)
+  end
+
+  def test_limit_with_order
+    %w(one two three four five six seven eight).each do |name|
+      LongShip.create!(:name => name)
+    end
+    ship_names = LongShip.find(:all, :order => "name", :limit => 2).map(&:name)
+    assert_equal(%w(eight five), ship_names)
+  end
+
+  def test_limit_and_offset_with_order
+    return if @connection.sybaseserver_version[0] < 10
+
+    %w(one two three four five six seven eight).each do |name|
+      LongShip.create!(:name => name)
+    end
+    ship_names = LongShip.find(:all, :order => "name", :offset => 4, :limit => 2).map(&:name)
+    assert_equal(%w(seven six), ship_names)
+  end
+
+  # TODO: work out how to fix DISTINCT support without breaking :include
+  # def test_limit_and_offset_with_distinct
+  #   %w(c a b a b a c d c d).each do |name|
+  #     LongShip.create!(:name => name)
+  #   end
+  #   ship_names = LongShip.find(:all, :select => "DISTINCT name", :order => "name", :offset => 1, :limit => 2).map(&:name)
+  #   assert_equal(%w(b c), ship_names)
+  # end
+
+  def test_limit_and_offset_with_include
+    return if @connection.sybaseserver_version[0] < 10
+
+    skei = LongShip.create!(:name => "Skei")
+    skei.vikings.create!(:name => "Bob")
+    skei.vikings.create!(:name => "Ben")
+    skei.vikings.create!(:name => "Basil")
+    ships = Viking.find(:all, :include => :long_ship, :offset => 1, :limit => 2)
+    assert_equal(2, ships.size)
+  end
+
+  def test_limit_and_offset_with_include_and_order
+    return if @connection.sybaseserver_version[0] < 10
+
+    boat1 = LongShip.create!(:name => "1-Skei")
+    boat2 = LongShip.create!(:name => "2-Skei")
+
+    boat1.vikings.create!(:name => "Adam")
+    boat2.vikings.create!(:name => "Ben")
+    boat1.vikings.create!(:name => "Carl")
+    boat2.vikings.create!(:name => "Donald")
+  
+    vikings = Viking.find(:all, :include => :long_ship, :order => "long_ships.name, vikings.name", :offset => 0, :limit => 3)
+    assert_equal(["Adam", "Carl", "Ben"], vikings.map(&:name))
+
+  end
+  
+end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-jdbcsqlanywhere-adapter
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-    - 1
-    - 0
-    - 0
-  version: 1.0.0
+  prerelease: 
+  version: 1.0.1
 platform: ruby
 authors: 
   - Brian Olsen
@@ -14,20 +10,16 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-09 00:00:00 +02:00
-default_executable: 
+date: 2011-10-17 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: activerecord-jdbc-adapter
     prerelease: false
     requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
       requirements: 
         - - ~>
           - !ruby/object:Gem::Version 
-            segments: 
-              - 1
-              - 1
-              - 1
             version: 1.1.1
     type: :runtime
     version_requirements: *id001
@@ -35,13 +27,10 @@ dependencies:
     name: bundler
     prerelease: false
     requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
-            segments: 
-              - 1
-              - 0
-              - 0
             version: 1.0.0
     type: :development
     version_requirements: *id002
@@ -70,9 +59,10 @@ files:
   - src/java/arjdbc/sqlanywhere/AdapterJavaService.java
   - src/java/arjdbc/sqlanywhere/SQLAnywhereRubyJdbcConnection.java
   - test/db/sqlanywhere.rb
+  - test/my-minitest-loader.rb
+  - test/sqlanywhere_limit_offset_test.rb
   - test/sqlanywhere_simple_test.rb
   - lib/arjdbc/sqlanywhere/adapter_java.jar
-has_rdoc: true
 homepage: http://github.com/griff/activerecord-jdbcsqlanywhere-adapter
 licenses: []
 
@@ -82,25 +72,21 @@ rdoc_options: []
 require_paths: 
   - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-          - 0
         version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-          - 1
-          - 3
-          - 6
         version: 1.3.6
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Sybase SQLAnywhere JDBC adapter for JRuby on Rails