fixed #261, map model and db column names

Author: wwwjfy

gino/crud.py

@@ -5,7 +5,7 @@
 from sqlalchemy.sql import ClauseElement
 
 from . import json_support
-from .declarative import Model
+from .declarative import Model, InvertDict
 from .exceptions import NoSuchRowError
 from .loader import AliasLoader, ModelLoader
 
@@ -78,7 +78,7 @@ class UpdateRequest:
     specific model instance and its database row.
 
     """
-    def __init__(self, instance):
+    def __init__(self, instance: 'CRUDModel'):
         self._instance = instance
         self._values = {}
         self._props = {}
@@ -124,7 +124,7 @@ async def apply(self, bind=None, timeout=DEFAULT):
         json_updates = {}
         for prop, value in self._props.items():
             value = prop.save(self._instance, value)
-            updates = json_updates.setdefault(prop.column_name, {})
+            updates = json_updates.setdefault(prop.prop_name, {})
             if self._literal:
                 updates[prop.name] = value
             else:
@@ -133,26 +133,26 @@ async def apply(self, bind=None, timeout=DEFAULT):
                 elif not isinstance(value, ClauseElement):
                     value = sa.cast(value, sa.Unicode)
                 updates[sa.cast(prop.name, sa.Unicode)] = value
-        for column_name, updates in json_updates.items():
-            column = getattr(cls, column_name)
+        for prop_name, updates in json_updates.items():
+            prop = getattr(cls, prop_name)
             from .dialects.asyncpg import JSONB
-            if isinstance(column.type, JSONB):
+            if isinstance(prop.type, JSONB):
                 if self._literal:
-                    values[column_name] = column.concat(updates)
+                    values[prop_name] = prop.concat(updates)
                 else:
-                    values[column_name] = column.concat(
+                    values[prop_name] = prop.concat(
                         sa.func.jsonb_build_object(
                             *itertools.chain(*updates.items())))
             else:
-                raise TypeError('{} is not supported.'.format(column.type))
+                raise TypeError('{} is not supported.'.format(prop.type))
 
         opts = dict(return_model=False)
         if timeout is not DEFAULT:
             opts['timeout'] = timeout
         clause = type(self._instance).update.where(
             self._locator,
         ).values(
-            **values,
+            **self._instance._get_sa_values(values),
         ).returning(
             *[getattr(cls, key) for key in values],
         ).execution_options(**opts)
@@ -161,7 +161,9 @@ async def apply(self, bind=None, timeout=DEFAULT):
         row = await bind.first(clause)
         if not row:
             raise NoSuchRowError()
-        self._instance.__values__.update(row)
+        for k, v in row.items():
+            self._instance.__values__[
+                self._instance._column_name_map.invert_get(k)] = v
         for prop in self._props:
             prop.reload(self._instance)
         return self
@@ -409,6 +411,7 @@ class CRUDModel(Model):
     """
 
     _update_request_cls = UpdateRequest
+    _column_name_map = InvertDict()
 
     def __init__(self, **values):
         super().__init__()
@@ -421,10 +424,10 @@ def _init_table(cls, sub_cls):
         for each_cls in sub_cls.__mro__[::-1]:
             for k, v in each_cls.__dict__.items():
                 if isinstance(v, json_support.JSONProperty):
-                    if not hasattr(sub_cls, v.column_name):
+                    if not hasattr(sub_cls, v.prop_name):
                         raise AttributeError(
                             'Requires "{}" JSON[B] column.'.format(
-                                v.column_name))
+                                v.prop_name))
                     v.name = k
         if rv is not None:
             rv.__model__ = weakref.ref(sub_cls)
@@ -440,12 +443,12 @@ async def _create(self, bind=None, timeout=DEFAULT):
         cls = type(self)
         # noinspection PyUnresolvedReferences,PyProtectedMember
         cls._check_abstract()
-        keys = set(self.__profile__.keys() if self.__profile__ else [])
-        for key in keys:
+        profile_keys = set(self.__profile__.keys() if self.__profile__ else [])
+        for key in profile_keys:
             cls.__dict__.get(key).save(self)
         # initialize default values
         for key, prop in cls.__dict__.items():
-            if key in keys:
+            if key in profile_keys:
                 continue
             if isinstance(prop, json_support.JSONProperty):
                 if prop.default is None or prop.after_get.method is not None:
@@ -458,15 +461,25 @@ async def _create(self, bind=None, timeout=DEFAULT):
         if timeout is not DEFAULT:
             opts['timeout'] = timeout
         # noinspection PyArgumentList
-        q = cls.__table__.insert().values(**self.__values__).returning(
-            *cls).execution_options(**opts)
+        q = cls.__table__.insert().values(
+            **self._get_sa_values(self.__values__)
+        ).returning(
+            *cls
+        ).execution_options(**opts)
         if bind is None:
             bind = cls.__metadata__.bind
         row = await bind.first(q)
-        self.__values__.update(row)
+        for k, v in row.items():
+            self.__values__[self._column_name_map.invert_get(k)] = v
         self.__profile__ = None
         return self
 
+    def _get_sa_values(self, instance_values: dict) -> dict:
+        values = {}
+        for k, v in instance_values.items():
+            values[self._column_name_map[k]] = v
+        return values
+
     @classmethod
     async def get(cls, ident, bind=None, timeout=DEFAULT):
         """
@@ -592,11 +605,12 @@ def to_dict(self):
 
         """
         cls = type(self)
-        keys = set(c.name for c in cls)
+        # noinspection PyTypeChecker
+        keys = set(cls._column_name_map.invert_get(c.name) for c in cls)
         for key, prop in cls.__dict__.items():
             if isinstance(prop, json_support.JSONProperty):
                 keys.add(key)
-                keys.discard(prop.column_name)
+                keys.discard(prop.prop_name)
         return dict((k, getattr(self, k)) for k in keys)
 
     @classmethod

gino/declarative.py

@@ -3,10 +3,12 @@
 import sqlalchemy as sa
 from sqlalchemy.exc import InvalidRequestError
 
+from .exceptions import GinoException
+
 
 class ColumnAttribute:
-    def __init__(self, column):
-        self.name = column.name
+    def __init__(self, name, column):
+        self.name = name
         self.column = column
 
     def __get__(self, instance, owner):
@@ -22,6 +24,29 @@ def __delete__(self, instance):
         raise AttributeError('Cannot delete value.')
 
 
+class InvertDict(dict):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._inverted_dict = dict()
+        for k, v in self.items():
+            if v in self._inverted_dict:
+                raise GinoException(
+                    'Column name {} already maps to {}'.format(
+                        v, self._inverted_dict[v]))
+            self._inverted_dict[v] = k
+
+    def __setitem__(self, key, value):
+        if value in self._inverted_dict:
+            raise GinoException(
+                'Column name {} already maps to {}'.format(
+                    value, self._inverted_dict[value]))
+        super().__setitem__(key, value)
+        self._inverted_dict[value] = key
+
+    def invert_get(self, key, default=None):
+        return self._inverted_dict.get(key, default)
+
+
 class ModelType(type):
     def _check_abstract(self):
         if self.__table__ is None:
@@ -119,18 +144,22 @@ def _init_table(cls, sub_cls):
         columns = []
         inspected_args = []
         updates = {}
+        column_name_map = InvertDict()
         for each_cls in sub_cls.__mro__[::-1]:
             for k, v in getattr(each_cls, '__namespace__',
                                 each_cls.__dict__).items():
                 if callable(v) and getattr(v, '__declared_attr__', False):
                     v = updates[k] = v(sub_cls)
                 if isinstance(v, sa.Column):
                     v = v.copy()
-                    v.name = k
+                    if not v.name:
+                        v.name = k
+                    column_name_map[k] = v.name
                     columns.append(v)
-                    updates[k] = sub_cls.__attr_factory__(v)
+                    updates[k] = sub_cls.__attr_factory__(k, v)
                 elif isinstance(v, (sa.Index, sa.Constraint)):
                     inspected_args.append(v)
+        sub_cls._column_name_map = column_name_map
 
         # handle __table_args__
         table_args = updates.get('__table_args__',
@@ -173,4 +202,5 @@ def inspect_model_type(target):
     return sa.inspection.inspect(target.__table__)
 
 
-__all__ = ['ColumnAttribute', 'Model', 'declarative_base', 'declared_attr']
+__all__ = ['ColumnAttribute', 'Model', 'declarative_base', 'declared_attr',
+           'InvertDict']

gino/engine.py

@@ -15,7 +15,7 @@
     from contextvars import ContextVar
 else:
     # noinspection PyPackageRequirements
-    from aiocontextvars import ContextVar
+    from aiocontextvars import ContextVar  # pragma: no cover
 
 
 class _BaseDBAPIConnection:

gino/json_support.py

@@ -22,18 +22,18 @@ def call(self, instance, val):
 
 
 class JSONProperty:
-    def __init__(self, default=None, column_name='profile'):
+    def __init__(self, default=None, prop_name='profile'):
         self.name = None
         self.default = default
-        self.column_name = column_name
+        self.prop_name = prop_name
         self.expression = Hook(self)
         self.after_get = Hook(self)
         self.before_set = Hook(self)
 
     def __get__(self, instance, owner):
         if instance is None:
             exp = self.make_expression(
-                getattr(owner, self.column_name)[self.name])
+                getattr(owner, self.prop_name)[self.name])
             return self.expression.call(owner, exp)
         val = self.get_profile(instance).get(self.name, NONE)
         if val is NONE:
@@ -54,16 +54,16 @@ def get_profile(self, instance):
         if instance.__profile__ is None:
             props = type(instance).__dict__
             instance.__profile__ = {}
-            for key, value in (getattr(instance, self.column_name, None)
+            for key, value in (getattr(instance, self.prop_name, None)
                                or {}).items():
                 instance.__profile__[key] = props[key].decode(value)
         return instance.__profile__
 
     def save(self, instance, value=NONE):
-        profile = getattr(instance, self.column_name, None)
+        profile = getattr(instance, self.prop_name, None)
         if profile is None:
             profile = {}
-            setattr(instance, self.column_name, profile)
+            setattr(instance, self.prop_name, profile)
         if value is NONE:
             value = instance.__profile__[self.name]
         if not isinstance(value, sa.sql.ClauseElement):
@@ -74,7 +74,7 @@ def save(self, instance, value=NONE):
     def reload(self, instance):
         if instance.__profile__ is None:
             return
-        profile = getattr(instance, self.column_name, None) or {}
+        profile = getattr(instance, self.prop_name, None) or {}
         value = profile.get(self.name, NONE)
         if value is NONE:
             instance.__profile__.pop(self.name, None)

gino/loader.py

@@ -75,7 +75,11 @@ def _do_load(self, row, *, none_as_none=None):
         if none_as_none and all((v is None) for v in values.values()):
             return None
         rv = self.model()
-        rv.__values__.update(values)
+        for c in self.columns:
+            if c in row:
+                # noinspection PyProtectedMember
+                instance_key = self.model._column_name_map.invert_get(c.name)
+                rv.__values__[instance_key] = row[c]
         return rv
 
     def do_load(self, row, context):

tests/models.py

@@ -31,14 +31,14 @@ class User(db.Model):
     __tablename__ = 'gino_users'
 
     id = db.Column(db.BigInteger(), primary_key=True)
-    nickname = db.Column(db.Unicode(), default='noname')
-    profile = db.Column(JSONB(), nullable=False, server_default='{}')
+    nickname = db.Column('name', db.Unicode(), default='noname')
+    profile = db.Column('props', JSONB(), nullable=False, server_default='{}')
     type = db.Column(
         db.Enum(UserType),
         nullable=False,
         default=UserType.USER,
     )
-    name = db.StringProperty()
+    realname = db.StringProperty()
     age = db.IntegerProperty(default=18)
     balance = db.IntegerProperty(default=0)
     birthday = db.DateTimeProperty(

tests/test_bind.py

@@ -36,7 +36,7 @@ async def test_unbind(asyncpg_pool):
 
 async def test_db_api(bind, random_name):
     assert await db.scalar(
-        User.insert().values(nickname=random_name).returning(
+        User.insert().values(name=random_name).returning(
             User.nickname)) == random_name
     assert (await db.first(User.query.where(
         User.nickname == random_name))).nickname == random_name

tests/test_declarative.py

@@ -1,5 +1,6 @@
 import pytest
 import gino
+from gino.declarative import InvertDict
 from asyncpg.exceptions import (
     UniqueViolationError, ForeignKeyViolationError, CheckViolationError)
 
@@ -54,7 +55,7 @@ class Model(db.Model):
 
 
 async def test_inline_constraints_and_indexes(bind, engine):
-    u = await User.create(name='test')
+    u = await User.create(nickname='test')
     us1 = await UserSetting.create(user_id=u.id, setting='skin', value='blue')
 
     # PrimaryKeyConstraint
@@ -222,3 +223,20 @@ class AbstractModel(db.Model):
 
     with pytest.raises(TypeError, match='AbstractModel is abstract'):
         await AbstractModel.get(1)
+
+
+async def test_invert_dict():
+    with pytest.raises(gino.GinoException,
+                       match=r'Column name c1 already maps to \w+'):
+        InvertDict({'col1': 'c1', 'col2': 'c1'})
+    with pytest.raises(gino.GinoException,
+                       match=r'Column name c1 already maps to \w+'):
+        d = InvertDict()
+        d['col1'] = 'c1'
+        d['col2'] = 'c1'
+
+    d = InvertDict()
+    d['col1'] = 'c1'
+    d['col2'] = 'c2'
+    assert d.invert_get('c1') == 'col1'
+    assert d.invert_get('c2') == 'col2'

tests/test_executemany.py

@@ -8,12 +8,11 @@
 # noinspection PyUnusedLocal
 async def test_status(bind):
     statement, params = db.compile(User.insert(),
-                                   [dict(nickname='1'), dict(nickname='2')])
-    assert statement == ('INSERT INTO gino_users (nickname, type) '
+                                   [dict(name='1'), dict(name='2')])
+    assert statement == ('INSERT INTO gino_users (name, type) '
                          'VALUES ($1, $2)')
     assert params == (('1', 'USER'), ('2', 'USER'))
-    result = await User.insert().gino.status(dict(nickname='1'),
-                                             dict(nickname='2'))
+    result = await User.insert().gino.status(dict(name='1'), dict(name='2'))
     assert result is None
     assert len(await User.query.gino.all()) == 2
 

tests/test_iterate.py

@@ -9,7 +9,7 @@
 def names(sa_engine):
     rv = {'11', '22', '33'}
     sa_engine.execute(User.__table__.insert(),
-                      [dict(nickname=name) for name in rv])
+                      [dict(name=name) for name in rv])
     yield rv
     sa_engine.execute('DELETE FROM gino_users')