ruby-binlog 0.1.0 → 0.1.1

data/README

@@ -22,6 +22,9 @@ gem install ruby-binlog
     case event
     when Binlog::QueryEvent
       puts event.query
+    when Binlog::RowEvent
+      puts event.event_type
+      p event.rows
     else
       puts "(#{event.event_type})"
     end

data/ext/Makefile

@@ -9,32 +9,32 @@ hdrdir = $(topdir)
 VPATH = $(srcdir):$(topdir):$(hdrdir)
 prefix = $(DESTDIR)/usr
 exec_prefix = $(DESTDIR)/usr
-vendorarchdir = $(libdir)/ruby/$(ruby_version)/$(sitearch)
-vendordir = $(DESTDIR)/usr/lib/ruby
-sitearchdir = $(libdir)/ruby/site_ruby/$(ruby_version)/$(sitearch)
+mandir = $(DESTDIR)/usr/share/man
 localedir = $(datarootdir)/locale
-dvidir = $(docdir)
+vendordir = $(DESTDIR)/usr/lib/ruby
 datadir = $(DESTDIR)/usr/share
-rubylibdir = $(vendordir)/$(ruby_version)
-bindir = $(DESTDIR)/usr/bin
-sharedstatedir = $(DESTDIR)/var/lib
+sitearchdir = $(libdir)/ruby/site_ruby/$(ruby_version)/$(sitearch)
 libexecdir = $(DESTDIR)/usr/libexec
-vendorlibdir = $(vendordir)/$(ruby_version)
-oldincludedir = $(DESTDIR)/usr/include
-sitedir = $(DESTDIR)/usr/lib/ruby/site_ruby
-mandir = $(DESTDIR)/usr/share/man
-datarootdir = $(prefix)/share
-htmldir = $(docdir)
-pdfdir = $(docdir)
-localstatedir = $(DESTDIR)/var
-includedir = $(DESTDIR)/usr/include
-sitelibdir = $(sitedir)/$(ruby_version)
-sysconfdir = $(DESTDIR)/etc
 psdir = $(docdir)
+sysconfdir = $(DESTDIR)/etc
+bindir = $(DESTDIR)/usr/bin
+includedir = $(DESTDIR)/usr/include
+vendorarchdir = $(libdir)/ruby/$(ruby_version)/$(sitearch)
+sitedir = $(DESTDIR)/usr/lib/ruby/site_ruby
 libdir = $(DESTDIR)/usr/lib64
+sitelibdir = $(sitedir)/$(ruby_version)
+rubylibdir = $(vendordir)/$(ruby_version)
+localstatedir = $(DESTDIR)/var
+infodir = $(DESTDIR)/usr/share/info
 docdir = $(datarootdir)/doc/$(PACKAGE)
+datarootdir = $(prefix)/share
 archdir = $(libdir)/ruby/$(ruby_version)/$(sitearch)
-infodir = $(DESTDIR)/usr/share/info
+oldincludedir = $(DESTDIR)/usr/include
+sharedstatedir = $(DESTDIR)/var/lib
+htmldir = $(docdir)
+dvidir = $(docdir)
+vendorlibdir = $(vendordir)/$(ruby_version)
+pdfdir = $(docdir)
 sbindir = $(DESTDIR)/usr/sbin
 
 CC = gcc

data/ext/ruby_binlog.cpp

@@ -16,19 +16,29 @@ namespace binlog {
 
 struct Client {
   Binary_log *m_binlog;
+  VALUE m_table_map;
 
   static void free(Client *p) {
     if (p->m_binlog) {
       delete p->m_binlog;
       p->m_binlog = 0;
+      p->m_table_map = 0;
     }
 
     delete p;
   }
 
+  static void mark(Client *p) {
+    if (p->m_table_map) {
+      rb_gc_mark(p->m_table_map);
+    }
+  }
+
   static VALUE alloc(VALUE klass) {
     Client *p = new Client();
-    return Data_Wrap_Struct(klass, 0, &free, p);
+    p->m_binlog = 0;
+    p->m_table_map = 0;
+    return Data_Wrap_Struct(klass, &mark, &free, p);
   }
 
   static VALUE initialize(VALUE self, VALUE uri) {
@@ -92,17 +102,18 @@ struct Client {
     case TABLE_MAP_EVENT:
       retval = rb_funcall(rb_cBinlogTableMapEvent, rb_intern("new"), 0);
       TableMapEvent::set_event(retval, event);
+      p->m_table_map = retval;
       break;
 
     // XXX: Is it right?
-    case PRE_GA_WRITE_ROWS_EVENT:
-    case PRE_GA_UPDATE_ROWS_EVENT:
-    case PRE_GA_DELETE_ROWS_EVENT:
+    //case PRE_GA_WRITE_ROWS_EVENT:
+    //case PRE_GA_UPDATE_ROWS_EVENT:
+    //case PRE_GA_DELETE_ROWS_EVENT:
     case WRITE_ROWS_EVENT: 
     case UPDATE_ROWS_EVENT:
     case DELETE_ROWS_EVENT:
       retval = rb_funcall(rb_cBinlogRowEvent, rb_intern("new"), 0);
-      RowEvent::set_event(retval, event);
+      RowEvent::set_event(retval, event, p->m_table_map);
       break;
 
     case INTVAR_EVENT:

data/ext/ruby_binlog_event.h

@@ -98,19 +98,30 @@ struct TableMapEvent : public Event {
 
 struct RowEvent : public Event {
   mysql::Row_event *m_event;
+  VALUE m_table_map;
 
   static void free(RowEvent *p);
+  static void mark(RowEvent *p);
   static VALUE alloc(VALUE klass);
-  static void set_event(VALUE self, mysql::Binary_log_event *event);
+  static void set_event(VALUE self, mysql::Binary_log_event *event, VALUE table_map);
   static void init();
 
   static VALUE get_table_id(VALUE self);
+  static VALUE get_db_name(VALUE self);
+  static VALUE get_table_name(VALUE self);
   static VALUE get_flags(VALUE self);
   static VALUE get_columns_len(VALUE self);
   static VALUE get_null_bits_len(VALUE self);
   static VALUE get_columns_before_image(VALUE self);
   static VALUE get_used_columns(VALUE self);
   static VALUE get_row(VALUE self);
+  static VALUE get_rows(VALUE self);
+
+private:
+  static void proc0(mysql::Row_of_fields &fields, VALUE rb_fields);
+  static VALUE proc_insert(mysql::Row_of_fields &fields);
+  static VALUE proc_update(mysql::Row_of_fields &old_fields, mysql::Row_of_fields &new_fields);
+  static VALUE proc_delete(mysql::Row_of_fields &fields);
 };
 
 struct IntVarEvent : public Event {

data/ext/ruby_binlog_row_event.cpp

@@ -9,27 +9,36 @@ void RowEvent::free(RowEvent *p) {
   if (p->m_event) {
     delete p->m_event;
     p->m_event = 0;
+    p->m_table_map = 0;
     p->m_event_header = 0;
   }
 
   delete p;
 }
 
+void RowEvent::mark(RowEvent *p) {
+  if (p->m_table_map) {
+    rb_gc_mark(p->m_table_map);
+  }
+}
+
 VALUE RowEvent::alloc(VALUE klass) {
   RowEvent *p;
 
   p = new RowEvent();
   p->m_event = 0;
+  p->m_table_map = 0;
   p->m_event_header = 0;
 
-  return Data_Wrap_Struct(klass, 0, &free, p);
+  return Data_Wrap_Struct(klass, &mark, &free, p);
 }
 
-void RowEvent::set_event(VALUE self, mysql::Binary_log_event *event) {
+void RowEvent::set_event(VALUE self, mysql::Binary_log_event *event, VALUE table_map) {
   RowEvent *p;
 
   Data_Get_Struct(self, RowEvent, p);
   p->m_event = static_cast<Row_event*>(event);
+  p->m_table_map = table_map;
   p->m_event_header = event->header();
 }
 
@@ -39,13 +48,16 @@ void RowEvent::init() {
 
   Event::init(rb_cBinlogRowEvent);
 
-  rb_define_method(rb_cBinlogRowEvent, "table_id",             __F(&get_table_id),             0);
-  rb_define_method(rb_cBinlogRowEvent, "flags",                __F(&get_flags),                0);
-  rb_define_method(rb_cBinlogRowEvent, "columns_len",          __F(&get_columns_len),          0);
-  rb_define_method(rb_cBinlogRowEvent, "null_bits_len",        __F(&get_null_bits_len),        0);
-  rb_define_method(rb_cBinlogRowEvent, "columns_before_image", __F(&get_columns_before_image), 0);
-  rb_define_method(rb_cBinlogRowEvent, "used_columns",         __F(&get_used_columns),         0);
-  rb_define_method(rb_cBinlogRowEvent, "row",                  __F(&get_row),                  0);
+  rb_define_method(rb_cBinlogRowEvent, "table_id",                 __F(&get_table_id),             0);
+  rb_define_method(rb_cBinlogRowEvent, "db_name",                  __F(&get_db_name),              0);
+  rb_define_method(rb_cBinlogRowEvent, "table_name",               __F(&get_table_name),           0);
+  rb_define_method(rb_cBinlogRowEvent, "flags",                    __F(&get_flags),                0);
+  rb_define_method(rb_cBinlogRowEvent, "columns_len",              __F(&get_columns_len),          0);
+  rb_define_method(rb_cBinlogRowEvent, "null_bits_len",            __F(&get_null_bits_len),        0);
+  rb_define_method(rb_cBinlogRowEvent, "raw_columns_before_image", __F(&get_columns_before_image), 0);
+  rb_define_method(rb_cBinlogRowEvent, "raw_used_columns",         __F(&get_used_columns),         0);
+  rb_define_method(rb_cBinlogRowEvent, "raw_row",                  __F(&get_row),                  0);
+  rb_define_method(rb_cBinlogRowEvent, "rows",                     __F(&get_rows),                 0);
 }
 
 VALUE RowEvent::get_table_id(VALUE self) {
@@ -54,6 +66,32 @@ VALUE RowEvent::get_table_id(VALUE self) {
   return ULL2NUM(p->m_event->table_id);
 }
 
+VALUE RowEvent::get_db_name(VALUE self) {
+  RowEvent *p;
+  Data_Get_Struct(self, RowEvent, p);
+
+  if (p->m_table_map) {
+    TableMapEvent *tme;
+    Data_Get_Struct(p->m_table_map, TableMapEvent, tme);
+    return rb_str_new2(tme->m_event->db_name.c_str());
+  } else {
+    return Qnil;
+  }
+}
+
+VALUE RowEvent::get_table_name(VALUE self) {
+  RowEvent *p;
+  Data_Get_Struct(self, RowEvent, p);
+
+  if (p->m_table_map) {
+    TableMapEvent *tme;
+    Data_Get_Struct(p->m_table_map, TableMapEvent, tme);
+    return rb_str_new2(tme->m_event->table_name.c_str());
+  } else {
+    return Qnil;
+  }
+}
+
 VALUE RowEvent::get_flags(VALUE self) {
   RowEvent *p;
   Data_Get_Struct(self, RowEvent, p);
@@ -114,5 +152,91 @@ VALUE RowEvent::get_row(VALUE self) {
   return retval;
 }
 
+VALUE RowEvent::get_rows(VALUE self) {
+  RowEvent *p;
+  TableMapEvent *tme;
+  VALUE retval = rb_ary_new();
+
+  Data_Get_Struct(self, RowEvent, p);
+
+  if (!p->m_table_map) {
+    return retval;
+  }
+
+  Data_Get_Struct(p->m_table_map , TableMapEvent, tme);
+
+  mysql::Row_event_set rows(p->m_event, tme->m_event);
+  mysql::Row_event_set::iterator itor = rows.begin();
+
+  do {
+    VALUE rb_row = Qnil;
+    mysql::Row_of_fields fields = *itor;
+    Log_event_type event_type = p->m_event->get_event_type();
+
+    if (event_type == mysql::WRITE_ROWS_EVENT) {
+      rb_row = proc_insert(fields);
+    } else if (event_type == mysql::UPDATE_ROWS_EVENT) {
+      itor++;
+      mysql::Row_of_fields fields2 = *itor;
+      rb_row = proc_update(fields, fields2);
+    } else if (event_type == mysql::DELETE_ROWS_EVENT) {
+      rb_row = proc_delete(fields);
+    }
+
+    /*
+          if (event->get_event_type() == mysql::UPDATE_ROWS_EVENT)
+          {
+            ++it;
+            mysql::Row_of_fields fields2= *it;
+            table_update(os.str(),fields,fields2);
+          }
+          if (event->get_event_type() == mysql::DELETE_ROWS_EVENT)
+            table_delete(os.str(),fields);
+      */
+
+    rb_ary_push(retval, rb_row);
+  } while (++itor != rows.end());
+
+  return retval;
+}
+
+void RowEvent::proc0(mysql::Row_of_fields &fields, VALUE rb_fields) {
+  mysql::Converter converter;
+  mysql::Row_of_fields::iterator itor = fields.begin();
+
+  do {
+    std::string str;
+    converter.to(str, *itor);
+    rb_ary_push(rb_fields, rb_str_new2(str.c_str()));
+  } while(++itor != fields.end());
+}
+
+VALUE RowEvent::proc_insert(mysql::Row_of_fields &fields) {
+  VALUE rb_new_fields = rb_ary_new();
+  proc0(fields, rb_new_fields);
+  return rb_new_fields;
+}
+
+VALUE RowEvent::proc_update(mysql::Row_of_fields &old_fields, mysql::Row_of_fields &new_fields) {
+  VALUE rb_row, rb_old_fields, rb_new_fields;
+
+  rb_row = rb_ary_new();
+  rb_old_fields = rb_ary_new();
+  rb_new_fields = rb_ary_new();
+
+  proc0(old_fields, rb_old_fields);
+  proc0(new_fields, rb_new_fields);
+  rb_ary_push(rb_row, rb_old_fields);
+  rb_ary_push(rb_row, rb_new_fields);
+
+  return rb_row;
+}
+
+VALUE RowEvent::proc_delete(mysql::Row_of_fields &fields) {
+  VALUE rb_old_fields = rb_ary_new();
+  proc0(fields, rb_old_fields);
+  return rb_old_fields;
+}
+
 } // namespace binlog
 } // namespace ruby

data/ext/test.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require "binlog"
+
+client = Binlog::Client.new("mysql://repl:repl@hastur")
+client.connect
+client.position = 4
+    
+while event = client.wait_for_next_event
+  case event
+  when Binlog::QueryEvent
+    puts event.query
+  when Binlog::RowEvent
+    puts event.event_type
+    p event.rows
+  else
+    puts "(#{event.event_type})"
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-binlog
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - winebarrel
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-25 00:00:00 Z
+date: 2012-08-26 00:00:00 Z
 dependencies: []
 
 description: Ruby binding for MySQL Binary log API.
@@ -57,6 +57,7 @@ files:
 - ext/binlog.so
 - ext/ruby_binlog_incident_event.cpp
 - ext/ruby_binlog_table_map_event.o
+- ext/test.rb
 - README
 homepage: https://bitbucket.org/winebarrel/ruby-binlog
 licenses: []