activerecord-jdbc-adapter 1.0.3-java → 50.1-java

data/lib/arjdbc/derby/connection_methods.rb

@@ -1,18 +1,20 @@
-module ActiveRecord
-  class Base
-    class << self
-      def derby_connection(config)
-        config[:url] ||= "jdbc:derby:#{config[:database]};create=true"
-        config[:driver] ||= "org.apache.derby.jdbc.EmbeddedDriver"
-        conn = embedded_driver(config)
-        md = conn.jdbc_connection.meta_data
-        if md.database_major_version < 10 || (md.database_major_version == 10 && md.database_minor_version < 5)
-          raise ::ActiveRecord::ConnectionFailed, "Derby adapter requires Derby 10.5 or later"
-        end
-        conn
-      end
+ArJdbc::ConnectionMethods.module_eval do
+  def derby_connection(config)
+    config[:adapter_spec] ||= ::ArJdbc::Derby
 
-      alias_method :jdbcderby_connection, :derby_connection
+    return jndi_connection(config) if jndi_config?(config)
+
+    begin
+      require 'jdbc/derby'
+      ::Jdbc::Derby.load_driver(:require) if defined?(::Jdbc::Derby.load_driver)
+    rescue LoadError # assuming driver.jar is on the class-path
     end
+
+    config[:url] ||= "jdbc:derby:#{config[:database]};create=true"
+    config[:driver] ||= defined?(::Jdbc::Derby.driver_name) ?
+      ::Jdbc::Derby.driver_name : 'org.apache.derby.jdbc.EmbeddedDriver'
+
+    embedded_driver(config)
   end
+  alias_method :jdbcderby_connection, :derby_connection
 end

data/lib/arjdbc/derby/schema_creation.rb

@@ -0,0 +1,15 @@
+module ArJdbc
+  module Derby
+    # @private
+    class SchemaCreation < ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation
+
+      private
+
+    end
+  end
+
+  def schema_creation
+    SchemaCreation.new self
+  end
+
+end if ::ActiveRecord::ConnectionAdapters::AbstractAdapter.const_defined? :SchemaCreation

data/lib/arjdbc/discover.rb

@@ -1,84 +1,81 @@
-# arjdbc/discover.rb: Declare ArJdbc.extension modules in this file
-# that loads a custom module and adapter.
+# this file is discovered by the extension mechanism 
+# @see {ArJdbc#discover_extensions}
 
-module ::ArJdbc
-  # Adapters built-in to AR are required up-front so we can override
-  # the native ones
-  require 'arjdbc/mysql'
+module ArJdbc
+  
+  require 'arjdbc/jdbc/adapter_require'
+  
+  # Adapters built-in to AR :
+  
+  require 'arjdbc/mysql' if Java::JavaLang::Boolean.getBoolean('arjdbc.mysql.eager_load')
+  require 'arjdbc/postgresql' if Java::JavaLang::Boolean.getBoolean('arjdbc.postgresql.eager_load')
+  require 'arjdbc/sqlite3' if Java::JavaLang::Boolean.getBoolean('arjdbc.sqlite3.eager_load')
+  
   extension :MySQL do |name|
-    name =~ /mysql/i
+    require('arjdbc/mysql') || true if name =~ /mysql/i
   end
-
-  require 'arjdbc/postgresql'
+  
   extension :PostgreSQL do |name|
-    name =~ /postgre/i
+    require('arjdbc/postgresql') || true if name =~ /postgre/i
   end
 
-  require 'arjdbc/sqlite3'
   extension :SQLite3 do |name|
-    name =~ /sqlite/i
-  end
-
-  # Other adapters are lazy-loaded
-  extension :DB2 do |name, config|
-    if name =~ /(db2|as400)/i && config[:url] !~ /^jdbc:derby:net:/
-      require 'arjdbc/db2'
-      true
-    end
+    require('arjdbc/sqlite3') || true if name =~ /sqlite/i
   end
+  
+  # Other supported adapters :
 
-  extension :Derby do |name|
+  extension :Derby do |name, config|
     if name =~ /derby/i
       require 'arjdbc/derby'
-      true
-    end
-  end
 
-  extension :FireBird do |name|
-    if name =~ /firebird/i
-      require 'arjdbc/firebird'
+      if config && config[:username].nil? # set the database schema name (:username) :
+        begin
+          ArJdbc.with_meta_data_from_data_source_if_any(config) do
+            |meta_data| config[:username] = meta_data.getUserName
+          end
+        rescue => e
+          ArJdbc.warn("failed to set :username from (Derby) database meda-data: #{e.inspect}")
+        end
+      end
+
       true
     end
   end
 
   extension :H2 do |name|
-    if name =~ /\.h2\./i
-      require 'arjdbc/h2'
-      true
-    end
+    require('arjdbc/h2') || true if name =~ /\.h2\./i
   end
 
   extension :HSQLDB do |name|
-    if name =~ /hsqldb/i
-      require 'arjdbc/hsqldb'
-      true
-    end
+    require('arjdbc/hsqldb') || true if name =~ /hsqldb/i
   end
 
-  extension :Informix do |name|
-    if name =~ /informix/i
-      require 'arjdbc/informix'
-      true
-    end
+  extension :MSSQL do |name|
+    require('arjdbc/mssql') || true if name =~ /sqlserver|tds|Microsoft SQL/i
   end
 
-  extension :Mimer do |name|
-    if name =~ /mimer/i
-      require 'arjdbc/mimer'
+  extension :DB2 do |name, config|
+    if name =~ /db2/i && name !~ /as\/?400/i && config[:url] !~ /^jdbc:derby:net:/
+      require 'arjdbc/db2'
       true
     end
   end
-
-  extension :MsSQL do |name|
-    if name =~ /sqlserver|tds|Microsoft SQL/i
-      require 'arjdbc/mssql'
+  
+  extension :AS400 do |name, config|
+    # The native JDBC driver always returns "DB2 UDB for AS/400"
+    if name =~ /as\/?400/i
+      require 'arjdbc/db2'
+      require 'arjdbc/db2/as400'
       true
     end
   end
 
-  extension :Oracle do |name|
-    if name =~ /oracle/i
-      require 'arjdbc/oracle'
+  # NOTE: following ones are likely getting deprecated :
+  
+  extension :FireBird do |name|
+    if name =~ /firebird/i
+      require 'arjdbc/firebird'
       true
     end
   end
@@ -89,4 +86,19 @@ module ::ArJdbc
       true
     end
   end
+  
+  extension :Informix do |name|
+    if name =~ /informix/i
+      require 'arjdbc/informix'
+      true
+    end
+  end
+
+  extension :Mimer do |name|
+    if name =~ /mimer/i
+      require 'arjdbc/mimer'
+      true
+    end
+  end
+  
 end

data/lib/arjdbc/firebird.rb

@@ -1,2 +1,4 @@
-require 'arjdbc/jdbc'
+require 'arjdbc'
 require 'arjdbc/firebird/adapter'
+require 'arjdbc/firebird/connection_methods'
+ArJdbc.warn_unsupported_adapter 'firebird', [4, 2] # warns on AR >= 4.2

data/lib/arjdbc/firebird/adapter.rb

@@ -1,76 +1,306 @@
-module ::ArJdbc
-  module FireBird
-
-    def self.extended(mod)
-      unless @lob_callback_added
-        ActiveRecord::Base.class_eval do
-          def after_save_with_firebird_blob
-            self.class.columns.select { |c| c.sql_type =~ /blob/i }.each do |c|
-              value = self[c.name]
-              value = value.to_yaml if unserializable_attribute?(c.name, c)
-              next if value.nil?
-              connection.write_large_object(c.type == :binary, c.name, self.class.table_name, self.class.primary_key, quote_value(id), value)
-            end
-          end
+ArJdbc.load_java_part :Firebird
+
+require 'arel/visitors/firebird'
+
+module ArJdbc
+  module Firebird
+
+    # @private
+    def self.extended(adapter); initialize!; end
+
+    # @private
+    @@_initialized = nil
+
+    # @private
+    def self.initialize!
+      return if @@_initialized; @@_initialized = true
+
+      require 'arjdbc/util/serialized_attributes'
+      Util::SerializedAttributes.setup /blob/i
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::FirebirdJdbcConnection
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
+    def self.column_selector
+      [ /firebird/i, lambda { |cfg, column| column.extend(Column) } ]
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
+    module Column
+
+      def default_value(value)
+        return nil unless value
+        if value =~ /^\s*DEFAULT\s+(.*)\s*$/i
+          return $1 unless $1.upcase == 'NULL'
         end
+      end
+
+      private
 
-        ActiveRecord::Base.after_save :after_save_with_firebird_blob
-        @lob_callback_added = true
+      def simplified_type(field_type)
+        case field_type
+        when /timestamp/i    then :datetime
+        when /^smallint/i    then :integer
+        when /^bigint|int/i  then :integer
+        when /^double/i      then :float # double precision
+        when /^decimal/i     then
+          extract_scale(field_type) == 0 ? :integer : :decimal
+        when /^char\(1\)$/i  then Firebird.emulate_booleans? ? :boolean : :string
+        when /^char/i        then :string
+        when /^blob\ssub_type\s(\d)/i
+          return :binary if $1 == '0'
+          return :text   if $1 == '1'
+        else
+          super
+        end
       end
+
     end
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class
+    def jdbc_column_class; ::ActiveRecord::ConnectionAdapters::FirebirdColumn end
+
+    # @private
+    @@emulate_booleans = true
+
+    # Boolean emulation can be disabled using :
+    #
+    #   ArJdbc::Firebird.emulate_booleans = false
+    #
+    def self.emulate_booleans?; @@emulate_booleans; end
+    # @deprecated Use {#emulate_booleans?} instead.
+    def self.emulate_booleans; @@emulate_booleans; end
+    # @see #emulate_booleans?
+    def self.emulate_booleans=(emulate); @@emulate_booleans = emulate; end
+
+
+    @@update_lob_values = true
+
+    # Updating records with LOB values (binary/text columns) in a separate
+    # statement can be disabled using :
+    #
+    #   ArJdbc::Firebird.update_lob_values = false
+    def self.update_lob_values?; @@update_lob_values; end
+    # @see #update_lob_values?
+    def self.update_lob_values=(update); @@update_lob_values = update; end
+
+    # @see #update_lob_values?
+    def update_lob_values?; Firebird.update_lob_values?; end
+
+    # @see #quote
+    # @private
+    BLOB_VALUE_MARKER = "''"
+
+    ADAPTER_NAME = 'Firebird'.freeze
+
     def adapter_name
-      'Firebird'
+      ADAPTER_NAME
     end
 
-    def modify_types(tp)
-      tp[:primary_key] = 'INTEGER NOT NULL PRIMARY KEY'
-      tp[:string][:limit] = 252
-      tp[:integer][:limit] = nil
-      tp
+    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" },
+      :datetime => { :name => "timestamp" },
+      :timestamp => { :name => "timestamp" },
+      :time => { :name => "time" },
+      :date => { :name => "date" },
+      :binary => { :name => "blob" },
+      :boolean => { :name => 'char', :limit => 1 },
+      :numeric => { :name => "numeric" },
+      :decimal => { :name => "decimal" },
+      :char => { :name => "char" },
+    }
+
+    def native_database_types
+      NATIVE_DATABASE_TYPES
     end
 
-    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) # :nodoc:
-      execute(sql, name)
+    def initialize_type_map(m)
+      register_class_with_limit m, %r(binary)i, ActiveRecord::Type::Binary
+      register_class_with_limit m, %r(text)i,   ActiveRecord::Type::Text
+
+      register_class_with_limit m, %r(date(?:\(.*?\))?$)i, DateType
+      register_class_with_limit m, %r(time(?:\(.*?\))?$)i, ActiveRecord::Type::Time
+
+      register_class_with_limit m, %r(float)i, ActiveRecord::Type::Float
+      register_class_with_limit m, %r(int)i,   ActiveRecord::Type::Integer
+
+      m.alias_type %r(blob)i,   'binary'
+      m.alias_type %r(clob)i,   'text'
+      m.alias_type %r(double)i, 'float'
+
+      m.register_type(%r(decimal)i) do |sql_type|
+        scale = extract_scale(sql_type)
+        precision = extract_precision(sql_type)
+        if scale == 0
+          ActiveRecord::Type::Integer.new(precision: precision)
+        else
+          ActiveRecord::Type::Decimal.new(precision: precision, scale: scale)
+        end
+      end
+      m.alias_type %r(numeric)i, 'decimal'
+
+      register_class_with_limit m, %r(varchar)i, ActiveRecord::Type::String
+
+      m.register_type(%r(^char)i) do |sql_type|
+        precision = extract_precision(sql_type)
+        if Firebird.emulate_booleans? && precision == 1
+          ActiveRecord::Type::Boolean.new
+        else
+          ActiveRecord::Type::String.new(:precision => precision)
+        end
+      end
+
+      register_class_with_limit m, %r(datetime)i, ActiveRecord::Type::DateTime
+      register_class_with_limit m, %r(timestamp)i, TimestampType
+    end if AR42
+
+    def clear_cache!
+      super
+      reload_type_map
+    end if AR42
+
+    # @private
+    class DateType < ActiveRecord::Type::Date
+      # NOTE: quote still gets called ...
+      #def type_cast_for_database(value)
+      #  if value.acts_like?(:date)
+      #    "'#{value.strftime("%Y-%m-%d")}'"
+      #  else
+      #    super
+      #  end
+      #end
+    end if AR42
+
+    # @private
+    class TimestampType < ActiveRecord::Type::DateTime
+      def type; :timestamp end
+    end if AR42
+
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+      case type
+      when :integer
+        case limit
+          when nil  then 'integer'
+          when 1..2 then 'smallint'
+          when 3..4 then 'integer'
+          when 5..8 then 'bigint'
+          else raise(ActiveRecordError, "No integer type has byte size #{limit}. "<<
+                                        "Use a NUMERIC with PRECISION 0 instead.")
+        end
+      when :float
+        if limit.nil? || limit <= 4
+          'float'
+        else
+          'double precision'
+        end
+      else super
+      end
+    end
+
+    # Does this adapter support migrations?
+    def supports_migrations?
+      true
+    end
+
+    # Can this adapter determine the primary key for tables not attached
+    # to an Active Record class, such as join tables?
+    def supports_primary_key?
+      true
+    end
+
+    # Does this adapter support DDL rollbacks in transactions? That is, would
+    # CREATE TABLE or ALTER TABLE get rolled back by a transaction? PostgreSQL,
+    # SQL Server, and others support this. MySQL and others do not.
+    def supports_ddl_transactions?
+      false
+    end
+
+    # Does this adapter restrict the number of IDs you can use in a list.
+    # Oracle has a limit of 1000.
+    def ids_in_list_limit
+      1499
+    end
+
+    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+      execute(sql, name, binds)
       id_value
     end
 
-    def add_limit_offset!(sql, options) # :nodoc:
-      if options[:limit]
-        limit_string = "FIRST #{options[:limit]}"
-        limit_string << " SKIP #{options[:offset]}" if options[:offset]
-        sql.sub!(/\A(\s*SELECT\s)/i, '\&' + limit_string + ' ')
+    def add_limit_offset!(sql, options)
+      if limit = options[:limit]
+        insert_limit_offset!(sql, limit, options[:offset])
       end
     end
 
+    # @private
+    SELECT_RE = /\A(\s*SELECT\s)/i
+
+    def insert_limit_offset!(sql, limit, offset)
+      lim_off = ''
+      lim_off << "FIRST #{limit}"  if limit
+      lim_off << " SKIP #{offset}" if offset
+      lim_off.strip!
+
+      sql.sub!(SELECT_RE, "\\&#{lim_off} ") unless lim_off.empty?
+    end
+
+    # Should primary key values be selected from their corresponding
+    # sequence before the insert statement?
+    # @see #next_sequence_value
+    # @override
     def prefetch_primary_key?(table_name = nil)
-      true
+      return true if table_name.nil?
+      primary_keys(table_name.to_s).size == 1
+      # columns(table_name).count { |column| column.primary } == 1
     end
 
-    def default_sequence_name(table_name, primary_key) # :nodoc:
-      "#{table_name}_seq"
+    IDENTIFIER_LENGTH = 31 # usual DB meta-identifier: 31 chars maximum
+
+    def table_alias_length; IDENTIFIER_LENGTH; end
+    def table_name_length;  IDENTIFIER_LENGTH; end
+    def index_name_length;  IDENTIFIER_LENGTH; end
+    def column_name_length; IDENTIFIER_LENGTH; end
+
+    def default_sequence_name(table_name, column = nil)
+      len = IDENTIFIER_LENGTH - 4
+      table_name.to_s.gsub (/(^|\.)([\w$-]{1,#{len}})([\w$-]*)$/), '\1\2_seq'
+    end
+
+    # Set the sequence to the max value of the table's column.
+    def reset_sequence!(table, column, sequence = nil)
+      max_id = select_value("SELECT max(#{column}) FROM #{table}")
+      execute("ALTER SEQUENCE #{default_sequence_name(table, column)} RESTART WITH #{max_id}")
     end
 
     def next_sequence_value(sequence_name)
       select_one("SELECT GEN_ID(#{sequence_name}, 1 ) FROM RDB$DATABASE;")["gen_id"]
     end
 
-    def create_table(name, options = {}) #:nodoc:
+    def create_table(name, options = {})
       super(name, options)
-      execute "CREATE GENERATOR #{name}_seq"
+      execute "CREATE GENERATOR #{default_sequence_name(name)}"
     end
 
-    def rename_table(name, new_name) #:nodoc:
+    def rename_table(name, new_name)
       execute "RENAME #{name} TO #{new_name}"
-      execute "UPDATE RDB$GENERATORS SET RDB$GENERATOR_NAME='#{new_name}_seq' WHERE RDB$GENERATOR_NAME='#{name}_seq'" rescue nil
+      name_seq, new_name_seq = default_sequence_name(name), default_sequence_name(new_name)
+      execute_quietly "UPDATE RDB$GENERATORS SET RDB$GENERATOR_NAME='#{new_name_seq}' WHERE RDB$GENERATOR_NAME='#{name_seq}'"
     end
 
-    def drop_table(name, options = {}) #:nodoc:
+    def drop_table(name, options = {})
       super(name)
-      execute "DROP GENERATOR #{name}_seq" rescue nil
+      execute_quietly "DROP GENERATOR #{default_sequence_name(name)}"
     end
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+    def change_column(table_name, column_name, type, options = {})
       execute "ALTER TABLE #{table_name} ALTER  #{column_name} TYPE #{type_to_sql(type, options[:limit])}"
     end
 
@@ -78,54 +308,127 @@ module ::ArJdbc
       execute "ALTER TABLE #{table_name} ALTER  #{column_name} TO #{new_column_name}"
     end
 
-    def remove_index(table_name, options) #:nodoc:
+    def remove_index(table_name, options)
       execute "DROP INDEX #{index_name(table_name, options)}"
     end
 
-    def quote(value, column = nil) # :nodoc:
+    # @override
+    def quote(value, column = nil)
       return value.quoted_id if value.respond_to?(:quoted_id)
+      return value if sql_literal?(value)
+
+      type = column && column.type
 
       # BLOBs are updated separately by an after_save trigger.
-      return value.nil? ? "NULL" : "'#{quote_string(value[0..1])}'" if column && [:binary, :text].include?(column.type)
+      if type == :binary || type == :text
+        if update_lob_values?
+          return value.nil? ? "NULL" : BLOB_VALUE_MARKER
+        else
+          return "'#{quote_string(value)}'"
+        end
+      end
 
-      if [Time, DateTime].include?(value.class)
-        "CAST('#{value.strftime("%Y-%m-%d %H:%M:%S")}' AS TIMESTAMP)"
+      case value
+      when String, ActiveSupport::Multibyte::Chars
+        value = value.to_s
+        if type == :integer
+          value.to_i.to_s
+        elsif type == :float
+          value.to_f.to_s
+        else
+          "'#{quote_string(value)}'"
+        end
+      when NilClass then 'NULL'
+      when TrueClass then (type == :integer ? '1' : quoted_true)
+      when FalseClass then (type == :integer ? '0' : quoted_false)
+      when Float, Fixnum, Bignum 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)}'"
       else
-        if column && column.type == :primary_key
-          return value.to_s
+        if type == :time && value.acts_like?(:time)
+          return "'#{get_time(value).strftime("%H:%M:%S")}'"
+        end
+        if type == :date && value.acts_like?(:date)
+          return "'#{value.strftime("%Y-%m-%d")}'"
         end
         super
       end
     end
 
-    def quote_string(string) # :nodoc:
-      string.gsub(/'/, "''")
-    end
+    # @override
+    def quoted_date(value)
+      if value.acts_like?(:time) && value.respond_to?(:usec)
+        usec = sprintf "%04d", (value.usec / 100.0).round
+        value = ::ActiveRecord::Base.default_timezone == :utc ? value.getutc : value.getlocal
+        "#{value.strftime("%Y-%m-%d %H:%M:%S")}.#{usec}"
+      else
+        super
+      end
+    end if ::ActiveRecord::VERSION::MAJOR >= 3
 
-    def quote_column_name(column_name) # :nodoc:
-      %Q("#{ar_to_fb_case(column_name)}")
+    # @override
+    def quote_string(string)
+      string.gsub(/'/, "''")
     end
 
-    def quoted_true # :nodoc:
+    # @override
+    def quoted_true
       quote(1)
     end
 
-    def quoted_false # :nodoc:
+    # @override
+    def quoted_false
       quote(0)
     end
 
-    private
+    # @override
+    def quote_table_name_for_assignment(table, attr)
+      quote_column_name(attr)
+    end if ::ActiveRecord::VERSION::MAJOR >= 4
+
+    # @override
+    def quote_column_name(column_name)
+      column_name = column_name.to_s
+      %Q("#{column_name =~ /[[:upper:]]/ ? column_name : column_name.upcase}")
+    end
+
+  end
+  FireBird = Firebird
+end
+
+require 'arjdbc/util/quoted_cache'
+
+module ActiveRecord::ConnectionAdapters
+
+  remove_const(:FirebirdAdapter) if const_defined?(:FirebirdAdapter)
+
+  class FirebirdAdapter < JdbcAdapter
+    include ::ArJdbc::Firebird
+    include ::ArJdbc::Util::QuotedCache
 
-    # 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.to_s.downcase
+    # By default, the FirebirdAdapter will consider all columns of type
+    # <tt>char(1)</tt> as boolean. If you wish to disable this :
+    #
+    #   ActiveRecord::ConnectionAdapters::FirebirdAdapter.emulate_booleans = false
+    #
+    def self.emulate_booleans?; ::ArJdbc::Firebird.emulate_booleans?; end
+    def self.emulate_booleans;  ::ArJdbc::Firebird.emulate_booleans?; end
+    def self.emulate_booleans=(emulate); ::ArJdbc::Firebird.emulate_booleans = emulate; end
+
+    def initialize(*args)
+      ::ArJdbc::Firebird.initialize!
+      super
     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.to_s.upcase
+    def arel_visitor
+      Arel::Visitors::Firebird.new(self)
     end
+
   end
+
+  class FirebirdColumn < JdbcColumn
+    include ::ArJdbc::Firebird::Column
+  end
+
 end