ibruby 0.5.1-i586-linux → 0.5.2-i586-linux

data/lib/ibmeta.rb

@@ -0,0 +1,823 @@
+#-------------------------------------------------------------------------------
+# ibmeta.rb
+#-------------------------------------------------------------------------------
+# Copyright � Peter Wood, 2005; Richard Vowles, 2006
+#
+# The contents of this file are subject to the Mozilla Public License Version
+# 1.1 (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.mozilla.org/MPL/
+#
+# Software distributed under the License is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
+# the specificlanguage governing rights and  limitations under the License.
+#
+# The Original Code is the FireRuby extension for the Ruby language.
+#
+# The Initial Developer of the Original Code is Peter Wood. All Rights
+# Reserved. All modifications (and all InterBaseMetaFunctions) are by Richard Vowles
+# (richard@developers-inc.co.nz). 
+
+module IBRuby
+  class InterBaseIndex
+  
+    attr_accessor :table, :name, :unique, :columns, :direction, :active
+    
+    def initialize(table, name, unique, columns, direction = nil, active = nil)
+      @table = table
+      @name = name
+      @unique = unique
+      @columns = columns
+      @direction = direction
+      @active = active
+    end
+  
+    INDEX_ACTIVE = :INDEX_ACTIVE
+    INDEX_INACTIVE = :INDEX_INACTIVE
+
+    def to_sql
+      sql = "create"
+      if unique == true
+        sql << " unique"
+      end
+      if @direction
+        case @direction
+          when InterBaseMetaFunctions::ASCENDING
+            sql << " asc"
+          when InterBaseMetaFunctions::DESCENDING
+            sql << " desc"
+        end
+      end
+      
+      sql << " index"
+      
+      sql << " #{@name}"
+      
+      sql << " on #{@table} ("
+      columns.each() do |col|
+        sql << ", " unless col == columns.first
+        sql << ((col.instance_of? InterBaseColumn) ? col.name : col.to_s)
+      end
+      
+      sql << ")"
+      
+      #puts "sql is #{sql}"
+      
+      sql
+    end
+    
+    def create_index(conn)
+      #puts #{to_sql} vs #{self.to_sql}"
+      conn.execute_immediate(self.to_sql)
+    end
+    
+    def rename_index(conn, new_name)
+      old_name = @name
+      @name = new_name
+      begin
+        create(conn)
+        @name = old_name
+        remove(conn)
+      ensure
+        @name = old_name
+      end
+    end
+    
+    def change_activation(conn, activation)
+      sql = "alter index #{@name} "
+      sql << (activation == InterBaseIndex::INDEX_ACTIVE) ? "active" : "inactive"
+      conn.execute_immediate( sql )      
+    end
+
+    def remove_index(conn)
+      conn.execute_immediate( "DROP INDEX #{name}" )
+    end
+  end
+  
+  class InterBaseConstraint
+    attr_accessor :name, :type, :columns, :table, :foreign_cols, :foreign_table_name
+    
+    PRIMARY_KEY = :PRIMARY_KEY
+    FOREIGN_KEY = :FOREIGN_KEY
+    
+    # columns are strings only, not complete columns. if they are complete columns
+    # then we just get their name
+    def initialize(type, columns, foreign_cols=nil, foreign_table_name=nil, name=nil)
+      @name = name
+      @type = type
+      @columns = columns
+      @foreign_cols=foreign_cols
+      @foreign_table_name=foreign_table_name
+      
+      #puts "constraint created #{to_sql}"
+    end
+    
+    def to_sql
+      tab_name = table.nil? ? "NULL" : table.name
+      sql = "alter table #{tab_name} add "
+      
+      if @type == :PRIMARY_KEY
+        sql << "primary key ("
+        sql << cycle_cols
+        sql << ")"
+      elsif @type == :FOREIGN_KEY
+        sql << "foreign key ("
+        sql << cycle_cols
+        sql << ") references #{foreign_table_name} ("
+        sql << cycle_cols(foreign_cols)
+        sql << ")"
+      else
+        raise NotImplementedError, "Other constraints #{@type.to_s} not implemented yet"
+      end
+    end
+    
+    private
+      def cycle_cols(columns=@columns)
+        sql = ""
+        if !columns.nil?
+          col_count = 0
+          columns.each() do |col|
+            sql << ", " unless col_count == 0
+            col_count += 1 # can't use columns.first as it may not be passed first by each????
+            if col === InterBaseColumn
+              sql << col.name
+            else
+              sql << col.to_s
+            end
+          end
+        end
+        
+        sql
+      end
+    
+  end
+  
+  class InterBaseTable 
+    attr_accessor :name, :columns, :indices, :constraints
+    
+    SQL_ALL = :SQL_ALL
+    SQL_TABLE = :SQL_TABLE
+    SQL_INDICES = :SQL_INDICES
+    SQL_PRIMARY_KEYS = :SQL_PRIMARY_KEYS
+    SQL_FOREIGN_KEYS = :SQL_FOREIGN_KEYS
+    
+    def initialize(name, columns=[], indices=[], constraints=[] )
+      #puts "table name new table: #{name}"
+      @name = name.to_s.upcase
+      @columns = columns
+      @indices = indices
+      @constraints = constraints
+      
+      if @constraints
+        @constraints.each() {|c| c.table = self }
+      end
+    end
+    
+    def load(conn)
+      @columns = InterBaseMetaFunctions.table_fields(conn,@name,true)
+      @indices = InterBaseMetaFunctions.indices(conn,@name)
+      @constraints = InterBaseMetaFunctions.table_constraints(conn,@name)
+      
+      #puts "#{@constraints.size} constraints found"
+      
+      @constraints.each() {|c| c.table = self }
+      
+      @loaded = true
+    end
+    
+    def drop_table(conn)
+      #puts "DROP TABLE #{name}"
+      conn.execute_immediate( "DROP TABLE #{name}" )
+    end
+    
+    def create_table(conn)
+      to_sql.each() do |sql|
+        #puts "executing: #{sql}"
+        conn.execute_immediate( sql )
+      end
+    end
+    
+    ## returns an array of sql required to create the table and all dependents
+    # when reconstructing the database, create all the tables, then create the primary keys and then
+    # create the foreign keys and then the indices
+    def to_sql(sql_restriction=:SQL_ALL)
+      sql = []
+      
+      if ( [:SQL_ALL, :SQL_TABLE].include?(sql_restriction) )
+        sql << to_sql_create_table
+      end
+      
+      if ( [:SQL_ALL, :SQL_INDICES].include?(sql_restriction) && @indices )
+        @indices.each() {|index| sql << index.to_sql }
+      end
+      
+      if ( [:SQL_ALL, :SQL_PRIMARY_KEYS].include?(sql_restriction) && @constraints )
+        @constraints.each() do |c| 
+          if (c.type == InterBaseConstraint::PRIMARY_KEY) 
+            sql << c.to_sql
+          end 
+        end
+      end
+      
+      if ( [:SQL_ALL, :SQL_FOREIGN_KEYS].include?(sql_restriction) && @constraints )
+        @constraints.each() do |c| 
+          if (c.type == InterBaseConstraint::FOREIGN_KEY) 
+            sql << c.to_sql
+          end 
+        end
+      end
+      
+      sql
+    end
+    
+    def rename_table(conn, ntable_name)
+      new_table_name = ntable_name.to_s.upcase
+      
+      if @loaded.nil? or !@loaded
+        load(conn)
+      end
+      
+      old_table_name = @name
+      load(conn)  # load the definition
+      @name = new_table_name
+      to_sql(:SQL_TABLE).each() {|sql| conn.execute_immediate(sql) }
+      # copy all the data across
+      conn.execute_immediate( "insert into #{new_table_name} select * from #{old_table_name}")
+      to_sql(:SQL_PRIMARY_KEYS).each() {|sql| conn.execute_immediate(sql) }
+      to_sql(:SQL_FOREIGN_KEYS).each() {|sql| conn.execute_immediate(sql) }
+      @indices.each() do |index| 
+        index.remove_index(conn)
+        index.table = new_table_name
+        index.create_index(conn)
+      end
+      @name = old_table_name
+      drop_table(conn)
+    end
+    
+    private
+    def to_sql_create_table
+      sql = "create table #{name} ("
+      
+      if !columns.nil?
+        col_count = 0
+        columns.each() do |col|
+          sql << ", " unless col_count == 0
+          col_count += 1
+          sql << col.to_sql
+        end
+      end
+      
+      sql << ")"
+      
+      #puts sql
+      sql
+    end
+  end
+  
+  # InterBaseMetaFunctions
+  # Rather than requiring Ruby on Rails for access to these useful functions, I decided to move
+  # them here instead.
+  # 
+  
+  class InterBaseMetaFunctions
+  
+    ASCENDING = :ASCENDING
+    DESCENDING = :DESCENDING
+    
+    def self.quote( value, column_meta_data )
+      if column_meta_data.expects_quoting
+        '#{value}'
+      elsif ((column_meta_data.type == InterBaseColumn::BLOB) && (column_meta_data.sub_type != 1 ) )
+        raise IBRubyException.new("'#{value}' is not a valid default for this column #{column_meta_data.name}.")
+      else
+        value
+      end
+    end
+    
+    
+    def self.table_names(conn)
+      tables = []
+      
+      conn.execute_immediate("select rdb$relation_name from rdb$relations where rdb$relation_name not starting 'RDB$' and rdb$flags=1") do |row|
+        tables << row[0].to_s.rstrip
+      end
+      
+      tables
+    end
+    
+    def self.indices(conn, table_name)
+      indices = []
+      
+      # we must make sure the current transaction is committed, otherwise this won't work!
+      indicesSQL = <<-END_SQL
+      select rdb$index_name, rdb$unique_flag,RDB$INDEX_INACTIVE,RDB$INDEX_TYPE  from rdb$indices
+         where rdb$relation_name = '#{table_name.to_s.upcase}' and rdb$index_name not starting 'RDB$'
+      END_SQL
+      
+      #~ puts "SQL"
+      #~ puts indicesSQL
+      
+      conn.execute_immediate(indicesSQL) do |row|
+        #puts "index #{ib_to_ar_case(row[0].to_s.rstrip)}"
+        indices << InterBaseIndex.new(table_name, row[0].to_s.rstrip, 
+               row[1].to_i == 1, [], 
+               (row[3] == 1)?InterBaseMetaFunctions::DESCENDING : InterBaseMetaFunctions::ASCENDING, 
+               (row[2] == 1)?InterBaseIndex::INDEX_INACTIVE : InterBaseIndex::INDEX_ACTIVE)
+      end
+      
+      #puts "Indices size #{indices.size}"
+      
+      if !indices.empty? 
+        indices.each() do |index|
+          sql = "select rdb$field_name from rdb$index_segments where rdb$index_name "\
+                 "= '#{index.name.upcase}' order by rdb$index_name, rdb$field_position"
+          
+          #puts "index SQL: #{sql}"
+          
+          conn.execute_immediate(sql) do |row|
+            index.columns << table_fields(conn, table_name, true, row[0].to_s.rstrip )
+          end # each row in the index and get the InterBaseColumn
+        end # each index
+      end # if we found indices
+      
+      indices
+    end
+    
+    def self.remove_index(conn, index_name)
+      conn.execute_immediate( "DROP INDEX #{index_name}" )
+    end
+    
+    # This class method fetches the type details for a named table. The
+    # method returns a hash that links column names to InterBaseColumn objects.
+    #
+    # ==== Parameters
+    # table::       A string containing the name of the table.
+    # connection::  A reference to the connection to be used to determine
+    #               the type information.
+    # extract_ordered: if true then returns an ordered array of columns otherwise returns hash with col names
+    # column_name: if true then returns a single column (not array or hash)
+    #
+    # ==== Exception
+    # IBRubyException::  Generated if an invalid table name is specified
+    #                      or an SQL error occurs.
+    def self.table_fields(connection, table, extract_ordered = false, column_name = nil)
+      # Check for naughty table names.
+      if /\s+/ =~ table.to_s
+        raise IBRubyException.new("'#{table.to_s}' is not a valid table name.")
+      end
+      
+      extract_ordered = true if !column_name.nil?
+      
+      types     = extract_ordered ? [] : {}
+      begin
+        # r.rdb$field_source,
+        sql = "SELECT r.rdb$field_name, f.rdb$field_type, "\
+                 "f.rdb$field_length, f.rdb$field_precision, f.rdb$field_scale * -1, "\
+                 "f.rdb$field_sub_type, "\
+                 "COALESCE(r.rdb$default_source, f.rdb$default_source) rdb$default_source, "\
+                 "COALESCE(r.rdb$null_flag, f.rdb$null_flag) rdb$null_flag, rdb$character_length "\
+          "FROM rdb$relation_fields r "\
+          "JOIN rdb$fields f ON r.rdb$field_source = f.rdb$field_name "\
+          "WHERE r.rdb$relation_name = '#{table.to_s.upcase}'";
+        
+        if !column_name.nil?
+          sql << " AND r.rdb$field_name = '#{column_name.to_s.upcase}'"
+        elsif extract_ordered
+          sql << " ORDER BY r.rdb$field_position"
+        end
+        
+        #puts "sql: #{sql}"
+        
+        #            sql = "SELECT RF.RDB$FIELD_NAME, F.RDB$FIELD_TYPE, "\
+        #                  "F.RDB$FIELD_LENGTH, F.RDB$FIELD_PRECISION, "\
+        #                  "F.RDB$FIELD_SCALE * -1, F.RDB$FIELD_SUB_TYPE "\
+        #                  "FROM RDB$RELATION_FIELDS RF, RDB$FIELDS F "\
+        #                  "WHERE RF.RDB$RELATION_NAME = UPPER('#{table}') "\
+        #                  "AND RF.RDB$FIELD_SOURCE = F.RDB$FIELD_NAME"
+        
+        #connection.start_transaction do |tx|
+        #  tx.execute(sql) 
+        connection.execute_immediate(sql) do |row|
+            sql_type   = InterBaseColumn.to_base_type(row[1], row[5])
+            type       = nil
+            field_name = row[0].strip
+            
+            #column_name, table_name, type, default_source=nil, null_flag=false, length=nil, precision=nil, scale=nil, sub_type=nil )
+            #row[0], row
+            case sql_type
+            when InterBaseColumn::BLOB
+              type = InterBaseColumn.new(field_name, table.to_s, sql_type, row[6], !row[7].nil?, nil, nil, nil, row[5] )
+            when InterBaseColumn::CHAR, InterBaseColumn::VARCHAR
+              type = InterBaseColumn.new(field_name, table.to_s, sql_type, row[6], !row[7].nil?, row[8] )
+              # row[8] is the real length, field_length depends on the character set being used
+            when InterBaseColumn::DECIMAL, InterBaseColumn::NUMERIC
+              type = InterBaseColumn.new(field_name, table.to_s, sql_type, row[6], !row[7].nil?, nil, row[3], row[4] )
+            else
+              type = InterBaseColumn.new(field_name, table.to_s, sql_type, row[6], !row[7].nil? )
+            end
+            
+            if extract_ordered
+              types << type
+            else
+              types[field_name] = type
+            end
+            
+            #puts "col: #{type.to_sql}"
+          end
+          
+        #end
+      end
+      if ( types.size > 1 || column_name.nil? )
+        types
+      elsif (types.size == 1)
+        types[0]
+      else
+        nil
+      end
+    end # table_fields
+    
+    def self.table_constraints(conn, table_name)
+      sql = "select rdb$constraint_name, rdb$constraint_type, rdb$index_name "\
+      "from rdb$relation_constraints "\
+        "where rdb$constraint_type in ('FOREIGN KEY', 'PRIMARY KEY' ) "\
+        "and rdb$relation_name = '#{table_name.to_s.upcase}'"
+        
+      constraints = []
+      
+      conn.execute_immediate(sql) do |constraint|
+        constraint_name = constraint[0].strip
+        constraint_type = ( constraint[1].strip == 'PRIMARY KEY' ) ? 
+          InterBaseConstraint::PRIMARY_KEY : InterBaseConstraint::FOREIGN_KEY;
+        representing_index = constraint[2]
+        # now we need to get the columns that are being keyed on on this table, that is the same
+        # for PK and FK
+        columns = []
+        conn.execute_immediate( "select rdb$field_name "\
+              "from rdb$index_segments where rdb$index_name='#{representing_index}'") do |col|
+          columns << col[0].to_s.strip
+        end
+        # and now for foreign keys, we need to find out what the foreign key index name is
+        if constraint_type == InterBaseConstraint::FOREIGN_KEY
+          fk_columns = []
+          foreign_key_index = nil
+          foreign_key_table = nil
+          conn.execute_immediate( "select rdb$foreign_key from rdb$indices "\
+                "where rdb$index_name='#{representing_index}'") do |fk|
+            foreign_key_index = fk[0].strip
+          end
+          conn.execute_immediate( "select rdb$relation_name from rdb$indices "\
+                "where rdb$index_name='#{foreign_key_index}'") do |fk|
+            foreign_key_table = fk[0].strip
+          end
+          conn.execute_immediate( "select rdb$field_name "\
+              "from rdb$index_segments where rdb$index_name='#{foreign_key_index}'") do |col|
+            fk_columns << col[0].to_s.strip
+          end
+          
+          constraints << InterBaseConstraint.new( constraint_type, columns, fk_columns, foreign_key_table )
+        else
+          constraints << InterBaseConstraint.new( constraint_type, columns  )
+        end #if constraints_type
+      end #conn.execute_immediate
+      
+      constraints
+    end #def table_constraints
+
+    def self.db_type_cast( conn, column_type, column_value )
+      sql = "SELECT CAST(#{column_value} AS #{column_type}) FROM RDB$DATABASE ROWS 1 TO 1"
+      #puts "db_type_cast: #{sql}"
+      retVal = nil
+      conn.execute_immediate(sql) do |row|
+        retVal = row[0]
+      end
+      retVal
+    end
+    
+    
+    # end of InterBaseMetaFunctions class
+  end
+  
+  
+  # This class is used to represent SQL table column tables.
+  class InterBaseColumn
+    # allow these to be overriden
+    @@default_precision = 10
+    @@default_scale = 2
+    @@default_length = 255
+  
+    # A definition for a base SQL type.
+    BOOLEAN                          = :BOOLEAN
+    
+    # A definition for a base SQL type.
+    BLOB                             = :BLOB
+    
+    # A definition for a base SQL type.
+    CHAR                             = :CHAR
+    
+    # A definition for a base SQL type.
+    DATE                             = :DATE
+    
+    # A definition for a base SQL type.
+    DECIMAL                          = :DECIMAL
+    
+    # A definition for a base SQL type.
+    DOUBLE                           = :DOUBLE
+    
+    # A definition for a base SQL type.
+    FLOAT                            = :FLOAT
+    
+    # A definition for a base SQL type.
+    INTEGER                          = :INTEGER
+    
+    # A definition for a base SQL type.
+    NUMERIC                          = :NUMERIC
+    
+    # A definition for a base SQL type.
+    SMALLINT                         = :SMALLINT
+    
+    # A definition for a base SQL type.
+    TIME                             = :TIME
+    
+    # A definition for a base SQL type.
+    TIMESTAMP                        = :TIMESTAMP
+    
+    # A definition for a base SQL type.
+    VARCHAR                          = :VARCHAR
+    
+    # data type can be returned when arithmetic occurs, e.g. SMALLINT * -1 returns a INT64
+    INT64                            = :INT64
+    
+    # Attribute accessor.
+    attr_accessor :type, :length, :precision, :scale, :sub_type, :name, :table_name, :default, :not_null
+    
+    def self.expects_quoting(col)
+      case col.type
+        when InterBaseColumn::NUMERIC, InterBaseColumn::DECIMAL, InterBaseColumn::INTEGER, 
+                InterBaseColumn::DOUBLE, InterBaseColumn::FLOAT
+          false
+        when InterBaseColumn::CHAR, InterBaseColumn::VARCHAR, InterBaseColumn::BLOB, 
+                InterBaseColumn::DATE, InterBaseColumn::TIME, InterBaseColumn::TIMESTAMP
+          true
+        else
+          nil
+      end
+    end
+    
+    def expects_quoting
+      InterBaseColumn.expects_quoting(self)
+    end
+    
+    # This is the constructor for the InterBaseColumn class.
+    #
+    # ==== Parameters
+    # type::       The base type for the InterBaseColumn object. Must be one of the
+    #              base types defined within the class.
+    # length::     The length setting for the type. Defaults to nil.
+    # precision::  The precision setting for the type. Defaults to nil.
+    # scale::      The scale setting for the type. Defaults to nil.
+    # sub_type::    The SQL sub-type setting. Defaults to nil.
+    # default_source:: the whole string "default xxx" or "default 'xxx'"
+    # not_null:   true for NOT NULL, false for nulls allowed
+    # actual_default:: if specified then we don't bother processing default_source
+    def initialize(column_name, table_name, type, default_source=nil, not_null=false, 
+          length=nil, precision=10, scale=0, sub_type=nil, actual_default=nil )
+      @name = column_name
+      @table_name = table_name
+      @not_null = not_null
+      @type      = type
+      @length    = length
+      @precision = precision
+      @scale     = scale
+      @sub_type  = sub_type
+
+      
+      if !actual_default.nil?
+        #puts "actual default #{actual_default}"
+        @default = actual_default
+      else
+        validate_default_source(default_source)
+      end
+    end
+    
+    def validate
+      # ensure sensible defaults are set      
+      @precision = @@default_precision if @precision.nil?
+      @scale = @@default_scale if @scale.nil?  
+      @length = @@default_length if @length.nil?
+    end
+    
+    def validate_default_source(default_source)
+      if !default_source.nil?
+        #puts "checking default: #{default_source}"
+        match = Regexp.new( '^\s*DEFAULT\s+(.*)\s*', Regexp::IGNORECASE )
+        matchData = match.match(default_source.to_s)
+        if matchData
+          @default = matchData[1]
+          
+          #puts "result was #{@default} type is #{@type}"
+          
+          if @default
+            if InterBaseColumn.expects_quoting(self)
+              len = @default.size - 2
+              @default = @default[1..len]
+            else
+              case @type
+               when InterBaseColumn::BOOLEAN
+                 @default = "true".casecmp( @default.to_s ) == 0
+               when InterBaseColumn::DECIMAL, InterBaseColumn::NUMERIC
+                 @default = BigDecimal.new( @default.to_s )
+               when InterBaseColumn::DOUBLE, InterBaseColumn::FLOAT
+                 @default = @default.to_f
+               when InterBaseColumn::INTEGER
+                 @default = @default.to_i
+               when InterBaseColumn::DATE, InterBaseColumn::TIME, InterBaseColumn::TIMESTAMP
+                 if @default.to_s !~ /^current/i
+                   @default = InterBaseMetaFunctions.db_type_cast( @default, to_s )
+                 end
+              end
+            end
+          end
+         end
+      else
+        #puts "default source passed is null"
+        @default = nil
+      end
+    end
+    
+    
+    # This method overloads the equivalence test operator for the InterBaseColumn
+    # class.
+    #
+    # ==== Parameters
+    # object::  A reference to the object to be compared with.
+    def ==(object)
+      result = false
+      if object.instance_of?(InterBaseColumn)
+        result = (@type      == object.type &&
+                  @length    == object.length &&
+                  @precision == object.precision &&
+                  @scale     == object.scale &&
+                  @sub_type   == object.sub_type)
+      end
+      result
+    end
+    
+    
+    # This method generates a textual description for a InterBaseColumn object.
+    def to_s
+      validate  # ensure sensible defaults
+
+      if @type == InterBaseColumn::DECIMAL or @type == InterBaseColumn::NUMERIC
+            "#{@type.id2name}(#{@precision},#{@scale})"
+      elsif @type == InterBaseColumn::BLOB
+            "#{@type.id2name} SUB_TYPE #{@sub_type}"
+      elsif @type == InterBaseColumn::CHAR or @type == InterBaseColumn::VARCHAR
+            "#{@type.id2name}(#{@length})"
+      elsif @type == InterBaseColumn::DOUBLE
+            "DOUBLE PRECISION"
+      else
+        @type.id2name
+      end
+    end
+    
+    def to_sql
+      sql = name + " " + to_s
+      if !@default.nil?
+        sql << " default "
+        equote = expects_quoting
+        sql << "'" if equote
+        sql << @default.to_s
+        sql << "'" if equote
+      end
+      if @not_null == true
+        sql << " not null"
+      end
+      sql      
+      # all manner of other things, we are ignoring (e.g. check constraints)
+    end
+    
+    def to_base_type
+      InterBaseColumn.to_base_type(self.type, self.sub_type)
+    end
+    
+    # This class method converts a InterBase internal type to a InterBaseColumn base
+    # type.
+    #
+    # ==== Parameters
+    # type::     A reference to the Interbase field type value.
+    # sub_type::  A reference to the Interbase field subtype value.
+    def self.to_base_type(type, subtype)
+      case type
+      when 16  #  DECIMAL, NUMERIC
+        if subtype
+          subtype == 1 ? InterBaseColumn::NUMERIC : InterBaseColumn::DECIMAL
+        else
+          InterBaseColumn::INT64 # can't actually define a column of this type
+        end
+      when 17  # BOOLEAN
+        InterBaseColumn::BOOLEAN
+        
+      when 261 # BLOB
+        InterBaseColumn::BLOB
+        
+      when 14  # CHAR
+        InterBaseColumn::CHAR
+        
+      when 12  # DATE
+        InterBaseColumn::DATE
+        
+      when 27  # DOUBLE, DECIMAL, NUMERIC
+        if subtype
+          subtype == 1 ? InterBaseColumn::NUMERIC : InterBaseColumn::DECIMAL
+        else
+          InterBaseColumn::DOUBLE
+        end
+        
+      when 10  # FLOAT
+        InterBaseColumn::FLOAT
+        
+      when 8   # INTEGER, DECIMAL, NUMERIC
+        if subtype
+          subtype == 1 ? InterBaseColumn::NUMERIC : InterBaseColumn::DECIMAL
+        else
+          InterBaseColumn::INTEGER
+        end
+        
+      when 7   # SMALLINT, DECIMAL, NUMERIC
+        if subtype
+          subtype == 1 ? InterBaseColumn::NUMERIC : InterBaseColumn::DECIMAL
+        else
+          InterBaseColumn::SMALLINT
+        end
+        
+      when 13  # TIME
+        InterBaseColumn::TIME
+        
+      when 35  # TIMESTAMP
+        InterBaseColumn::TIMESTAMP
+        
+      when 37  # VARCHAR
+        InterBaseColumn::VARCHAR
+      end
+    end
+    
+    # we should also check to see if this table has indexes which need to be dropped and re-created
+    # but the migrations user should really do that
+    def rename_column( connection, new_column_name )
+      #puts "alter table #{@table_name} alter column #{@name} to #{new_column_name}"
+      connection.execute_immediate( "alter table #{@table_name} alter column #{@name} to #{new_column_name}" )
+    end
+    
+    # this column does not exist in the database, please create it!
+    def add_column( connection )
+      validate  # ensure sensible defaults
+      #puts "alter table #{@table_name} add #{self.to_sql}"
+      connection.execute_immediate( "alter table #{@table_name} add #{self.to_sql}" )
+    end
+    
+    def change_column(conn, new_column)
+      new_column.validate  # ensure sensible defaults
+      
+      if new_column.type != self   # should use == defined above
+        change_type_sql = "ALTER TABLE #{@table_name} alter #{@name} type #{new_column.to_s}"
+        #puts change_type_sql
+        conn.execute_immediate(change_type_sql)
+      end
+
+      if new_column.not_null != @not_null      
+        # now change the NULL status, this may make the table invalid so...
+        nullFlag = new_column.not_null ? "1" : "NULL"
+        update_relations_fields_sql = 
+           "UPDATE rdb$relation_fields set rdb$null_flags = #{nullFlag}"\
+           " where rdb$relation_name='#{@table_name.upcase}' and "\
+           "rdb$field_name='#{@name.upcase}'"
+        conn.execute_immediate(update_relations_fields_sql)
+      end
+      
+      # changed default or changed type
+      if (new_column.default != @default) || (new_column.type != self)
+        # now the default change, which is complicated!
+        defaultSource = new_column.default.nil? ? "" : ("default " << InterBaseMetaFunctions.quote(new_column.default.to_s, new_column ) )
+        #puts "alter table #{@table_name} add ib$$temp type #{new_column.to_s} #{defaultSource}"
+        conn.execute_immediate("alter table #{@table_name} add ib$$temp #{new_column.to_s} #{defaultSource}")
+        
+        # standard hack to change the default type
+        begin
+          sql = <<-END_SQL
+              update rdb$relation_fields set
+              rdb$default_source=(select rdb$default_source from rdb$relation_fields where
+                rdb$field_name='IB$$TEMP' and rdb$relation_name='#{@table_name.upcase}'),
+              rdb$default_value=(select rdb$default_value from rdb$relation_fields where
+                rdb$field_name='IB$$TEMP' and rdb$relation_name='#{@table_name.upcase}')
+              where rdb$field_name='#{@name.upcase}' and rdb$relation_name='#{@table_name.upcase}';
+          END_SQL
+          conn.execute_immediate(sql)
+        ensure
+          conn.execute_immediate("alter table #{@table_name} drop ib$$temp" )
+        end
+       end
+    end
+    
+  end # End of the InterBaseColumn class.
+end # End of the IBRuby module.

data/lib/ibruby.rb

@@ -19,4 +19,4 @@
 # Reserved.
 
 require 'ib_lib'
-require 'SQLType'
+require 'ibmeta'

data/test/ConnectionTest.rb

@@ -3,7 +3,7 @@
 require 'TestSetup'
 require 'test/unit'
 #require 'rubygems'
-require 'ibruby'
+require 'ib_lib'
 
 include IBRuby
 

data/test/MetaTest.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class MetaTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}meta_unit_test.ib"
+   
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+
+      @database    = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @connection = @database.connect(DB_USER_NAME, DB_PASSWORD)
+      
+      @creation_sql = "create table mtest (id integer not null, "\
+        "bool1 boolean default false, bool2 boolean, bool3 boolean default true, bool4 boolean default true not null,"\
+        " blob1 blob sub_type 1 not null, blob2 blob sub_type 1, blob3 blob sub_type 0,"\
+        " char1 char(10) default 'fred', char2 char(10) default 'fred' not null, char3 char(10), char4 char(20) default 'wil''ma',"\
+        " date1 date default current_date, date2 date not null, date3 date default current_date not null,"\
+        " decimal1 decimal(18,5) default 1.345, decimal2 decimal(15,5) default 20.22 not null, decimal3 decimal(12,6) not null"\
+        ")"
+      #puts sql
+      @connection.execute_immediate( @creation_sql );
+      @connection.execute_immediate( "create table pk_table(id integer not null primary key)" )
+      @connection.execute_immediate( "create table fk_table(id integer not null primary key, "\
+        "fk_id integer references pk_table(id))" )
+      @pk_sql = "alter table mtest "
+      
+   end
+   
+  
+   def teardown
+      @connection.close
+
+#      if File::exist?(DB_FILE)
+#         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+#      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   def test01
+     table = InterBaseTable.new('mtest')
+     assert_nothing_thrown( "failed to load table mtest" ) { table.load(@connection) }
+     sql = []
+     assert_nothing_thrown( "unable to build sql!" ) { sql = table.to_sql }
+     assert_not_nil sql, "sql returned nil for create table"
+     assert_equal sql.size > 0, true, "sql returned has nothing in it for table creation!"
+     #assert_equal @creation_sql.upcase, sql[0].upcase
+     #they ARE the same, but shows false and don't know why
+     puts sql
+   end
+   
+   def test02
+    col = InterBaseMetaFunctions.table_fields( @connection, "mtest", true, "decimal2" )
+    new_col = col.dup
+    new_col.precision = 16
+    new_col.scale = 2
+    col.change_column(@connection,new_col)
+    new_col = InterBaseMetaFunctions.table_fields( @connection, "mtest", true, "decimal2" )
+    
+    assert_equal false, new_col == col, "column decimal2 not changed"
+    assert_equal new_col.precision, 16, "column decimal2 precision not 16!"
+    assert_equal new_col.scale, 2, "column scale should be 2!"
+   end
+   
+   def test03
+     col = InterBaseMetaFunctions.table_fields( @connection, "mtest", true, "decimal2" )
+     col.rename_column( @connection, "decimal_rename" )
+     ren_col = InterBaseMetaFunctions.table_fields( @connection, "mtest", true, "decimal2" )
+     assert_equal nil, ren_col, "column not renamed!"
+     new_col = InterBaseMetaFunctions.table_fields( @connection, "mtest", true, "decimal_rename" )
+     assert_equal new_col, col, "column types not identical after rename"
+     new_col.rename_column( @connection, "decimal2" )
+   end
+
+   def test04
+     table = InterBaseTable.new('fk_table')
+     table.load(@connection)
+     assert_nothing_thrown( "unable build sql for table fk_table! " ) do
+       table.to_sql.each() {|sql| puts "table creation sql: #{sql}" }
+     end
+     assert_nothing_thrown( "unable to rename table" ) do
+       table.rename_table( @connection, 'new_fk_table' )
+     end
+     table = InterBaseTable.new('new_fk_table')
+     table.load(@connection)
+     assert_nothing_thrown( "unable build sql for table fk_table! " ) do
+       table.to_sql.each() {|sql| puts "table creation sql: #{sql}" }
+     end
+   end   
+ end

metadata

@@ -3,12 +3,12 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ibruby
 version: !ruby/object:Gem::Version 
-  version: 0.5.1
-date: 2006-12-05 00:00:00 +13:00
+  version: 0.5.2
+date: 2006-12-23 00:00:00 +13:00
 summary: Ruby interface library for the InterBase database.
 require_paths: 
 - lib
-email: paw220470@yahoo.ie, rvowles@codegear.com
+email: paw220470@yahoo.ie, richard@developers-inc.co.nz
 homepage: http://rubyforge.org/projects/ibruby/
 rubyforge_project: 
 description: IBRuby is an extension to the Ruby programming language that provides access to the InterBase RDBMS. IBRuby is based in the InterBase C API and has no additional dependencies. The IBRuby library wraps the API calls in a Ruby OO interface.
@@ -30,9 +30,9 @@ authors:
 - Peter Wood, Richard Vowles
 files: 
 - lib/mkdoc
-- lib/SQLType.rb
 - lib/ibruby.rb
 - lib/src.rb
+- lib/ibmeta.rb
 - lib/ib_lib.so
 - test/SQLTest.rb
 - test/DatabaseTest.rb
@@ -47,6 +47,7 @@ files:
 - test/BooleanTest.rb
 - test/KeyTest.rb
 - test/TestSetup.rb
+- test/MetaTest.rb
 - test/BackupRestoreTest.rb
 - test/RowCountTest.rb
 - test/UnitTest.rb

data/lib/SQLType.rb

@@ -1,230 +0,0 @@
-#-------------------------------------------------------------------------------
-# SQLType.rb
-#-------------------------------------------------------------------------------
-# Copyright � Peter Wood, 2005; Richard Vowles, 2006
-#
-# The contents of this file are subject to the Mozilla Public License Version
-# 1.1 (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.mozilla.org/MPL/
-#
-# Software distributed under the License is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
-# the specificlanguage governing rights and  limitations under the License.
-#
-# The Original Code is the FireRuby extension for the Ruby language.
-#
-# The Initial Developer of the Original Code is Peter Wood. All Rights
-# Reserved.
-
-module IBRuby
-   # This class is used to represent SQL table column tables.
-   class SQLType
-      # A definition for a base SQL type.
-      BOOLEAN                          = :BOOLEAN
-
-      # A definition for a base SQL type.
-      BLOB                             = :BLOB
-
-      # A definition for a base SQL type.
-      CHAR                             = :CHAR
-
-      # A definition for a base SQL type.
-      DATE                             = :DATE
-
-      # A definition for a base SQL type.
-      DECIMAL                          = :DECIMAL
-
-      # A definition for a base SQL type.
-      DOUBLE                           = :DOUBLE
-
-      # A definition for a base SQL type.
-      FLOAT                            = :FLOAT
-
-      # A definition for a base SQL type.
-      INTEGER                          = :INTEGER
-
-      # A definition for a base SQL type.
-      NUMERIC                          = :NUMERIC
-
-      # A definition for a base SQL type.
-      SMALLINT                         = :SMALLINT
-
-      # A definition for a base SQL type.
-      TIME                             = :TIME
-
-      # A definition for a base SQL type.
-      TIMESTAMP                        = :TIMESTAMP
-
-      # A definition for a base SQL type.
-      VARCHAR                          = :VARCHAR
-
-      # Attribute accessor.
-      attr_reader :type, :length, :precision, :scale, :subtype
-
-
-      # This is the constructor for the SQLType class.
-      #
-      # ==== Parameters
-      # type::       The base type for the SQLType object. Must be one of the
-      #              base types defined within the class.
-      # length::     The length setting for the type. Defaults to nil.
-      # precision::  The precision setting for the type. Defaults to nil.
-      # scale::      The scale setting for the type. Defaults to nil.
-      # subtype::    The SQL sub-type setting. Defaults to nil.
-      def initialize(type, length=nil, precision=nil, scale=nil, subtype=nil)
-         @type      = type
-         @length    = length
-         @precision = precision
-         @scale     = scale
-         @subtype   = subtype
-      end
-
-
-      # This class method fetches the type details for a named table. The
-      # method returns a hash that links column names to SQLType objects.
-      #
-      # ==== Parameters
-      # table::       A string containing the name of the table.
-      # connection::  A reference to the connection to be used to determine
-      #               the type information.
-      #
-      # ==== Exception
-      # IBRubyException::  Generated if an invalid table name is specified
-      #                      or an SQL error occurs.
-      def SQLType.for_table(table, connection)
-         # Check for naughty table names.
-         if /\s+/ =~ table
-            raise IBRubyException.new("'#{table}' is not a valid table name.")
-         end
-
-         types     = {}
-         begin
-            sql = "SELECT RF.RDB$FIELD_NAME, F.RDB$FIELD_TYPE, "\
-                  "F.RDB$FIELD_LENGTH, F.RDB$FIELD_PRECISION, "\
-                  "F.RDB$FIELD_SCALE * -1, F.RDB$FIELD_SUB_TYPE "\
-                  "FROM RDB$RELATION_FIELDS RF, RDB$FIELDS F "\
-                  "WHERE RF.RDB$RELATION_NAME = UPPER('#{table}') "\
-                  "AND RF.RDB$FIELD_SOURCE = F.RDB$FIELD_NAME"
-
-            connection.start_transaction do |tx|
-               tx.execute(sql) do |row|
-                  sql_type = SQLType.to_base_type(row[1], row[5])
-                  type     = nil
-                  case sql_type
-                     when BLOB
-                        type = SQLType.new(sql_type, nil, nil, nil, row[5])
-
-                     when CHAR, VARCHAR
-                        type = SQLType.new(sql_type, row[2])
-
-                     when DECIMAL, NUMERIC
-                        type = SQLType.new(sql_type, nil, row[3], row[4])
-
-                     else
-                        type = SQLType.new(sql_type)
-                  end
-                  types[row[0].strip] = type
-               end
-
-            end
-         end
-         types
-      end
-
-
-      # This method overloads the equivalence test operator for the SQLType
-      # class.
-      #
-      # ==== Parameters
-      # object::  A reference to the object to be compared with.
-      def ==(object)
-         result = false
-         if object.instance_of?(SQLType)
-            result = (@type      == object.type &&
-                      @length    == object.length &&
-                      @precision == object.precision &&
-                      @scale     == object.scale &&
-                      @subtype   == object.subtype)
-         end
-         result
-      end
-
-
-      # This method generates a textual description for a SQLType object.
-      def to_s
-         if @type == SQLType::DECIMAL or @type == SQLType::NUMERIC
-            "#{@type.id2name}(#{@precision},#{@scale})"
-         elsif @type == SQLType::BLOB
-            "#{@type.id2name} SUB TYPE #{@subtype}"
-         elsif @type == SQLType::CHAR or @type == SQLType::VARCHAR
-            "#{@type.id2name}(#{@length})"
-         else
-            @type.id2name
-         end
-      end
-
-
-      # This class method converts a InterBase internal type to a SQLType base
-      # type.
-      #
-      # ==== Parameters
-      # type::     A reference to the Interbase field type value.
-      # subtype::  A reference to the Interbase field subtype value.
-      def SQLType.to_base_type(type, subtype)
-         case type
-            when 16  #  DECIMAL, NUMERIC
-               if subtype
-                  subtype == 1 ? SQLType::NUMERIC : SQLType::DECIMAL
-               else
-                  SQLType::BIGINT
-               end
-            when 17  # BOOLEAN
-               SQLType::BOOLEAN
-
-            when 261 # BLOB
-               SQLType::BLOB
-
-            when 14  # CHAR
-               SQLType::CHAR
-
-            when 12  # DATE
-               SQLType::DATE
-
-            when 27  # DOUBLE, DECIMAL, NUMERIC
-               if subtype
-                  subtype == 1 ? SQLType::NUMERIC : SQLType::DECIMAL
-               else
-                  SQLType::DOUBLE
-               end
-
-            when 10  # FLOAT
-               SQLType::FLOAT
-
-            when 8   # INTEGER, DECIMAL, NUMERIC
-               if subtype
-                  subtype == 1 ? SQLType::NUMERIC : SQLType::DECIMAL
-               else
-                  SQLType::INTEGER
-               end
-
-            when 7   # SMALLINT, DECIMAL, NUMERIC
-               if subtype
-                  subtype == 1 ? SQLType::NUMERIC : SQLType::DECIMAL
-               else
-                  SQLType::SMALLINT
-               end
-
-            when 13  # TIME
-               SQLType::TIME
-
-            when 35  # TIMESTAMP
-               SQLType::TIMESTAMP
-
-            when 37  # VARCHAR
-               SQLType::VARCHAR
-         end
-      end
-   end # End of the SQLType class.
-end # End of the FireRuby module.