Support generating tablenames in more cases.

Extends naming rules to apply to base classes of models.

Author: davidism

AUTHORS

@@ -45,4 +45,5 @@ Patches and Suggestions
 - Matthew Geltz
 - Daniel Lepage
 - Ignacy Sokołowski
-- Steven Harms
+- Steven Harms
+- David Lord @davidism

CHANGES

@@ -4,6 +4,14 @@ Changelog
 Here you can see the full list of changes between each Flask-SQLAlchemy
 release.
 
+Version 2.1
+-----------
+
+In development
+
+- Table names are automatically generated in more cases, including
+  subclassing mixins and abstract models.
+
 Version 2.0
 -----------
 

flask_sqlalchemy/__init__.py

@@ -504,24 +504,51 @@ def get_engine(self):
             return rv
 
 
-def _defines_primary_key(d):
-    """Figures out if the given dictionary defines a primary key column."""
-    return any(v.primary_key for k, v in iteritems(d)
-               if isinstance(v, sqlalchemy.Column))
+def _should_set_tablename(bases, d):
+    """Check what values are set by a class and its bases to determine if a
+    tablename should be automatically generated.
+
+    The class and its bases are checked in order of precedence: the class
+    itself then each base in the order they were given at class definition.
+
+    Abstract classes do not generate a tablename, although they may have set
+    or inherited a tablename elsewhere.
+
+    If a class defines a tablename or table, a new one will not be generated.
+    Otherwise, if the class defines a primary key, a new name will be generated.
+
+    This supports:
+
+    * Joined table inheritance without explicitly naming sub-models.
+    * Single table inheritance.
+    * Inheriting from mixins or abstract models.
+
+    :param bases: base classes of new class
+    :param d: new class dict
+    :return: True if tablename should be set
+    """
+
+    if '__tablename__' in d or '__table__' in d or '__abstract__' in d:
+        return False
+
+    if any(v.primary_key for v in itervalues(d) if isinstance(v, sqlalchemy.Column)):
+        return True
+
+    for base in bases:
+        if hasattr(base, '__tablename__') or hasattr(base, '__table__'):
+            return False
+
+        for name in dir(base):
+            attr = getattr(base, name)
+
+            if isinstance(attr, sqlalchemy.Column) and attr.primary_key:
+                return True
 
 
 class _BoundDeclarativeMeta(DeclarativeMeta):
 
     def __new__(cls, name, bases, d):
-        tablename = d.get('__tablename__')
-
-        # generate a table name automatically if it's missing and the
-        # class dictionary declares a primary key.  We cannot always
-        # attach a primary key to support model inheritance that does
-        # not use joins.  We also don't want a table name if a whole
-        # table is defined
-        if not tablename and d.get('__table__') is None and \
-           _defines_primary_key(d):
+        if _should_set_tablename(bases, d):
             def _join(match):
                 word = match.group()
                 if len(word) > 1:

test_sqlalchemy.py

@@ -1,11 +1,11 @@
 from __future__ import with_statement
 
-import os
 import atexit
 import unittest
 from datetime import datetime
 import flask
 from flask.ext import sqlalchemy
+from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.orm import sessionmaker
 
 
@@ -157,20 +157,108 @@ def committed(sender, changes):
             self.assertEqual(recorded[0][1], 'delete')
 
 
-class HelperTestCase(unittest.TestCase):
-
-    def test_default_table_name(self):
+class TablenameTestCase(unittest.TestCase):
+    def test_name(self):
         app = flask.Flask(__name__)
-        app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
+        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
         db = sqlalchemy.SQLAlchemy(app)
 
         class FOOBar(db.Model):
             id = db.Column(db.Integer, primary_key=True)
+
         class BazBar(db.Model):
             id = db.Column(db.Integer, primary_key=True)
 
+        class Ham(db.Model):
+            __tablename__ = 'spam'
+            id = db.Column(db.Integer, primary_key=True)
+
         self.assertEqual(FOOBar.__tablename__, 'foo_bar')
         self.assertEqual(BazBar.__tablename__, 'baz_bar')
+        self.assertEqual(Ham.__tablename__, 'spam')
+
+    def test_single_name(self):
+        """Single table inheritance should not set a new name."""
+
+        app = flask.Flask(__name__)
+        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
+        db = sqlalchemy.SQLAlchemy(app)
+
+        class Duck(db.Model):
+            id = db.Column(db.Integer, primary_key=True)
+
+        class Mallard(Duck):
+            pass
+
+        self.assertEqual(Mallard.__tablename__, 'duck')
+
+    def test_joined_name(self):
+        """Model has a separate primary key; it should set a new name."""
+
+        app = flask.Flask(__name__)
+        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
+        db = sqlalchemy.SQLAlchemy(app)
+
+        class Duck(db.Model):
+            id = db.Column(db.Integer, primary_key=True)
+
+        class Donald(Duck):
+            id = db.Column(db.Integer, db.ForeignKey(Duck.id), primary_key=True)
+
+        self.assertEqual(Donald.__tablename__, 'donald')
+
+    def test_mixin_name(self):
+        """Primary key provided by mixin should still allow model to set tablename."""
+
+        app = flask.Flask(__name__)
+        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
+        db = sqlalchemy.SQLAlchemy(app)
+
+        class Base(object):
+            id = db.Column(db.Integer, primary_key=True)
+
+        class Duck(Base, db.Model):
+            pass
+
+        self.assertFalse(hasattr(Base, '__tablename__'))
+        self.assertEqual(Duck.__tablename__, 'duck')
+
+    def test_abstract_name(self):
+        """Abstract model should not set a name.  Subclass should set a name."""
+
+        app = flask.Flask(__name__)
+        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
+        db = sqlalchemy.SQLAlchemy(app)
+
+        class Base(db.Model):
+            __abstract__ = True
+            id = db.Column(db.Integer, primary_key=True)
+
+        class Duck(Base):
+            pass
+
+        self.assertFalse(hasattr(Base, '__tablename__'))
+        self.assertEqual(Duck.__tablename__, 'duck')
+
+    def test_complex_inheritance(self):
+        """Joined table inheritance, but the new primary key is provided by a mixin, not directly on the class."""
+
+        app = flask.Flask(__name__)
+        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
+        db = sqlalchemy.SQLAlchemy(app)
+
+        class Duck(db.Model):
+            id = db.Column(db.Integer, primary_key=True)
+
+        class IdMixin(object):
+            @declared_attr
+            def id(cls):
+                return db.Column(db.Integer, db.ForeignKey(Duck.id), primary_key=True)
+
+        class RubberDuck(IdMixin, Duck):
+            pass
+
+        self.assertEqual(RubberDuck.__tablename__, 'rubber_duck')
 
 
 class PaginationTestCase(unittest.TestCase):
@@ -493,7 +581,7 @@ def suite():
     suite = unittest.TestSuite()
     suite.addTest(unittest.makeSuite(BasicAppTestCase))
     suite.addTest(unittest.makeSuite(TestQueryProperty))
-    suite.addTest(unittest.makeSuite(HelperTestCase))
+    suite.addTest(unittest.makeSuite(TablenameTestCase))
     suite.addTest(unittest.makeSuite(PaginationTestCase))
     suite.addTest(unittest.makeSuite(BindsTestCase))
     suite.addTest(unittest.makeSuite(DefaultQueryClassTestCase))