activerecord-jdbc-adapter 1.2.8 → 1.2.9

data/lib/arjdbc/mssql/lock_helpers.rb

@@ -1,5 +1,5 @@
-module ::ArJdbc
-  module MsSQL
+module ArJdbc
+  module MSSQL
     module LockHelpers
       module SqlServerAddLock
         # Microsoft SQL Server uses its own syntax for SELECT .. FOR UPDATE:

data/lib/arjdbc/mssql/tsql_methods.rb

@@ -0,0 +1,58 @@
+# Common methods for handling TSQL databases.
+module ArJdbc
+  module MSSQL
+    module TSqlMethods
+
+      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]
+          total_rows = select_all("SELECT count(*) as TotalRows from (#{sql.gsub(/\bSELECT(\s+DISTINCT)?\b/i, "SELECT\\1 TOP 1000000000")}) tally")[0]["TotalRows"].to_i
+          if (options[:limit] + options[:offset]) >= total_rows
+            options[:limit] = (total_rows - options[:offset] >= 0) ? (total_rows - options[:offset]) : 0
+          end
+          sql.sub!(/^\s*SELECT(\s+DISTINCT)?/i, "SELECT * FROM (SELECT TOP #{options[:limit]} * FROM (SELECT\\1 TOP #{options[:limit] + options[:offset]} ")
+          sql << ") AS tmp1"
+          if options[:order]
+            options[:order] = options[:order].split(',').map do |field|
+              parts = field.split(" ")
+              tc = parts[0]
+              if sql =~ /\.\[/ and tc =~ /\./ # if column quoting used in query
+                tc.gsub!(/\./, '\\.\\[')
+                tc << '\\]'
+              end
+              if sql =~ /#{tc} AS (t\d_r\d\d?)/
+                  parts[0] = $1
+              elsif parts[0] =~ /\w+\.(\w+)/
+                parts[0] = $1
+              end
+              parts.join(' ')
+            end.join(', ')
+            sql << " ORDER BY #{change_order_direction(options[:order])}) AS tmp2 ORDER BY #{options[:order]}"
+          else
+            sql << " ) AS tmp2"
+          end
+        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
+      
+    end
+  end
+end

data/lib/arjdbc/mssql/utils.rb

@@ -0,0 +1,53 @@
+# NOTE: lot of code kindly borrowed from __activerecord-sqlserver-adapter__
+module ArJdbc
+  module MSSQL
+    module Utils
+      
+      module_function
+      
+      GET_TABLE_NAME_INSERT_UPDATE_RE = 
+        /^\s*(INSERT|EXEC sp_executesql N'INSERT)\s+INTO\s+([^\(\s,]+)\s*|^\s*update\s+([^\(\s,]+)\s*/i
+      
+      GET_TABLE_NAME_FROM_RE = /\bFROM\s+([^\(\)\s,]+)\s*/i
+      
+      def get_table_name(sql, qualified = nil)
+        if sql =~ GET_TABLE_NAME_INSERT_UPDATE_RE
+          tn = $2 || $3
+          qualified ? tn : unqualify_table_name(tn)
+        elsif sql =~ GET_TABLE_NAME_FROM_RE
+          qualified ? $1 : unqualify_table_name($1)
+        else
+          nil
+        end
+      end
+      
+      # protected
+
+      def unquote_table_name(table_name)
+        unquote_column_name(table_name)
+      end
+      
+      def unquote_column_name(column_name)
+        column_name.to_s.tr('[]', '')
+      end
+      
+      def unquote_string(string)
+        string.to_s.gsub("''", "'")
+      end
+      
+      def unqualify_table_name(table_name)
+        table_name.to_s.split('.').last.tr('[]', '')
+      end
+
+      def unqualify_table_schema(table_name)
+        table_name.to_s.split('.')[-2].gsub(/[\[\]]/, '') rescue nil
+      end
+
+      def unqualify_db_name(table_name)
+        table_names = table_name.to_s.split('.')
+        table_names.length == 3 ? table_names.first.tr('[]', '') : nil
+      end
+      
+    end
+  end
+end

data/lib/arjdbc/oracle/adapter.rb

@@ -32,11 +32,6 @@ module ArJdbc
         require 'arjdbc/jdbc/quoted_primary_key'
         ActiveRecord::Base.extend ArJdbc::QuotedPrimaryKeyExtension
       end
-      
-      (class << mod; self; end).class_eval do
-        alias_chained_method :insert, :query_dirty, :ora_insert
-        alias_chained_method :columns, :query_cache, :ora_columns
-      end
     end
 
     def self.column_selector
@@ -141,14 +136,44 @@ module ArJdbc
       
     end
 
-    def adapter_name
-      'Oracle'
-    end
-
     def self.arel2_visitors(config)
       { 'oracle' => Arel::Visitors::Oracle }
     end
 
+    ADAPTER_NAME = 'Oracle'
+    
+    def adapter_name
+      ADAPTER_NAME
+    end
+    
+    NATIVE_DATABASE_TYPES = {
+      :primary_key => "NUMBER(38) NOT NULL PRIMARY KEY",
+      :string => { :name => "VARCHAR2", :limit => 255 },
+      :text => { :name => "CLOB" },
+      :integer => { :name => "NUMBER", :limit => 38 },
+      :float => { :name => "NUMBER" },
+      :decimal => { :name => "DECIMAL" },
+      :datetime => { :name => "DATE" },
+      :timestamp => { :name => "TIMESTAMP" },
+      :time => { :name => "DATE" },
+      :date => { :name => "DATE" },
+      :binary => { :name => "BLOB" },
+      :boolean => { :name => "NUMBER", :limit => 1 },
+      :raw => { :name => "RAW", :limit => 2000 },
+    }
+
+    def native_database_types
+      super.merge(NATIVE_DATABASE_TYPES)
+    end
+    
+    def modify_types(types)
+      super(types)
+      NATIVE_DATABASE_TYPES.each do |key, value|
+        types[key] = value.dup
+      end
+      types
+    end
+    
     def prefetch_primary_key?(table_name = nil)
       columns(table_name).detect {|c| c.primary } if table_name
     end
@@ -159,14 +184,16 @@ module ArJdbc
     end
     alias_method :ids_in_list_limit, :in_clause_length
     
+    IDENTIFIER_LENGTH = 30 # :nodoc:
+    
     # maximum length of Oracle identifiers is 30
-    def table_alias_length; 30; end # :nodoc:
-    def table_name_length;  30; end # :nodoc:
-    def index_name_length;  30; end # :nodoc:
-    def column_name_length; 30; end # :nodoc:
+    def table_alias_length; IDENTIFIER_LENGTH; end # :nodoc:
+    def table_name_length;  IDENTIFIER_LENGTH; end # :nodoc:
+    def index_name_length;  IDENTIFIER_LENGTH; end # :nodoc:
+    def column_name_length; IDENTIFIER_LENGTH; end # :nodoc:
 
-    def default_sequence_name(table, column = nil) #:nodoc:
-      "#{table}_seq"
+    def default_sequence_name(table_name, column = nil) # :nodoc:
+      "#{table_name.to_s[0, IDENTIFIER_LENGTH - 4]}_seq"
     end
 
     def create_table(name, options = {}) #:nodoc:
@@ -229,40 +256,30 @@ module ArJdbc
       defined?(::Arel::SqlLiteral) && ::Arel::SqlLiteral === value
     end
 
-    def ora_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = []) #:nodoc:
+    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = []) # :nodoc:
       if (id_value && ! sql_literal?(id_value)) || pk.nil?
         # Pre-assigned id or table without a primary key
         # Presence of #to_sql means an Arel literal bind variable
         # that should use #execute_id_insert below
-        execute sql, name, binds
+        value = exec_insert(to_sql(sql, binds), name, binds)
+        id_value || last_inserted_id(value) # super
       else
         # Assume the sql contains a bind-variable for the id
         # Extract the table from the insert sql. Yuck.
-        table = sql.split(" ", 4)[2].gsub('"', '')
-        sequence_name ||= default_sequence_name(table)
-        id_value = next_sequence_value(sequence_name)
-        log(sql, name) do
-          @connection.execute_id_insert(sql, id_value)
+        sequence_name ||= begin
+          table = extract_table_ref_from_insert_sql(sql)
+          default_sequence_name(table)
         end
+        id_value = next_sequence_value(sequence_name)
+        log(sql, name) { @connection.execute_id_insert(sql, id_value) }
+        id_value
       end
-      id_value
     end
-
+    
     def indexes(table, name = nil)
       @connection.indexes(table, name, @connection.connection.meta_data.user_name)
     end
 
-    def modify_types(types)
-      super(types)
-      types[:primary_key] = "NUMBER(38) NOT NULL PRIMARY KEY"
-      types[:integer] = { :name => "NUMBER", :limit => 38 }
-      types[:datetime] = { :name => "DATE" }
-      types[:timestamp] = { :name => "TIMESTAMP" }
-      types[:time] = { :name => "DATE" }
-      types[:date] = { :name => "DATE" }
-      types
-    end
-
     def add_limit_offset!(sql, options) #:nodoc:
       offset = options[:offset] || 0
 
@@ -425,13 +442,13 @@ module ArJdbc
     def tables
       @connection.tables(nil, oracle_schema)
     end
-
+    
     # NOTE: better to use current_schema instead of the configured one ?!
     
-    def ora_columns(table_name, name = nil)
+    def columns(table_name, name = nil) # :nodoc:
       @connection.columns_internal(table_name.to_s, name, oracle_schema)
     end
-
+    
     # QUOTING ==================================================
 
     # See ACTIVERECORD_JDBC-33 for details -- better to not quote
@@ -514,7 +531,12 @@ module ArJdbc
         @connection.execute_update(sql)
       end
     end
-
+    
+    def extract_table_ref_from_insert_sql(sql) # :nodoc:
+      table = sql.split(" ", 4)[2].gsub('"', '')
+      ( idx = table.index('(') ) ? table[0...idx] : table # INTO table(col1, col2) ...
+    end
+    
     # In Oracle, schemas are usually created under your username :
     # http://www.oracle.com/technology/obe/2day_dba/schema/schema.htm
     # 

data/lib/arjdbc/sqlite3/adapter.rb

@@ -197,12 +197,9 @@ module ::ArJdbc
     end
     
     def tables(name = nil, table_name = nil) # :nodoc:
-      sql = "SELECT name FROM sqlite_master WHERE type = 'table'"
-      if table_name
-        sql << " AND name = #{quote_table_name(table_name)}"
-      else
-        sql << " AND NOT name = 'sqlite_sequence'"
-      end
+      sql = "SELECT name FROM sqlite_master " +
+      "WHERE type = 'table' AND NOT name = 'sqlite_sequence'"
+      sql << " AND name = #{quote_table_name(table_name)}" if table_name
 
       select_rows(sql, name).map { |row| row[0] }
     end

data/lib/arjdbc/version.rb

@@ -1,6 +1,6 @@
 module ArJdbc
   module Version
-    VERSION = "1.2.8"
+    VERSION = "1.2.9"
   end
 end
 # Compatibility with older versions of ar-jdbc for other extensions out there

data/src/java/arjdbc/jdbc/AdapterJavaService.java

@@ -34,7 +34,8 @@ import arjdbc.derby.DerbyModule;
 import arjdbc.h2.H2RubyJdbcConnection;
 import arjdbc.hsqldb.HSQLDBModule;
 import arjdbc.informix.InformixRubyJdbcConnection;
-import arjdbc.mssql.MssqlRubyJdbcConnection;
+import arjdbc.mssql.MSSQLModule;
+import arjdbc.mssql.MSSQLRubyJdbcConnection;
 import arjdbc.mysql.MySQLModule;
 import arjdbc.mysql.MySQLRubyJdbcConnection;
 import arjdbc.oracle.OracleModule;
@@ -54,7 +55,7 @@ public class AdapterJavaService implements BasicLibraryService {
         // ActiveRecord::ConnectionAdapter-s :
         RubyClass jdbcConnection = RubyJdbcConnection.createJdbcConnectionClass(runtime);
         PostgresqlRubyJdbcConnection.createPostgresqlJdbcConnectionClass(runtime, jdbcConnection);
-        MssqlRubyJdbcConnection.createMssqlJdbcConnectionClass(runtime, jdbcConnection);
+        MSSQLRubyJdbcConnection.createMSSQLJdbcConnectionClass(runtime, jdbcConnection);
         InformixRubyJdbcConnection.createInformixJdbcConnectionClass(runtime, jdbcConnection);
         OracleRubyJdbcConnection.createOracleJdbcConnectionClass(runtime, jdbcConnection);
         SQLite3RubyJdbcConnection.createSQLite3JdbcConnectionClass(runtime, jdbcConnection);
@@ -64,6 +65,7 @@ public class AdapterJavaService implements BasicLibraryService {
         // ArJdbc :
         RubyModule arJdbc = runtime.getOrCreateModule("ArJdbc");
         MySQLModule.load(arJdbc);
+        MSSQLModule.load(arJdbc);
         DerbyModule.load(arJdbc);
         HSQLDBModule.load(arJdbc);
         SQLite3Module.load(arJdbc);

data/src/java/arjdbc/mssql/MSSQLModule.java

@@ -0,0 +1,70 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2013 Karol Bucek.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package arjdbc.mssql;
+
+import static arjdbc.util.QuotingUtils.BYTES_0;
+import static arjdbc.util.QuotingUtils.BYTES_1;
+import static arjdbc.util.QuotingUtils.quoteSingleQuotesWithFallback;
+
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * ArJdbc::MSSQL
+ * 
+ * @author kares
+ */
+public class MSSQLModule {
+    
+    public static void load(final RubyModule arJdbc) {
+        RubyModule mssql = arJdbc.defineModuleUnder("MSSQL");
+        mssql.defineAnnotatedMethods( MSSQLModule.class );
+    }
+    
+    @JRubyMethod(name = "quote_string", required = 1, frame = false)
+    public static IRubyObject quote_string(
+            final ThreadContext context, 
+            final IRubyObject self, 
+            final IRubyObject string) {
+        return quoteSingleQuotesWithFallback(context, string);
+    }
+    
+    @JRubyMethod(name = "quoted_true", required = 0, frame = false)
+    public static IRubyObject quoted_true(
+            final ThreadContext context, 
+            final IRubyObject self) {
+        return RubyString.newString(context.getRuntime(), BYTES_1);
+    }
+    
+    @JRubyMethod(name = "quoted_false", required = 0, frame = false)
+    public static IRubyObject quoted_false(
+            final ThreadContext context, 
+            final IRubyObject self) {
+        return RubyString.newString(context.getRuntime(), BYTES_0);
+    }
+    
+}

data/src/java/arjdbc/mssql/MSSQLRubyJdbcConnection.java

@@ -0,0 +1,128 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
+ * Copyright (c) 2008-2009 Thomas E Enebo <enebo@acm.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ***** END LICENSE BLOCK *****/
+package arjdbc.mssql;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.util.List;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+import static arjdbc.jdbc.RubyJdbcConnection.ColumnData;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyString;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ *
+ * @author nicksieger
+ */
+public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
+
+    private RubyString _row_num;
+
+    protected MSSQLRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+        _row_num = runtime.newString("_row_num");
+    }
+
+    public static RubyClass createMSSQLJdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
+        final RubyClass clazz = getConnectionAdapters(runtime). // ActiveRecord::ConnectionAdapters
+            defineClassUnder("MSSQLJdbcConnection", jdbcConnection, MSSQL_JDBCCONNECTION_ALLOCATOR);
+        clazz.defineAnnotatedMethods(MSSQLRubyJdbcConnection.class);
+        getConnectionAdapters(runtime).setConstant("MssqlJdbcConnection", clazz); // backwards-compat
+        return clazz;
+    }
+
+    private static ObjectAllocator MSSQL_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new MSSQLRubyJdbcConnection(runtime, klass);
+        }
+    };
+
+    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 Mssql for purposes of converting a JDBC value to Ruby.
+     * Treat BOOLEAN/BIT as Boolean, rather than the default behaviour of conversion to string
+     */
+    @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);
+    }
+
+    /**
+     * Microsoft SQL 2000+ support schemas
+     */
+    @Override
+    protected boolean databaseSupportsSchemas() {
+        return true;
+    }
+
+    @Override
+    protected void populateFromResultSet(ThreadContext context, Ruby runtime, List results,
+                                         ResultSet resultSet, ColumnData[] columns) throws SQLException {
+        super.populateFromResultSet(context, runtime, results, resultSet, filterRowNumFromColumns(columns));
+    }
+
+    /**
+     * Filter out the <tt>_row_num</tt> column from results.
+     */
+    private ColumnData[] filterRowNumFromColumns(ColumnData[] columns) {
+        for (int i = 0; i < columns.length; i++) {
+            if (columns[i].name.equals(_row_num)) {
+                ColumnData[] filtered = new ColumnData[columns.length - 1];
+                if (i > 0) {
+                    System.arraycopy(columns, 0, filtered, 0, i);
+                }
+
+                if (i + 1 < columns.length) {
+                    System.arraycopy(columns, i + 1, filtered, i, columns.length - (i + 1));
+                }
+
+                return filtered;
+            }
+        }
+
+        return columns;
+    }
+    
+}