schema: support encoding=None connections

Several different problems are fixed here, but all have the same root.
When a connection encoding is None (it is default on Python 2 and may be
set explicitly on Python 3), all mp_str values are decoded into bytes,
not Unicode strings (note that bytes is alias for str in Python 2). But
the database schema parsing code have assumptions that _vspace / _vindex
values are Unicode strings.

The resolved problems are the following:

1. Default encoding in bytes#decode() method is 'ascii', however names
   in tarantool can contain symbols beyond ASCII symbol table. Set
   'utf-8' for names decoding.
2. Convert all binary values into Unicode strings before parse or store
   them. This allows further correct accesses to the local schema
   representation.
3. Convert binary parameters like space, index or field name into
   Unicode strings, when a schema is accessed to don't trigger redundant
   schema refetching.

Those problems are briefly mentioned in [1].

Tested manually with Python 2 and Python 3: my testing tarantool
instance has a space with name '©' and after the changes I'm able to
connect to it when the connection encoding is set to None. Also I
verified that schema is not fetched each time when I do
<connection>.select('©') in Python 2 (where such string literal is str /
bytes, not Unicode string).

[1]: #105 (comment)

Author: Totktonada

tarantool/schema.py

@@ -21,14 +21,16 @@ def __init__(self, index_row, space):
         self.iid = index_row[1]
         self.name = index_row[2]
         if isinstance(self.name, bytes):
-            self.name = self.name.decode()
+            self.name = self.name.decode(encoding='utf-8')
         self.index = index_row[3]
         self.unique = index_row[4]
         self.parts = []
         if isinstance(index_row[5], (list, tuple)):
             for val in index_row[5]:
                 if isinstance(val, dict):
-                    self.parts.append((val['field'], val['type']))
+                    val_field = val.get('field', val.get(b'field'))
+                    val_type = val.get('type', val.get(b'type'))
+                    self.parts.append((val_field, val_type))
                 else:
                     self.parts.append((val[0], val[1]))
         else:
@@ -54,14 +56,24 @@ def __init__(self, space_row, schema):
         self.arity = space_row[1]
         self.name = space_row[2]
         if isinstance(self.name, bytes):
-            self.name = self.name.decode()
+            self.name = self.name.decode(encoding='utf-8')
         self.indexes = {}
         self.schema = schema
         self.schema[self.sid] = self
         if self.name:
             self.schema[self.name] = self
         self.format = dict()
-        for part_id, part in enumerate(space_row[6]):
+        for part_id, raw_part in enumerate(space_row[6]):
+            # Convert keys and values from bytes to str.
+            # It is necessary for an encoding=None connection.
+            part = dict()
+            for key, val in raw_part.items():
+                if isinstance(key, bytes):
+                    key = key.decode(encoding='utf-8')
+                if isinstance(val, bytes):
+                    val = val.decode(encoding='utf-8')
+                part[key] = val
+
             part['id'] = part_id
             self.format[part['name']] = part
             self.format[part_id     ] = part
@@ -78,6 +90,9 @@ def __init__(self, con):
         self.con = con
 
     def get_space(self, space):
+        if isinstance(space, bytes):
+            space = space.decode(encoding='utf-8')
+
         try:
             return self.schema[space]
         except KeyError:
@@ -135,6 +150,11 @@ def fetch_space_all(self):
             SchemaSpace(row, self.schema)
 
     def get_index(self, space, index):
+        if isinstance(space, bytes):
+            space = space.decode(encoding='utf-8')
+        if isinstance(index, bytes):
+            index = index.decode(encoding='utf-8')
+
         _space = self.get_space(space)
         try:
             return _space.indexes[index]
@@ -203,6 +223,11 @@ def fetch_index_from(self, space, index):
         return index_row
 
     def get_field(self, space, field):
+        if isinstance(space, bytes):
+            space = space.decode(encoding='utf-8')
+        if isinstance(field, bytes):
+            field = field.decode(encoding='utf-8')
+
         _space = self.get_space(space)
         try:
             return _space.format[field]