diff --git a/pymysqlreplication/binlogstream.py b/pymysqlreplication/binlogstream.py
index 39208413..fea9d1f8 100644
--- a/pymysqlreplication/binlogstream.py
+++ b/pymysqlreplication/binlogstream.py
@@ -12,11 +12,11 @@ class BinLogStreamReader(object):
     '''Connect to replication stream and read event'''
 
     def __init__(self, connection_settings={}, resume_stream=False, blocking=False, only_events=None, server_id=255):
-        '''
+        """
         resume_stream: Start for latest event of binlog or from older available event
         blocking: Read on stream is blocking
         only_events: Array of allowed events
-        '''
+        """
         self.__connection_settings = connection_settings
         self.__connection_settings['charset'] = 'utf8'
 
@@ -29,7 +29,7 @@ def __init__(self, connection_settings={}, resume_stream=False, blocking=False,
         self.__log_pos = None
         self.__log_file = None
 
-        #Store table meta informations
+        #Store table meta information
         self.table_map = {}
 
     def close(self):
@@ -97,7 +97,7 @@ def fetchone(self):
                 return None
             binlog_event = BinLogPacketWrapper(pkt, self.table_map, self._ctl_connection)
             if binlog_event.event_type == TABLE_MAP_EVENT:
-                self.table_map[binlog_event.event.table_id] = binlog_event.event
+                self.table_map[binlog_event.event.table_id] = binlog_event.event.get_table()
             if self.__filter_event(binlog_event.event):
                 continue
             if binlog_event.event_type == ROTATE_EVENT:
diff --git a/pymysqlreplication/column.py b/pymysqlreplication/column.py
index a31f7b38..b5aaf13c 100644
--- a/pymysqlreplication/column.py
+++ b/pymysqlreplication/column.py
@@ -2,60 +2,85 @@
 from .constants import FIELD_TYPE
 from pymysql.util import byte2int, int2byte
 
+
 class Column(object):
-    '''Definition of a column'''
+    """Definition of a column"""
+
+    def __init__(self, *args, **kwargs):
+        self.data = {}
+        if len(args) == 3:
+            self.__parse_column_definition(*args)
+        else:
+            self.data = kwargs
 
-    def __init__(self, column_type, column_schema, packet):
-        self.type = column_type
-        self.name = column_schema["COLUMN_NAME"]
-        self.collation_name = column_schema["COLLATION_NAME"]
-        self.character_set_name = column_schema["CHARACTER_SET_NAME"]
-        self.comment = column_schema["COLUMN_COMMENT"]
-        self.unsigned = False
+    def __parse_column_definition(self, column_type, column_schema, packet):
+        self.data["type"] = column_type
+        self.data["name"] = column_schema["COLUMN_NAME"]
+        self.data["collation_name"] = column_schema["COLLATION_NAME"]
+        self.data["character_set_name"] = column_schema["CHARACTER_SET_NAME"]
+        self.data["comment"] = column_schema["COLUMN_COMMENT"]
+        self.data["unsigned"] = False
+        self.data["type_is_bool"] = False
 
         if column_schema["COLUMN_TYPE"].find("unsigned") != -1:
-            self.unsigned = True
+            self.data["unsigned"] = True
         if self.type == FIELD_TYPE.VAR_STRING or self.type == FIELD_TYPE.STRING:
             self.__read_string_metadata(packet, column_schema)
         elif self.type == FIELD_TYPE.VARCHAR:
-            self.max_length = struct.unpack('<H', packet.read(2))[0]
+            self.data["max_length"] = struct.unpack('<H', packet.read(2))[0]
         elif self.type == FIELD_TYPE.BLOB:
-            self.length_size = packet.read_uint8()
+            self.data["length_size"] = packet.read_uint8()
         elif self.type == FIELD_TYPE.GEOMETRY:
-            self.length_size = packet.read_uint8()
+            self.data["length_size"] = packet.read_uint8()
         elif self.type == FIELD_TYPE.NEWDECIMAL:
-            self.precision = packet.read_uint8()
-            self.decimals = packet.read_uint8()
+            self.data["precision"] = packet.read_uint8()
+            self.data["decimals"] = packet.read_uint8()
         elif self.type == FIELD_TYPE.DOUBLE:
-            self.size = packet.read_uint8()
+            self.data["size"] = packet.read_uint8()
         elif self.type == FIELD_TYPE.FLOAT:
-            self.size = packet.read_uint8()
+            self.data["size"] = packet.read_uint8()
         elif self.type == FIELD_TYPE.BIT:
             bits = packet.read_uint8()
             bytes = packet.read_uint8()
-            self.bits = (bytes * 8) + bits
-            self.bytes = int((self.bits + 7) / 8)
+            self.data["bits"] = (bytes * 8) + bits
+            self.data["bytes"] = int((self.bits + 7) / 8)
         elif self.type == FIELD_TYPE.TIMESTAMP2:
-            self.fsp = packet.read_uint8()
+            self.data["fsp"] = packet.read_uint8()
         elif self.type == FIELD_TYPE.DATETIME2:
-            self.fsp = packet.read_uint8()
+            self.data["fsp"] = packet.read_uint8()
         elif self.type == FIELD_TYPE.TIME2:
-            self.fsp = packet.read_uint8()
-
+            self.data["fsp"] = packet.read_uint8()
+        elif self.type == FIELD_TYPE.TINY and column_schema["COLUMN_TYPE"] == "tinyint(1)":
+            self.data["type_is_bool"] = True
 
     def __read_string_metadata(self, packet, column_schema):
-        metadata  = (packet.read_uint8() << 8) + packet.read_uint8()
+        metadata = (packet.read_uint8() << 8) + packet.read_uint8()
         real_type = metadata >> 8
         if real_type == FIELD_TYPE.SET or real_type == FIELD_TYPE.ENUM:
-            self.type = real_type
-            self.size = metadata & 0x00ff
+            self.data["type"] = real_type
+            self.data["size"] = metadata & 0x00ff
             self.__read_enum_metadata(column_schema)
         else:
-            self.max_length = (((metadata >> 4) & 0x300) ^ 0x300) + (metadata & 0x00ff)
+            self.data["max_length"] = (((metadata >> 4) & 0x300) ^ 0x300) + (metadata & 0x00ff)
 
     def __read_enum_metadata(self, column_schema):
         enums = column_schema["COLUMN_TYPE"]
         if self.type == FIELD_TYPE.ENUM:
-            self.enum_values = enums.replace('enum(', '').replace(')', '').replace('\'', '').split(',')
+            self.data["enum_values"] = enums.replace('enum(', '').replace(')', '').replace('\'', '').split(',')
+        else:
+            self.data["set_values"] = enums.replace('set(', '').replace(')', '').replace('\'', '').split(',')
+
+    def __eq__(self, other):
+        return self.data == other.data
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def serializable_data(self):
+        return self.data
+
+    def __getattr__(self, item):
+        if item in self.data:
+            return self.data[item]
         else:
-            self.set_values = enums.replace('set(', '').replace(')', '').replace('\'', '').split(',')
+            raise AttributeError("{0} not found".format(item))
diff --git a/pymysqlreplication/packet.py b/pymysqlreplication/packet.py
index a3f4edc9..d9eacbbb 100644
--- a/pymysqlreplication/packet.py
+++ b/pymysqlreplication/packet.py
@@ -107,15 +107,15 @@ def read_length_coded_binary(self):
         """
         c = byte2int(self.read(1))
         if c == NULL_COLUMN:
-          return None
+            return None
         if c < UNSIGNED_CHAR_COLUMN:
-          return c
+            return c
         elif c == UNSIGNED_SHORT_COLUMN:
             return self.unpack_uint16(self.read(UNSIGNED_SHORT_LENGTH))
         elif c == UNSIGNED_INT24_COLUMN:
-          return self.unpack_int24(self.read(UNSIGNED_INT24_LENGTH))
+            return self.unpack_int24(self.read(UNSIGNED_INT24_LENGTH))
         elif c == UNSIGNED_INT64_COLUMN:
-          return self.unpack_int64(self.read(UNSIGNED_INT64_LENGTH))
+            return self.unpack_int64(self.read(UNSIGNED_INT64_LENGTH))
 
     def read_length_coded_string(self):
         """Read a 'Length Coded String' from the data buffer.
diff --git a/pymysqlreplication/row_event.py b/pymysqlreplication/row_event.py
index 767e5ec8..170c988d 100644
--- a/pymysqlreplication/row_event.py
+++ b/pymysqlreplication/row_event.py
@@ -7,6 +7,8 @@
 from .constants import FIELD_TYPE
 from .constants import BINLOG
 from .column import Column
+from .table import Table
+
 
 class RowsEvent(BinLogEvent):
     def __init__(self, from_packet, event_size, table_map, ctl_connection):
@@ -19,8 +21,8 @@ def __init__(self, from_packet, event_size, table_map, ctl_connection):
 
         #Event V2
         if self.event_type == BINLOG.WRITE_ROWS_EVENT or \
-            self.event_type == BINLOG.DELETE_ROWS_EVENT or \
-            self.event_type == BINLOG.UPDATE_ROWS_EVENT:
+                        self.event_type == BINLOG.DELETE_ROWS_EVENT or \
+                        self.event_type == BINLOG.UPDATE_ROWS_EVENT:
             self.extra_data_length = struct.unpack('<H', self.packet.read(2))[0]
             self.extra_data = self.packet.read(self.extra_data_length / 8)
 
@@ -54,6 +56,9 @@ def _read_column_data(self, null_bitmap):
                     values[name] = struct.unpack("<B", self.packet.read(1))[0]
                 else:
                     values[name] = struct.unpack("<b", self.packet.read(1))[0]
+
+                if column.type_is_bool:
+                    values[name] = bool(values[name])
             elif column.type == FIELD_TYPE.SHORT:
                 if unsigned:
                     values[name] = struct.unpack("<H", self.packet.read(2))[0]
@@ -94,10 +99,11 @@ def _read_column_data(self, null_bitmap):
             # For new date format: http://dev.mysql.com/doc/internals/en/date-and-time-data-type-representation.html
             elif column.type == FIELD_TYPE.DATETIME2:
                 values[name] = self.__read_datetime2(column)
-            elif  column.type == FIELD_TYPE.TIME2:
+            elif column.type == FIELD_TYPE.TIME2:
                 values[name] = self.__read_time2(column)
             elif column.type == FIELD_TYPE.TIMESTAMP2:
-                values[name] = self.__add_fsp_to_time(datetime.datetime.fromtimestamp(self.packet.read_int_be_by_size(4)), column)
+                values[name] = self.__add_fsp_to_time(
+                    datetime.datetime.fromtimestamp(self.packet.read_int_be_by_size(4)), column)
             elif column.type == FIELD_TYPE.LONGLONG:
                 if unsigned:
                     values[name] = self.packet.read_uint64()
@@ -110,7 +116,7 @@ def _read_column_data(self, null_bitmap):
             elif column.type == FIELD_TYPE.SET:
                 #We read set columns as a bitmap telling us which options are enabled
                 bit_mask = self.packet.read_uint_by_size(column.size)
-                values[name] = {val for idx,val in enumerate(column.set_values) if bit_mask & 2**idx} or None
+                values[name] = {val for idx, val in enumerate(column.set_values) if bit_mask & 2 ** idx} or None
 
             elif column.type == FIELD_TYPE.BIT:
                 values[name] = self.__read_bit(column)
@@ -134,9 +140,9 @@ def __add_fsp_to_time(self, time, column):
         if read > 0:
             microsecond = self.packet.read_int_be_by_size(read)
             if column.fsp % 2:
-                time = time.replace(microsecond = int(microsecond / 10))
+                time = time.replace(microsecond=int(microsecond / 10))
             else:
-                time = time.replace(microsecond = microsecond)
+                time = time.replace(microsecond=microsecond)
         return time
 
     def __read_string(self, size, column):
@@ -171,9 +177,9 @@ def __read_bit(self, column):
     def __read_time(self):
         time = self.packet.read_uint24()
         date = datetime.time(
-            hour = int(time / 10000),
-            minute = int((time % 10000) / 100),
-            second = int(time % 100))
+            hour=int(time / 10000),
+            minute=int((time % 10000) / 100),
+            second=int(time % 100))
         return date
 
     def __read_time2(self, column):
@@ -187,9 +193,9 @@ def __read_time2(self, column):
 24 bits = 3 bytes'''
         data = self.packet.read_int_be_by_size(3)
         t = datetime.time(
-            hour = self.__read_binary_slice(data, 2, 10, 24),
-            minute = self.__read_binary_slice(data, 12, 6, 24),
-            second = self.__read_binary_slice(data, 18, 6, 24))
+            hour=self.__read_binary_slice(data, 2, 10, 24),
+            minute=self.__read_binary_slice(data, 12, 6, 24),
+            second=self.__read_binary_slice(data, 18, 6, 24))
         return self.__add_fsp_to_time(t, column)
 
     def __read_date(self):
@@ -198,9 +204,9 @@ def __read_date(self):
             return None
 
         date = datetime.date(
-            year = (time & ((1 << 15) - 1) << 9) >> 9,
-            month = (time & ((1 << 4) - 1) << 5) >> 5,
-            day = (time & ((1 << 5) - 1))
+            year=(time & ((1 << 15) - 1) << 9) >> 9,
+            month=(time & ((1 << 4) - 1) << 5) >> 5,
+            day=(time & ((1 << 5) - 1))
         )
         return date
 
@@ -219,12 +225,12 @@ def __read_datetime(self):
             return None
 
         date = datetime.datetime(
-            year = year,
-            month = month,
-            day = day,
-            hour = int(time / 10000),
-            minute = int((time % 10000) / 100),
-            second = int(time % 100))
+            year=year,
+            month=month,
+            day=day,
+            hour=int(time / 10000),
+            minute=int((time % 10000) / 100),
+            second=int(time % 100))
         return date
 
     def __read_datetime2(self, column):
@@ -241,12 +247,12 @@ def __read_datetime2(self, column):
         year_month = self.__read_binary_slice(data, 1, 17, 40)
         try:
             t = datetime.datetime(
-                year = int(year_month / 13),
-                month = year_month % 13,
-                day = self.__read_binary_slice(data, 18, 5, 40),
-                hour = self.__read_binary_slice(data, 23, 5, 40),
-                minute = self.__read_binary_slice(data, 28, 6, 40),
-                second = self.__read_binary_slice(data, 34, 6, 40))
+                year=int(year_month / 13),
+                month=year_month % 13,
+                day=self.__read_binary_slice(data, 18, 5, 40),
+                hour=self.__read_binary_slice(data, 23, 5, 40),
+                minute=self.__read_binary_slice(data, 28, 6, 40),
+                second=self.__read_binary_slice(data, 34, 6, 40))
         except ValueError:
             return None
         return self.__add_fsp_to_time(t, column)
@@ -278,7 +284,6 @@ def __read_new_decimal(self, column):
             res = "-"
         self.packet.unread(struct.pack('<B', value ^ 0x80))
 
-
         size = compressed_bytes[comp_integral]
         if size > 0:
             value = self.packet.read_int_be_by_size(size) ^ mask
@@ -316,7 +321,7 @@ def __read_binary_slice(self, binary, start, size, data_length):
     def _dump(self):
         super(RowsEvent, self)._dump()
         print("Table: %s.%s" % (self.schema, self.table))
-        print("Affected columns: %d" % (self.number_of_columns))
+        print("Affected columns: %d" % self.number_of_columns)
         print("Changed rows: %d" % (len(self.rows)))
 
     def _fetch_rows(self):
@@ -332,7 +337,8 @@ def __getattr__(self, name):
 
 
 class DeleteRowsEvent(RowsEvent):
-    '''This evenement is trigger when a row in database is removed'''
+    """This event is trigger when a row in the database is removed"""
+
     def __init__(self, from_packet, event_size, table_map, ctl_connection):
         super(DeleteRowsEvent, self).__init__(from_packet, event_size, table_map, ctl_connection)
         self.columns_present_bitmap = self.packet.read((self.number_of_columns + 7) / 8)
@@ -354,7 +360,8 @@ def _dump(self):
 
 
 class WriteRowsEvent(RowsEvent):
-    '''This evenement is trigger when a row in database is added'''
+    """This event is triggered when a row in database is added"""
+
     def __init__(self, from_packet, event_size, table_map, ctl_connection):
         super(WriteRowsEvent, self).__init__(from_packet, event_size, table_map, ctl_connection)
         self.columns_present_bitmap = self.packet.read((self.number_of_columns + 7) / 8)
@@ -376,9 +383,10 @@ def _dump(self):
 
 
 class UpdateRowsEvent(RowsEvent):
-    '''This evenement is trigger when a row in database change'''
+    """This event is triggered when a row in the database is changed"""
+
     def __init__(self, from_packet, event_size, table_map, ctl_connection):
-        super(UpdateRowsEvent,self).__init__(from_packet, event_size, table_map, ctl_connection)
+        super(UpdateRowsEvent, self).__init__(from_packet, event_size, table_map, ctl_connection)
         #Body
         self.columns_present_bitmap = self.packet.read((self.number_of_columns + 7) / 8)
         self.columns_present_bitmap2 = self.packet.read((self.number_of_columns + 7) / 8)
@@ -395,7 +403,7 @@ def _fetch_one_row(self):
 
     def _dump(self):
         super(UpdateRowsEvent, self)._dump()
-        print("Affected columns: %d" % (self.number_of_columns))
+        print("Affected columns: %d" % self.number_of_columns)
         print("Values:")
         for row in self.rows:
             print("--")
@@ -407,6 +415,7 @@ class TableMapEvent(BinLogEvent):
     '''This evenement describe the structure of a table.
     It's send before a change append on a table.
     A end user of the lib should have no usage of this'''
+
     def __init__(self, from_packet, event_size, table_map, ctl_connection):
         super(TableMapEvent, self).__init__(from_packet, event_size, table_map, ctl_connection)
 
@@ -414,12 +423,11 @@ def __init__(self, from_packet, event_size, table_map, ctl_connection):
         self.table_id = self._read_table_id()
         self.flags = struct.unpack('<H', self.packet.read(2))[0]
 
-
         # Payload
-        self.schema_length =  byte2int(self.packet.read(1))
+        self.schema_length = byte2int(self.packet.read(1))
         self.schema = self.packet.read(self.schema_length).decode()
         self.packet.advance(1)
-        self.table_length =  byte2int(self.packet.read(1))
+        self.table_length = byte2int(self.packet.read(1))
         self.table = self.packet.read(self.table_length).decode()
         self.packet.advance(1)
         self.column_count = self.packet.read_length_coded_binary()
@@ -429,7 +437,7 @@ def __init__(self, from_packet, event_size, table_map, ctl_connection):
         if self.table_id in table_map:
             self.column_schemas = table_map[self.table_id].column_schemas
         else:
-            self.column_schemas = self.__get_table_informations(self.schema, self.table)
+            self.column_schemas = self.__get_table_information(self.schema, self.table)
 
         #Read columns meta data
         column_types = list(self.packet.read(self.column_count))
@@ -440,15 +448,24 @@ def __init__(self, from_packet, event_size, table_map, ctl_connection):
             col = Column(byte2int(column_type), column_schema, from_packet)
             self.columns.append(col)
 
+        self.table_obj = Table(self.column_schemas, self.table_id, self.schema, self.table, self.columns)
 
         # TODO: get this informations instead of trashing data
         # n              NULL-bitmask, length: (column-length * 8) / 7
 
-    def __get_table_informations(self, schema, table):
+    def __get_table_information(self, schema, table):
         cur = self._ctl_connection.cursor()
-        cur.execute("""SELECT * FROM columns WHERE table_schema = %s AND table_name = %s""", (schema, table))
+        cur.execute("""SELECT
+                         COLUMN_NAME, COLLATION_NAME, CHARACTER_SET_NAME, COLUMN_COMMENT, COLUMN_TYPE
+                       FROM
+                         columns
+                       WHERE
+                         table_schema = %s AND table_name = %s""", (schema, table))
         return cur.fetchall()
 
+    def get_table(self):
+        return self.table_obj
+
     def _dump(self):
         super(TableMapEvent, self)._dump()
         print("Table id: %d" % (self.table_id))
diff --git a/pymysqlreplication/table.py b/pymysqlreplication/table.py
new file mode 100644
index 00000000..2e0f53b8
--- /dev/null
+++ b/pymysqlreplication/table.py
@@ -0,0 +1,22 @@
+class Table(object):
+    def __init__(self, column_schemas, table_id, schema, table, columns):
+        self.data = {"column_schemas": column_schemas, "table_id": table_id, "schema": schema, "table": table,
+                     "columns": columns}
+
+    def __getattr__(self, item):
+        if item in self.data:
+            return self.data[item]
+        else:
+            raise AttributeError
+
+    def __eq__(self, other):
+        return self.data == other.data
+
+    def __ne__(self, other):
+        return self.__eq__(other)
+
+    def serializable_data(self):
+        return self.data
+
+
+
diff --git a/pymysqlreplication/tests/__init__.py b/pymysqlreplication/tests/__init__.py
index 3cc6a5be..1bc44e54 100644
--- a/pymysqlreplication/tests/__init__.py
+++ b/pymysqlreplication/tests/__init__.py
@@ -1,5 +1,6 @@
 from pymysqlreplication.tests.test_basic import *
 from pymysqlreplication.tests.test_data_type import *
+from pymysqlreplication.tests.test_data_objects import *
 
 if __name__ == "__main__":
     import unittest
diff --git a/pymysqlreplication/tests/base.py b/pymysqlreplication/tests/base.py
index 3f877413..85084c29 100644
--- a/pymysqlreplication/tests/base.py
+++ b/pymysqlreplication/tests/base.py
@@ -3,14 +3,15 @@
 import copy
 from pymysqlreplication import BinLogStreamReader
 
+
 class PyMySQLReplicationTestCase(unittest.TestCase):
     '''Test the module. Be carefull it will reset your MySQL server'''
-    database =  {"host":"localhost",
-        "user":"root",
-        "passwd":"",
-        "use_unicode": True,
-        "charset": "utf8",
-        "db": "pymysqlreplication_test"
+    database = {"host": "localhost",
+                "user": "root",
+                "passwd": "",
+                "use_unicode": True,
+                "charset": "utf8",
+                "db": "pymysqlreplication_test"
     }
 
     def setUp(self):
@@ -57,5 +58,5 @@ def resetBinLog(self):
         self.execute("RESET MASTER")
         if self.stream is not None:
             self.stream.close()
-        self.stream = BinLogStreamReader(connection_settings = self.database)
+        self.stream = BinLogStreamReader(connection_settings=self.database)
 
diff --git a/pymysqlreplication/tests/test_basic.py b/pymysqlreplication/tests/test_basic.py
index a28b821f..238964a3 100644
--- a/pymysqlreplication/tests/test_basic.py
+++ b/pymysqlreplication/tests/test_basic.py
@@ -230,9 +230,9 @@ def test_update_multiple_row_event(self):
 
         event = self.stream.fetchone()
         if self.isMySQL56AndMore():
-           self.assertEqual(event.event_type, UPDATE_ROWS_EVENT)
+            self.assertEqual(event.event_type, UPDATE_ROWS_EVENT)
         else:
-           self.assertEqual(event.event_type, UPDATE_ROWS_EVENT_V1)
+            self.assertEqual(event.event_type, UPDATE_ROWS_EVENT_V1)
         self.assertIsInstance(event, UpdateRowsEvent)
         self.assertEqual(len(event.rows), 2)
         self.assertEqual(event.rows[0]["before_values"]["id"], 1)
diff --git a/pymysqlreplication/tests/test_data_objects.py b/pymysqlreplication/tests/test_data_objects.py
new file mode 100644
index 00000000..557fe062
--- /dev/null
+++ b/pymysqlreplication/tests/test_data_objects.py
@@ -0,0 +1,43 @@
+import unittest
+
+from pymysqlreplication.column import Column
+from pymysqlreplication.table import Table
+
+from pymysqlreplication.tests import base
+
+
+class TestDataObjects(base.PyMySQLReplicationTestCase):
+    def test_column(self):
+        col = Column(1, {"COLUMN_NAME": "test", "COLLATION_NAME": "utf8_general_ci", "CHARACTER_SET_NAME": "UTF8",
+                         "COLUMN_COMMENT": "", "COLUMN_TYPE": "tinyint(2)"}, None)
+
+        serialized = col.serializable_data()
+        self.assertIn("type", serialized)
+        self.assertIn("name", serialized)
+        self.assertIn("collation_name", serialized)
+        self.assertIn("character_set_name", serialized)
+        self.assertIn("comment", serialized)
+        self.assertIn("unsigned", serialized)
+        self.assertIn("type_is_bool", serialized)
+
+        self.assertEqual(col, Column(**serialized))
+
+    def test_table(self):
+        tbl = Table(1, "test_schema", "test_table", [], [])
+
+        serialized = tbl.serializable_data()
+        self.assertIn("table_id", serialized)
+        self.assertIn("schema", serialized)
+        self.assertIn("table", serialized)
+        self.assertIn("columns", serialized)
+        self.assertIn("column_schemas", serialized)
+
+        self.assertEqual(tbl, Table(**serialized))
+
+
+__all__ = ["TestDataObjects"]
+
+if __name__ == "__main__":
+    import unittest
+
+    unittest.main()
diff --git a/pymysqlreplication/tests/test_data_type.py b/pymysqlreplication/tests/test_data_type.py
index 906dadee..9729d4d4 100644
--- a/pymysqlreplication/tests/test_data_type.py
+++ b/pymysqlreplication/tests/test_data_type.py
@@ -109,6 +109,30 @@ def test_tiny(self):
         self.assertEqual(event.rows[0]["values"]["id"], 255)
         self.assertEqual(event.rows[0]["values"]["test"], -128)
 
+    def test_tiny_maps_to_boolean_true(self):
+        create_query = "CREATE TABLE test (id TINYINT UNSIGNED NOT NULL, test BOOLEAN)"
+        insert_query = "INSERT INTO test VALUES(1, TRUE)"
+        event = self.create_and_insert_value(create_query, insert_query)
+        self.assertEqual(event.rows[0]["values"]["id"], 1)
+        self.assertEqual(type(event.rows[0]["values"]["test"]), type(True))
+        self.assertEqual(event.rows[0]["values"]["test"], True)
+
+    def test_tiny_maps_to_boolean_false(self):
+        create_query = "CREATE TABLE test (id TINYINT UNSIGNED NOT NULL, test BOOLEAN)"
+        insert_query = "INSERT INTO test VALUES(1, FALSE)"
+        event = self.create_and_insert_value(create_query, insert_query)
+        self.assertEqual(event.rows[0]["values"]["id"], 1)
+        self.assertEqual(type(event.rows[0]["values"]["test"]), type(True))
+        self.assertEqual(event.rows[0]["values"]["test"], False)
+
+    def test_tiny_maps_to_none(self):
+        create_query = "CREATE TABLE test (id TINYINT UNSIGNED NOT NULL, test BOOLEAN)"
+        insert_query = "INSERT INTO test VALUES(1, NULL)"
+        event = self.create_and_insert_value(create_query, insert_query)
+        self.assertEqual(event.rows[0]["values"]["id"], 1)
+        self.assertEqual(type(event.rows[0]["values"]["test"]), type(None))
+        self.assertEqual(event.rows[0]["values"]["test"], None)
+
     def test_short(self):
         create_query = "CREATE TABLE test (id SMALLINT UNSIGNED NOT NULL, test SMALLINT)"
         insert_query = "INSERT INTO test VALUES(65535, -32768)"
diff --git a/setup.py b/setup.py
index 7507ae6d..8836acc2 100644
--- a/setup.py
+++ b/setup.py
@@ -5,8 +5,9 @@
 
 import sys
 
+
 class TestCommand(Command):
-    user_options = [ ]
+    user_options = []
 
     def initialize_options(self):
         pass
@@ -15,25 +16,26 @@ def finalize_options(self):
         pass
 
     def run(self):
-        '''
+        """
         Finds all the tests modules in tests/, and runs them.
-        '''
+        """
         from pymysqlreplication import tests
         import unittest
+
         unittest.main(tests, argv=sys.argv[:1])
 
 
 version = "0.1.0"
 
 setup(
-    name = "mysql-replication",
-    version = version,
-    url = 'https://github.com/noplay/python-mysql-replication',
-    author = 'Julien Duponchelle',
-    author_email = 'julien@duponchelle.info',
-    description = 'Pure Python Implementation of MySQL replication protocol build on top of PyMYSQL.',
-    license = "Apache 2",
-    packages = ['pymysqlreplication', 'pymysqlreplication.constants', 'pymysqlreplication.tests'],
-    cmdclass = {'test': TestCommand},
-    install_requires = ['pymysql'],
+    name="mysql-replication",
+    version=version,
+    url='https://github.com/noplay/python-mysql-replication',
+    author='Julien Duponchelle',
+    author_email='julien@duponchelle.info',
+    description='Pure Python Implementation of MySQL replication protocol build on top of PyMYSQL.',
+    license="Apache 2",
+    packages=['pymysqlreplication', 'pymysqlreplication.constants', 'pymysqlreplication.tests'],
+    cmdclass={'test': TestCommand},
+    install_requires=['pymysql'],
 )