ruby-binlog 0.1.0

data/ext/ruby_binlog_query_event.cpp

@@ -0,0 +1,95 @@
+#include "ruby_binlog.h"
+
+VALUE rb_cBinlogQueryEvent;
+
+namespace ruby {
+namespace binlog {
+
+void QueryEvent::free(QueryEvent *p) {
+  if (p->m_event) {
+    delete p->m_event;
+    p->m_event = 0;
+    p->m_event_header = 0;
+  }
+
+  delete p;
+}
+
+VALUE QueryEvent::alloc(VALUE klass) {
+  QueryEvent *p;
+
+  p = new QueryEvent();
+  p->m_event = 0;
+  p->m_event_header = 0;
+
+  return Data_Wrap_Struct(klass, 0, &free, p);
+}
+
+void QueryEvent::set_event(VALUE self, mysql::Binary_log_event *event) {
+  QueryEvent *p;
+
+  Data_Get_Struct(self, QueryEvent, p);
+  p->m_event = static_cast<Query_event*>(event);
+  p->m_event_header = event->header();
+}
+
+void QueryEvent::init() {
+  rb_cBinlogQueryEvent = rb_define_class_under(rb_mBinlog, "QueryEvent", rb_cBinlogEvent);
+  rb_define_alloc_func(rb_cBinlogQueryEvent, &alloc);
+
+  Event::init(rb_cBinlogQueryEvent);
+
+  rb_define_method(rb_cBinlogQueryEvent, "thread_id",  __F(&get_thread_id),  0);
+  rb_define_method(rb_cBinlogQueryEvent, "exec_time",  __F(&get_exec_time),  0);
+  rb_define_method(rb_cBinlogQueryEvent, "error_code", __F(&get_error_code), 0);
+  rb_define_method(rb_cBinlogQueryEvent, "variables", __F(&get_variables), 0);
+  rb_define_method(rb_cBinlogQueryEvent, "db_name",    __F(&get_db_name),    0);
+  rb_define_method(rb_cBinlogQueryEvent, "query",      __F(&get_query),      0);
+}
+
+VALUE QueryEvent::get_thread_id(VALUE self) {
+  QueryEvent *p;
+  Data_Get_Struct(self, QueryEvent, p);
+  return ULONG2NUM(p->m_event->thread_id);
+}
+
+VALUE QueryEvent::get_exec_time(VALUE self) {
+  QueryEvent *p;
+  Data_Get_Struct(self, QueryEvent, p);
+  return ULONG2NUM(p->m_event->exec_time);
+}
+
+VALUE QueryEvent::get_error_code(VALUE self) {
+  QueryEvent *p;
+  Data_Get_Struct(self, QueryEvent, p);
+  return ULONG2NUM(p->m_event->error_code);
+}
+
+VALUE QueryEvent::get_variables(VALUE self) {
+  QueryEvent *p;
+  VALUE retval = rb_ary_new();
+
+  Data_Get_Struct(self, QueryEvent, p);
+
+  for (std::vector<uint8_t>::iterator itor = p->m_event->variables.begin();
+       itor != p->m_event->variables.end(); itor++) {
+    rb_ary_push(retval, UINT2NUM(*itor));
+  }
+
+  return retval;
+}
+
+VALUE QueryEvent::get_db_name(VALUE self) {
+  QueryEvent *p;
+  Data_Get_Struct(self, QueryEvent, p);
+  return rb_str_new2(p->m_event->db_name.c_str());
+}
+
+VALUE QueryEvent::get_query(VALUE self) {
+  QueryEvent *p;
+  Data_Get_Struct(self, QueryEvent, p);
+  return rb_str_new2(p->m_event->query.c_str());
+}
+
+} // namespace binlog
+} // namespace ruby

data/ext/ruby_binlog_rotate_event.cpp

@@ -0,0 +1,59 @@
+#include "ruby_binlog.h"
+
+VALUE rb_cBinlogRotateEvent;
+
+namespace ruby {
+namespace binlog {
+
+void RotateEvent::free(RotateEvent *p) {
+  if (p->m_event) {
+    delete p->m_event;
+    p->m_event = 0;
+    p->m_event_header = 0;
+  }
+
+  delete p;
+}
+
+VALUE RotateEvent::alloc(VALUE klass) {
+  RotateEvent *p;
+
+  p = new RotateEvent();
+  p->m_event = 0;
+  p->m_event_header = 0;
+
+  return Data_Wrap_Struct(klass, 0, &free, p);
+}
+
+void RotateEvent::set_event(VALUE self, mysql::Binary_log_event *event) {
+  RotateEvent *p;
+
+  Data_Get_Struct(self, RotateEvent, p);
+  p->m_event = static_cast<Rotate_event*>(event);
+  p->m_event_header = event->header();
+}
+
+void RotateEvent::init() {
+  rb_cBinlogRotateEvent = rb_define_class_under(rb_mBinlog, "RotateEvent", rb_cBinlogEvent);
+  rb_define_alloc_func(rb_cBinlogRotateEvent, &alloc);
+
+  Event::init(rb_cBinlogRotateEvent);
+
+  rb_define_method(rb_cBinlogRotateEvent, "binlog_file", __F(&get_binlog_file), 0);
+  rb_define_method(rb_cBinlogRotateEvent, "binlog_pos",  __F(&get_binlog_pos),  0);
+}
+
+VALUE RotateEvent::get_binlog_file(VALUE self) {
+  RotateEvent *p;
+  Data_Get_Struct(self, RotateEvent, p);
+  return rb_str_new2(p->m_event->binlog_file.c_str());
+}
+
+VALUE RotateEvent::get_binlog_pos(VALUE self) {
+  RotateEvent *p;
+  Data_Get_Struct(self, RotateEvent, p);
+  return ULL2NUM(p->m_event->binlog_pos);
+}
+
+} // namespace binlog
+} // namespace ruby

data/ext/ruby_binlog_row_event.cpp

@@ -0,0 +1,118 @@
+#include "ruby_binlog.h"
+
+VALUE rb_cBinlogRowEvent;
+
+namespace ruby {
+namespace binlog {
+
+void RowEvent::free(RowEvent *p) {
+  if (p->m_event) {
+    delete p->m_event;
+    p->m_event = 0;
+    p->m_event_header = 0;
+  }
+
+  delete p;
+}
+
+VALUE RowEvent::alloc(VALUE klass) {
+  RowEvent *p;
+
+  p = new RowEvent();
+  p->m_event = 0;
+  p->m_event_header = 0;
+
+  return Data_Wrap_Struct(klass, 0, &free, p);
+}
+
+void RowEvent::set_event(VALUE self, mysql::Binary_log_event *event) {
+  RowEvent *p;
+
+  Data_Get_Struct(self, RowEvent, p);
+  p->m_event = static_cast<Row_event*>(event);
+  p->m_event_header = event->header();
+}
+
+void RowEvent::init() {
+  rb_cBinlogRowEvent = rb_define_class_under(rb_mBinlog, "RowEvent", rb_cBinlogEvent);
+  rb_define_alloc_func(rb_cBinlogRowEvent, &alloc);
+
+  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);
+}
+
+VALUE RowEvent::get_table_id(VALUE self) {
+  RowEvent *p;
+  Data_Get_Struct(self, RowEvent, p);
+  return ULL2NUM(p->m_event->table_id);
+}
+
+VALUE RowEvent::get_flags(VALUE self) {
+  RowEvent *p;
+  Data_Get_Struct(self, RowEvent, p);
+  return UINT2NUM(p->m_event->flags);
+}
+
+VALUE RowEvent::get_columns_len(VALUE self) {
+  RowEvent *p;
+  Data_Get_Struct(self, RowEvent, p);
+  return ULONG2NUM(p->m_event->columns_len);
+}
+
+VALUE RowEvent::get_null_bits_len(VALUE self) {
+  RowEvent *p;
+  Data_Get_Struct(self, RowEvent, p);
+  return UINT2NUM(p->m_event->null_bits_len);
+}
+
+VALUE RowEvent::get_columns_before_image(VALUE self) {
+  RowEvent *p;
+  VALUE retval = rb_ary_new();
+
+  Data_Get_Struct(self, RowEvent, p);
+
+  for (std::vector<uint8_t>::iterator itor = p->m_event->columns_before_image.begin();
+       itor != p->m_event->columns_before_image.end(); itor++) {
+    rb_ary_push(retval, UINT2NUM(*itor));
+  }
+
+  return retval;
+}
+
+VALUE RowEvent::get_used_columns(VALUE self) {
+  RowEvent *p;
+  VALUE retval = rb_ary_new();
+
+  Data_Get_Struct(self, RowEvent, p);
+
+  for (std::vector<uint8_t>::iterator itor = p->m_event->used_columns.begin();
+       itor != p->m_event->used_columns.end(); itor++) {
+    rb_ary_push(retval, UINT2NUM(*itor));
+  }
+
+  return retval;
+}
+
+VALUE RowEvent::get_row(VALUE self) {
+  RowEvent *p;
+  VALUE retval = rb_ary_new();
+
+  Data_Get_Struct(self, RowEvent, p);
+
+  for (std::vector<uint8_t>::iterator itor = p->m_event->row.begin();
+       itor != p->m_event->row.end(); itor++) {
+    rb_ary_push(retval, UINT2NUM(*itor));
+  }
+
+  return retval;
+}
+
+} // namespace binlog
+} // namespace ruby

data/ext/ruby_binlog_table_map_event.cpp

@@ -0,0 +1,118 @@
+#include "ruby_binlog.h"
+
+VALUE rb_cBinlogTableMapEvent;
+
+namespace ruby {
+namespace binlog {
+
+void TableMapEvent::free(TableMapEvent *p) {
+  if (p->m_event) {
+    delete p->m_event;
+    p->m_event = 0;
+    p->m_event_header = 0;
+  }
+
+  delete p;
+}
+
+VALUE TableMapEvent::alloc(VALUE klass) {
+  TableMapEvent *p;
+
+  p = new TableMapEvent();
+  p->m_event = 0;
+  p->m_event_header = 0;
+
+  return Data_Wrap_Struct(klass, 0, &free, p);
+}
+
+void TableMapEvent::set_event(VALUE self, mysql::Binary_log_event *event) {
+  TableMapEvent *p;
+
+  Data_Get_Struct(self, TableMapEvent, p);
+  p->m_event = static_cast<Table_map_event*>(event);
+  p->m_event_header = event->header();
+}
+
+void TableMapEvent::init() {
+  rb_cBinlogTableMapEvent = rb_define_class_under(rb_mBinlog, "TableMapEvent", rb_cBinlogEvent);
+  rb_define_alloc_func(rb_cBinlogTableMapEvent, &alloc);
+
+  Event::init(rb_cBinlogTableMapEvent);
+
+  rb_define_method(rb_cBinlogTableMapEvent, "table_id",   __F(&get_table_id),   0);
+  rb_define_method(rb_cBinlogTableMapEvent, "flags",      __F(&get_flags),      0);
+  rb_define_method(rb_cBinlogTableMapEvent, "db_name",    __F(&get_db_name),    0);
+  rb_define_method(rb_cBinlogTableMapEvent, "table_name", __F(&get_table_name), 0);
+  rb_define_method(rb_cBinlogTableMapEvent, "columns",    __F(&get_columns),    0);
+  rb_define_method(rb_cBinlogTableMapEvent, "metadata",   __F(&get_metadata),   0);
+  rb_define_method(rb_cBinlogTableMapEvent, "null_bits",  __F(&get_null_bits),  0);
+}
+
+VALUE TableMapEvent::get_table_id(VALUE self) {
+  TableMapEvent *p;
+  Data_Get_Struct(self, TableMapEvent, p);
+  return ULL2NUM(p->m_event->table_id);
+}
+
+VALUE TableMapEvent::get_flags(VALUE self) {
+  TableMapEvent *p;
+  Data_Get_Struct(self, TableMapEvent, p);
+  return UINT2NUM(p->m_event->flags);
+}
+
+VALUE TableMapEvent::get_db_name(VALUE self) {
+  TableMapEvent *p;
+  Data_Get_Struct(self, TableMapEvent, p);
+  return rb_str_new2(p->m_event->db_name.c_str());
+}
+
+VALUE TableMapEvent::get_table_name(VALUE self) {
+  TableMapEvent *p;
+  Data_Get_Struct(self, TableMapEvent, p);
+  return rb_str_new2(p->m_event->table_name.c_str());
+}
+
+VALUE TableMapEvent::get_columns(VALUE self) {
+  TableMapEvent *p;
+  VALUE retval = rb_ary_new();
+
+  Data_Get_Struct(self, TableMapEvent, p);
+
+  for (std::vector<uint8_t>::iterator itor = p->m_event->columns.begin();
+       itor != p->m_event->columns.end(); itor++) {
+    rb_ary_push(retval, UINT2NUM(*itor));
+  }
+
+  return retval;
+}
+
+VALUE TableMapEvent::get_metadata(VALUE self) {
+  TableMapEvent *p;
+  VALUE retval = rb_ary_new();
+
+  Data_Get_Struct(self, TableMapEvent, p);
+
+  for (std::vector<uint8_t>::iterator itor = p->m_event->metadata.begin();
+       itor != p->m_event->metadata.end(); itor++) {
+    rb_ary_push(retval, UINT2NUM(*itor));
+  }
+
+  return retval;
+}
+
+VALUE TableMapEvent::get_null_bits(VALUE self) {
+  TableMapEvent *p;
+  VALUE retval = rb_ary_new();
+
+  Data_Get_Struct(self, TableMapEvent, p);
+
+  for (std::vector<uint8_t>::iterator itor = p->m_event->null_bits.begin();
+       itor != p->m_event->null_bits.end(); itor++) {
+    rb_ary_push(retval, UINT2NUM(*itor));
+  }
+
+  return retval;
+}
+
+} // namespace binlog
+} // namespace ruby

data/ext/ruby_binlog_unimplemented_event.cpp

@@ -0,0 +1,44 @@
+#include "ruby_binlog.h"
+
+VALUE rb_cBinlogUnimplementedEvent;
+
+namespace ruby {
+namespace binlog {
+
+void UnimplementedEvent::free(QueryEvent *p) {
+  if (p->m_event) {
+    delete p->m_event;
+    p->m_event = 0;
+    p->m_event_header = 0;
+  }
+
+  delete p;
+}
+
+VALUE UnimplementedEvent::alloc(VALUE klass) {
+  UnimplementedEvent *p;
+
+  p = new UnimplementedEvent();
+  p->m_event = 0;
+  p->m_event_header = 0;
+
+  return Data_Wrap_Struct(klass, 0, &free, p);
+}
+
+void UnimplementedEvent::set_event(VALUE self, mysql::Binary_log_event *event) {
+  UnimplementedEvent *p;
+
+  Data_Get_Struct(self, UnimplementedEvent, p);
+  p->m_event = event;
+  p->m_event_header = event->header();
+}
+
+void UnimplementedEvent::init() {
+  rb_cBinlogUnimplementedEvent = rb_define_class_under(rb_mBinlog, "UnimplementedEvent", rb_cBinlogEvent);
+  rb_define_alloc_func(rb_cBinlogUnimplementedEvent, &alloc);
+
+  Event::init(rb_cBinlogUnimplementedEvent);
+}
+
+} // namespace binlog
+} // namespace ruby