arxutils_sqlite3 0.1.37

data/lib/arxutils_sqlite3/hier.rb

@@ -0,0 +1,218 @@
+module Arxutils_Sqlite3
+  # 階層処理
+  class HierOp
+    # 階層処理を付加したいフィールド名(未使用か？)
+    attr_reader :field_name
+    # '/'が区切り文字の文字列で階層処理を実現するクラスの階層構造を表す文字列を持つメソッド／アトリビュートを表すシンボル
+    attr_reader :hier_symbol
+    # '/'が区切り文字の文字列で階層処理を実現するクラスのクラス名(DB中のテーブルに対応するActiveRecordの子クラス)
+    # シンボルhier_symbolで指定できるメソッド／アトリビュート(string)を持つ。
+    # nameというメソッド／アトリビュート(string)を持つ。"'/'を区切り文字として持つ階層を表す文字列
+    # registerメソッドを呼び出す時は、hier_symbolのみを指定してcreate出来なければならない（そうでなければSQLの制約違反発生）
+    attr_reader :base_klass
+    # '/'が区切り文字の文字列で階層処理を実現するクラスのカレントに対応するクラス名(DB中のテーブルに対応するActiveRecordの子クラス)
+    attr_reader :current_klass
+    # '/'が区切り文字の文字列で階層処理を実現するクラスのインバリッドに対応するクラス名(DB中のテーブルに対応するActiveRecordの子クラス)
+    attr_reader :invalid_klass
+    # IDの親子関係で階層処理を実現するクラス名(DB中のテーブルに対応するActiveRecordの子クラス)
+    # parent_id(integer) , child_id(integer) , leve(integer)というメソッド／アトリビュートを持つ
+    attr_reader :hier_klass
+
+    # 初期化
+    def initialize(field_name, hier_symbol, _hier_name, base_klass, hier_klass, current_klass, invalid_klass)
+      # 階層処理を付加したいフィールド名
+      @field_name = field_name
+      # '/'が区切り文字の文字列で階層処理を実現するクラスの階層構造を表す文字列を持つメソッド／アトリビュートを表すシンボ
+      @hier_symbol = hier_symbol
+      # '/'が区切り文字の文字列で階層処理を実現するクラスのクラス名(DB中のテーブルに対応するActiveRecordの子クラス)
+      @base_klass = base_klass
+      # '/'が区切り文字の文字列で階層処理を実現するクラスのカレントに対応するクラス名(DB中のテーブルに対応するActiveRecordの子クラス)
+      @current_klass = current_klass
+      # '/'が区切り文字の文字列で階層処理を実現するクラスのインバリッドに対応するクラス名(DB中のテーブルに対応するActiveRecordの子クラス)
+      @invalid_klass = invalid_klass
+      # IDの親子関係で階層処理を実現するクラス名(DB中のテーブルに対応するActiveRecordの子クラス)
+      #  print_id(integer), child_id(integer), level(integer)
+      @hier_klass = hier_klass
+    end
+
+    # 指定した階層(階層を/で区切って表現)のアイテムをbase_klassから削除
+    def delete(hier)
+      # 子として探す
+      id = nil
+      base = @base_klass.find_by({ @hier_symbol => hier })
+      if base
+        delete_at(base.org_id)
+        @base_klass.delete_at(base.id)
+      end
+      id
+    end
+
+    def delete_by_id(id)
+      base = @base_klass.find_by(org_id: id)
+      delete_at(id)
+      @base_klass.delete_at(base.id)
+    end
+
+    # 文字列で指定した階層を移動
+    def move(src_hier, dest_parent_hier)
+      # dest_parent_hierがsrc_hierの子であれば(=src_hierがdest_parent_hierの先頭からの部分文字列である)何もせずエラーを返す
+      escaped = Regexp.escape(src_hier)
+      src_re = Regexp.new(%(^#{escaped}))
+      ret = (src_re =~ dest_parent_hier)
+      # 自身の子への移動はエラーとする
+      return false if ret
+
+      src_row_item = @base_klass.where(name: src_hier)
+      src_num = src_row_item.id
+      # srcが子である(tblでは項目を一意に指定できる)tblでの項目を得る
+      src_row = @hire_klass.find_by(child_id: src_num)
+
+      dest_parent_row_item = @base_klass.find_by(name: dest_parent_hier)
+      dest_parent_num = if dest_parent_row_item
+                          dest_parent_row_item.id
+                        else
+                          register(dest_parent_hier)
+                        end
+      dest_parent_level = get_level_by_child(dest_parent_num)
+
+      # srcの親をdest_parentにする
+      src_row.parent_id = dest_parent_num
+      src_row.save
+      # destに移動後のsrcの子のレベルを調整する
+      level_adjust(src_row, dest_parent_level)
+      # destに移動後のsrcのhierを再設定
+      set_hier(src_row_item, make_hier(dest_parent_row_item.name, get_name(src_row_item)))
+      src_row_item.save
+      # destに移動後のsrcの子のhierを調整する
+      hier_adjust(src_row_item)
+
+      true
+    end
+
+    # 配列で指定した階層を親の階層としてhier_klassに登録
+    def register_parent(hier_ary, child_num, level)
+      hier_ary.pop
+      parent_hier_ary = hier_ary
+      parent_hier = parent_hier_ary.join("/")
+      parent_num = register(parent_hier)
+      hs = { parent_id: parent_num, child_id: child_num, level: level }
+      @hier_klass.create(hs)
+    end
+
+    # 文字列で指定した階層(/を区切り文字として持つ)をhier_klassに登録
+    def register(hier)
+      hier_ary = hier.split("/")
+      level = get_level_by_array(hier_ary)
+
+      # もしhier_aryがnilだけを1個持つ配列、または空文字列だけを1個もつ配列であれば、hier_nameは空文字列になる
+      item_row = @current_klass.find_by({ @hier_symbol => hier })
+      if item_row
+        new_num = item_row.org_id
+        if level.zero?
+          unless @hier_klass.find_by(child_id: new_num)
+            hs = { parent_id: new_num, child_id: new_num, level: level }
+            @hier_klass.create(hs)
+          end
+        else
+          register_parent(hier_ary, new_num, level) unless @hier_klass.find_by(child_id: new_num)
+        end
+      else
+        # @base_klassがhierだけでcreateできる場合は（他にフィールドがnot_nullでないか）、ここに来てもよい。
+        # そうでなければ、SQLの制約違反が発生するため、ここに来ることを避けなければならない。
+        # （あらかじめここが呼ばれないようにdatabaseに登録済みにしておかなければならない。）
+        new_category = @base_klass.create({ @hier_symbol => hier })
+        new_num = new_category.id
+        if level.zero?
+          unless @hier_klass.find_by(child_id: new_num)
+            hs = { parent_id: new_num, child_id: new_num, level: level }
+            @hier_klass.create(hs)
+          end
+        else
+          register_parent(hier_ary, new_num, level)
+        end
+      end
+      new_num
+    end
+
+    private
+
+    # IDで指定した階層を削除
+    def delete_at(num)
+      # 子として探す
+      hier = @hier_klass.find_by(child_id: num)
+      level = hier.level
+      parent_id = hier.parent_id
+      base = @base_klass.find_by(ord_id: num)
+
+      parent_base = @base_klass.find_by(ord_id: parent_id)
+      parent_hier_string = parent_base.__send__ @hier_symbol
+
+      # 属する子を探す
+      children_hier = @hier_klass.where(parent_id: num)
+      # 属する子の階層レベルを調整する(削除するのでlevel - 1になる)
+      children_hier.map { |x| level_adjust(x, level - 1) }
+      # 属する子の親を、親の親にする
+      children_hier.map do |x|
+        x.parent_id = parent_id
+        x.save
+      end
+      # 属する子のhierを調整する
+      children_hier.map do |x|
+        child_base = @base_klass.find_by(org_id: x.child_id)
+        name = get_name(child_base)
+        child_base.hier = make_hier(parent_hier, name)
+        child_base.save
+        hier_adjust(child_base)
+      end
+    end
+
+    # 配列で指定した階層のレベルを得る
+    def get_level_by_array(hier_ary)
+      level = hier_ary.size - 1
+      level = 0 if level.negative?
+      level
+    end
+
+    # 階層を表すデータ構造から階層の名前を得る
+    def get_name(items_row)
+      items_row ? items_row.name.split("/").pop : ""
+    end
+
+    # 階層を表すデータ構造で指定された階層の下部階層の名前を調整する
+    def hier_adjust(base)
+      parent_hier_string = base.__send__ @hier_symbol
+      parent_num = base.org_id
+
+      tbl_rows = @hier_klass.where(parent_id: parent_num)
+      return if tbl_rows.size.zero?
+
+      tbl_rows.map do |x|
+        child_num = x.child_id
+        item_row = @base_klass.find_by(org_id: child_num)
+        item_row.hier = make_hier(parent_hier_string, get_name(item_row))
+        item_row.save
+        hier_adjust(item_row)
+      end
+    end
+
+    # 指定項目と、その子のlevelを調整
+    def level_adjust(row, parent_level)
+      row.level = parent_level + 1
+      row.save
+      child_rows = @hier_klass.where(parent_id: row.id)
+      return if child_rows.size.zero?
+
+      child_rows.map { |x| level_adjust(x, row.level) }
+    end
+
+    # IDで指定された階層のレベルを得る
+    def get_level_by_child(num)
+      @hier_klass.find_by(child_id: num).level
+    end
+
+    # 文字列で指定された親の階層の下の子の名前から、子の名前を作成
+    def make_hier(parent_hier, name)
+      [parent_hier, name].join("/")
+    end
+  end
+end

data/lib/arxutils_sqlite3/migrate.rb

@@ -0,0 +1,225 @@
+#require "arxutils_sqlite3"
+require "ykutils"
+require "fileutils"
+#require "active_support"
+require "active_record"
+require "active_record/migration"
+require "pp"
+
+# ActiveRecord用ユーティリティモジュール
+module Arxutils_Sqlite3
+  ##
+  # migrateに必要なファイルをテンプレートから作成し、migarteを実行する
+  class Migrate
+    # migrate用スクリプトファイル名の先頭の番号の間隔
+    FILENAME_COUNTER_STEP = 10
+
+    # migrateに必要なファイルをテンプレートから作成し、migarteを実行する
+    def self.migrate(dbconnect, db_scheme_ary, migrate_cmd, relation, opts)
+      mig = Migratex.new(dbconnect, db_scheme_ary, relation, opts)
+      # DB構成情報の生成
+      # dbconfigのテンプレートは内容が固定である。
+      if  migrate_cmd == "makeconfig"
+        mig.make_dbconfig(opts)
+        return
+      end
+      # remigrateが指定されれば、migrate用スクリプトとDB構成ファイルとDBファイルを削除する
+      if migrate_cmd == "delete"
+        mig.delete_migrate_config_and_db
+        return
+      end
+      # マイグレーション用スクリプトの生成、relationのクラス定義ファイルの生成、migrate実行
+      mig.process
+    end
+
+    # migrationのスクリプトをファイル出力する
+    def output_all_script(mig, db_scheme_ary)
+      # スキーマ設定配列から、migrate用のスクリプトを作成する
+      db_scheme_ary.map { |x| mig.make_script_group(x) }.flatten(1).each_with_index do |data, index|
+        idy = (index + 1) * FILENAME_COUNTER_STEP
+        mig.output_script(idy, *data)
+      end
+    end
+
+    # migrate用のスクリプトの内容をテンプレートから作成し、ファイルに出力し、migrateを実行する
+    class Migratex
+      # DB接続までの初期化を行うDbinitクラスのインスタンス
+      #attr_reader :dbinit
+
+      # migrate用のスクリプトの生成、migrateの実行を行うmigratexの生成
+      def initialize(dbconnect, db_scheme_ary, relation, opts)
+        # DB接続までの初期化を行うDbinitクラスのインスタンス
+        @dbconnect = dbconnect
+        # 生成するDB構成情報ファイルパス
+        @dbconfig_dest_path = @dbconnect.dbconfig_dest_path
+        # 参照用DB構成情報ファイル名
+        @dbconfig_src_fname = @dbconnect.dbconfig_src_fname
+
+        # migrate用スクリプトの出力先ディレクトリ名
+        @migrate_dir = @dbconnect.migrate_dir
+        # テンプレートファイル格納ディレクトリ名
+        @src_path = Arxutils_Sqlite3::TEMPLATE_RELATION_DIR
+        # 構成ファイル格納ディレクトリ
+        @src_config_path = Arxutils_Sqlite3::TEMPLATE_CONFIG_DIR
+        # データベーススキーマ定義配列
+        @db_scheme_ary = db_scheme_ary
+        # リレーション指定
+        @relation = relation
+        # オプション指定
+        @opts = opts
+      end
+
+      # マイグレート用スクリプト、DB構成情報ファイル、DBファイルの削除
+      def delete_migrate_config_and_db
+        migrate_dir = @dbconnect.migrate_dir
+        dest_config_dir = @dbconnect.dest_config_dir
+        db_dir = @dbconnect.db_dir
+
+        FileUtils.rm(Dir.glob(File.join(migrate_dir, "*"))) if migrate_dir
+        FileUtils.rm(Dir.glob(File.join(dest_config_dir, "*")))
+        Dir.glob(File.join(db_dir, "*")).each do |x|
+          # puts x
+          FileUtils.rm(x) if File.file?(x)
+        end
+      end
+
+      # マイグレーション用スクリプトの生成、relationのクラス定義ファイルの生成、migrate実行
+      def process
+        # migrationのスクリプトをファイル出力する
+        output_all_script
+
+        # relationを表すクラス定義のファイルの内容を生成
+        content_array = make_content_array
+        # p "content_array=#{content_array}"
+        # 複数形のクラス名を集める
+        count_class_plurals = content_array.reject do |x|
+          x[:need_count_class_plural].nil?
+        end
+        need_count_class_plural = count_class_plurals.map { |x| x[:need_count_class_plural] }
+        # relationのmigrateが必要であれば、それをテンプレートファイルから作成して、スクリプトの内容として追加する
+        if content_array.find { |x| !x.nil? }
+          # p "####### 1"
+          data_count = {
+            count_classname: "Count",
+            need_count_class_plural: need_count_class_plural
+          }
+          # p "data_count=#{data_count}"
+          ary = content_array.collect { |x| x[:content] }.flatten
+          count_content = convert_count_class_relation(data_count, "relation_count.tmpl")
+          ary.unshift(count_content)
+          content_array = ary
+        end
+        # relationのスクリプトを作成
+        output_relation_script(content_array, @relation)
+      end
+
+      # migrationのスクリプトをファイル出力する
+      def output_all_script
+        # スキーマ設定配列から、migrate用のスクリプトを作成する
+        @db_scheme_ary.map { |x| make_script_group(x) }.flatten(1).each_with_index do |data, index|
+          idy = (index + 1) * FILENAME_COUNTER_STEP
+          output_script(idy, *data)
+        end
+      end
+
+      # relationを表すクラス定義のファイルの内容を生成
+      def make_content_array
+        # スキーマ設定配列から、relationのmigrate用のスクリプトの内容(ハッシュ形式)の配列を作成する
+        relations = @db_scheme_ary.map do |x|
+          make_relation(x, "count")
+        end
+        relations.select { |x| x.size.positive? }
+      end
+
+      # Countクラス用のrelationのスクリプトの内容に変換
+      def convert_count_class_relation(data, src_fname)
+        convert(data, @src_path, src_fname)
+      end
+
+      # テンプレートファイルからスクリプトの内容に変換
+      def convert(data, src_dir, src_fname)
+        arx = Arx.new(data, File.join(src_dir, src_fname))
+        # 指定テンプレートファイルからスクリプトの内容に作成
+        arx.create
+      end
+
+      # データベース構成ファイルをテンプレートから生成する
+      def make_dbconfig(data)
+        content = convert(data, @src_config_path, @dbconfig_src_fname)
+        File.open(
+          @dbconfig_dest_path, "w:utf-8") do |f|
+          f.puts(content)
+        end
+      end
+
+      # 英子文字で表現したクラス名が、countを表していなければ、relationを
+      # 英子文字で表現したクラス名が、countを表していれが、空のハッシュを返す
+      # スキーマでbase, noitem以外のフィールドが指定されていれば、そのフィールドに対するrelationの設定の内容を返す
+      def make_relation(data, count_classname_downcase)
+        if data[:classname_downcase] == count_classname_downcase
+          {}
+        else
+          # 指定フィールドのフィールド名に対応したテンプレートファイルを用いて、relation設定を作成
+          data[:flist].each_with_object({ content: [], need_count_class: nil }) do |field_name, s|
+            case field_name
+            when "base", "noitem"
+              name_base = "relation"
+              # data[:relation]がnilに設定されていたら改めて空の配列を設定
+              data[:relation] = [] unless data[:relation]
+            else
+              data[:count_classname_downcase] = count_classname_downcase
+              name_base = "relation_#{field_name}"
+              s[:need_count_class_plural] ||= data[:plural]
+            end
+            # テンプレートファイルからスクリプトの内容を作成
+            content = convert(data, @src_path, "#{name_base}.tmpl")
+            s[:content] << content
+          end
+        end
+      end
+
+      # スキーマ設定からmigarte用スクリプトの内容を生成
+      def make_script_group(data)
+        #p data
+        data[:flist].map {
+          |kind|
+          [kind,
+            convert(data, @src_path, "#{kind}.tmpl"),
+            data[:classname_downcase]
+            ] }
+      end
+
+      # migrationのスクリプトをファイル出力する
+      def output_script(idy, kind, content, classname_downcase)
+        additional = case kind
+                     when "base", "noitem"
+                       ""
+                     else
+                       kind
+                     end
+        fname = File.join(@migrate_dir, format("%03d_create_%s%s.rb", idy, additional, classname_downcase))
+        File.open(fname, "w", **{ encoding: Encoding::UTF_8 }) do |f|
+          f.puts(content)
+        end
+      end
+
+      # relationのスクリプトをファイル出力する
+      def output_relation_script(content_array, opts)
+        # pp "=="
+        # pp opts
+        dir = opts[:dir]
+        fname = opts[:filename]
+        fpath = File.join(dir, fname)
+        File.open(fpath, "w") do |file|
+          opts[:module].map { |mod| file.puts("module #{mod}") }
+          content_array.map do |x|
+            file.puts x
+            file.puts ""
+          end
+          opts[:module].map { |_mod| file.puts("end") }
+        end
+      end
+
+    end
+  end
+end

data/lib/arxutils_sqlite3/transactstate.rb

@@ -0,0 +1,76 @@
+module Arxutils_Sqlite3
+  # 簡易的なトランザクション処理
+  class TransactState
+    # 対象ID群
+    attr_reader :ids
+    # 状態
+    attr_accessor :state
+
+    # 初期化
+    def initialize
+      # 対象ID群
+      @ids = []
+      # 状態
+      @state = :NONE
+    end
+
+    # :TRACE状態の時のみ対象IDとして追加
+    def add(xid)
+      @ids << xid if @state == :TRACE
+    end
+
+    # 対象ID群をクリア
+    def clear
+      @ids = []
+    end
+
+    # 処理の必要性の確認
+    def need?
+      @ids.size.positive?
+    end
+  end
+
+  # 複数の簡易的なトランザクション処理
+  class TransactStateGroup
+    # 初期化
+    def initialize(*names)
+      @names = names
+      @state = :NONE
+      @inst = {}
+      names.map { |x| @inst[x] = TransactState.new }
+    end
+
+    # 処理の必要性の確認
+    def need?
+      @state != :NONE
+    end
+
+    # 状態の一括設定
+    def set_all_inst_state
+      @inst.map { |x| x[1].state = @state }
+    end
+
+    # 状態を:TRACEに一括設定
+    def trace
+      @state = :TRACE
+      set_all_inst_state
+    end
+
+    # 状態を:NONEに一括設定
+    def reset
+      @state = :NONE
+      set_all_inst_state
+    end
+
+    # 指定名の状態を返す
+    def method_missing(name, _lang = nil)
+      @inst[name]
+    end
+
+    # 指定名に対応するかを返す
+    def respond_to_missing?(symbol)
+      name = symbol.to_s
+      @names.include?(name)
+    end
+  end
+end

data/lib/arxutils_sqlite3/version.rb

@@ -0,0 +1,4 @@
+module Arxutils_Sqlite3
+  # バージョン番号
+  VERSION = "0.1.37".freeze
+end

data/lib/arxutils_sqlite3.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require "ykutils"
+require "ykxutils"
+
+require "bigdecimal"
+require "active_support"
+require "active_support/core_ext"
+require "active_record"
+require "pathname"
+
+require_relative "arxutils_sqlite3/version"
+require_relative "arxutils_sqlite3/arx"
+require_relative "arxutils_sqlite3/transactstate"
+require_relative "arxutils_sqlite3/hier"
+require_relative "arxutils_sqlite3/migrate"
+require_relative "arxutils_sqlite3/dbutil"
+
+module Arxutils_Sqlite3
+  TOP_DIR = Pathname(__FILE__).parent
+  TEMPLATE_DIR = TOP_DIR.join("template")
+  TEMPLATE_RELATION_DIR = TEMPLATE_DIR.join("relation")
+  TEMPLATE_CONFIG_DIR = TEMPLATE_DIR.join("config")
+  CONFIG_DIR = "config".freeze
+  DEST_CONFIG_DIR = Pathname.new("config")
+  DB_SCHEME_DIR = TEMPLATE_RELATION_DIR.join("db_scheme")
+  DB_SCHEME_FILE = DB_SCHEME_DIR.join("db_scheme.yml")
+  OPTS_FILE_NAME = "opts.rb"
+  OPTS_FILE_NAME_2 = "opts"
+  DBSETUP_FILE_NAME = "dbsetup.rb"
+  DBSETUP_FILE_NAME_2 = "dbsetup"
+  OPTS_FILE = DB_SCHEME_DIR.join(OPTS_FILE_NAME)
+  DBSETUP_FILE = DB_SCHEME_DIR.join(DBSETUP_FILE_NAME)
+  DEST_OPTS_FILE = DEST_CONFIG_DIR.join(OPTS_FILE_NAME)
+  DEST_OPTS_FILE_2 = DEST_CONFIG_DIR.join(OPTS_FILE_NAME_2)
+  DEST_DBSETUP_FILE = DEST_CONFIG_DIR.join(DBSETUP_FILE_NAME)
+  DEST_DBSETUP_FILE_2 = DEST_CONFIG_DIR.join(DBSETUP_FILE_NAME_2)
+
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/template/config/mysql.tmpl

@@ -0,0 +1,29 @@
+# MySQL
+#   gem install mysql2
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem 'sqlite3'
+#
+default_env: &default
+  adapter: mysql2
+  host:    localhost
+  username: 
+  password: 
+  database: <%= @data[:dbname] %>
+  pool: 5
+  timeout: 5000
+
+development:
+  <<: *default
+  database: <%= @data[:dbname] %>_developement
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  <<: *default
+  database: <%= @data[:dbname] %>_test
+
+production:
+  <<: *default
+  database: <%= @data[:dbname] %>_production

data/lib/template/config/sqlite3.tmpl

@@ -0,0 +1,26 @@
+# SQLite version 3.x
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem 'sqlite3'
+#
+default_env: &default
+  adapter: sqlite3
+  pool: 5
+  timeout: 5000
+  database: <%= @data[:db_dir] %>/production.sqlite3
+
+development:
+  <<: *default
+  database: <%= @data[:db_dir] %>/development.sqlite3
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  <<: *default
+  database: <%= @data[:db_dir] %>/test.sqlite3
+
+production:
+  <<: *default
+  database: <%= @data[:db_dir] %>/production.sqlite3

data/lib/template/relation/base.tmpl

@@ -0,0 +1,14 @@
+class Create<%= @data[:classname] %> < ActiveRecord::Migration[<%= @data[:ar_version] %>]
+  def self.up
+    create_table :<%= @data[:plural] %> do |t|
+<% @data[:ary].each do |x| %>    
+      t.column :<%= x.name %>, :<%= x.type %>, :null => <%= x.null %>
+<% end %>
+      t.timestamps  null: false
+    end
+  end
+
+  def self.down
+    drop_table :<%= @data[:plural] %>
+  end
+end

data/lib/template/relation/current.tmpl

@@ -0,0 +1,15 @@
+class CreateCurrent<%= @data[:classname_downcase] %> < ActiveRecord::Migration[<%= @data[:ar_version] %>]
+  def self.up
+    execute <<-SQL
+      CREATE VIEW current<%= @data[:plural] %> AS SELECT id as org_id,
+<%= @data[:ary].map{|x| x.name }.join(" , ") %>    
+      FROM <%= @data[:plural] %> where not exists (select * from invalid<%= @data[:plural] %> where invalid<%= @data[:plural] %>.org_id = <%= @data[:plural] %>.id )
+    SQL
+  end
+
+  def self.down
+    execute <<-SQL
+      DROP VIEW current<%= @data[:plural] %>
+    SQL
+  end
+end