rigrate 0.0.1

data/lib/rigrate/interface/row.rb

@@ -0,0 +1,69 @@
+# encoding : utf-8
+
+module Rigrate
+  # start
+	module RowStatus
+    NEW     =  :NEW
+    UPDATED =  :UPDATED
+    DELETE  =  :DELETE
+    ORIGIN  =  :ORIGIN
+
+    def test; end
+  end
+  # end
+
+  class Row
+    attr_accessor :data
+    attr_accessor :status
+    attr_accessor :fields
+
+    def initialize(data = [], status = RowStatus::ORIGIN)
+      self.data = data
+      self.status = status
+    end
+
+    def values(*idxes)
+      idxes.map do |idx|
+        self[idx]
+      end
+    end
+
+    # why need in this way?
+    # TODO need rework
+    def +(t_row)
+      t_row.data.each { |item| @data << item }
+      @status = RowStatus::UPDATED
+
+      self
+    end
+
+    def ==(t_row)
+      @data == t_row.data && @status == t_row.status
+    end
+
+    def fill_with_nil(num)
+      @data += Array.new(num)
+
+      self
+    end
+
+    def [](idx)
+      @data[idx]
+    end
+
+    def []=(idx, val, status_force = true)
+      @data[idx] = val
+      @status = RowStatus::UPDATED if status_force
+    end
+
+    def size
+     @data.size
+    end
+
+    def <<(item)
+      @data << item
+
+      self
+    end
+  end
+end

data/lib/rigrate/interface/sqlite.rb

@@ -0,0 +1,106 @@
+# encoding : utf-8
+
+require 'sqlite3'
+
+module Rigrate
+  class Sqlite < Driver
+    def initialize(url = nil)
+      url ||= "sqlite://memory"
+
+      opts = extract_conn_param(URI.parse(url))
+      file = extract_db_path(url)
+
+      @db = ::SQLite3::Database.new(file, opts)
+    end
+
+    def select(sql, *args)
+      target_tbl_name = extract_tbl_from_sql(sql)
+
+      ResultSet.new.tap do |rs|
+        stm = @db.prepare sql, *args
+
+        rs.db = self
+        rs.target_tbl_name = target_tbl_name
+        rs.column_info = statement_fields(stm.columns, stm.types)
+        rs.rows = []
+        stm.execute.each do |row|
+          new_row = Row.new(to_rb_row(row.to_a))
+          yield new_row if block_given?
+          rs.rows << new_row
+        end
+      end
+    end
+
+    def save(resultset)
+      resultset.db = self
+
+      resultset.save!
+    end
+
+    def update(sql, *args)
+      begin
+        stm = @db.prepare sql
+        args.each do |row|
+          if Rigrate::Row === row
+            row = row.data
+          end
+          stm.execute(*row)
+        end
+      rescue Exception => e
+        Rigrate.logger.error("execute SQL [#{sql}] ARGS [#{args.size}] -> #{e.backtrace.join('\n')}")
+        raise DriverError.new("execute error #{e.message}")
+      end
+    end
+    alias :insert :update
+    alias :delete :update
+
+    def primary_key(tbl_name)
+      (@db.table_info(tbl_name).select do |col_hash|
+        col_hash["pk"] == 1
+      end).map do |col_hash|
+        col_hash["name"]
+      end
+    end
+
+    def to_rb_row(row)
+      row.map do |field|
+        if field.nil?
+          field.to_s
+        else
+          field
+        end
+      end
+    end
+
+    def statement_fields(names, types)
+      cols = []
+      names.each_with_index do |name, idx|
+        cols << Column.new(name, types[idx])
+      end
+
+      cols
+    end
+
+    def extract_db_path(path)
+      result = ":memory:"
+
+      if path =~ /sqlite:\/\/(.*)/
+        if $1 == 'memory'
+          result = ":memory:"
+        else
+          result = $1
+        end
+      end
+
+      result
+    end
+
+    def transaction
+      @db.transaction
+    end
+
+    def commit
+      @db.commit
+    end
+  end
+end

data/lib/rigrate/migration.rb

@@ -0,0 +1,89 @@
+# encoding : utf-8
+
+module Rigrate
+  module Migration
+    def union(rs_first_str, rs_second_str)
+      if String === rs_first_str
+        rs_first = instance_eval rs_first_str
+      else
+        rs_first = rs_first_str
+      end
+      rs_second = instance_eval rs_second_str
+
+      if ResultSet === rs_first && ResultSet === rs_second
+        Rigrate.logger.info("start union two ResultSet rs [#{rs_first.size}] <---> rs [#{rs_second.size}]")
+        return rs_first.union rs_second
+      else
+        raise Exception.new('rs_first or rs_second is not a resultset')
+      end
+    end
+
+    def minus(rs_first_str, rs_second_str)
+      if String === rs_first_str
+        rs_first = instance_eval rs_first_str
+      else
+        rs_first = rs_first_str
+      end
+      rs_second = instance_eval rs_second_str
+
+      if ResultSet === rs_first && ResultSet === rs_second
+        Rigrate.logger.info("start minus two ResultSet rs [#{rs_first.size}] <---> rs [#{rs_second.size}]")
+        return rs_first.minus rs_second
+      else
+        raise Exception.new('rs_first or rs_second is not a resultset')
+      end
+    end
+
+    def join(rs_first_str, rs_second_str, condition = nil)
+      if String === rs_first_str
+        rs_first = instance_eval rs_first_str
+      else
+        rs_first = rs_first_str
+      end
+      condition = eval("{#{condition}}") unless condition.nil?
+      rs_second = instance_eval rs_second_str
+
+      if ResultSet === rs_first && ResultSet === rs_second
+        Rigrate.logger.info("start join two ResultSet rs [#{rs_first.size}] <---> rs [#{rs_second.size}]")
+        return rs_first.join(rs_second, condition)
+      else
+        raise Exception.new('rs_first or rs_second is not a resultset')
+      end
+    end
+
+    # migration mode
+    def migrate(rs_first_str, rs_second_str, condition = nil, mode = nil)
+      if String === rs_first_str
+        rs_source = instance_eval rs_first_str 
+      else
+        rs_source = rs_first_str
+      end
+      rs_target = instance_eval rs_second_str
+
+      default_opts = { :mode => Rigrate.config[:mode] }
+      if mode
+        default_opts[:mode] = instance_eval("#{mode}")
+      end
+
+      if ResultSet === rs_source && ResultSet === rs_target
+        return rs_target.migrate_from(rs_source, condition, default_opts)
+      else
+        raise Exception.new('rs_target or rs_source is not a resultset.')
+      end
+    end
+
+    def self_eval(rb_str)
+      instance_eval(rb_str)
+    end
+
+    def data_source(name, conn_str)
+      name = name.to_s
+      ds = DataSource.new(conn_str)
+      variable_name = "@#{name}".to_sym unless name.start_with? "@"
+      instance_variable_set variable_name, ds
+      instance_eval("def #{name}=(x); #{variable_name}=x; end;\
+        def #{name}; #{variable_name}; end")
+    end
+    alias :ds :data_source
+  end
+end

data/lib/rigrate/parser.rb

@@ -0,0 +1,270 @@
+# encoding : utf-8
+
+module Rigrate
+  class Parser
+    include Migration
+    
+    module TokenType
+      FROM      = :FROM_TAG
+      TO        = :TO_TAG
+      UNION     = :UNION_TAG
+      JOIN      = :JOIN_TAG
+      MINUS     = :MINUS_TAG
+      ON        = :ON_TAG
+      USING     = :USING_TAG
+      RUBY_STR  = :RUBY_STR_TAG
+    end
+
+    module StringType
+      DOUBLE_QUOTE = :DQ_STR
+      SINGLE_QUOTE = :SQ_STR
+    end
+
+    module LexStatus
+      INIT        = :INIT_STATUS
+      IN_KEYWORD  = :IN_KEYWORD_STATUS
+      IN_RUBY_CODE= :IN_RUBY_CODE_STATUS
+      IN_RUBY_STR = :IN_RUBY_STR_STATUS
+      IN_COMMENT  = :IN_COMMENT_STATUS
+    end
+
+    Token = Struct.new(:type, :value)
+    attr_accessor :tokens
+
+    ##
+    # load script str -> tokens
+    #  TODO there is a bug need to fixed, when comment str include FROM key word will praser error.
+    def lex(str)
+      status = LexStatus::INIT
+      @tokens = []
+      t_token = ''
+      t_sub_token = ''
+      string_type = StringType::DOUBLE_QUOTE
+      char_arr = str.chars
+      loop do
+        c = char_arr.shift
+
+        if c == nil
+          token = Token.new TokenType::RUBY_STR, t_token
+          @tokens << token
+          break
+        end
+
+        if status == LexStatus::IN_KEYWORD && c =~ /\s/
+          if is_a_token?(t_token)
+            @tokens << (Token.new get_token_type(t_token), t_token)
+            t_token = ''
+            t_sub_token = ''
+            status = LexStatus::INIT
+            next
+          else
+            status = LexStatus::IN_RUBY_CODE
+          end
+        end
+
+        if status != LexStatus::IN_RUBY_CODE && status != LexStatus::IN_RUBY_STR
+          (status = LexStatus::INIT && next) if c =~ /\s/
+        end
+
+        t_token << c
+        t_sub_token << c
+
+        if status == LexStatus::IN_RUBY_CODE ||
+          status == LexStatus::IN_KEYWORD
+          if c == '"'
+            string_type = StringType::DOUBLE_QUOTE
+            status = LexStatus::IN_RUBY_STR
+            next
+          elsif c == "'"
+            string_type = StringType::SINGLE_QUOTE
+            status = LexStatus::IN_RUBY_STR
+            next
+          end
+        end
+
+        if status == LexStatus::IN_RUBY_STR
+          is_matched = false
+          if (string_type == StringType::DOUBLE_QUOTE && c == '"') ||
+             (string_type == StringType::SINGLE_QUOTE && c == "'")
+            is_matched = true
+          end
+          
+          if is_matched && t_token[-1] != "\\"
+            status = LexStatus::IN_RUBY_CODE
+          elsif c =~ /\s/
+            t_sub_token = ''
+          end
+        end
+
+        if status == LexStatus::IN_RUBY_CODE && c =~ /\s/
+          if is_a_token? t_sub_token
+            token = Token.new TokenType::RUBY_STR, t_token.sub(/#{t_sub_token}$/, '')
+            @tokens << token
+            token = Token.new get_token_type(t_sub_token), t_sub_token
+            @tokens << token
+
+            status = LexStatus::INIT
+            t_token = ''
+          end
+
+          t_sub_token = ''
+        end
+
+        if status == LexStatus::INIT
+          status = LexStatus::IN_KEYWORD
+        end
+      end
+
+      self
+    end
+
+    def parsing
+      full_parse tokens.dup
+    end
+
+    #private
+
+    def full_parse(tks)
+      while tks.size > 0
+        parse_rs_or_migrate_exp(tks)
+      end
+    end
+
+    def parse_rs_or_migrate_exp(tks)
+      token = tks.shift
+
+      if token.type == TokenType::RUBY_STR
+        v1 = self_eval token.value
+      else
+        tks.unshift token
+        v1 = parse_migrate_exp(tks)
+      end
+
+      v1
+    end
+
+    def parse_migrate_exp(tks)
+      token = tks.shift
+
+      if token.type == TokenType::FROM
+        v1 = parse_operate_exp(tks)
+
+        sub_token = tks.shift
+        if sub_token.type == TokenType::TO
+          v2 = parse_rs_exp(tks)
+          v3 = parse_condition_exp(tks)
+          v4 = parse_using_exp(tks)
+          migrate(v1, v2, v3, v4)
+
+          # sub_token_1 = tks.shift
+          # if not sub_token_1.nil?
+          #   if sub_token_1.type == TokenType::ON
+          #     cond = tks.shift
+          #     migrate(v1, v2, cond)
+          #   else
+          #     tks.unshift sub_token_1
+          #     migrate(v1, v2)
+          #   end
+          # else
+          #   migrate(v1, v2)
+          # end
+        else
+          raise ParserError.new("Syntax Error: need TO expression")
+        end
+      end
+    end
+
+    def parse_operate_exp(tks)
+      v1 = parse_rs_exp(tks)
+
+      while true
+        token = tks.shift
+        if token.type != TokenType::UNION &&
+           token.type != TokenType::JOIN &&
+           token.type != TokenType::MINUS
+          tks.unshift token
+          break
+        end
+
+        v2 = parse_rs_exp(tks)
+        if token.type == TokenType::UNION
+          v1 = union(v1, v2)
+        elsif token.type == TokenType::MINUS
+          v1 = minus(v1, v2) 
+        elsif token.type == TokenType::JOIN
+          sub_token = tks.shift
+
+          if not sub_token.nil?
+            if sub_token.type == TokenType::ON
+              cond = tks.shift
+              v1 = join(v1, v2, cond.value)
+            else
+              tks.unshift sub_token
+              v1 = join(v1, v2)
+            end
+          else
+            v1 = join(v1, v2)
+          end
+        end
+      end
+
+      v1
+    end
+
+    def parse_condition_exp(tks)
+      token = tks.shift
+      return if token.nil?
+
+      if token.type == TokenType::ON
+        v1 = parse_rs_exp(tks)
+
+        if v1.nil?
+          raise ParserError.new("ON expression should end with a [RUBY_STR]")
+        end
+      else
+        tks.unshift token
+        return
+      end
+
+      v1
+    end
+
+    def parse_using_exp(tks)
+      token = tks.shift
+      return if token.nil?
+
+      if token.type == TokenType::USING
+        v1 = parse_rs_exp(tks)
+
+        if v1.nil?
+          raise ParserError.new("USING expression should end with a [RUBY_STR]")
+        end
+      else
+        tks.unshift token
+        return
+      end
+
+      v1
+    end
+
+    # TODO return value should change
+    def parse_rs_exp(tks)
+      token = tks.shift
+      return if token.nil?
+
+      if token.type == TokenType::RUBY_STR
+        return token.value
+      else
+        raise ParserError.new("Invalid Syntax")
+      end
+    end
+
+    def is_a_token?(str)
+      TokenType.constants.include? str.strip.upcase.to_sym
+    end
+
+    def get_token_type(str)
+      TokenType.const_get(str.strip.upcase) 
+    end
+  end
+end