db_suit_rails 0.4.1

data/lib/db_suit_rails/sql_skelton/tbl_index.rb

@@ -0,0 +1,310 @@
+# -*- encoding: utf-8 -*-
+
+# Author: M. Sakano (Wise Babel Ltd)
+
+require 'active_support/all'
+require 'db_suit_rails/sql_skelton/utils'  # class SqlSkelton is defined.
+require 'db_suit_rails/db_suit_rails_error'
+
+# =class SqlSkelton::TblIndex
+#
+# ==Summary
+#
+# Class for mapping between the original and modified SQL tables
+#
+# ==Description
+#
+# This holds the information of old and new names for each table.
+#
+# When you specify something, it is always the old table name.
+#
+# ==Example
+#
+#     ci = SqlSkelton::TblIndex.new(tables)  # Columns are not set.
+#     ci.update!(tables[0])
+#     ci.update!(:all)
+#
+#     # Manually sets
+#     ci.set_newtblval_with(oldtbl, new_value)
+#     new_tbl_name = newtblval(oldtbl)
+#
+class SqlSkelton::TblIndex
+
+  # Constant SuffixId is defined.
+  include Object.const_get(parent_name)::Utils  # parent_name defined in active_support/all
+
+  # REgular expression for TaBLe for RESerVeD SUFFIXes.
+  ReTblResvdSuffix = /(_id_seq|_pkey|_?unique)$/
+
+  # Hash:
+  #     { Old-Table-Name => New-Table-Name }
+  attr_reader :tblmaps
+
+  # Constructor
+  #
+  # Table list is NOT mandatory to specify.
+  #
+  # @param oldtbls [Array,String] Old table name(s)
+  def initialize(oldtbls=[])
+    @tblmaps = {}
+
+    # [oldtbls].flatten.each do |ec|
+    [oldtbls].flatten.map{|i| remove_sqlprefix(i)}.uniq.each do |ec|
+      push(ec)
+    end
+  end
+
+  # Whether empty
+  #
+  def empty?()
+    @tblmaps.empty?
+  end
+
+  # Whether a old-name table is registered?
+  #
+  # @param oldtbl [String] Old table name
+  def table_exist?(oldtbl)
+    oldtbl = remove_sqlprefix(oldtbl)
+    @tblmaps.has_key?(oldtbl)
+  end
+
+  # Gets a stored newtbl name
+  #
+  # @param oldtbl [String] Old table name
+  # @return [String] Stored new table name
+  def newtblval(oldtbl)
+    oldtbl = remove_sqlprefix(oldtbl)
+    table_exist?(oldtbl) || (raise DbSuitRailsError, "ERROR: old-table (#{oldtbl}) is not registered.")
+    @tblmaps[oldtbl]
+  end
+
+  # Sets a newtbl name
+  #
+  # @param oldtbl [String] Old table name
+  # @param value [String] new table name to set
+  # @return [String] Stored new table name
+  def set_newtblval_with(oldtbl, value)
+    # @tblmaps[oldtbl] = value
+    @tblmaps[remove_sqlprefix(oldtbl)] = remove_sqlprefix(value)
+  end
+
+  # Push a new table
+  #
+  # Make sure to use this method to add a record in @tblmaps .
+  # Or, alternatively, you can use {#update!}, which calls this method,
+  # and sets newtbl automatically.
+  #
+  # If the record already exists, this raises an error.
+  #
+  # @param oldtbl [String] Old table name
+  # @param newtbl [String] New table name
+  # @return [self]
+  def push(oldtbl, newtbl=nil)
+    oldtbl = remove_sqlprefix(oldtbl)
+    if table_exist?(oldtbl)
+      raise DbSuitRailsError, "ERROR: Failed to push old-table (#{oldtbl}) as it already exists."
+    else
+      if (oldtbl == :all) || (newtbl == :all)
+         raise DbSuitRailsError, "ERROR: :all is not allowed in push()."
+      end
+      @tblmaps[oldtbl] = remove_sqlprefix(newtbl)
+    end
+
+    self
+  end
+
+  # Update a table entry (or all the table entries) according to the rule
+  #
+  # If oldtbl is :all, all the tables are updated.
+  #
+  # This updates a newtbl name only
+  # if the existing one is empty or nil.
+  #
+  # If force: option is true, regardless of current newtbl name,
+  # newtbl is updated.
+  #
+  # To manually set the new table name, use {#set_newtblval_with}
+  #
+  # @param oldtbl [String, Symbol] Old table name or :all
+  # @param force forcibly updates.
+  # @return [self]
+  def update(oldtbl=:all, force: false)
+    oldtbl = remove_sqlprefix(oldtbl)
+    if :all == oldtbl
+      oldtblnames().each do |ec_tbl|
+        update(ec_tbl, force: force)
+      end
+      return self
+    end
+
+    table_exist?(oldtbl) || (raise DbSuitRailsError, "ERROR: Failed to update old-table (#{oldtbl}), which is not registered.")
+
+    newtbl = newtblval(oldtbl)
+    if !newtbl || newtbl.empty?
+      set_newtblval_with(oldtbl, mk_newtblname(oldtbl))
+    end
+
+    ## If force, attempts to update newtbl name regardless the other conditions.
+    force && set_newtblval_with(oldtbl, mk_newtblname(oldtbl))
+
+    return self
+  end
+
+
+  # Updates a table or pushes it if it is not registered, yet.
+  #
+  # Basically, this method is a wrapper for {#update} and {#push}
+  #
+  # This updates a newtbl name regardless the conditions (force option is set).
+  #
+  # If oldtbl is :all, all the table are updated, in which case
+  # fkey option is ignored.
+  #
+  # @param oldtbl [String, Symbol] Old table name or :all
+  # @return [self]
+  #
+  # @see SqlSkelton::TblIndex.update
+  def update!(oldtbl=:all)
+    oldtbl = remove_sqlprefix(oldtbl)
+    if defined? oldtbl.gsub
+      table_exist?(oldtbl) || push(oldtbl)
+    end
+    return update(oldtbl, force: true)
+  end
+
+
+  # Wrapper of {#update!}
+  #
+  # It returns the new tablename.
+  # Also, it does NOT update the record, if the new file is already registered.
+  #
+  # @param oldtbl [String] Old table name
+  # @return [String]
+  #
+  # @see SqlSkelton::TblIndex.update!
+  def updated_tbl!(oldtbl)
+    oldtbl = remove_sqlprefix(oldtbl)
+    if ! table_exist?(oldtbl)
+      push(oldtbl)
+      update(oldtbl, force: true)
+    end
+    newtblval(oldtbl)
+  end
+
+
+  # Returns an Array of old table names.
+  #
+  # @param exclude [String] Old table name, the corresponding value of which either becomes nil in, or if compact option is true, is excluded from, the result.
+  # @param compact [Boolean] Read only when exclude option is non-nil. If true (Def), the result is compacted; else the excluded value becomes nil.
+  # @return [Array[Hash]]
+  def oldtblnames(exclude: nil, compact: true)
+    old_or_newtblnames(:old, exclude: exclude, compact: compact)
+  end
+
+
+  # Returns an Array of new table names.
+  #
+  # @param (see #oldtblnames)
+  def newtblnames(exclude: nil, compact: true)
+    old_or_newtblnames(:new, exclude: exclude, compact: compact)
+  end
+
+
+  # Returns an Array of mixed table names == (new OR old)
+  #
+  # @param (see #oldtblnames)
+  def mixtblnames(exclude: nil, compact: true)
+    newtbl = newtblnames(exclude: exclude, compact: compact).map{|i| remove_sqlprefix(i)}
+    oldtbl = oldtblnames(exclude: exclude, compact: compact).map{|i| remove_sqlprefix(i)}
+
+    mixtbl = []
+    newtbl.each_with_index do |newc, i| 
+      mixtbl[i] = (newc || oldtbl[i])
+    end
+    mixtbl
+  end
+
+
+  #######################################################
+  private
+  #######################################################
+
+  # Gets a non-existing new table name
+  #
+  # This is a low-level method,
+  # In practice, use {#update!} etc.
+  #
+  # At the moment no potential name crush is resolved.
+  # If you want to implement it, refer to in col_index.rb 
+  #
+  #     unique_colname()
+  #
+  # where a sequential trial is implemented.
+  # Note in the case of tables, there may be more than one table name
+  # related to a table, like `XXX_id_seq`.  Hence if you change one,
+  # you should change all the related table names at the same time.
+  #
+  # @param oldtbl [String] Old table name
+  # @param useprefix [Boolean] If true, add a prefix as opposed to suffix.
+  # @return [String] Unique new table name
+  def mk_newtblname(oldtbl, useprefix: false)
+    oldtbl = remove_sqlprefix(oldtbl)
+    existing_tables = mixtblnames(exclude: oldtbl)
+
+    matched = ReTblResvdSuffix.match(oldtbl)
+    newtbl_root = (matched ? matched.pre_match : oldtbl)
+
+    ## NOTE: The format *_[0-9]* for a table name is inconvenient.
+    ##   Therefore, it is converted into '*_n[0-9]*'
+    ## singularize defined in active_support/all library
+    newtbl_root = ((/_\d/ =~ newtbl_root) ? newtbl_root.gsub(/_(\d)/, '_n\1') : newtbl_root).singularize
+    
+    begin 
+      # Singularized table name should not coincides with any existing constant names,
+      # be it Class name or existing Constant like Pi (if it does).
+      # If it does, the following raises NameError
+      # Note the table name "stdout" is OK, because the standard constant is STDOUT and is not Stdout.
+      # Note: to judge if it agrees with an existinc class but other constants,
+      #   (Class == newtbl_root.classify.constantize.class)
+      newtbl_root.classify.constantize
+      newtbl_root += SuffixId
+    rescue NameError
+    end
+
+    # unique_name_cand defined in Utils module.
+    newtbl_root = unique_name_cand(newtbl_root, useprefix: useprefix){ |cand|
+      ! existing_tables.include?( cand.pluralize +  (matched ? matched[1] : '') )
+    }
+
+    if ! newtbl_root
+      raise DbSuitRailsError, "ERROR: new table name (#{oldtbl}) already exists.  Consult the code developer."
+    end
+
+    newtbl_root.pluralize + (matched ? matched[1] : '')
+  end
+
+
+  # Core routine for {#oldtblnames} and {#newtblnames}
+  #
+  # @param old_or_new [Symbol] :old or :new.
+  # @param (see #oldtblnames)
+  # @return [Array]
+  def old_or_newtblnames(old_or_new, exclude: nil, compact: true)
+    arold = @tblmaps.keys
+    case old_or_new
+    when :old
+      arret = arold
+    when :new
+      arret = @tblmaps.values
+    else
+      raise
+    end
+
+    exclude || (return arret)
+
+    i = arold.find_index{ |val| exclude == val }
+    compact ? arret.delete_at(i) : (arret[i] = nil)
+
+    arret
+  end
+end

data/lib/db_suit_rails/sql_skelton/utils.rb

@@ -0,0 +1,56 @@
+# -*- encoding: utf-8 -*-
+
+# Author: M. Sakano (Wise Babel Ltd)
+
+class SqlSkelton
+
+  # =module SqlSkelton::SuffixId
+  #
+  # ==Summary
+  #
+  # Module to define the constant {SqlSkelton::SuffixId::SuffixId}
+  # and other common functions.
+  #
+  module Utils
+    # Suffix to append to an "id"-type column name (in "client"-DBs).
+    SuffixId = '_cli'
+
+    #######################################################
+    private
+    #######################################################
+
+    # Returns a unique new table/column name.
+    #
+    # If the CANDIDATE is accepted, returns it.
+    # Else it searches for CANDIDATE1, CANDIDATE2, ... etc.
+    # Or, n1_CANDIDATE, n2_CANDIDATE1, ... etc, if useprefix option is true.
+    #
+    # This method yields a block, where a candidate name is given and true should be returned when accepted.
+    #
+    # @param name_root [String, NilClass] Candidate new column name. If unspecified, copied from oldcol
+    # @param useprefix [Boolean] If true, add a prefix as opposed to suffix.
+    # @yield [name_cand] Candidate name is passed to the block.  It should return true if the name is OK.
+    # @yieldparam [name_cand, String] Candidate name
+    # @yieldreturn [String, NilClass] Candidate name if found, else nil.
+    # @return [String, NilClass] Unique new column name
+    def unique_name_cand(name_root, useprefix: false)
+      yield(name_root) && (return name_root) 
+      (1..99999).each do |i|
+        name_cand = (useprefix ? sprintf('n%d_%s', i, name_root) : sprintf('%s%d', name_root, i))
+        yield(name_cand) && (return name_cand) 
+      end
+      nil
+    end
+
+
+    # Remove the 'public.' prefix for the table (for the internal use)
+    #
+    # @param tblname [String] Table name
+    # @return [String]
+    def remove_sqlprefix(tblname)
+      return tblname if !defined?(tblname.gsub)
+      tblname = tblname.sub(/^public\./, '')
+    end
+  end
+end
+

data/test/sql_skelton/test_col_index.rb

@@ -0,0 +1,224 @@
+# -*- encoding: utf-8 -*-
+
+# Author: M. Sakano (Wise Babel Ltd)
+
+require 'db_suit_rails/sql_skelton/col_index'
+
+$stdout.sync=true
+$stderr.sync=true
+
+#################################################
+# Unit Test
+#################################################
+
+#if $0 == __FILE__
+  gem "minitest"
+  # require 'minitest/unit'
+  require 'minitest/autorun'
+  # MiniTest::Unit.autorun
+
+  class TestUnitSqlSkeltonColIndex < MiniTest::Test
+    T = true
+    F = false
+    SCFNAME = File.basename(__FILE__)
+    CI = SqlSkelton::ColIndex
+
+    def setup
+      # @ib = 1
+    end
+    # teardown is not often used.
+    def teardown
+      # @foo = nil
+    end
+
+
+    def test_initialize01
+      c1 = CI.new('tblold')
+      assert_equal ['tblold'],  c1.colmaps.keys
+      c2 = CI.new(['tblold'])
+      assert_equal ['tblold'],  c2.colmaps.keys
+      c3 = CI.new()
+      c3.push('tblold')
+      assert_equal ['tblold'],  c3.colmaps.keys
+      c3.push('tblold2')
+      assert_equal %w(tblold tblold2),  c3.colmaps.keys
+    end
+
+    def test_push01
+      oldtbl = 'tblold1'
+      oldcol = 'tblcol1'
+      ci = CI.new(oldtbl)
+      assert_raises(DbSuitRailsError){ ci.push(oldtbl) }
+      ci.push(oldtbl, oldcol, 'atai')
+      assert_raises(DbSuitRailsError){ ci.push(oldtbl, oldcol) }
+
+      assert  ci.table_exist?(oldtbl)
+      assert  ci.column_registered?(oldtbl, oldcol)
+      assert !ci.table_exist?('naiyo')
+      assert !ci.column_registered?('naiyo', oldcol)
+      assert !ci.column_registered?(oldtbl, 'naiyo')
+
+      assert_equal 'atai', ci.newcolval(oldtbl, oldcol)
+      ci.set_newcolval_with(oldtbl, oldcol, nil)
+      assert_nil           ci.newcolval(oldtbl, oldcol)
+    end
+
+    def test_fkey01
+      oldtbl = 'tblold1'
+      oldcol = 'tblcol1'
+      ci = CI.new(oldtbl)
+      assert  !ci.fkey?(oldtbl, oldcol)
+
+      ci.push(oldtbl, oldcol, fkey: true)
+      assert   ci.fkey?(oldtbl, oldcol)
+      assert_equal true, ci.fkeyval(oldtbl, oldcol)
+
+      ci.set_fkeyval_with(oldtbl, oldcol, nil)
+      assert  !ci.fkey?(oldtbl, oldcol)
+    end
+
+    def test_update01
+      oldtbls = %w(tblold1 tblold2 tblold3)
+      oldcols = %w(colold1 colold2 colold21)
+      ci = CI.new(oldtbls[0])
+
+      ci.push(oldtbls[0], oldcols[0])
+      ci.push(oldtbls[0], oldcols[1])
+
+      assert_raises(DbSuitRailsError){ ci.paircolnames('naiyo') }
+      assert_equal oldcols[0..1], ci.oldcolnames(oldtbls[0])
+
+      assert_raises(DbSuitRailsError){ ci.update(oldtbls[1], oldcols[0]) }
+      assert_raises(DbSuitRailsError){ ci.update(oldtbls[0], oldcols[2]) }
+
+      assert_nil               ci.newcolval(oldtbls[0], oldcols[0])
+      ci.update(oldtbls[0], oldcols[0])
+      assert_equal oldcols[0], ci.newcolval(oldtbls[0], oldcols[0])
+
+      # Test update!() - wrapper of push()
+                                       ci.update!(oldtbls[0], oldcols[2])
+      assert_equal oldcols,    ci.oldcolnames(oldtbls[0])
+      assert_equal oldcols[2], ci.newcolval(oldtbls[0], oldcols[2])
+      ci.update!(oldtbls[2], oldcols[0])  # Push for new table.
+
+      # Test update!() - wrapper of update()
+      ci.update!(oldtbls[0], oldcols[1])
+      assert_equal oldcols[1], ci.newcolval(oldtbls[0], oldcols[1])
+      # Test newcolnames()
+      assert_equal oldcols,    ci.newcolnames(oldtbls[0])
+
+      # Test unique_colname
+      assert_equal 'n1_'+oldcols[1], ci.instance_eval{ unique_colname(oldtbls[0], oldcols[0], oldcols[1], useprefix: true) }
+      assert_equal oldcols[1]+'2',   ci.instance_eval{ unique_colname(oldtbls[0], oldcols[0], oldcols[1], useprefix: false) }
+      assert_equal oldcols[1],       ci.instance_eval{ unique_colname(oldtbls[0], oldcols[1], useprefix: false) }
+      # Reserved words: 'type' => 'type_cli',  'MyTable_count' => 'MyTable_count_cli'
+      ['type', oldtbls[0]+'count'].each do |i|
+        ci.push(oldtbls[0], i)
+        assert_equal i+'_cli',   ci.instance_eval{ unique_colname(oldtbls[0], i, useprefix: false) }
+      end
+    end
+
+
+    def test_newcolnames01
+      oldtbls = %w(tblold1 tblprt2 tblprt3)
+      oldcols = %w(id non_id non_id_cli job_id normal)
+      ci = CI.new(oldtbls)
+      oldtbl  = oldtbls[0]
+      oldcols.each do |ec|
+        ci.push(oldtbl, ec, ec) 
+      end 
+      assert_equal oldcols,              ci.newcolnames(oldtbl)
+      assert_equal [nil]+oldcols[1..-1], ci.newcolnames(oldtbl, exclude: 'id', compact: false)
+      assert_equal oldcols[1..-1],       ci.newcolnames(oldtbl, exclude: 'id', compact: true)
+    end
+
+    def test_mk_newcolname01
+      oldtbls = %w(tblold1 tblprt2 tblprt3)
+      oldcols = %w(id non_id non_id_cli job_id normal)
+      ci = CI.new(oldtbls)
+
+      oldtbl  = oldtbls[0]
+      oldcols.each do |ec|
+        ci.push(oldtbl, ec, ec) 
+      end 
+      assert_equal oldcols,       ci.newcolnames(oldtbl)
+      assert_equal 'non_id_cli1', ci.instance_eval{ mk_newcolname(oldtbl, oldcols[1]) }
+
+      ci.update(oldtbl, oldcols[1])
+      ## update does nothing, because everything is already set and fkey is nil.
+      assert_equal oldcols,       ci.newcolnames(oldtbl)
+      assert(    'non_id_cli1' != ci.newcolval(oldtbl, oldcols[1]))
+
+      ## force option
+      ci.update(oldtbl, oldcols[1], force: true)
+      assert_equal 'non_id_cli1', ci.newcolval(oldtbl, oldcols[1])
+
+      ## update!
+      ci.update( oldtbl, oldcols[3])
+      assert(    'job_id_cli' != ci.newcolval(oldtbl, oldcols[3]))
+      ci.update!(oldtbl, oldcols[3])
+      assert_equal 'job_id_cli', ci.newcolval(oldtbl, oldcols[3])
+
+      ## update! with :all
+      assert(      'id_cli'   != ci.newcolval(oldtbl, oldcols[0]))
+      ci.update!(oldtbl, :all)
+      assert(      'id_cli'   == ci.newcolval(oldtbl, oldcols[0]))
+      assert_equal 'id_cli',     ci.newcolval(oldtbl, oldcols[0])
+      assert_equal 'job_id_cli', ci.newcolval(oldtbl, oldcols[3]) # unchanged
+      # p ci.newcolnames(oldtbl)
+      #  => ["id_cli", "non_id_cli2", "non_id_cli", "job_id_cli1", "normal"]
+
+      ## update! with fkey is set
+      fk_job = SqlSkelton::Fkey.new('tblold1', oldcols[3], 'tblprt2', 'eid')
+      ci.set_fkeyval_with(oldtbl, oldcols[3], fk_job)
+      assert_equal 'job_id',     ci.instance_eval{ mk_newcolname(oldtbl, oldcols[3]) }
+
+      assert_equal 'job_id_cli', ci.newcolval(oldtbl, oldcols[3])
+      ci.update(oldtbl, oldcols[3], fkey: fk_job)
+      assert_equal 'job_id',     ci.newcolval(oldtbl, oldcols[3])
+
+      ## Is non_id_cli1 reversed if fkey is set?
+      fk_non = SqlSkelton::Fkey.new('tblold1', oldcols[1], 'tblprt2', 'eid')
+      assert_equal 'non_id_cli1', ci.newcolval(oldtbl, oldcols[1])
+      ci.update!(oldtbl, oldcols[1], fkey: fk_non)
+      assert_equal 'non_id',      ci.newcolval(oldtbl, oldcols[1])
+
+      ## Is id properly set if fkey is set?
+      fk_id  = SqlSkelton::Fkey.new('tblold1', oldcols[0], 'tblprt2', 'eid')
+      assert_equal 'id_cli',    ci.newcolval(oldtbl, oldcols[0])
+      ci.update!(oldtbl, oldcols[0], fkey: fk_id)
+      assert_equal 'id_cli_id', ci.newcolval(oldtbl, oldcols[0])
+    end
+
+    def test_updated_col01
+      oldtbls = %w(tblold1 tblprt2 tblprt3)
+      oldcols = %w(id non_id non_id_cli job_id normal)
+      ci = CI.new()
+
+      assert_equal 'id_cli', ci.updated_col!(oldtbls[0], oldcols[0])
+
+      ## updated_col! not updates if the record exists.
+      ci.push(oldtbls[0], oldcols[3])
+      assert(    'job_id_cli' != ci.updated_col!(oldtbls[0], oldcols[3]))
+
+      ## update! does update.
+      ci.update!(oldtbls[0], oldcols[3])
+      assert_equal 'job_id_cli', ci.updated_col!(oldtbls[0], oldcols[3])
+    end 
+
+    def test_update02
+      ci = CI.new()
+      hs = {"reha_b01"=>{:order=>["id", "tax_id"], "id"=>{:name=>"id_cli", :fkey=>nil}, "tax_id"=>{:name=>"tax_id_cli", :fkey=>nil}}}
+      ci.instance_eval{ @colmaps = hs }
+      fk_now = SqlSkelton::Fkey.new("reha_b01", 'tax_id', "tax_table", "vat_id")
+
+      ci.update!("reha_b01", nil, fkey: nil)  # fkey: fk_now  would issues a WARNING as expected.
+      assert_equal hs, ci.colmaps
+
+      ci.update!("reha_b01", 'id_cli', fkey: fk_now)
+    end
+  end	# class TestUnitSqlSkeltonColIndex < MiniTest::Test
+
+#end	# if $0 == __FILE__
+
+