flydata 0.6.3 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45df6073e7d4b59b307a695058cd1ee70366eb89
-  data.tar.gz: cdac2f4feb8dfdd4531c14f97a38f1dd2df91f48
+  metadata.gz: 12c8fd94c861658f352698075555d8a868d3ca6d
+  data.tar.gz: ff5061d23bb1cee12430d471834131034bc925b2
 SHA512:
-  metadata.gz: df38e5c265ee0b0e4f9cfcde1a6f219db1fa0b4df013d4f79d1a9dc648d4d5684210560153d91ace7a5267cde76c4d26d00d5ee95e757c0acee2867b4ea6be9c
-  data.tar.gz: 7ec85d6e13314f445649d64c1769597f2fd192d35c5a6b76b42043accfca4be1d2fc5d95b7c40de7f00e462876bd67076e0102efa0634f755af4d88ebba2f2f0
+  metadata.gz: 0c956f29080dbc9a517a08b2b865aceef102f26a509061cb2152ee519d0f2d99794348546001d09c48f9b7ae2ed8015b12a593520780ffe1517614a9fc1dedde
+  data.tar.gz: 731ecc427a94b7aab2afb638c8dbbb532b6055f080ed938574d26a19b187478d1fecbb75dc1c09a066b816983dfb0611711a27b8123b14370efda8128f535da0

data/Rakefile

@@ -36,8 +36,8 @@ task :default => :spec
 require 'rake/extensiontask'
 
 Rake::ExtensionTask.new "dump_parser_ext" do |ext|
-  ext.ext_dir = "ext/flydata/parser/mysql"
-  ext.lib_dir = "lib/flydata/parser/mysql"
+  ext.ext_dir = "ext/flydata/source_mysql/parser"
+  ext.lib_dir = "lib/flydata/source_mysql/parser"
 end
 
 Rake::ExtensionTask.new "json_ext" do |ext|

data/VERSION

@@ -1 +1 @@
-0.6.3
+0.6.4

data/bin/fdredshift

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'rubygems'
+require 'flydata'
+require 'shellwords'
+
+# Write your code from here
+class FdRedshift < Flydata::Command::Base
+  def run(*args)
+    validate_required_values
+    rs_info = retrieve_redshift_info
+    cmd = generate_psql_command(rs_info, args)
+    $stderr.puts "cmd:#{cmd}" if ENV['FLYDATA_DEBUG']
+    if $stdin.tty?
+      # interactive shell
+      system cmd
+    else
+      # execute queries given to $stdin
+      Open3.popen2e(cmd) do |i, o, wt|
+        $stdin.each_line do |line|
+          i.print line
+        end
+        i.close
+        while line = o.gets
+          print line
+        end
+      end
+    end
+  end
+
+  def generate_psql_command(rs_info,args)
+    password = "PGPASSWORD=#{rs_info['password'].shellescape}"
+    cmd = "psql"
+    dbname = "-d #{rs_info['dbname'].shellescape}"
+    host = "-h #{rs_info['host'].shellescape}"
+    port = "-p #{rs_info['port'].to_s.shellescape}"
+    username = "-U #{rs_info['username'].shellescape}"
+    options = args.join(' ')
+    #"PGPASSWORD='#{password}' psql -d '#{dbname}' -h '#{host}' -p '#{port}' -U '#{username}'"
+    [password,cmd,dbname,host,port,username,options].join(' ')
+  end
+
+  def retrieve_redshift_info(token = Flydata::Credentials.new.token)
+    admin_agent_key = read_admin_agent_api_key
+    headers = {'AUTHORIZATION' => %Q|Token token="#{admin_agent_key}"|}
+
+    host = read_admin_agent_api_host
+    path = "/api/v1/redshift_clusters/show_default?user_auth_token=#{token}"
+    url = host + path
+    response = RestClient::Request.execute(method: :get,
+                                           url: url,
+                                           headers: headers)
+    JSON.parse(response)
+  end
+
+  def read_admin_agent_api_host
+    ENV['FLYDATA_AGENT_FLYDATA_ADMIN_API_HOST']
+  end
+
+  def read_admin_agent_api_key
+    ENV['FLYDATA_AGENT_FLYDATA_ADMIN_API_KEY']
+  end
+
+  def validate_required_values
+    unless read_admin_agent_api_host && read_admin_agent_api_key
+      $stderr.puts "ERROR! This command is not supported in your environment."
+      exit 1
+    end
+  end
+end
+
+
+args = ARGV.dup
+ARGV.clear # for 'gets'
+FdRedshift.new().run(args)

data/circle.yml

@@ -12,7 +12,7 @@ dependencies:
     - sudo apt-get install -y libboost-thread1.54.0
     - sudo apt-get install -y libboost-thread1.54-dev
     - sudo apt-get install -y libboost1.54-dev
-    - wget --no-check-certificate -O mysql-replication-listener.zip https://github.com/hapyrus/mysql-replication-listener/archive/master.zip
+    - wget --no-check-certificate -O mysql-replication-listener.zip https://github.com/flydata/mysql-replication-listener/archive/master.zip
     - unzip mysql-replication-listener.zip
     - cd mysql-replication-listener-master; cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr -DBoost_NO_BOOST_CMAKE=ON .; make -j4; sudo make install
 

data/ext/flydata/{parser/mysql → source_mysql/parser}/dump_parser_ext.cpp

@@ -97,9 +97,9 @@ static VALUE rb_insert_parser_parse2(VALUE self, VALUE sql)
 void Init_dump_parser_ext()
 {
   VALUE mFlydata = rb_define_module("Flydata");
-  VALUE mParser  = rb_define_module_under(mFlydata, "Parser");
-  VALUE mMysql   = rb_define_module_under(mParser, "Mysql");
-  VALUE cMysqlDumpParser = rb_define_class_under(mMysql, "MysqlDumpParser", rb_cObject);
+  VALUE mSourceMysql   = rb_define_module_under(mFlydata, "SourceMysql");
+  VALUE mParser  = rb_define_module_under(mSourceMysql, "Parser");
+  VALUE cMysqlDumpParser = rb_define_class_under(mParser, "MysqlDumpParser", rb_cObject);
   VALUE cInsertParser = rb_define_class_under(cMysqlDumpParser, "InsertParser", rb_cObject);
 
   rb_define_private_method(cInsertParser, "_parse2", __F(&rb_insert_parser_parse2), 1);

data/ext/flydata/source_mysql/parser/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile "flydata/source_mysql/parser/dump_parser_ext"

data/flydata-core/lib/flydata-core/mysql/binlog_pos.rb

@@ -2,17 +2,26 @@ module FlydataCore
 module Mysql
 
 class BinlogPos
+  include Comparable
   def initialize(binlog_str_or_filename_or_hash, binlog_pos = nil)
     arg = binlog_str_or_filename_or_hash
     if binlog_pos
       @pos = binlog_pos
       @filename = arg
     elsif arg.kind_of?(String)
-      @filename, @pos = arg.split("\t")
+      if arg == "-"
+        set_empty
+      else
+        @filename, @pos = arg.split("\t")
+      end
     elsif arg.kind_of?(Hash)
-      @pos = arg[:pos]
-      @filename = arg[:filename]
-      @filename ||= arg[:binfile]
+      if arg[:filename] == "-" || arg[:binfile] == "-"
+        set_empty
+      else
+        @pos = arg[:pos]
+        @filename = arg[:filename]
+        @filename ||= arg[:binfile]
+      end
     end
     if @filename.nil? || @pos.nil?
       raise "Invalid initialize argument (#{arg}, #{binlog_pos})"
@@ -22,50 +31,43 @@ class BinlogPos
 
   attr_reader :filename, :pos
 
+  def empty?
+    @filename && @filename == "-"
+  end
+
   def <=>(other_pos)
     if other_pos.nil?
       raise ArgumentError.new("comparison of BinlosPos with nil failed")
     end
 
     other_pos = BinlogPos.new(other_pos) unless other_pos.kind_of?(BinlogPos)
-
-    if @filename < other_pos.filename
-      -1
-    elsif @filename == other_pos.filename
-      if @pos < other_pos.pos
-        -1
-      elsif @pos == other_pos.pos
-        0
-      else
-        1
-      end
+    if empty? && other_pos.empty?
+      return 0
+    elsif empty? || other_pos.empty?
+      raise ArgumentError.new("comparison with empty BinlogPos failed")
     else
-      1
+      (@filename <=> other_pos.filename) == 0 ? (@pos <=> other_pos.pos) : (@filename <=> other_pos.filename)
     end
   end
-  def <(other_pos)
-    self.<=>(other_pos) < 0
-  end
-  def <=(other_pos)
-    self.<=>(other_pos) <= 0
-  end
+
   def ==(other_pos)
     return false if other_pos.nil?
+    return @filename == other_pos.filename if empty? || other_pos.empty?
     self.<=>(other_pos) == 0
   end
-  def !=(other_pos)
-    !self.==(other_pos)
-  end
-  def >(other_pos)
-    self.<=>(other_pos) > 0
-  end
-  def >=(other_pos)
-    self.<=>(other_pos) >= 0
-  end
 
   def to_s
-    "#{@filename}\t#{@pos}"
+    empty? ? "-" : "#{@filename}\t#{@pos}"
   end
+
+  private
+  def set_empty
+    # @filename == "-" is the definition of `empty`. @pos could be anything but nul
+    @filename = "-"
+    @pos = -1
+  end
+
+
 end
 
 end

data/flydata-core/lib/flydata-core/mysql/compatibility_checker.rb

@@ -226,6 +226,26 @@ EOT
       end
     end
 
+    class MySqlVersion57CompabilityChecker < MysqlCompatibilityChecker
+
+      def create_query(option = @option)
+        "show variables where Variable_name in ('version','show_compatibility_56');"
+      end
+
+      def check_result(result, option = @option)
+        mysqlversion = nil
+        compability56 = nil
+        result.each { |value|
+          mysqlversion = value['Value'] if value['Variable_name'] == 'version'
+          compability56 = value['Value'] if value['Variable_name'] == 'show_compatibility_56'
+        }
+        if mysqlversion.start_with?('5.7') && compability56 == "OFF"
+          raise FlydataCore::MysqlCompatibilityError,
+                "Make sure you set 'show_compatibility_56 = ON' in your MySQL configuration. Once you update your MySQL configuration, restart the MySQL server for the change to take effect."
+        end
+      end
+    end
+
     class TableTypeChecker < MysqlCompatibilityChecker
       SELECT_TABLE_INFO_TMPLT = 
         "SELECT table_name, table_type, engine " +

data/flydata-core/lib/flydata-core/table_def/mysql_table_def.rb

@@ -171,6 +171,11 @@ class MysqlTableDef
 
     tabledef
   end
+  
+  # Replaces a MySQL string with an empty string ('')
+  def self.strip_string(line)
+    line.gsub(/'(\\'|''|[^'])*'/, "''")
+  end
 
   def self.parse_one_column_def(query)
     line = query.strip
@@ -207,11 +212,14 @@ class MysqlTableDef
         column[:type] = convert_to_flydata_type(type)
 
         cond = :options
+
       when :options
-        column[:type] += ' unsigned' if line =~ /unsigned/i
-        column[:auto_increment] = true if line =~ /AUTO_INCREMENT/i
-        column[:not_null] = true if line =~ /NOT NULL/i
-        column[:unique] = true if line =~ /UNIQUE/i
+        strip_line = strip_string(line)
+        column[:type] += ' unsigned' if strip_line =~ /unsigned/i
+        column[:auto_increment] = true if strip_line =~ /AUTO_INCREMENT/i
+        column[:not_null] = true if strip_line =~ /NOT NULL/i
+        column[:unique] = true if strip_line =~ /UNIQUE/i
+        
         if /DEFAULT\s+((?:[bx]?'(?:\\'|[^'])*')|(?:[^'\s]+\b))/i.match(line)
           val = $1
           column[:default] = val == "NULL" ? nil : val

data/flydata-core/lib/flydata-core/table_def/redshift_table_def.rb

@@ -45,9 +45,14 @@ class RedshiftTableDef
       tabledef = ""
       tabledef += create_schema_sql(schema_name) if options[:flydata_ctl_table] && !schema_name.to_s.empty?
       tabledef += create_flydata_ctl_table_sql(schema_name) if options[:flydata_ctl_table]
+      options[:backup_postfix] = "_flydata#{Time.now.strftime('%Y%m%d%H%M%S')}"
+      tabledef += "BEGIN;\n"
+      tabledef += remove_table_sql(flydata_tabledef, schema_name, options) unless options[:ctl_only]
       tabledef += create_table_sql(flydata_tabledef, schema_name) unless options[:ctl_only]
       tabledef += comment_sql(flydata_tabledef, schema_name) unless options[:ctl_only]
       tabledef += flydata_ctl_sql(flydata_tabledef, schema_name)
+      tabledef += "COMMIT;\n"
+      tabledef += drop_backup_table_sql(flydata_tabledef, schema_name, options) unless options[:ctl_only]
     rescue => e
       # Catch errors from generating schema. Generally an unsupported data type
       raise TableDefError, {error: "errors generating schema. Please contact us for further instructions", table: flydata_tabledef[:table_name]}
@@ -124,14 +129,61 @@ EOS
     CREATE_FLYDATA_CTL_TABLES_SQL % [tables_tbl]
   end
 
-  CREATE_TABLE_SQL = <<EOS
+  DROP_TABLE_SQL = <<EOS
 DROP TABLE IF EXISTS %s;
+EOS
+
+  RENAME_TABLE_SQL = <<EOS
+ALTER TABLE %s RENAME TO %s;
+EOS
+
+  CREATE_TABLE_SQL = <<EOS
 CREATE TABLE %s (
 %s
 )%s;
 EOS
 
-  def self.create_table_sql(flydata_tabledef, schema_name)
+  CREATE_TABLE_IF_NOT_EXISTS_SQL = <<EOS
+CREATE TABLE IF NOT EXISTS %s (
+%s
+)%s;
+EOS
+
+  def self.remove_table_sql(flydata_tabledef, schema_name, options)
+    return "" if options[:skip_drop_table]
+    table_name = flydata_tabledef[:table_name]
+    redshift_tbl = table_name_for_ddl(table_name, schema_name)
+    sql = ""
+    if options[:backup_postfix]
+      # drop backup table if exists
+      sql += drop_backup_table_sql(flydata_tabledef, schema_name, options)
+      # create an empty table to prevent RENAME TABLE query from failing
+      sql += create_table_sql(flydata_tabledef, schema_name,
+                       create_table_sql: CREATE_TABLE_IF_NOT_EXISTS_SQL)
+      backup_tbl = table_name_for_ddl(
+                     "#{table_name}#{options[:backup_postfix]}", nil)
+      sql += RENAME_TABLE_SQL % [redshift_tbl, backup_tbl]
+    else
+      sql += DROP_TABLE_SQL % redshift_tbl
+    end
+    sql
+  end
+
+  def self.drop_backup_table_sql(flydata_tabledef, schema_name, options)
+    return "" if options[:skip_drop_table]
+    sql = ""
+    if options[:backup_postfix]
+      table_name = flydata_tabledef[:table_name]
+      backup_tbl = table_name_for_ddl(
+                     "#{table_name}#{options[:backup_postfix]}", schema_name)
+      sql += DROP_TABLE_SQL % backup_tbl
+    end
+
+    sql
+  end
+
+  def self.create_table_sql(flydata_tabledef, schema_name, options = {})
+    ct_sql = options[:create_table_sql] || CREATE_TABLE_SQL
     lines = flydata_tabledef[:columns].collect{|column| column_def_sql(column) }
     pk_def = primary_key_sql(flydata_tabledef)
     lines << pk_def if pk_def
@@ -142,7 +194,9 @@ EOS
 
     table_name = flydata_tabledef[:table_name]
     redshift_tbl = table_name_for_ddl(table_name, schema_name)
-    CREATE_TABLE_SQL % [redshift_tbl, redshift_tbl, contents, dk_sk_def]
+    sql = ""
+    sql += ct_sql % [redshift_tbl, contents, dk_sk_def]
+    sql
   end
 
   def self.column_def_sql(column, opt = {})
@@ -261,7 +315,7 @@ EOS
   end
 
   def self.flydata_ctl_sql(flydata_tabledef, schema_name)
-    flydata_ctl_columns_sql(flydata_tabledef, schema_name) + "\n" +
+    flydata_ctl_columns_sql(flydata_tabledef, schema_name) +
     flydata_ctl_tables_sql(flydata_tabledef, schema_name)
   end
   FLYDATA_CTL_COLUMNS_SQL = <<EOS
@@ -276,7 +330,7 @@ EOS
       charset = col[:charset] ? " cs:#{col[:charset]}" : ""
       values << "('#{escape(flydata_tabledef[:table_name])}', '#{escape(col[:column])}', '#{escape(col[:type])}#{charset}', #{i})"
     end
-    sql += values.join(",\n") + ';'
+    sql += values.join(",\n") + ";\n"
     sql
   end
 
@@ -292,7 +346,7 @@ EOS
     values << "('#{flydata_tabledef[:table_name]}', 'cs', '#{escape(flydata_tabledef[:default_charset])}')"
     values << "('#{flydata_tabledef[:table_name]}', 'revision', 1)"
     values << "('#{flydata_tabledef[:table_name]}', 'src_ddl', '#{escape(flydata_tabledef[:src_ddl])}')"
-    sql += values.join(",\n") + ';'
+    sql += values.join(",\n") + ";\n"
     sql
   end
 

data/flydata-core/spec/mysql/binlog_pos_spec.rb

@@ -0,0 +1,474 @@
+require 'spec_helper'
+require 'flydata-core/mysql/binlog_pos.rb'
+
+module FlydataCore
+module Mysql
+  describe BinlogPos do
+    let(:subject_object) { described_class.new(binlog_str) }
+    let(:binlog_str) { "#{filename}\t#{pos}" }
+    let(:filename) { 'mysql-bin.000064' }
+    let(:pos) { 104 }
+    
+    describe '#pos' do
+      subject { subject_object.pos }
+      it { is_expected.to eq(pos) }
+    end
+    describe '#filename' do
+      subject { subject_object.filename }
+      it { is_expected.to eq(filename) }
+    end
+    describe '#to_s' do
+      subject { subject_object.to_s }
+      it { is_expected.to eq(binlog_str) }
+    end
+
+    describe '.new' do
+      subject { described_class.new(*args) }
+      shared_examples "properly constructed" do
+        it do
+          expect(subject.filename).to eq(filename)
+          expect(subject.pos).to eq(pos)
+        end
+      end
+
+      context 'when given two arguments' do
+        let(:args) { [filename, pos] }
+        it_behaves_like "properly constructed"
+      end
+    
+      let(:args) { [ arg1 ] }
+      context 'when given a String' do
+        let(:arg1) { binlog_str }
+        it_behaves_like "properly constructed"
+      end
+
+      context 'when given a Hash' do
+        let(:arg1) { { filename: filename, pos: pos } }
+        it_behaves_like "properly constructed"
+      end
+    end
+
+    let(:arg) { described_class.new (arg_str) }
+    let(:arg_str) { arg_binlog_str }
+    let(:arg_binlog_str) { "#{arg_filename}\t#{arg_pos}" }
+    let(:older_filename) { 'mysql-bin.000061' }
+    let(:newer_filename) { 'mysql-bin.000065' }
+ 
+    shared_examples 'returning the same result no matter what pos value is' do
+      context 'when the target pos is smaller' do 
+        let(:arg_pos) { pos - 10 }
+        it { is_expected.to eq expected_result }
+      end
+      context 'when the target pos is the same' do
+        let(:arg_pos) { pos }
+        it { is_expected.to eq expected_result }
+      end
+      context 'when the target pos is larger' do
+        let(:arg_pos) { pos + 10 }
+        it { is_expected.to eq expected_result }
+      end
+    end
+
+    describe '#<=>' do
+      subject { subject_object <=> arg }
+
+      context 'when the target is nil' do
+        let(:arg) { nil }
+        it { expect { subject }.to raise_error(ArgumentError) }
+      end
+      context 'when the target has the same value' do
+        let(:arg_filename) { filename }
+        let(:arg_pos) { pos }
+        it { is_expected.to eq 0 }
+      end 
+
+      context 'when the target binlog filename is the same' do
+        let(:arg_filename) { filename }
+        context 'when the target pos is smaller' do 
+          let(:arg_pos) { pos - 10 }
+          it { is_expected.to eq 1 }
+        end
+        context 'when the target pos is the same' do
+          let(:arg_pos) { pos }
+          it { is_expected.to eq 0 }
+        end
+        context 'when the target pos is larger' do
+          let(:arg_pos) { pos + 10 }
+          it { is_expected.to eq -1 }
+        end
+      end
+    
+      context 'when the target binlog filename is older' do
+        let(:arg_filename) { older_filename }
+        let(:expected_result) { 1 }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+      context 'when the target binlog filename is newer' do
+        let(:arg_filename) { newer_filename }
+        let(:expected_result) { -1 }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+
+      context 'when the target is empty' do
+        let(:arg_str) { "-" }
+        it { expect { subject }.to raise_error(ArgumentError) }
+      end
+      context 'when self is empty' do
+        let(:binlog_str) { "-" }
+        context 'when target is empty' do
+          let(:arg_str) { "-" }
+          it { is_expected.to eq 0 }
+        end
+        context 'when target is not empty' do
+          let(:arg) { double('arg') }
+          before do
+            allow(arg).to receive(:kind_of?).with(BinlogPos).and_return(true)
+            allow(arg).to receive(:empty?).and_return(false)
+          end
+          it { expect { subject }.to raise_error(ArgumentError) }
+        end
+      end
+    end
+
+    describe '#<' do
+      subject { subject_object < arg }
+
+      context 'when the target has the same value' do
+        let(:arg_filename) { filename }
+        let(:arg_pos) { pos }
+        it { is_expected.to be_falsey }
+      end 
+
+      context 'when the target binlog filename is the same' do
+        let(:arg_filename) { filename }
+        context 'when the target pos is smaller' do
+          let(:arg_pos) { pos - 10 }
+	  it { is_expected.to be_falsey }
+        end
+        context 'when the target pos is the same' do
+          let(:arg_pos) { pos }
+          it { is_expected.to be_falsey }
+        end
+        context 'when the target pos is larger' do
+          let(:arg_pos) { pos + 10 }
+          it { is_expected.to be_truthy }
+        end
+      end
+
+      context 'when the target binlog filename is older' do
+        let(:arg_filename) { older_filename }
+        let(:expected_result) { false }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+      context 'when the target binlog filename is newer' do
+        let(:arg_filename) { newer_filename }
+        let(:expected_result) { true }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+
+      context 'when the target is empty' do
+        let(:arg_str) { "-" }
+        it { expect { subject }.to raise_error(ArgumentError) }
+      end
+      context 'when self is empty' do
+        let(:binlog_str) { "-" }
+        context 'when target is empty' do
+          let(:arg_str) { "-" }
+          it { is_expected.to be_falsey }
+        end
+        context 'when target is not empty' do
+          let(:arg_str) { arg_binlog_str }
+          let(:arg_filename) { filename }
+          let(:arg_pos) { pos }
+          it { expect { subject }.to raise_error(ArgumentError) }
+        end
+      end
+    end
+
+    describe '#<=' do
+      subject { subject_object <= arg }
+ 
+      context 'when the target has the same value' do
+        let(:arg_filename) { filename }
+        let(:arg_pos) { pos }
+        it { is_expected.to be_truthy }
+      end 
+
+      context 'when the target binlog filename is the same' do
+        let(:arg_filename) { filename }
+        context 'when the target pos is smaller' do
+          let(:arg_pos) { pos - 10 }
+	  it { is_expected.to be_falsey }
+        end
+        context 'when the target pos is the same' do
+          let(:arg_pos) { pos }
+          it { is_expected.to be_truthy }
+        end
+        context 'when the target pos is larger' do
+          let(:arg_pos) { pos + 10 }
+          it { is_expected.to be_truthy }
+        end
+      end
+
+      context 'when the target binlog filename is older' do
+        let(:arg_filename) { older_filename }
+        let(:expected_result) { false }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+      context 'when the target binlog filename is newer' do
+        let(:arg_filename) { newer_filename }
+        let(:expected_result) { true }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+
+      context 'when the target is empty' do
+        let(:arg_str) { "-" }
+        it { expect { subject }.to raise_error(ArgumentError) }
+      end
+      context 'when self is empty' do
+        let(:binlog_str) { "-" }
+        context 'when target is empty' do
+          let(:arg_str) { "-" }
+          it { is_expected.to be_truthy }
+        end
+        context 'when target is not empty' do
+          let(:arg_str) { arg_binlog_str }
+          let(:arg_filename) { filename }
+          let(:arg_pos) { pos }
+          it { expect { subject }.to raise_error(ArgumentError) }
+        end
+      end
+    end
+
+    describe '#>=' do
+      subject { subject_object >= arg }
+ 
+      context 'when the target has the same value' do
+        let(:arg_filename) { filename }
+        let(:arg_pos) { pos }
+        it { is_expected.to be_truthy }
+      end 
+
+      context 'when the target binlog filename is the same' do
+        let(:arg_filename) { filename }
+        context 'when the target pos is smaller' do
+          let(:arg_pos) { pos - 10 }
+	  it { is_expected.to be_truthy }
+        end
+        context 'when the target pos is the same' do
+          let(:arg_pos) { pos }
+          it { is_expected.to be_truthy }
+        end
+        context 'when the target pos is larger' do
+          let(:arg_pos) { pos + 10 }
+          it { is_expected.to be_falsey }
+        end
+      end
+
+      context 'when the target binlog filename is older' do
+        let(:arg_filename) { older_filename }
+        let(:expected_result) { true }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+      context 'when the target binlog filename is newer' do
+        let(:arg_filename) { newer_filename }
+        let(:expected_result) { false }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+
+      context 'when the target is empty' do
+        let(:arg_str) { "-" }
+        it { expect { subject }.to raise_error(ArgumentError) }
+      end
+      context 'when self is empty' do
+        let(:binlog_str) { "-" }
+        context 'when target is empty' do
+          let(:arg_str) { "-" }
+          it { is_expected.to be_truthy }
+        end
+        context 'when target is not empty' do
+          let(:arg_str) { arg_binlog_str }
+          let(:arg_filename) { filename }
+          let(:arg_pos) { pos }
+          it { expect { subject }.to raise_error(ArgumentError) }
+        end
+      end
+    end
+
+    describe '#>' do
+      subject { subject_object > arg }
+ 
+      context 'when the target has the same value' do
+        let(:arg_filename) { filename }
+        let(:arg_pos) { pos }
+        it { is_expected.to be_falsey }
+      end 
+
+      context 'when the target binlog filename is the same' do
+        let(:arg_filename) { filename }
+        context 'when the target pos is smaller' do
+          let(:arg_pos) { pos - 10 }
+	  it { is_expected.to be_truthy }
+        end
+        context 'when the target pos is the same' do
+          let(:arg_pos) { pos }
+          it { is_expected.to be_falsey }
+        end
+        context 'when the target pos is larger' do
+          let(:arg_pos) { pos + 10 }
+          it { is_expected.to be_falsey }
+        end
+      end
+
+      context 'when the target binlog filename is older' do
+        let(:arg_filename) { older_filename }
+        let(:expected_result) { true }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+      context 'when the target binlog filename is newer' do
+        let(:arg_filename) { newer_filename }
+        let(:expected_result) { false }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+
+      context 'when the target is empty' do
+        let(:arg_str) { "-" }
+        it { expect { subject }.to raise_error(ArgumentError) }
+      end
+      context 'when self is empty' do
+        let(:binlog_str) { "-" }
+        context 'when target is empty' do
+          let(:arg_str) { "-" }
+          it { is_expected.to be_falsey }
+        end
+        context 'when target is not empty' do
+          let(:arg_str) { arg_binlog_str }
+          let(:arg_filename) { filename }
+          let(:arg_pos) { pos }
+          it { expect { subject }.to raise_error(ArgumentError) }
+        end
+      end
+    end
+
+    describe '#==' do
+      subject { subject_object == arg }
+
+      context 'when comparing with nil' do
+        let(:arg) { nil }
+        it { is_expected.to be_falsey }
+      end
+ 
+      context 'when the target has the same value' do
+        let(:arg_filename) { filename }
+        let(:arg_pos) { pos }
+        it { is_expected.to be_truthy }
+      end 
+
+      context 'when the target binlog filename is the same' do
+        let(:arg_filename) { filename }
+        context 'when the target pos is smaller' do
+          let(:arg_pos) { pos - 10 }
+	  it { is_expected.to be_falsey }
+        end
+        context 'when the target pos is the same' do
+          let(:arg_pos) { pos }
+          it { is_expected.to be_truthy }
+        end
+        context 'when the target pos is larger' do
+          let(:arg_pos) { pos + 10 }
+          it { is_expected.to be_falsey }
+        end
+      end
+
+      context 'when the target binlog filename is older' do
+        let(:arg_filename) { older_filename }
+        let(:expected_result) { false }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+      context 'when the target binlog filename is newer' do
+        let(:arg_filename) { newer_filename }
+        let(:expected_result) { false }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+
+      context 'when the target is empty' do
+        let(:arg_str) { "-" }
+        it { is_expected.to be_falsey }
+      end
+      context 'when self is empty' do
+        let(:binlog_str) { "-" }
+        context 'when target is empty' do
+          let(:arg_str) { "-" }
+          it { is_expected.to be_truthy }
+        end
+        context 'when target is not empty' do
+          let(:arg_str) { arg_binlog_str }
+          let(:arg_filename) { filename }
+          let(:arg_pos) { pos }
+	  it { is_expected.to be_falsey }
+        end
+      end
+    end
+
+    describe '#!=' do
+      subject { subject_object != arg }
+
+      context 'when comparing with nil' do
+        let(:arg) { nil }
+        it { is_expected.to be_truthy }
+      end
+ 
+      context 'when the target has the same value' do
+        let(:arg_filename) { filename }
+        let(:arg_pos) { pos }
+        it { is_expected.to be_falsey }
+      end 
+
+      context 'when the target binlog filename is the same' do
+        let(:arg_filename) { filename }
+        context 'when the target pos is smaller' do
+          let(:arg_pos) { pos - 10 }
+	  it { is_expected.to be_truthy }
+        end
+        context 'when the target pos is the same' do
+          let(:arg_pos) { pos }
+          it { is_expected.to be_falsey }
+        end
+        context 'when the target pos is larger' do
+          let(:arg_pos) { pos + 10 }
+          it { is_expected.to be_truthy }
+        end
+      end
+
+      context 'when the target binlog filename is older' do
+        let(:arg_filename) { older_filename }
+        let(:expected_result) { true }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+      context 'when the target binlog filename is newer' do
+        let(:arg_filename) { newer_filename }
+        let(:expected_result) { true }
+        it_behaves_like 'returning the same result no matter what pos value is'
+      end
+
+      context 'when the target is empty' do
+        let(:arg_str) { "-" }
+        it { is_expected.to be_truthy }
+      end
+      context 'when self is empty' do
+        let(:binlog_str) { "-" }
+        context 'when target is empty' do
+          let(:arg_str) { "-" }
+          it { is_expected.to be_falsey }
+        end
+        context 'when target is not empty' do
+          let(:arg_str) { arg_binlog_str }
+          let(:arg_filename) { filename }
+          let(:arg_pos) { pos }
+          it { is_expected.to be_truthy }
+        end
+      end
+    end
+  end
+end
+end