Class: Baza::Revision

Inherits:

Object

• Object
• Baza::Revision

Defined in:

lib/baza/revision.rb

Overview

This class takes a database-schema from a hash and runs it against the database. It then checks that the database matches the given schema.

Examples

db = Baza::Db.new(type: :sqlite3, path: “test_db.sqlite3”) schema =

"tables" => {
  "User" => {
    "columns" => [
      {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true,
      => "name", "type" => "varchar",
      => "lastname", "type" => "varchar"
    ],
    "indexes" => [
      "name",
      => "lastname", "columns" => ["lastname"]
    ],
    "on_create_after" => proc{|d|
      d["db"].insert("User", {"name" => "John", "lastname" => "Doe"})
    }
  }
}

}

rev = Baza::Revision.new rev.init_db(“db” => db, “schema” => schema)

Constant Summary

INIT_DB_ALLOWED_ARGS =

[:db, :schema, :tables_cache, :debug]

INIT_DB_SCHEMA_ALLOWED_ARGS =

[:tables]

INIT_DB_TABLE_ALLOWED_ARGS =

[:columns, :indexes, :rows, :renames]

Instance Method Summary

• #init_db(args) ⇒ Object

  This initializes a database-structure and content based on a schema-hash.

• #initialize(args = {}) ⇒ Revision constructor

  A new instance of Revision.

Constructor Details

#initialize(args = {}) ⇒ Revision

Returns a new instance of Revision.

# File 'lib/baza/revision.rb', line 27

def initialize(args = {})
  @args = args
end

Instance Method Details

#init_db(args) ⇒ Object

This initializes a database-structure and content based on a schema-hash.

Examples

dbrev = Baza::Revision.new dbrev.init_db(“db” => db_obj, “schema” => schema_hash)

# File 'lib/baza/revision.rb', line 38

def init_db(args)
  args.each do |key, val|
    raise "Invalid key: '#{key}' (#{key.class.name})." unless INIT_DB_ALLOWED_ARGS.include?(key)
  end

  schema = args[:schema]
  db = args[:db]
  raise "No 'db' was given." unless db

  schema.each do |key, val|
    raise "Invalid key for schema: '#{key}' (#{key.class.name})." unless INIT_DB_SCHEMA_ALLOWED_ARGS.include?(key)
  end

  #Check for normal bugs and raise apropiate error.
  raise "'schema' argument was not a Hash: '#{schema.class.name}'." unless schema.is_a?(Hash)
  raise "No tables given." unless schema.has_key?(:tables)

  #Cache tables to avoid constant reloading.
  if !args.key?(:tables_cache) || args[:tables_cache]
    puts "Caching tables-list." if args[:debug]
    tables = db.tables.list
  else
    puts "Skipping tables-cache." if args[:debug]
  end

  schema[:tables].each do |table_name, table_data|
    table_data.each do |key, val|
      raise "Invalid key: '#{key}' (#{key.class.name})." unless INIT_DB_TABLE_ALLOWED_ARGS.include?(key)
    end

    begin
      begin
        table_name = table_name.to_sym

        puts "Getting table-object for table: '#{table_name}'." if args[:debug]
        table_obj = db.tables[table_name]

        #Cache indexes- and column-objects to avoid constant reloading.
        cols = table_obj.columns
        indexes = table_obj.indexes

        if table_data[:columns]
          first_col = true
          table_data[:columns].each do |col_data|
            begin
              col_name = col_data[:name].to_sym
              col_obj = table_obj.column(col_name)
              col_str = "#{table_name}.#{col_obj.name}"
              type = col_data[:type].to_sym
              dochange = false

              if !first_col and !col_data[:after]
                #Try to find out the previous column - if so we can set "after" which makes the column being created in the right order as defined.
                if !col_data.has_key?(:after)
                  prev_no = table_data[:columns].index(col_data)
                  if prev_no != nil and prev_no != 0
                    prev_no = prev_no - 1
                    prev_col_data = table_data[:columns][prev_no]
                    col_data[:after] = prev_col_data[:name]
                  end
                end

                actual_after = nil
                set_next = false
                cols.each do |col_name, col_iter|
                  if col_iter.name == col_obj.name
                    break
                  else
                    actual_after = col_iter.name
                  end
                end

                if actual_after != col_data[:after]
                  print "Changing '#{col_str}' after from '#{actual_after}' to '#{col_data[:after]}'.\n" if args[:debug]
                  dochange = true
                end
              end

              #BUGFIX: When using SQLite3 the primary-column or a autoincr-column may never change type from int... This will break it!
              if db.opts[:type] == "sqlite3" and col_obj.type.to_s == "int" and (col_data[:primarykey] or col_data[:autoincr]) and db.int_types.index(col_data[:type].to_s)
                type = :int
              end

              if type and col_obj.type.to_s != type
                print "Type mismatch on #{col_str}: #{col_data[:type]}, #{col_obj.type}\n" if args[:debug]
                dochange = true
              end

              if col_data.has_key?(:primarykey) and col_obj.primarykey? != col_data[:primarykey]
                print "Primary-key mismatch for #{col_str}: #{col_data[:primarykey]}, #{col_obj.primarykey?}\n" if args[:debug]
                dochange = true
              end

              if col_data.has_key?(:autoincr) and col_obj.autoincr? != col_data[:autoincr]
                print "Auto-increment mismatch for #{col_str}: #{col_data[:autoincr]}, #{col_obj.autoincr?}\n" if args[:debug]
                dochange = true
              end

              if col_data.has_key?(:maxlength) and col_obj.maxlength.to_s != col_data[:maxlength].to_s
                print "Maxlength mismatch on #{col_str}: #{col_data[:maxlength]}, #{col_obj.maxlength}\n" if args[:debug]
                dochange = true
              end

              if col_data.has_key?(:null) and col_obj.null?.to_s != col_data[:null].to_s
                print "Null mismatch on #{col_str}: #{col_data[:null]}, #{col_obj.null?}\n" if args[:debug]
                dochange = true
              end

              if col_data.has_key?(:default) and col_obj.default.to_s != col_data[:default].to_s
                print "Default mismatch on #{col_str}: #{col_data[:default]}, #{col_obj.default}\n" if args[:debug]
                dochange = true
              end

              if col_data.has_key?(:comment) and col_obj.respond_to?(:comment) and col_obj.comment.to_s != col_data[:comment].to_s
                print "Comment mismatch on #{col_str}: #{col_data[:comment]}, #{col_obj.comment}\n" if args[:debug]
                dochange = true
              end

              if col_data.is_a?(Hash) and col_data[:on_before_alter]
                callback_data = col_data[:on_before_alter].call(:db => db, :table => table_obj, :col => col_obj, :col_data => col_data)
                if callback_data and callback_data[:action]
                  if callback_data[:action] == :retry
                    raise Baza::Errors::Retry
                  end
                end
              end

              if dochange
                col_data_change = col_data.clone
                col_data_change.delete(:renames)

                col_obj.change(col_data_change)

                #Change has been made - update cache.
                cols = table_obj.columns
              end

              first_col = false
            rescue Errno::ENOENT => e
              print "Column not found: #{table_obj.name}.#{col_data[:name]}.\n" if args[:debug]

              if col_data.has_key?(:renames)
                raise "'renames' was not an array for column '#{table_obj.name}.#{col_data[:name]}'." if !col_data[:renames].is_a?(Array)

                rename_found = false
                col_data[:renames].each do |col_name|
                  begin
                    col_rename = table_obj.column(col_name)
                  rescue Errno::ENOENT => e
                    next
                  end

                  print "Rename #{table_obj.name}.#{col_name} to #{table_obj.name}.#{col_data[:name]}\n" if args[:debug]
                  if col_data.is_a?(Hash) and col_data[:on_before_rename]
                    col_data[:on_before_rename].call(:db => db, :table => table_obj, :col => col_rename, :col_data => col_data)
                  end

                  col_data_change = col_data.clone
                  col_data_change.delete(:renames)

                  col_rename.change(col_data_change)

                  #Change has been made - update cache.
                  cols = table_obj.columns

                  if col_data.is_a?(Hash) and col_data[:on_after_rename]
                    col_data[:on_after_rename].call(:db => db, :table => table_obj, :col => col_rename, :col_data => col_data)
                  end

                  rename_found = true
                  break
                end

                retry if rename_found
              end

              oncreated = col_data[:on_created]
              col_data.delete(:on_created) if col_data[:oncreated]

              col_data_create = col_data
              col_data_create.delete(:renames)

              col_obj = table_obj.create_columns([col_data])

              #Change has been made - update cache.
              cols = table_obj.columns

              oncreated.call(:db => db, :table => table_obj) if oncreated
            end
          end
        end

        if table_data[:columns_remove]
          table_data[:columns_remove].each do |column_name, column_data|
            begin
              col_obj = table_obj.column(column_name)
            rescue Errno::ENOENT => e
              next
            end

            column_data[:callback].call if column_data.is_a?(Hash) and column_data[:callback]
            col_obj.drop
          end
        end

        if table_data[:indexes]
          table_data[:indexes].each do |index_data|
            if index_data.is_a?(String) or index_data.is_a?(Symbol)
              index_data = {:name => index_data, :columns => [index_data]}
            end

            begin
              index_obj = table_obj.index(index_data[:name])

              rewrite_index = false
              rewrite_index = true if index_data.key?(:unique) and index_data[:unique] != index_obj.unique?

              if rewrite_index
                index_obj.drop
                table_obj.create_indexes([index_data])
              end
            rescue Errno::ENOENT => e
              table_obj.create_indexes([index_data])
            end
          end
        end

        if table_data[:indexes_remove]
          table_data[:indexes_remove].each do |index_name, index_data|
            begin
              index_obj = table_obj.index(index_name)
            rescue Errno::ENOENT => e
              next
            end

            if index_data.is_a?(Hash) and index_data[:callback]
              index_data[:callback].call if index_data[:callback]
            end

            index_obj.drop
          end
        end

        rows_init(:db => db, :table => table_obj, :rows => table_data[:rows]) if table_data and table_data[:rows]
      rescue Errno::ENOENT => e
        puts "Table did not exist: '#{table_name}'." if args[:debug]

        if table_data.key?(:renames)
          table_data[:renames].each do |table_name_rename|
            begin
              puts "Renaming table: '#{table_name_rename}' to '#{table_name}'." if args[:debug]
              table_rename = db.tables[table_name_rename.to_sym]
              table_rename.rename(table_name)
              raise Baza::Errors::Retry
            rescue Errno::ENOENT
              next
            end
          end
        end

        if !table_data.key?(:columns)
          puts "Notice: Skipping creation of '#{table_name}' because no columns were given in hash." if args[:debug]
          next
        end

        if table_data[:on_create]
          table_data[:on_create].call(:db => db, :table_name => table_name, :table_data => table_data)
        end

        table_data_create = table_data.clone
        table_data_create.delete(:rows)

        puts "Creating table: '#{table_name}'." if args[:debug]
        db.tables.create(table_name, table_data_create)
        table_obj = db.tables[table_name.to_sym]

        if table_data[:on_create_after]
          table_data[:on_create_after].call(:db => db, :table_name => table_name, :table_data => table_data)
        end

        rows_init(:db => db, :table => table_obj, :rows => table_data[:rows]) if table_data[:rows]
      end
    rescue Baza::Errors::Retry
      retry
    end
  end

  if schema[:tables_remove]
    schema[:tables_remove].each do |table_name, table_data|
      begin
        table_obj = db.tables[table_name.to_sym]
        table_data[:callback].call(:db => db, :table => table_obj) if table_data.is_a?(Hash) and table_data[:callback]
        table_obj.drop
      rescue Errno::ENOENT => e
        next
      end
    end
  end


  #Free cache.
  tables.clear if tables
  tables = nil
end