ruby-binlog 0.1.0

data/ext/ruby_binlog.h

@@ -0,0 +1,33 @@
+#ifndef __RUBY_BINLOG_H__
+#define __RUBY_BINLOG_H__
+
+#include <string>
+#include <binlog_api.h>
+#include <ruby.h>
+#include <rubysig.h>
+
+#include "ruby_binlog_event.h"
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#ifdef _WIN32
+#define __F(f) (reinterpret_cast<VALUE (__cdecl *)(...)>(f))
+#else
+#define __F(f) (reinterpret_cast<VALUE (*)(...)>(f))
+#endif
+
+extern VALUE rb_mBinlog;
+
+extern "C" {
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+void Init_binlog();
+}
+
+#endif // __RUBY_BINLOG_H__

data/ext/ruby_binlog_event.cpp

@@ -0,0 +1,67 @@
+#include "ruby_binlog.h"
+
+namespace ruby {
+namespace binlog {
+
+VALUE Event::get_marker(VALUE self) {
+  Event *p;
+  Data_Get_Struct(self, Event, p);
+  return UINT2NUM(p->m_event_header->marker);
+}
+
+VALUE Event::get_timestamp(VALUE self) {
+  Event *p;
+  Data_Get_Struct(self, Event, p);
+  return ULONG2NUM(p->m_event_header->timestamp);
+}
+
+VALUE Event::get_type_code(VALUE self) {
+  Event *p;
+  Data_Get_Struct(self, Event, p);
+  return UINT2NUM(p->m_event_header->type_code);
+}
+
+VALUE Event::get_server_id(VALUE self) {
+  Event *p;
+  Data_Get_Struct(self, Event, p);
+  return ULONG2NUM(p->m_event_header->server_id);
+}
+
+VALUE Event::get_event_length(VALUE self) {
+  Event *p;
+  Data_Get_Struct(self, Event, p);
+  return ULONG2NUM(p->m_event_header->event_length);
+}
+
+VALUE Event::get_next_position(VALUE self) {
+  Event *p;
+  Data_Get_Struct(self, Event, p);
+  return ULONG2NUM(p->m_event_header->next_position);
+}
+
+VALUE Event::get_flags(VALUE self) {
+  Event *p;
+  Data_Get_Struct(self, Event, p);
+  return UINT2NUM(p->m_event_header->flags);
+}
+
+VALUE Event::get_event_type(VALUE self) {
+  Event *p;
+  Data_Get_Struct(self, Event, p);
+  return rb_str_new2(
+    mysql::system::get_event_type_str(static_cast<enum Log_event_type>(p->m_event_header->type_code)));
+}
+
+void Event::init(VALUE clazz) {
+  rb_define_method(clazz, "marker",        __F(&get_marker),        0);
+  rb_define_method(clazz, "timestamp",     __F(&get_timestamp),     0);
+  rb_define_method(clazz, "type_code",     __F(&get_type_code),     0);
+  rb_define_method(clazz, "server_id",     __F(&get_server_id),     0);
+  rb_define_method(clazz, "event_length",  __F(&get_event_length),  0);
+  rb_define_method(clazz, "next_position", __F(&get_next_position), 0);
+  rb_define_method(clazz, "flags",         __F(&get_flags),         0);
+  rb_define_method(clazz, "event_type",    __F(&get_event_type),    0);
+}
+
+} // namespace binlog
+} // namespace ruby

data/ext/ruby_binlog_event.h

@@ -0,0 +1,163 @@
+#ifndef __RUBY_BINLOG_EVENT_H__
+#define __RUBY_BINLOG_EVENT_H__
+
+#include "ruby_binlog.h"
+
+extern VALUE rb_cBinlogEvent;
+
+namespace ruby {
+namespace binlog {
+
+struct Event {
+  mysql::Log_event_header *m_event_header;
+
+  static VALUE get_marker(VALUE self);
+  static VALUE get_timestamp(VALUE self);
+  static VALUE get_type_code(VALUE self);
+  static VALUE get_server_id(VALUE self);
+  static VALUE get_event_length(VALUE self);
+  static VALUE get_next_position(VALUE self);
+  static VALUE get_flags(VALUE self);
+  static VALUE get_event_type(VALUE self);
+  static void init(VALUE clazz);
+};
+
+struct QueryEvent : public Event {
+  mysql::Query_event *m_event;
+
+  static void free(QueryEvent *p);
+  static VALUE alloc(VALUE klass);
+  static void set_event(VALUE self, mysql::Binary_log_event *event);
+  static void init();
+
+  static VALUE get_thread_id(VALUE self);
+  static VALUE get_exec_time(VALUE self);
+  static VALUE get_error_code(VALUE self);
+  static VALUE get_variables(VALUE self);
+  static VALUE get_db_name(VALUE self);
+  static VALUE get_query(VALUE self);
+};
+
+struct RotateEvent : public Event {
+  mysql::Rotate_event *m_event;
+
+  static void free(RotateEvent *p);
+  static VALUE alloc(VALUE klass);
+  static void set_event(VALUE self, mysql::Binary_log_event *event);
+  static void init();
+
+  static VALUE get_binlog_file(VALUE self);
+  static VALUE get_binlog_pos(VALUE self);
+};
+
+struct FormatEvent : public Event {
+  mysql::Format_event *m_event;
+
+  static void free(FormatEvent *p);
+  static VALUE alloc(VALUE klass);
+  static void set_event(VALUE self, mysql::Binary_log_event *event);
+  static void init();
+
+  static VALUE get_binlog_version(VALUE self);
+  static VALUE get_master_version(VALUE self);
+  static VALUE get_created_ts(VALUE self);
+  static VALUE get_log_header_len(VALUE self);
+};
+
+struct UserVarEvent : public Event {
+  mysql::User_var_event *m_event;
+
+  static void free(UserVarEvent *p);
+  static VALUE alloc(VALUE klass);
+  static void set_event(VALUE self, mysql::Binary_log_event *event);
+  static void init();
+
+  static VALUE get_name(VALUE self);
+  static VALUE get_is_null(VALUE self);
+  static VALUE get_type(VALUE self);
+  static VALUE get_charset(VALUE self);
+  static VALUE get_value(VALUE self);
+};
+
+struct TableMapEvent : public Event {
+  mysql::Table_map_event *m_event;
+
+  static void free(TableMapEvent *p);
+  static VALUE alloc(VALUE klass);
+  static void set_event(VALUE self, mysql::Binary_log_event *event);
+  static void init();
+
+  static VALUE get_table_id(VALUE self);
+  static VALUE get_flags(VALUE self);
+  static VALUE get_db_name(VALUE self);
+  static VALUE get_table_name(VALUE self);
+  static VALUE get_columns(VALUE self);
+  static VALUE get_metadata(VALUE self);
+  static VALUE get_null_bits(VALUE self);
+};
+
+struct RowEvent : public Event {
+  mysql::Row_event *m_event;
+
+  static void free(RowEvent *p);
+  static VALUE alloc(VALUE klass);
+  static void set_event(VALUE self, mysql::Binary_log_event *event);
+  static void init();
+
+  static VALUE get_table_id(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);
+};
+
+struct IntVarEvent : public Event {
+  mysql::Int_var_event *m_event;
+
+  static void free(IntVarEvent *p);
+  static VALUE alloc(VALUE klass);
+  static void set_event(VALUE self, mysql::Binary_log_event *event);
+  static void init();
+
+  static VALUE get_type(VALUE self);
+  static VALUE get_value(VALUE self);
+};
+
+struct IncidentEvent : public Event {
+  mysql::Incident_event *m_event;
+
+  static void free(IncidentEvent *p);
+  static VALUE alloc(VALUE klass);
+  static void set_event(VALUE self, mysql::Binary_log_event *event);
+  static void init();
+
+  static VALUE get_type(VALUE self);
+  static VALUE get_message(VALUE self);
+};
+
+struct XidEvent : public Event {
+  mysql::Xid *m_event;
+
+  static void free(XidEvent *p);
+  static VALUE alloc(VALUE klass);
+  static void set_event(VALUE self, mysql::Binary_log_event *event);
+  static void init();
+
+  static VALUE get_xid_id(VALUE self);
+};
+
+struct UnimplementedEvent : public Event {
+  mysql::Binary_log_event *m_event;
+
+  static void free(QueryEvent *p);
+  static VALUE alloc(VALUE klass);
+  static void set_event(VALUE self, mysql::Binary_log_event *event);
+  static void init();
+};
+
+} // namespace binlog
+} // namespace ruby
+
+#endif // __RUBY_BINLOG_EVENT_H__

data/ext/ruby_binlog_format_event.cpp

@@ -0,0 +1,74 @@
+#include "ruby_binlog.h"
+
+VALUE rb_cBinlogFormatEvent;
+
+namespace ruby {
+namespace binlog {
+
+void FormatEvent::free(FormatEvent *p) {
+  if (p->m_event) {
+    delete p->m_event;
+    p->m_event = 0;
+    p->m_event_header = 0;
+  }
+
+  delete p;
+}
+
+VALUE FormatEvent::alloc(VALUE klass) {
+  FormatEvent *p;
+
+  p = new FormatEvent();
+  p->m_event = 0;
+  p->m_event_header = 0;
+
+  return Data_Wrap_Struct(klass, 0, &free, p);
+}
+
+void FormatEvent::set_event(VALUE self, mysql::Binary_log_event *event) {
+  FormatEvent *p;
+
+  Data_Get_Struct(self, FormatEvent, p);
+  p->m_event = static_cast<Format_event*>(event);
+  p->m_event_header = event->header();
+}
+
+void FormatEvent::init() {
+  rb_cBinlogFormatEvent = rb_define_class_under(rb_mBinlog, "FormatEvent", rb_cBinlogEvent);
+  rb_define_alloc_func(rb_cBinlogFormatEvent, &alloc);
+
+  Event::init(rb_cBinlogFormatEvent);
+
+  rb_define_method(rb_cBinlogFormatEvent, "binlog_version", __F(&get_binlog_version), 0);
+  // XXX: [BUG] Segmentation fault
+  //rb_define_method(rb_cBinlogFormatEvent, "master_version", __F(&get_master_version), 0);
+  rb_define_method(rb_cBinlogFormatEvent, "created_ts",     __F(&get_created_ts),     0);
+  rb_define_method(rb_cBinlogFormatEvent, "log_header_len", __F(&get_log_header_len), 0);
+}
+
+VALUE FormatEvent::get_binlog_version(VALUE self) {
+  FormatEvent *p;
+  Data_Get_Struct(self, FormatEvent, p);
+  return UINT2NUM(p->m_event->binlog_version);
+}
+
+VALUE FormatEvent::get_master_version(VALUE self) {
+  FormatEvent *p;
+  Data_Get_Struct(self, FormatEvent, p);
+  return rb_str_new2(p->m_event->master_version.c_str());
+}
+
+VALUE FormatEvent::get_created_ts(VALUE self) {
+  FormatEvent *p;
+  Data_Get_Struct(self, FormatEvent, p);
+  return ULONG2NUM(p->m_event->created_ts);
+}
+
+VALUE FormatEvent::get_log_header_len(VALUE self) {
+  FormatEvent *p;
+  Data_Get_Struct(self, FormatEvent, p);
+  return UINT2NUM(p->m_event->log_header_len);
+}
+
+} // namespace binlog
+} // namespace ruby

data/ext/ruby_binlog_incident_event.cpp

@@ -0,0 +1,59 @@
+#include "ruby_binlog.h"
+
+VALUE rb_cBinlogIncidentEvent;
+
+namespace ruby {
+namespace binlog {
+
+void IncidentEvent::free(IncidentEvent *p) {
+  if (p->m_event) {
+    delete p->m_event;
+    p->m_event = 0;
+    p->m_event_header = 0;
+  }
+
+  delete p;
+}
+
+VALUE IncidentEvent::alloc(VALUE klass) {
+  IncidentEvent *p;
+
+  p = new IncidentEvent();
+  p->m_event = 0;
+  p->m_event_header = 0;
+
+  return Data_Wrap_Struct(klass, 0, &free, p);
+}
+
+void IncidentEvent::set_event(VALUE self, mysql::Binary_log_event *event) {
+  IncidentEvent *p;
+
+  Data_Get_Struct(self, IncidentEvent, p);
+  p->m_event = static_cast<Incident_event*>(event);
+  p->m_event_header = event->header();
+}
+
+void IncidentEvent::init() {
+  rb_cBinlogIncidentEvent = rb_define_class_under(rb_mBinlog, "IncidentEvent", rb_cBinlogEvent);
+  rb_define_alloc_func(rb_cBinlogIncidentEvent, &alloc);
+
+  Event::init(rb_cBinlogIncidentEvent);
+
+  rb_define_method(rb_cBinlogIncidentEvent, "incident_type", __F(&get_type),    0);
+  rb_define_method(rb_cBinlogIncidentEvent, "message",       __F(&get_message), 0);
+}
+
+VALUE IncidentEvent::get_type(VALUE self) {
+  IncidentEvent *p;
+  Data_Get_Struct(self, IncidentEvent, p);
+  return UINT2NUM(p->m_event->type);
+}
+
+VALUE IncidentEvent::get_message(VALUE self) {
+  IncidentEvent *p;
+  Data_Get_Struct(self, IncidentEvent, p);
+  return rb_str_new2(p->m_event->message.c_str());
+}
+
+} // namespace binlog
+} // namespace ruby

data/ext/ruby_binlog_int_var_event.cpp

@@ -0,0 +1,59 @@
+#include "ruby_binlog.h"
+
+VALUE rb_cBinlogIntVarEvent;
+
+namespace ruby {
+namespace binlog {
+
+void IntVarEvent::free(IntVarEvent *p) {
+  if (p->m_event) {
+    delete p->m_event;
+    p->m_event = 0;
+    p->m_event_header = 0;
+  }
+
+  delete p;
+}
+
+VALUE IntVarEvent::alloc(VALUE klass) {
+  IntVarEvent *p;
+
+  p = new IntVarEvent();
+  p->m_event = 0;
+  p->m_event_header = 0;
+
+  return Data_Wrap_Struct(klass, 0, &free, p);
+}
+
+void IntVarEvent::set_event(VALUE self, mysql::Binary_log_event *event) {
+  IntVarEvent *p;
+
+  Data_Get_Struct(self, IntVarEvent, p);
+  p->m_event = static_cast<Int_var_event*>(event);
+  p->m_event_header = event->header();
+}
+
+void IntVarEvent::init() {
+  rb_cBinlogIntVarEvent = rb_define_class_under(rb_mBinlog, "IntVarEvent", rb_cBinlogEvent);
+  rb_define_alloc_func(rb_cBinlogIntVarEvent, &alloc);
+
+  Event::init(rb_cBinlogIntVarEvent);
+
+  rb_define_method(rb_cBinlogIntVarEvent, "var_type", __F(&get_type),  0);
+  rb_define_method(rb_cBinlogIntVarEvent, "value",    __F(&get_value), 0);
+}
+
+VALUE IntVarEvent::get_type(VALUE self) {
+  IntVarEvent *p;
+  Data_Get_Struct(self, IntVarEvent, p);
+  return UINT2NUM(p->m_event->type);
+}
+
+VALUE IntVarEvent::get_value(VALUE self) {
+  IntVarEvent *p;
+  Data_Get_Struct(self, IntVarEvent, p);
+  return ULL2NUM(p->m_event->value);
+}
+
+} // namespace binlog
+} // namespace ruby