activerecord-fb-adapter 0.8.9 → 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2678bd6b3b5635e1bdae1638babacb97d42af498
+  data.tar.gz: ee672fe8d0e86cc4ae2e86b633492cc4d7db888e
+SHA512:
+  metadata.gz: fc9b1a2711bfca2a744eb83066f3b79ca96f4ddfd64f302c656cd77ec023fa1484b848d028a2f4c90daa6474fa3058ebc13dcdecb4a70a73d0815e38c7a64e1c
+  data.tar.gz: d720204fe3cca4a0689089c7841f329776e4bd693b9ca536cf70e1042fc04ec4a294b745a615d71b062e52335cbb8d482ae1f3bd651db62c28f9c1edc453cdb4

data/README.md

@@ -0,0 +1,82 @@
+# ActiveRecord Firebird Adapter
+[![Gem Version](https://badge.fury.io/rb/activerecord-fb-adapter.svg)](http://badge.fury.io/rb/activerecord-fb-adapter)
+
+<img src="/project_logo.png" align="left" hspace="10">
+This is the ActiveRecord adapter for working with the [Firebird SQL Server](http://firebirdsql.org/). It currently supports Rails 3.2.x and 4.x. Although this adapter may not yet have feature parity with the 1st tier databases supported by Rails, it has been used in production by different people for several months without issues and may be considered stable. It uses under the hood the [Ruby Firebird Extension Library](https://github.com/rowland/fb).
+
+## What's supported
+
+- Datatypes: string, integer, datetime, boolean, float, decimal, text (blob).
+- Rails migrations and db/schema.rb generation.
+- Linux, OS X, and Windows supported.
+
+## Getting started
+
+1) Install and start the Firebird Server in your machine (varies across operating systems).
+
+2) Create a new Rails project.
+
+```
+rails new firebird_test
+cd firebird_test
+```
+
+3) Edit the project Gemfile and add the **activerecord-fb-adapter** gem:
+
+```ruby
+gem 'activerecord-fb-adapter'
+```
+
+Then run:
+
+```
+bundle update
+```
+
+which will make bundler to get the gem with it's only dependency: the Fb gem which is "native" (has C code) and will be compiled the first time. Be sure you have a Firebird installation with access to the "ibase.h" file for this to succeed.
+
+4) Edit the **database.yml** for configuring your database connection:
+
+```ruby
+development:
+  adapter: fb
+  database: db/development.fdb
+  username: SYSDBA
+  password: masterkey
+  host: localhost
+  encoding: UTF-8
+  create: true
+```
+
+The default Firebird administrator username and password are **SYSDBA** and **masterkey**, you may have to adjust this to your installation.
+
+Currently the adapter does not supports the "rake db:create" task, so in order to create the database you must add the "create: true" option; with this switch the first time the adapter tries to connect to the database it will be created if it doesn't exists.
+
+5) Start the rails server in development mode
+
+```
+bundle exec rails server
+```
+
+Open your browser at http://localhost:3000, this will create the database on the first connection.
+
+On Linux you may get:
+
+```
+Fb::Error (Unsuccessful execution caused by a system error that precludes successful execution of subsequent statements
+I/O error during "open O_CREAT" operation for file "db/development.fdb"
+Error while trying to create file
+Permission denied
+```
+
+This is because, by default, the Firebird Server runs under the "firebird" user and group, which has no write access to the "db" folder of the project. To fix it run:
+
+```
+chmod o+w db
+```
+which will add write permission to "others" group.
+
+6) Now you can start generating scaffolds or models and rails will create the corresponding migrations. Use **bundle exec rake db:migrate** and **bundle exec rake db:rollback** for migrating the database; this will update your **db/schema.rb** file automatically.
+
+## License
+It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.

data/lib/active_record/connection_adapters/fb/database_limits.rb

@@ -0,0 +1,42 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Fb
+      module DatabaseLimits
+        # the maximum length of a table alias
+        def table_alias_length
+          31
+        end
+
+        # the maximum length of a column name
+        def column_name_length
+          31
+        end
+
+        # the maximum length of a table name
+        def table_name_length
+          31
+        end
+
+        # the maximum length of an index name
+        def index_name_length
+          31
+        end
+
+        # the maximum number of indexes per table
+        def indexes_per_table
+          65_535
+        end
+
+        # the maximum number of elements in an IN (x,y,z) clause
+        def in_clause_length
+          1_499
+        end
+
+        # the maximum length of an SQL query
+        def sql_query_length
+          32_767
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/fb/database_statements.rb

@@ -0,0 +1,127 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Fb
+      module DatabaseStatements
+        # Returns an array of arrays containing the field values.
+        # Order is the same as that returned by +columns+.
+        def select_rows(sql, name = nil, binds = [])
+          exec_query(sql, name, binds).to_a.map(&:values)
+        end
+
+        # Executes the SQL statement in the context of this connection.
+        def execute(sql, name = nil, skip_logging = false)
+          translate(sql) do |translated, args|
+            if (name == :skip_logging) || skip_logging
+              @connection.execute(translated, *args)
+            else
+              log(sql, args, name) do
+                @connection.execute(translated, *args)
+              end
+            end
+          end
+        end
+
+        # Executes +sql+ statement in the context of this connection using
+        # +binds+ as the bind substitutes. +name+ is logged along with
+        # the executed +sql+ statement.
+        def exec_query(sql, name = 'SQL', binds = [])
+          translate(sql, binds) do |translated, args|
+            log(expand(translated, args), name) do
+              result, rows = @connection.execute(translated, *args) do |cursor|
+                [cursor.fields, cursor.fetchall]
+              end
+              next result unless result.respond_to?(:map)
+              cols = result.map { |col| col.name }
+              ActiveRecord::Result.new(cols, rows)
+            end
+          end
+        end
+
+        def explain(arel, binds = [])
+          to_sql(arel, binds)
+        end
+
+        # Checks whether there is currently no transaction active. This is done
+        # by querying the database driver, and does not use the transaction
+        # house-keeping information recorded by #increment_open_transactions and
+        # friends.
+        #
+        # Returns true if there is no transaction active, false if there is a
+        # transaction active, and nil if this information is unknown.
+        def outside_transaction?
+          !@connection.transaction_started
+        end
+
+        # Begins the transaction (and turns off auto-committing).
+        def begin_db_transaction
+          @connection.transaction('READ COMMITTED')
+        end
+
+        # Commits the transaction (and turns on auto-committing).
+        def commit_db_transaction
+          @connection.commit
+        end
+
+        # Rolls back the transaction (and turns on auto-committing). Must be
+        # done if the transaction block raises an exception or returns false.
+        def rollback_db_transaction
+          @connection.rollback
+        end
+
+        # Appends +LIMIT+ and +OFFSET+ options to an SQL statement, or some SQL
+        # fragment that has the same semantics as LIMIT and OFFSET.
+        #
+        # +options+ must be a Hash which contains a +:limit+ option
+        # and an +:offset+ option.
+        #
+        # This method *modifies* the +sql+ parameter.
+        #
+        # ===== Examples
+        #  add_limit_offset!('SELECT * FROM suppliers', {:limit => 10, :offset => 50})
+        # generates
+        #  SELECT * FROM suppliers LIMIT 10 OFFSET 50
+        def add_limit_offset!(sql, options) # :nodoc:
+          if limit = options[:limit]
+            if offset = options[:offset]
+              sql << " ROWS #{offset.to_i + 1} TO #{offset.to_i + limit.to_i}"
+            else
+              sql << " ROWS #{limit.to_i}"
+            end
+          end
+          sql
+        end
+
+        def default_sequence_name(table_name, _column = nil)
+          "#{table_name.to_s.tr('-', '_')[0, table_name_length - 4]}_seq"
+        end
+
+        # Set the sequence to the max value of the table's column.
+        def reset_sequence!(table, column, sequence = nil)
+          sequence ||= default_sequence_name(table, column)
+          max_id = select_value("select max(#{column}) from #{table}")
+          execute("alter sequence #{sequence} restart with #{max_id}")
+        end
+
+        # Uses the raw connection to get the next sequence value.
+        def next_sequence_value(sequence_name)
+          @connection.query("SELECT NEXT VALUE FOR #{sequence_name} FROM RDB$DATABASE")[0][0]
+        end
+
+        protected
+
+        # Returns an array of record hashes with the column names as keys and
+        # column values as values. ActiveRecord >= 4 returns an ActiveRecord::Result.
+        def select(sql, name = nil, binds = [])
+          result = exec_query(sql, name, binds)
+          ActiveRecord::VERSION::MAJOR > 3 ? result : result.to_a
+        end
+
+        # Since the ID is prefetched and passed to #insert, this method is useless.
+        # Overriding this method allows us to avoid overriding #insert.
+        def last_inserted_id(_result)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/fb/quoting.rb

@@ -0,0 +1,103 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Fb
+      module Quoting
+        def quote(value, column = nil)
+          # records are quoted as their primary key
+          return value.quoted_id if value.respond_to?(:quoted_id)
+          type = column && column.type
+
+          case value
+          when String, ActiveSupport::Multibyte::Chars
+            value = value.to_s
+            if [:integer, :float].include?(type)
+              value = type == :integer ? value.to_i : value.to_f
+              value.to_s
+            elsif type && type != :binary && value.size < 256 && !value.include?('@')
+              "'#{quote_string(value)}'"
+            else
+              "@#{Base64.encode64(value).chop}@"
+            end
+          when nil                   then "NULL"
+          when true                  then quoted_true
+          when false                 then quoted_false
+          when Numeric, ActiveSupport::Duration then value.to_s
+          # BigDecimals need to be output in a non-normalized form and quoted.
+          when BigDecimal            then value.to_s('F')
+          when Symbol                then "'#{quote_string(value.to_s)}'"
+          when Class                 then "'#{value}'"
+          else
+            if value.acts_like?(:date)
+              quote_date(value)
+            elsif value.acts_like?(:time)
+              quote_timestamp(value)
+            else
+              quote_object(value)
+            end
+          end
+        end
+
+        def quote_date(value)
+          "@#{Base64.encode64(value.strftime('%Y-%m-%d')).chop}@"
+        end
+
+        def quote_timestamp(value)
+          get = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+          value = value.respond_to?(get) ? value.send(get) : value
+          "@#{Base64.encode64(value.strftime('%Y-%m-%d %H:%M:%S')).chop}@"
+        end
+
+        def quote_string(string) # :nodoc:
+          string.gsub(/'/, "''")
+        end
+
+        def quote_object(obj)
+          if obj.respond_to?(:to_str)
+            "@#{Base64.encode64(obj.to_str).chop}@"
+          else
+            "@#{Base64.encode64(obj.to_yaml).chop}@"
+          end
+        end
+
+        def quote_column_name(column_name) # :nodoc:
+          if @connection.dialect == 1
+            %Q(#{ar_to_fb_case(column_name.to_s)})
+          else
+            %Q("#{ar_to_fb_case(column_name.to_s)}")
+          end
+        end
+
+        def quote_table_name_for_assignment(_table, attr)
+          quote_column_name(attr)
+        end if ::ActiveRecord::VERSION::MAJOR >= 4
+
+        def quoted_true # :nodoc:
+          quote(boolean_domain[:true])
+        end
+
+        def quoted_false # :nodoc:
+          quote(boolean_domain[:false])
+        end
+
+        def type_cast(value, column)
+          return super unless value == true || value == false
+          value ? quoted_true : quoted_false
+        end
+
+        private
+
+        # Maps uppercase Firebird column names to lowercase for ActiveRecord;
+        # mixed-case columns retain their original case.
+        def fb_to_ar_case(column_name)
+          column_name =~ /[[:lower:]]/ ? column_name : column_name.downcase
+        end
+
+        # Maps lowercase ActiveRecord column names to uppercase for Fierbird;
+        # mixed-case columns retain their original case.
+        def ar_to_fb_case(column_name)
+          column_name =~ /[[:upper:]]/ ? column_name : column_name.upcase
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/fb/schema_statements.rb

@@ -0,0 +1,247 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Fb
+      module SchemaStatements
+        # Returns a Hash of mappings from the abstract data types to the native
+        # database types.  See TableDefinition#column for details on the recognized
+        # abstract data types.
+        def native_database_types
+          {
+            :primary_key => 'integer not null primary key',
+            :string      => { :name => 'varchar', :limit => 255 },
+            :text        => { :name => 'blob sub_type text' },
+            :integer     => { :name => 'integer' },
+            :float       => { :name => 'float' },
+            :decimal     => { :name => 'decimal' },
+            :datetime    => { :name => 'timestamp' },
+            :timestamp   => { :name => 'timestamp' },
+            :time        => { :name => 'time' },
+            :date        => { :name => 'date' },
+            :binary      => { :name => 'blob' },
+            :boolean     => { :name => boolean_domain[:name] }
+          }
+        end
+
+        def tables(_name = nil)
+          @connection.table_names
+        end
+
+        # Returns an array of indexes for the given table.
+        def indexes(table_name, _name = nil)
+          @connection.indexes.values.map { |ix|
+            if ix.table_name == table_name && ix.index_name !~ /^rdb\$/
+              IndexDefinition.new(table_name, ix.index_name, ix.unique, ix.columns)
+            end
+          }.compact
+        end
+
+        def primary_key(table_name) #:nodoc:
+          sql = <<-END_SQL
+            SELECT s.rdb$field_name
+            FROM rdb$indices i
+            JOIN rdb$index_segments s ON i.rdb$index_name = s.rdb$index_name
+            LEFT JOIN rdb$relation_constraints c ON i.rdb$index_name = c.rdb$index_name
+            WHERE i.rdb$relation_name = '#{ar_to_fb_case(table_name)}' and c.rdb$constraint_type = 'PRIMARY KEY';
+          END_SQL
+          row = select_one(sql)
+          row && fb_to_ar_case(row.values.first.rstrip)
+        end
+
+        # Returns an array of Column objects for the table specified by +table_name+.
+        # See the concrete implementation for details on the expected parameter values.
+        def columns(table_name, name = nil)
+          sql = <<-END_SQL
+            SELECT r.rdb$field_name, r.rdb$field_source, f.rdb$field_type, f.rdb$field_sub_type,
+                   f.rdb$field_length, f.rdb$field_precision, f.rdb$field_scale,
+                   COALESCE(r.rdb$default_source, f.rdb$default_source) rdb$default_source,
+                   COALESCE(r.rdb$null_flag, f.rdb$null_flag) rdb$null_flag
+            FROM rdb$relation_fields r
+            JOIN rdb$fields f ON r.rdb$field_source = f.rdb$field_name
+            WHERE r.rdb$relation_name = '#{ar_to_fb_case(table_name)}'
+            ORDER BY r.rdb$field_position
+          END_SQL
+          select_rows(sql, name).map do |field|
+            FbColumn.new(*field.map { |value|
+              value.is_a?(String) ? value.rstrip : value
+            })
+          end
+        end
+
+        def create_table(name, options = {}) # :nodoc:
+          needs_sequence = options[:id] != false
+          while_ensuring_boolean_domain do
+            super(name, options) do |table_def|
+              yield table_def if block_given?
+              needs_sequence ||= table_def.needs_sequence
+            end
+          end
+          return if options[:sequence] == false || !needs_sequence
+          create_sequence(options[:sequence] || default_sequence_name(name))
+        end
+
+        # Unfortunately, this is a limitation of Firebird.
+        def rename_table(name, new_name)
+          fail 'Firebird does not support renaming tables.'
+        end
+
+        def drop_table(name, options = {}) # :nodoc:
+          super(name)
+          return if options[:sequence] == false
+          sequence_name = options[:sequence] || default_sequence_name(name)
+          drop_sequence(sequence_name) if sequence_exists?(sequence_name)
+        end
+
+        # Creates a sequence
+        # ===== Examples
+        #  create_sequence('DOGS_SEQ')
+        def create_sequence(sequence_name)
+          execute("CREATE SEQUENCE #{sequence_name}") rescue nil
+        end
+
+        # Drops a sequence
+        # ===== Examples
+        #  drop_sequence('DOGS_SEQ')
+        def drop_sequence(sequence_name)
+          execute("DROP SEQUENCE #{sequence_name}") rescue nil
+        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 #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+          add_column_options!(add_column_sql, options)
+          while_ensuring_boolean_domain { execute(add_column_sql) }
+          if type == :primary_key && options[:sequence] != false
+            create_sequence(options[:sequence] || default_sequence_name(table_name))
+          end
+          return unless options[:position]
+          # position is 1-based but add 1 to skip id column
+          alter_position_sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} POSITION #{options[:position] + 1}"
+          execute(alter_position_sql)
+        end
+
+        # Changes the column's definition according to the new options.
+        # See TableDefinition#column for details of the options you can use.
+        # ===== Examples
+        #  change_column(:suppliers, :name, :string, :limit => 80)
+        #  change_column(:accounts, :description, :text)
+        def change_column(table_name, column_name, type, options = {})
+          sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} TYPE #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+          execute(sql)
+          change_column_null(table_name, column_name, !!options[:null]) if options.key?(:null)
+          change_column_default(table_name, column_name, options[:default]) if options[:default]
+        end
+
+        # Sets a new default value for a column. If you want to set the default
+        # value to +NULL+, you are out of luck.  You need to
+        # DatabaseStatements#execute the appropriate SQL statement yourself.
+        # ===== Examples
+        #  change_column_default(:suppliers, :qualification, 'new')
+        #  change_column_default(:accounts, :authorized, 1)
+        def change_column_default(table_name, column_name, default)
+          execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} SET DEFAULT #{quote(default)}")
+        end
+
+        def change_column_null(table_name, column_name, null, default = nil)
+          fail 'Firebird cannot change the nullability of a column using ALTER COLUMN.'
+        end
+
+        # Renames a column.
+        # ===== Example
+        #  rename_column(:suppliers, :description, :name)
+        def rename_column(table_name, column_name, new_column_name)
+          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
+          rename_column_indexes(table_name, column_name, new_column_name)
+        end
+
+        def remove_index!(_table_name, index_name) #:nodoc:
+          execute("DROP INDEX #{quote_column_name(index_name)}")
+        end
+
+        def index_name(table_name, options) #:nodoc:
+          if options.respond_to?(:keys) # legacy support
+            if options[:column]
+              "#{table_name}_#{Array.wrap(options[:column]) * '_'}"
+            elsif options[:name]
+              options[:name]
+            else
+              fail ArgumentError, "You must specify the index name"
+            end
+          else
+            index_name(table_name, :column => options)
+          end
+        end
+
+        def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+          case type
+          when :integer then integer_to_sql(limit)
+          when :float then float_to_sql(limit)
+          else super
+          end
+        end
+
+        # Deprecated in Rails 4.1. Backports functionality.
+        def add_column_options!(sql, options)
+          if options_include_default?(options)
+            sql << " DEFAULT #{quote(options[:default], options[:column])}"
+          end
+          # must explicitly check for :null to allow change_column to work on migrations
+          sql << ' NOT NULL' if options[:null] == false
+        end if ActiveRecord::VERSION::MAJOR > 3
+
+        private
+
+        if ActiveRecord::VERSION::MAJOR > 3
+          def create_table_definition(*args)
+            TableDefinition.new(native_database_types, *args)
+          end
+        else
+          def table_definition
+            TableDefinition.new(self)
+          end
+        end
+
+        # Map logical Rails types to Firebird-specific data types.
+        def integer_to_sql(limit)
+          return 'integer' if limit.nil?
+          case limit
+          when 1..2 then 'smallint'
+          when 3..4 then 'integer'
+          when 5..8 then 'bigint'
+          else
+            fail ActiveRecordError, "No integer type has byte size #{limit}. Use a NUMERIC with PRECISION 0 instead."
+          end
+        end
+
+        def float_to_sql(limit)
+          if limit.nil? || limit <= 4
+            'float'
+          else
+            'double precision'
+          end
+        end
+
+        # Creates a domain for boolean fields as needed
+        def while_ensuring_boolean_domain(&block)
+          block.call
+        rescue ActiveRecord::StatementInvalid => e
+          raise unless e.message =~ /Specified domain or source column \w+ does not exist/
+          create_boolean_domain
+          block.call
+        end
+
+        def create_boolean_domain
+          sql = <<-end_sql
+            CREATE DOMAIN #{boolean_domain[:name]} AS #{boolean_domain[:type]}
+            CHECK (VALUE IN (#{quoted_true}, #{quoted_false}) OR VALUE IS NULL)
+          end_sql
+          execute(sql)
+        end
+
+        def sequence_exists?(sequence_name)
+          @connection.generator_names.include?(sequence_name)
+        end
+      end
+    end
+  end
+end