activerecord-advantage-adapter 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+/*====================================================
+*
+*   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.
+*
+*
+*====================================================*/

data/README

@@ -0,0 +1,66 @@
+=Advantage ActiveRecord Driver
+
+This is a Advantage driver for Ruby ActiveRecord. This driver requires the
+native Advantage Ruby driver. To get the native driver, use:
+
+   gem install advantage
+
+This driver is designed for use with ActiveRecord 3.2.0 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  => 'advantage',
+      :database => 'c:\test\arunit.add',        #equivalent to the "Data Source" parameter
+      :username => 'adssys',                    #equivalent to the "UserID" parameter
+      :password => ''                           #equivalent to the "Password" parameter
+  }
+
+==Creating a new project.  The following is based on the tutorial at http://edgeguides.rubyonrails.org/getting_started.html
+
+1. Create the application:
+        rails new blog
+
+2. Switch into the new application folder
+        cd blog
+
+3. Create three databases.  This can be done via ARC using SQL
+        CREATE DATABASE "c:\blog\dbprod\blog_production.add";
+        CREATE DATABASE "c:\blog\dbtest\blog_test.add";
+        CREATE DATABASE "c:\blog\dbdev\blog_dev.add";
+
+4. Edit the file GemFile and add the activerecord-advantage-adapter
+   gem 'activerecord-advantage-adapter'
+
+5. Edit the config/database.yml file to match the following
+
+development:
+  adapter: advantage
+  database: c:/blog/dbdev/blog_dev.add
+  username: adssys
+  password:
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  adapter: advantage
+  database: c:/blog/dbtest/blog_test.add
+  username: adssys
+  password:
+
+production:
+  adapter: advantage
+  database: c:/blog/dbprod/blog_production.add
+  username: adssys
+  password:
+
+
+
+
+

data/lib/active_record/connection_adapters/advantage_adapter.rb

@@ -0,0 +1,531 @@
+#====================================================
+#
+#    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.
+#
+#
+#
+#====================================================
+
+require 'active_record/connection_adapters/abstract_adapter'
+require 'arel/visitors/advantage.rb'
+
+# Singleton class to hold a valid instance of the AdvantageInterface across all connections
+class ADS
+  include Singleton
+  attr_accessor :api
+
+  def initialize
+    require 'advantage' unless defined? Advantage
+    @api = Advantage::AdvantageInterface.new()
+    raise LoadError, "Could not load ACE library" if Advantage::API.ads_initialize_interface(@api) == 0
+    raise LoadError, "Could not initialize ACE library" if @api.ads_init() == 0
+  end
+end
+
+module ActiveRecord
+  class Base
+    DEFAULT_CONFIG = { :username => 'adssys', :password => nil }
+    # Main connection function to Advantage
+    # Connection Adapter takes four parameters:
+    # * :database (required, no default). Corresponds to "Data Source=" in connection string
+    # * :username (optional, default to 'adssys'). Correspons to "User ID=" in connection string
+    # * :password (optional, deafult to '')
+    # * :options (optional, defaults to ''). Corresponds to any additional options in connection string
+
+    def self.advantage_connection(config)
+
+      config = DEFAULT_CONFIG.merge(config)
+
+      raise ArgumentError, "No data source was given. Please add a :database option." unless config.has_key?(:database)
+
+      connection_string = "data source=#{config[:database]};User ID=#{config[:username]};"
+      connection_string += "Password=#{config[:password]};" unless config[:options].nil?
+      connection_string += "#{config[:options]};" unless config[:options].nil?
+
+      db = ADS.instance.api.ads_new_connection()
+
+      ConnectionAdapters::AdvantageAdapter.new(db, logger, connection_string)
+    end
+  end
+
+  module ConnectionAdapters
+    class AdvantageException < StandardError
+      attr_reader :errno
+      attr_reader :sql
+
+      def initialize(message, errno, sql)
+        super(message)
+        @errno = errno
+        @sql = sql
+      end
+    end
+
+    class AdvantageColumn < Column
+      private
+        # Overridden to handle Advantage integer, varchar, binary, and timestamp types
+        def simplified_type(field_type)
+          return :boolean if field_type =~ /logical/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 =~ /short|integer/i
+          return :integer if field_type =~ /autoinc/i
+          super
+        end
+
+#EJS Need?
+=begin
+        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
+=end
+
+      protected
+    end
+
+    class AdvantageAdapter < AbstractAdapter
+      def initialize( connection, logger, connection_string = "") #:nodoc:
+        super(connection, logger)
+        @auto_commit = true
+        @affected_rows = 0
+        @connection_string = connection_string
+        @visitor = Arel::Visitors::Advantage.new self
+        connect!
+      end
+
+      def adapter_name #:nodoc:
+        'Advantage'
+      end
+
+      def supports_migrations? #:nodoc:
+        true
+      end
+
+      def requires_reloading? #:nodoc:
+        true
+      end
+
+      def active? #:nodoc:
+        ADS.instance.api.ads_execute_immediate(@connection, "SELECT 1 FROM SYSTEM.IOTA") == 1
+      rescue
+        false
+      end
+
+      def disconnect! #:nodoc:
+        result = ADS.instance.api.ads_disconnect( @connection )
+        super
+      end
+
+      def reconnect! #:nodoc:
+        disconnect!
+        connect!
+      end
+
+      def supports_count_distinct? #:nodoc:
+        true
+      end
+
+      def supports_autoincrement? #:nodoc:
+        true
+      end
+
+      # Used from StackOverflow question 1000688
+      # Stip alone will return NIL if the string is not altered.  In that case,
+      # still return the string.
+      def strip_or_self(str)  #:nodoc:
+          str.strip! || str if str
+      end
+
+      # Maps native ActiveRecord/Ruby types into ADS types
+      def native_database_types #:nodoc:
+        {
+          :primary_key => 'AUTOINC PRIMARY KEY CONSTRAINT NOT NULL',
+          :string      => { :name => "varchar", :limit => 255 },
+          :text        => { :name => "memo" },
+          :integer     => { :name => "integer" },
+          :float       => { :name => "float" },
+          :decimal     => { :name => "numeric" },
+          :datetime    => { :name => "timestamp" },
+          :timestamp   => { :name => "timestamp" },
+          :time        => { :name => "time" },
+          :date        => { :name => "date" },
+          :binary      => { :name => "blob" },
+          :boolean     => { :name => "logical"}
+        }
+      end
+
+      # Applies quotations around column names in generated queries
+      def quote_column_name(name) #:nodoc:
+        %Q("#{name}")
+      end
+
+      def quote(value, column = nil)  #:nodoc:
+        super(value, column)
+      end
+
+      def quoted_true #:nodoc:
+        '1'
+      end
+
+      def quoted_false #:nodoc:
+        '0'
+      end
+
+      # The database execution function
+      def execute(sql, name = nil, binds = []) #:nodoc:
+        if name == :skip_logging
+            query(sql, binds)
+        else
+            log(sql, name, binds) { query(sql, binds) }
+        end
+      end
+
+      # Translate the exception if possible
+      def translate_exception(exception, message)  #:nodoc:
+        return super unless exception.respond_to?(:errno)
+        case exception.errno
+          when 2121
+            if exception.sql !~ /^SELECT/i then
+          raise ActiveRecord::ActiveRecordError.new(message)
+            else
+              super
+            end
+          when 7076
+            raise InvalidForeignKey.new(message, exception)
+          when 7057
+            raise RecordNotUnique.new(message, exception)
+          else
+            super
+        end
+        super
+      end
+
+      # The database update function.
+      def update_sql(sql, name = nil)  #:nodoc:
+        execute( sql, name )
+        return @affected_rows
+      end
+
+      # The database delete function.
+      def delete_sql(sql, name = nil) #:nodoc:
+        execute( sql, name )
+        return @affected_rows
+      end
+
+      # The database insert function.
+      # ActiveRecord requires that insert_sql returns the primary key of the row just inserted. In most cases, this can be accomplished
+      # by immediatly querying the @@identity property. If the @@identity property is 0, then passed id_value is used
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+        execute(sql, name)
+        identity = last_inserted_id(nil)
+        retval = id_value if retval == 0
+        return retval
+      end
+
+      # The Database insert function as part of the rails changes
+      def exec_insert(sql, name = nil, binds = [])  #:nodoc:
+        log(sql, "insert", binds) { query(sql, binds) }
+      end
+
+      # The Database update function as part of the rails changes
+      def exec_update(sql, name = nil, binds = [])  #:nodoc:
+        log(sql, "update", binds) { query(sql, binds) }
+      end
+
+      # The Database delete function as part of the rails changes
+      def exec_delete(sql, name = nil, binds = []) #:nodoc:
+        log(sql, "delete", binds) { query(sql, binds) }
+      end
+
+      # Retrieve the last AutoInc ID
+      def last_inserted_id(result) #:nodoc:
+        rs = ADS.instance.api.ads_execute_direct(@connection, 'SELECT LASTAUTOINC( CONNECTION ) FROM SYSTEM.IOTA')
+        raise ActiveRecord::StatementInvalid.new("#{ADS.instance.api.ads_error(@connection)}:#{sql}") if rs.nil?
+        ADS.instance.api.ads_fetch_next(rs)
+        retval, identity = ADS.instance.api.ads_get_column(rs, 0)
+        ADS.instance.api.ads_free_stmt(rs)
+        identity
+      end
+
+      # Returns a query as an array of arrays
+      def select_rows(sql, name = nil)
+        rs = ADS.instance.api.ads_execute_direct(@connection, sql)
+        raise ActiveRecord::StatementInvalid.new("#{ADS.instance.api.ads_error(@connection)}:#{sql}") if rs.nil?
+        record = []
+        while ADS.instance.api.ads_fetch_next(rs) == 1
+          max_cols = ADS.instance.api.ads_num_cols(rs)
+          result = Array.new(max_cols)
+          max_cols.times do |cols|
+            result[cols] = ADS.instance.api.ads_get_column(rs, cols)[1]
+          end
+          record << result
+        end
+        ADS.instance.api.ads_free_stmt(rs)
+        return record
+      end
+
+      # Begin a transaction
+      def begin_db_transaction #:nodoc:
+        ADS.instance.api.AdsBeginTransaction(@connection)
+        @auto_commit = false;
+      end
+
+      # Commit the transaction
+      def commit_db_transaction #:nodoc:
+        ADS.instance.api.ads_commit(@connection)
+        @auto_commit = true;
+      end
+
+      # Rollback the transaction
+      def rollback_db_transaction #:nodoc:
+        ADS.instance.api.ads_rollback(@connection)
+        @auto_commit = true;
+      end
+
+      def add_lock!(sql, options) #:nodoc:
+        sql
+      end
+
+      # Advantage does not support sizing of integers based on the sytax INTEGER(size).
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+        if native = native_database_types[type]
+          if type == :integer
+            column_type_sql = 'integer'
+          elsif type == :string and !limit.nil?
+            "varchar (#{limit})"
+          else
+            super(type, limit, precision, scale)
+          end
+        else
+          super(type, limit, precision, scale)
+        end
+      end
+
+      # Retrieve a list of Tables
+      def tables(name = nil) #:nodoc:
+          sql = "EXECUTE PROCEDURE sp_GetTables( NULL, NULL, NULL, 'TABLE' );"
+          select(sql, name).map { |row| strip_or_self(row["TABLE_NAME"]) }
+      end
+
+      # Return a list of columns
+      def columns(table_name, name = nil) #:nodoc:
+        table_structure(table_name).map do |field|
+          AdvantageColumn.new(strip_or_self(field['COLUMN_NAME']), field['COLUMN_DEF'], strip_or_self(field['TYPE_NAME']), field['NULLABLE'])
+        end
+      end
+
+      # Return a list of indexes
+      # EJS - Is there a way to get info without DD?
+      def indexes(table_name, name = nil) #:nodoc:
+        sql = "SELECT name, INDEX_OPTIONS & 1 AS [unique], index_expression FROM SYSTEM.INDEXES WHERE parent = '#{table_name}'"
+        select(sql, name).map do |row|
+          index = IndexDefinition.new(table_name, row['name'])
+          index.unique = row['unique'] == 1
+          index.columns = row['index_expression']
+          index
+        end
+      end
+
+      # Return the primary key
+      def primary_key(table_name) #:nodoc:
+        sql = "SELECT COLUMN_NAME FROM (EXECUTE PROCEDURE sp_GetBestRowIdentifier( NULL, NULL, '#{table_name}', NULL, FALSE)) as gbri"
+        rs = select(sql)
+        if !rs.nil? and !rs[0].nil?
+          strip_or_self(rs[0]['COLUMN_NAME'])
+        else
+          nil
+        end
+      end
+
+      # Drop an index
+      def remove_index(table_name, options={}) #:nodoc:
+        execute "DROP INDEX #{quote_table_name(table_name)}.#{quote_column_name(index_name(table_name, options))}"
+      end
+
+      # Rename a table
+      #EJS - can be done without dd?
+      def rename_table(name, new_name) #:nodoc:
+        execute "EXECUTE PROCEDURE sp_RenameDDObject(#{quote_table_name(name)} , #{quote_table_name(new_name)}, 1 /* ADS_DD_TABLE_OBJECT */, 0 /* Rename File */)"
+      end
+
+      # Helper function to retrieve the columns current type
+      def get_column_type(table_name, column_name) #:nodoc:
+          sql = <<-SQL
+SELECT
+    CASE
+    WHEN type_name = 'VARCHAR' or type_name = 'CHAR' or type_name = 'CICHAR' or
+         type_name = 'NVARCHAR' or type_name = 'NCHAR' or type_name = 'VARBINARY'
+         THEN CAST(TRIM(type_name) + '(' + TRIM(CAST(column_size AS SQL_CHAR)) + ')' AS SQL_CHAR)
+    WHEN type_name = 'NUMERIC' or type_name = 'DOUBLE' or type_name = 'CURDOUBLE'
+         THEN CAST(TRIM(type_name) + '(' + TRIM(CAST(column_size AS SQL_CHAR)) + ',' + TRIM(CAST(decimal_digits AS SQL_CHAR)) + ')' AS SQL_CHAR)
+    ELSE
+         TRIM(type_name COLLATE ads_default_cs)
+    END  AS "domain"
+from (EXECUTE PROCEDURE sp_GetColumns( NULL, NULL, '#{table_name}', NULL)) as spgc
+WHERE COLUMN_NAME = '#{column_name}'
+SQL
+         rs = select(sql)
+         if !rs.nil? and !rs[0].nil?
+             rs[0]['domain']
+         end
+      end
+
+      # Change a columns defaults.
+      def change_column_default(table_name, column_name, default) #:nodoc:
+        execute "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{get_column_type(table_name, column_name)} DEFAULT #{quote(default)}"
+      end
+
+      # Change a columns nullability
+      def change_column_null(table_name, column_name, null, default = nil) #:nodoc:
+        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)} #{quote_column_name(column_name)} #{get_column_type(table_name, column_name)} CONSTRAINT #{null ? '' : 'NOT'} NULL")
+      end
+
+      # Alter a column
+      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)} #{quote_column_name(column_name)} #{type_to_sql(type, type_options[:limit], type_options[:precision], type_options[:scale])}"
+        add_column_options!(add_column_sql, options)
+        execute(add_column_sql)
+      end
+
+      # Add column options
+      def add_column_options!(sql, options) #:nodoc:
+        sql << " DEFAULT #{quote(options[:default], options[:column])}" if options_include_default?(options)
+        # must explicitly check for :null to allow change_column to work on migrations
+        if options[:null] == false
+          sql << " CONSTRAINT NOT NULL"
+        end
+      end
+
+      # Rename a column
+      def rename_column(table_name, column_name, new_column_name) #:nodoc:
+        execute "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{type_to_sql(type, type_options[:limit], type_options[:precision], type_options[:scale])}"
+      end
+
+      # Drop a column from a table
+      def remove_column(table_name, column_name) #:nodoc:
+        execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}"
+      end
+
+      protected
+
+        # Execute a query
+        def select(sql, name = nil, binds = []) #:nodoc:
+          return execute(sql, name, binds)
+        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 = "SELECT COLUMN_NAME, IIF(COLUMN_DEF = 'NULL', null, COLUMN_DEF) as COLUMN_DEF, TYPE_NAME, NULLABLE from (EXECUTE PROCEDURE sp_GetColumns( NULL, NULL, '#{table_name}', NULL )) spgc;"
+          structure = execute(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
+
+        # Connect
+        def connect! #:nodoc:
+          result = ADS.instance.api.ads_connect(@connection, @connection_string)
+          if result != 1 then
+            error = ADS.instance.api.ads_error(@connection)
+            raise ActiveRecord::ActiveRecordError.new("#{error}: Cannot Establish Connection")
+          end
+        end
+
+        # Execute a query
+        def query(sql, binds = []) #:nodoc:
+          return if sql.nil?
+
+          if binds.empty?
+              rs = ADS.instance.api.ads_execute_direct(@connection, sql)
+          else
+              stmt = ADS.instance.api.ads_prepare(@connection, sql)
+              # bind each of the parameters
+              # col: Parameter array.  Col[0] -> Parameter info, Col[1] -> Parameter value
+              binds.each_with_index { |col, index|
+                result, param = ADS.instance.api.ads_describe_bind_param(stmt, index)
+                if result == 1
+                    # For date/time/timestamp fix up the format to remove the timzone
+                    if (col[0].type === :datetime or col[0].type === :timestamp or col[0] === :time) and !col[1].nil?
+                        param.set_value(col[1].to_s(:db))
+                    else
+                        param.set_value(col[1])
+                    end
+                    ADS.instance.api.ads_bind_param(stmt, index, param)
+                else
+                    result, errstr = ADS.instance.api.ads_error(@connection)
+                    raise AdvantageException.new(errstr, result, sql)
+                end
+              } #binds.each_with_index
+              result = ADS.instance.api.ads_execute(stmt)
+              if result == 1
+                  rs = stmt
+              else
+                  result, errstr = ADS.instance.api.ads_error(@connection)
+                  raise AdvantageException.new(errstr, result, sql)
+              end
+          end
+          if rs.nil?
+            result, errstr = ADS.instance.api.ads_error(@connection)
+            raise AdvantageException.new(errstr, result, sql)
+          end
+
+          record = []
+          if( ADS.instance.api.ads_num_cols(rs) > 0 )
+            while ADS.instance.api.ads_fetch_next(rs) == 1
+              max_cols = ADS.instance.api.ads_num_cols(rs)
+              result = Hash.new()
+              max_cols.times do |cols|
+                result[ADS.instance.api.ads_get_column_info(rs, cols)[2]] = ADS.instance.api.ads_get_column(rs, cols)[1]
+              end
+              record << result
+            end
+            @affected_rows = 0
+          else
+            @affected_rows = ADS.instance.api.ads_affected_rows(rs)
+          end
+          ADS.instance.api.ads_free_stmt(rs)
+
+          return record
+        end
+    end
+  end
+end
+

data/lib/arel/visitors/advantage.rb

@@ -0,0 +1,39 @@
+module Arel
+  module Visitors
+    class Advantage < Arel::Visitors::ToSql
+      private
+
+      def visit_Arel_Nodes_Offset o
+        "START AT #{visit(o.expr) + 1}"
+      end
+
+      def visit_Arel_Nodes_Limit(o)
+        "TOP #{visit o.expr}"
+      end
+
+      def visit_Arel_Nodes_SelectStatement(o)
+          [
+          "SELECT",
+          (visit(o.limit) if o.limit),
+          (visit(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?),
+          ].compact.join ' '
+      end
+
+      def visit_Arel_Nodes_SelectCore o
+        [
+          "#{o.projections.map { |x| visit x }.join ', '}",
+          ("FROM #{visit o.froms}" if o.froms),
+          ("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
+    end
+  end
+end
+
+Arel::Visitors::VISITORS['advantage'] = Arel::Visitors::Advantage
+
+

data/test/connection.rb

@@ -0,0 +1,23 @@
+print "Using native Advantage Interface\n"
+require_dependency 'models/course'
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+ActiveRecord::Base.configurations = {
+  'arunit' => {
+    :adapter  => 'advantage',
+    :database => 'c:/test/arunit.add',
+    :username => 'adssys',
+    :password => 
+  },
+  'arunit2' => {
+    :adapter  => 'advantage',
+    :database => 'c:/test/arunit2.add',
+    :username => 'adssys',
+    :password => 
+  }
+}
+
+ActiveRecord::Base.establish_connection 'arunit'
+Course.establish_connection 'arunit2'

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-advantage-adapter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Edgar Sherman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: advantage
+  requirement: &22592844 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *22592844
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &22592400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *22592400
+description: ! '    ActiveRecord driver for Advantage
+
+'
+email: advantage@sybase.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+- LICENSE
+files:
+- lib/active_record/connection_adapters/advantage_adapter.rb
+- lib/arel/visitors/advantage.rb
+- test/connection.rb
+- README
+- LICENSE
+homepage: http://devzone.advantagedatabase.com
+licenses: []
+post_install_message: 
+rdoc_options:
+- --title
+- ActiveRecord Driver for Advantage
+- --main
+- README
+- --line-numbers
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: ActiveRecord driver for Advantage
+test_files: []