activerecord 1.3.0 → 1.4.0

data/lib/active_record/fixtures.rb

@@ -364,4 +364,4 @@ module Test#:nodoc:
         end
     end
   end
-end
+end

data/lib/active_record/locking.rb

@@ -0,0 +1,57 @@
+module ActiveRecord
+  module Locking
+    # Active Records support optimistic locking if the field <tt>lock_version</tt> is present.  Each update to the
+    # record increments the lock_version column and the locking facilities ensure that records instantiated twice
+    # will let the last one saved raise a StaleObjectError if the first was also updated. Example:
+    #
+    #   p1 = Person.find(1)
+    #   p2 = Person.find(1)
+    #   
+    #   p1.first_name = "Michael"
+    #   p1.save
+    #   
+    #   p2.first_name = "should fail"
+    #   p2.save # Raises a ActiveRecord::StaleObjectError
+    #
+    # You're then responsible for dealing with the conflict by rescuing the exception and either rolling back, merging,
+    # or otherwise apply the business logic needed to resolve the conflict.
+    #
+    # You must ensure that your database schema defaults the lock_version column to 0.
+    #
+    # This behavior can be turned off by setting <tt>ActiveRecord::Base.lock_optimistically = false</tt>.
+    def self.append_features(base)
+      super
+      base.class_eval do
+        alias_method :update_without_lock, :update
+        alias_method :update, :update_with_lock
+      end
+    end
+
+    def update_with_lock
+      if locking_enabled?
+        previous_value    = self.lock_version
+        self.lock_version = previous_value + 1
+        
+        affected_rows = connection.update(
+          "UPDATE #{self.class.table_name} "+
+          "SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))} " +
+          "WHERE #{self.class.primary_key} = #{quote(id)} AND lock_version = #{quote(previous_value)}",
+          "#{self.class.name} Update with optimistic locking"
+        )
+        
+        raise(ActiveRecord::StaleObjectError, "Attempted to update a stale object") unless affected_rows == 1
+      else
+        update_without_lock
+      end
+    end
+  end
+
+  class Base
+    @@lock_optimistically = true
+    cattr_accessor :lock_optimistically
+
+    def locking_enabled?
+      lock_optimistically && respond_to?(:lock_version)
+    end
+  end
+end

data/lib/active_record/support/class_attribute_accessors.rb

@@ -1,5 +1,6 @@
-# attr_* style accessors for class-variables that can accessed both on an instance and class level.
-class Class #:nodoc:
+# Extends the class object with class and instance accessors for class attributes, 
+# just like the native attr* accessors for instance attributes.
+class Class # :nodoc:
   def cattr_reader(*syms)
     syms.each do |sym|
       class_eval <<-EOS
@@ -12,7 +13,16 @@ class Class #:nodoc:
         end
 
         def #{sym.id2name}
-          self.class.#{sym.id2name}
+          @@#{sym}
+        end
+
+        def call_#{sym.id2name}
+          case @@#{sym.id2name}
+            when Symbol then send(@@#{sym})
+            when Proc   then @@#{sym}.call(self)
+            when String then @@#{sym}
+            else nil
+          end
         end
       EOS
     end
@@ -29,8 +39,12 @@ class Class #:nodoc:
           @@#{sym.id2name} = obj
         end
 
+        def self.set_#{sym.id2name}(obj)
+          @@#{sym.id2name} = obj
+        end
+
         def #{sym.id2name}=(obj)
-          self.class.#{sym.id2name}=(obj)
+          @@#{sym} = obj
         end
       EOS
     end
@@ -39,5 +53,5 @@ class Class #:nodoc:
   def cattr_accessor(*syms)
     cattr_reader(*syms)
     cattr_writer(*syms)
-  end  
+  end
 end

data/lib/active_record/support/class_inheritable_attributes.rb

@@ -1,4 +1,4 @@
-# Allows attributes to be shared within an inheritance hierarchy, but where each descentent gets a copy of
+# Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
 # their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
 # to, for example, an array without those additions being shared with either their parent, siblings, or
 # children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
@@ -31,10 +31,11 @@ module ClassInheritableAttributes # :nodoc:
     def reset_inheritable_attributes
       inheritable_attributes.clear
     end
-    
+
     private 
       def inherited(child)
         @@classes[child] = inheritable_attributes.dup
-      end 
+      end
+   
   end
 end

data/lib/active_record/support/dependencies.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/module_attribute_accessors'
+
+module Dependencies
+  extend self
+  
+  @@loaded = [ ]
+  mattr_accessor :loaded
+
+  @@mechanism = :load
+  mattr_accessor :mechanism
+  
+  def depend_on(file_name, swallow_load_errors = false)
+    if !loaded.include?(file_name)
+      loaded << file_name
+
+      begin
+        require_or_load(file_name)
+      rescue LoadError
+        raise unless swallow_load_errors
+      end
+    end
+  end
+
+  def associate_with(file_name)
+    depend_on(file_name, true)
+  end
+
+  def reload
+    old_loaded = loaded
+    clear
+    
+    old_loaded.each do |file_name| 
+      begin
+        silence_warnings { load("#{file_name}.rb") }
+      rescue LoadError
+        # The association didn't reside in its own file, so we assume it was required by other means
+      end
+    end
+  end
+  
+  def clear
+    self.loaded = [ ]
+  end
+  
+  private
+    def require_or_load(file_name)
+      mechanism == :load ? silence_warnings { load("#{file_name}.rb") } : require(file_name)
+    end
+end
+
+Object.send(:define_method, :require_dependency)  { |file_name| Dependencies.depend_on(file_name) } unless Object.respond_to?(:require_dependency)
+Object.send(:define_method, :require_association) { |file_name| Dependencies.associate_with(file_name) } unless Object.respond_to?(:require_association)
+
+class Object
+  class << self
+    # Use const_missing to autoload associations so we don't have to
+    # require_association when using single-table inheritance.
+    unless respond_to?(:pre_dependency_const_missing)
+      alias_method :pre_dependency_const_missing, :const_missing
+
+      def const_missing(class_id)
+        begin
+          require_dependency(Inflector.underscore(Inflector.demodulize(class_id.to_s)))
+          return Object.const_get(class_id) if Object.const_defined?(class_id)
+        rescue LoadError
+          pre_dependency_const_missing(class_id)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/support/inflector.rb

@@ -48,6 +48,7 @@ module Inflector
     def plural_rules #:doc:
       [
         [/(x|ch|ss)$/, '\1es'],               # search, switch, fix, box, process, address
+        [/([^aeiouy]|qu)ies$/, '\1y'],
         [/([^aeiouy]|qu)y$/, '\1ies'],        # query, ability, agency
         [/(?:([^f])fe|([lr])f)$/, '\1\2ves'], # half, safe, wife
         [/sis$/, 'ses'],                      # basis, diagnosis

data/lib/active_record/support/misc.rb

@@ -1,6 +1,32 @@
 def silence_warnings
   old_verbose, $VERBOSE = $VERBOSE, nil
-  result = yield
-  $VERBOSE = old_verbose
-  return result
+  begin
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+end
+
+class Hash
+  # Return a new hash with all keys converted to symbols.
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[key.to_sym] = value
+      options
+    end
+  end
+
+  # Destructively convert all keys to symbols.
+  def symbolize_keys!
+    keys.each do |key|
+      unless key.is_a?(Symbol)
+        self[key.to_sym] = self[key]
+        delete(key)
+      end
+    end
+    self
+  end
+
+  alias_method :to_options,  :symbolize_keys
+  alias_method :to_options!, :symbolize_keys!
 end

data/lib/active_record/support/module_attribute_accessors.rb

@@ -0,0 +1,57 @@
+# Extends the module object with module and instance accessors for class attributes, 
+# just like the native attr* accessors for instance attributes.
+class Module # :nodoc:
+  def mattr_reader(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        if ! defined? @@#{sym.id2name}
+          @@#{sym.id2name} = nil
+        end
+        
+        def self.#{sym.id2name}
+          @@#{sym}
+        end
+
+        def #{sym.id2name}
+          @@#{sym}
+        end
+
+        def call_#{sym.id2name}
+          case @@#{sym.id2name}
+            when Symbol then send(@@#{sym})
+            when Proc   then @@#{sym}.call(self)
+            when String then @@#{sym}
+            else nil
+          end
+        end
+      EOS
+    end
+  end
+  
+  def mattr_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        if ! defined? @@#{sym.id2name}
+          @@#{sym.id2name} = nil
+        end
+        
+        def self.#{sym.id2name}=(obj)
+          @@#{sym.id2name} = obj
+        end
+
+        def self.set_#{sym.id2name}(obj)
+          @@#{sym.id2name} = obj
+        end
+
+        def #{sym.id2name}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+  
+  def mattr_accessor(*syms)
+    mattr_reader(*syms)
+    mattr_writer(*syms)
+  end
+end

data/lib/active_record/transactions.rb

@@ -1,4 +1,5 @@
 require 'active_record/vendor/simple.rb'
+Transaction::Simple.send(:remove_method, :transaction)
 require 'thread'
 
 module ActiveRecord
@@ -75,14 +76,10 @@ module ActiveRecord
     # should be ready to catch those in your application code.
     #
     # Tribute: Object-level transactions are implemented by Transaction::Simple by Austin Ziegler.
-    module ClassMethods      
+    module ClassMethods
       def transaction(*objects, &block)
-        TRANSACTION_MUTEX.synchronize do
-          Thread.current['open_transactions'] ||= 0
-          Thread.current['start_db_transaction'] = (Thread.current['open_transactions'] == 0)
-          Thread.current['open_transactions'] += 1
-        end
-
+        lock_mutex
+        
         begin
           objects.each { |o| o.extend(Transaction::Simple) }
           objects.each { |o| o.start_transaction }
@@ -95,11 +92,21 @@ module ActiveRecord
           objects.each { |o| o.abort_transaction }
           raise
         ensure
-          TRANSACTION_MUTEX.synchronize do
-            Thread.current['open_transactions'] -= 1
-          end
+          unlock_mutex
         end
       end
+      
+      def lock_mutex
+        Thread.current['open_transactions'] ||= 0
+        TRANSACTION_MUTEX.lock if Thread.current['open_transactions'] == 0
+        Thread.current['start_db_transaction'] = (Thread.current['open_transactions'] == 0)
+        Thread.current['open_transactions'] += 1
+      end
+      
+      def unlock_mutex
+        Thread.current['open_transactions'] -= 1
+        TRANSACTION_MUTEX.unlock if Thread.current['open_transactions'] == 0
+      end
     end
 
     def transaction(*objects, &block)
@@ -114,4 +121,4 @@ module ActiveRecord
       transaction { save_without_transactions(perform_validation) }
     end
   end
-end
+end

data/lib/active_record/validations.rb

@@ -213,9 +213,9 @@ module ActiveRecord
 
         for attr_name in attr_names
           if scope = configuration[:scope]
-            class_eval(%(validate %{errors.add('#{attr_name}', '#{configuration[:message]}') if self.class.find_first(new_record? ? ['#{attr_name} = ? AND #{scope} = ?', #{attr_name}, #{scope}] : ["#{attr_name} = ? AND id <> ? AND #{scope} = ?", #{attr_name}, id, #{scope}])}))
+            class_eval(%(validate %{errors.add('#{attr_name}', '#{configuration[:message]}') if self.class.find_first(new_record? ? ['#{attr_name} = ? AND #{scope} = ?', #{attr_name}, #{scope}] : ["#{attr_name} = ? AND \\\#{self.class.primary_key} <> ? AND #{scope} = ?", #{attr_name}, id, #{scope}])}))
           else
-            class_eval(%(validate %{errors.add('#{attr_name}', '#{configuration[:message]}') if self.class.find_first(new_record? ? ['#{attr_name} = ?', #{attr_name}] : ["#{attr_name} = ? AND id <> ?", #{attr_name}, id])}))
+            class_eval(%(validate %{errors.add('#{attr_name}', '#{configuration[:message]}') if self.class.find_first(new_record? ? ['#{attr_name} = ?', #{attr_name}] : ["#{attr_name} = ? AND \\\#{self.class.primary_key} <> ?", #{attr_name}, id])}))
           end
         end
       end
@@ -240,7 +240,7 @@ module ActiveRecord
         raise(ArgumentError, "A regular expression must be supplied as the :with option of the configuration hash") unless configuration[:with].is_a?(Regexp)
 
         for attr_name in attr_names 
-          class_eval(%(#{validation_method(configuration[:on])} %{errors.add("#{attr_name}", "#{configuration[:message]}") unless #{attr_name} and #{attr_name}.to_s.match(/#{configuration[:with]}/)}))
+          class_eval(%(#{validation_method(configuration[:on])} %{errors.add("#{attr_name}", "#{configuration[:message]}") unless #{attr_name} and #{attr_name}.to_s.match(/#{Regexp.quote(configuration[:with].source)}/)}))
         end
       end
 

data/lib/active_record/vendor/db2.rb

@@ -0,0 +1,357 @@
+require 'db2/db2cli.rb'
+
+module DB2
+  module DB2Util
+    include DB2CLI
+
+    def free() SQLFreeHandle(@handle_type, @handle); end
+    def handle() @handle; end
+
+    def check_rc(rc)
+      if ![SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_NO_DATA_FOUND].include?(rc)
+        rec = 1
+        msg = ''
+        loop do
+          a = SQLGetDiagRec(@handle_type, @handle, rec, 500)
+          break if a[0] != SQL_SUCCESS
+          msg << a[3] if !a[3].nil? and a[3] != '' # Create message.
+          rec += 1
+        end
+        raise "DB2 error: #{msg}"
+      end
+    end
+  end
+
+  class Environment
+    include DB2Util
+
+    def initialize
+      @handle_type = SQL_HANDLE_ENV
+      rc, @handle = SQLAllocHandle(@handle_type, SQL_NULL_HANDLE)
+      check_rc(rc)
+    end
+
+    def data_sources(buffer_length = 1024)
+      retval = []
+      max_buffer_length = buffer_length
+
+      a = SQLDataSources(@handle, SQL_FETCH_FIRST, SQL_MAX_DSN_LENGTH + 1, buffer_length)
+      retval << [a[1], a[3]]
+      max_buffer_length = [max_buffer_length, a[4]].max
+
+      loop do
+        a = SQLDataSources(@handle, SQL_FETCH_NEXT, SQL_MAX_DSN_LENGTH + 1, buffer_length)
+        break if a[0] == SQL_NO_DATA_FOUND
+
+        retval << [a[1], a[3]]
+        max_buffer_length = [max_buffer_length, a[4]].max
+      end
+
+      if max_buffer_length > buffer_length
+        get_data_sources(max_buffer_length)
+      else
+        retval
+      end
+    end
+  end
+
+  class Connection
+    include DB2Util
+
+    def initialize(environment)
+      @env = environment
+      @handle_type = SQL_HANDLE_DBC
+      rc, @handle = SQLAllocHandle(@handle_type, @env.handle)
+      check_rc(rc)
+    end
+
+    def connect(server_name, user_name = '', auth = '')
+      check_rc(SQLConnect(@handle, server_name, user_name, auth))
+    end
+
+    def set_connect_attr(attr, value)
+      value += "\0" if value.class == String
+      check_rc(SQLSetConnectAttr(@handle, attr, value))
+    end
+
+    def set_auto_commit_on
+      set_connect_attr(SQL_ATTR_AUTOCOMMIT, SQL_AUTOCOMMIT_ON)
+    end
+
+    def set_auto_commit_off
+      set_connect_attr(SQL_ATTR_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF)
+    end
+
+    def disconnect
+      check_rc(SQLDisconnect(@handle))
+    end
+
+    def rollback
+      check_rc(SQLEndTran(@handle_type, @handle, SQL_ROLLBACK))
+    end
+
+    def commit
+      check_rc(SQLEndTran(@handle_type, @handle, SQL_COMMIT))
+    end
+  end
+
+  class Statement
+    include DB2Util
+
+    def initialize(connection)
+      @conn = connection
+      @handle_type = SQL_HANDLE_STMT
+      @parms = []                           #yun
+      @sql = ''                             #yun
+      @numParms = 0                         #yun
+      @prepared = false                     #yun
+      @parmArray = []                       #yun. attributes of the parameter markers
+      rc, @handle = SQLAllocHandle(@handle_type, @conn.handle)
+      check_rc(rc)
+    end
+
+    def columns(table_name)
+      check_rc(SQLColumns(@handle, "", "%", table_name, "%"))
+      fetch_all
+    end
+
+    def tables
+      check_rc(SQLTables(@handle, "", "%", "%", "TABLE"))
+      fetch_all
+    end
+
+    def prepare(sql)
+      @sql = sql
+      check_rc(SQLPrepare(@handle, sql))
+      rc, @numParms = SQLNumParams(@handle) #number of question marks
+      check_rc(rc)
+      #--------------------------------------------------------------------------
+      # parameter attributes are stored in instance variable @parmArray so that
+      # they are available when execute method is called.
+      #--------------------------------------------------------------------------
+      if @numParms > 0           # get parameter marker attributes
+        1.upto(@numParms) do |i| # parameter number starts from 1
+          rc, type, size, decimalDigits = SQLDescribeParam(@handle, i)
+          check_rc(rc)
+          @parmArray << Parameter.new(type, size, decimalDigits)
+        end
+      end
+      @prepared = true
+      self
+    end
+
+    def execute(*parms)
+      raise "The statement was not prepared" if @prepared == false
+
+      if parms.size == 1 and parms[0].class == Array
+        parms = parms[0]
+      end
+
+      if @numParms != parms.size
+        raise "Number of parameters supplied does not match with the SQL statement"
+      end
+
+      if @numParms > 0            #need to bind parameters
+        #--------------------------------------------------------------------
+        #calling bindParms may not be safe. Look comment below.
+        #--------------------------------------------------------------------
+        #bindParms(parms)
+
+        valueArray = []
+        1.upto(@numParms) do |i|  # parameter number starts from 1
+          type = @parmArray[i - 1].class
+          size = @parmArray[i - 1].size
+          decimalDigits = @parmArray[i - 1].decimalDigits
+
+          if parms[i - 1].class == String
+            valueArray << parms[i - 1]
+          else
+            valueArray << parms[i - 1].to_s
+          end
+
+          rc = SQLBindParameter(@handle, i, type, size, decimalDigits, valueArray[i - 1])
+          check_rc(rc)
+        end
+      end
+
+      check_rc(SQLExecute(@handle))
+
+      if @numParms != 0
+        check_rc(SQLFreeStmt(@handle, SQL_RESET_PARAMS)) # Reset parameters
+      end
+
+      self
+    end
+
+    #-------------------------------------------------------------------------------
+    # The last argument(value) to SQLBindParameter is a deferred argument, that is,
+    # it should be available when SQLExecute is called. Even though "value" is
+    # local to bindParms method, it seems that it is available when SQLExecute
+    # is called. I am not sure whether it would still work if garbage collection
+    # is done between bindParms call and SQLExecute call inside the execute method
+    # above.
+    #-------------------------------------------------------------------------------
+    def bindParms(parms)        # This is the real thing. It uses SQLBindParms
+      1.upto(@numParms) do |i|  # parameter number starts from 1
+        rc, dataType, parmSize, decimalDigits = SQLDescribeParam(@handle, i)
+        check_rc(rc)
+        if parms[i - 1].class == String
+          value = parms[i - 1]
+        else
+          value = parms[i - 1].to_s
+        end
+        rc = SQLBindParameter(@handle, i, dataType, parmSize, decimalDigits, value)
+        check_rc(rc)
+      end
+    end
+ 
+    #------------------------------------------------------------------------------
+    # bind method does not use DB2's SQLBindParams, but replaces "?" in the
+    # SQL statement with the value before passing the SQL statement to DB2.
+    # It is not efficient and can handle only strings since it puts everything in
+    # quotes.
+    #------------------------------------------------------------------------------
+    def bind(sql, args)                #does not use SQLBindParams
+      arg_index = 0
+      result = ""
+      tokens(sql).each do |part|
+        case part
+        when '?'
+          result << "'" + (args[arg_index]) + "'"  #put it into quotes
+          arg_index += 1
+        when '??'
+          result << "?"
+        else
+          result << part
+        end
+      end
+      if arg_index < args.size
+        raise "Too many SQL parameters"
+      elsif arg_index > args.size
+        raise "Not enough SQL parameters"
+      end
+      result
+    end
+
+    ## Break the sql string into parts.
+    #
+    # This is NOT a full lexer for SQL.  It just breaks up the SQL
+    # string enough so that question marks, double question marks and
+    # quoted strings are separated.  This is used when binding
+    # arguments to "?" in the SQL string.  Note: comments are not
+    # handled.
+    #
+    def tokens(sql)
+      toks = sql.scan(/('([^'\\]|''|\\.)*'|"([^"\\]|""|\\.)*"|\?\??|[^'"?]+)/)
+      toks.collect { |t| t[0] }
+    end
+
+    def exec_direct(sql)
+      check_rc(SQLExecDirect(@handle, sql))
+      self
+    end
+
+    def set_cursor_name(name)
+      check_rc(SQLSetCursorName(@handle, name))
+      self
+    end
+
+    def get_cursor_name
+      rc, name = SQLGetCursorName(@handle)
+      check_rc(rc)
+      name
+    end
+
+    def row_count
+      rc, rowcount = SQLRowCount(@handle)
+      check_rc(rc)
+      rowcount
+    end
+
+    def num_result_cols
+      rc, cols = SQLNumResultCols(@handle)
+      check_rc(rc)
+      cols
+    end
+
+    def fetch_all
+      if block_given?
+        while row = fetch do
+          yield row
+        end
+      else
+        res = []
+        while row = fetch do
+          res << row
+        end
+        res
+      end
+    end
+
+    def fetch
+      cols = get_col_desc
+      rc = SQLFetch(@handle)
+      if rc == SQL_NO_DATA_FOUND
+        SQLFreeStmt(@handle, SQL_CLOSE)        # Close cursor
+        SQLFreeStmt(@handle, SQL_RESET_PARAMS) # Reset parameters
+        return nil
+      end
+      raise "ERROR" unless rc == SQL_SUCCESS
+
+      retval = []
+      cols.each_with_index do |c, i|
+        rc, content = SQLGetData(@handle, i + 1, c[1], c[2] + 1) #yun added 1 to c[2]
+        retval << adjust_content(content)
+      end
+      retval
+    end
+
+    def fetch_as_hash
+      cols = get_col_desc
+      rc = SQLFetch(@handle)
+      if rc == SQL_NO_DATA_FOUND
+        SQLFreeStmt(@handle, SQL_CLOSE)        # Close cursor
+        SQLFreeStmt(@handle, SQL_RESET_PARAMS) # Reset parameters
+        return nil
+      end
+      raise "ERROR" unless rc == SQL_SUCCESS
+
+      retval = {}
+      cols.each_with_index do |c, i|
+        rc, content = SQLGetData(@handle, i + 1, c[1], c[2] + 1)   #yun added 1 to c[2]
+        retval[c[0]] = adjust_content(content)
+      end
+      retval
+    end
+
+    def get_col_desc
+      rc, nr_cols = SQLNumResultCols(@handle)
+      cols = (1..nr_cols).collect do |c|
+        rc, name, bl, type, col_sz = SQLDescribeCol(@handle, c, 1024)
+        [name.downcase, type, col_sz]
+      end
+    end
+
+    def adjust_content(c)
+      case c.class.to_s
+      when 'DB2CLI::NullClass'
+        return nil
+      when 'DB2CLI::Time'
+        "%02d:%02d:%02d" % [c.hour, c.minute, c.second]
+      when 'DB2CLI::Date'
+        "%04d-%02d-%02d" % [c.year, c.month, c.day]
+      when 'DB2CLI::Timestamp'
+        "%04d-%02d-%02d %02d:%02d:%02d" % [c.year, c.month, c.day, c.hour, c.minute, c.second]
+      else
+        return c
+      end
+    end
+  end
+
+  class Parameter
+    attr_reader :type, :size, :decimalDigits
+    def initialize(type, size, decimalDigits)
+      @type, @size, @decimalDigits = type, size, decimalDigits
+    end
+  end
+end