clean up db.util, add core_schema_installed()

edbob/db/util.py

@@ -26,90 +26,41 @@
 ``edbob.db.util`` -- Database Utilities
 """
 
-import os.path
-
 import sqlalchemy.exc
-# import migrate.versioning.api
-# import migrate.exceptions
-
-# import rattail
-# from rattail.db import exc as exceptions
-# from rattail.db import Session
-# from rattail.db.classes import Role
-# from rattail.db.model import get_metadata
-# from rattail.db.perms import get_administrator
 
 import edbob.db
-from edbob.db import exceptions
+from edbob.db.model import ActiveExtension
-from edbob.db.model import Base
-# from edbob.db.model import get_metadata
 
 
-# def core_schema_installed(engine=None):
+def core_schema_installed(engine=None):
-#     """
-#     Returns boolean indicating whether or not the core schema has been
-#     installed to the database represented by ``engine``.  If ``engine`` is not
-#     provided, then ``rattail.engine`` will be assumed.
-#     """
-    
-#     if engine is None:
-#         engine = rattail.engine
-
-#     try:
-#         get_database_version(engine)
-#     except exceptions.CoreSchemaNotInstalled:
-#         return False
-#     return True
-
-
-# def get_database_version(engine=None, extension=None):
-#     """
-#     Returns a SQLAlchemy-Migrate version number found in the database
-#     represented by ``engine``.
-
-#     If no engine is provided, :attr:`edbob.db.engine` is assumed.
-
-#     If ``extension`` is provided, the version for its schema is returned;
-#     otherwise the core schema is assumed.
-#     """
-
-#     if engine is None:
-#         engine = edbob.db.engine
-
-#     try:
-#         version = migrate.versioning.api.db_version(
-#             str(engine.url), get_repository_path(extension))
-
-#     except (sqlalchemy.exc.NoSuchTableError,
-#             migrate.exceptions.DatabaseNotControlledError):
-#         raise exceptions.CoreSchemaNotInstalled(engine)
-
-#     return version
-
-
-def get_repository_path(extension=None):
     """
-    Returns the absolute filesystem path to the SQLAlchemy-Migrate repository
+    Returns boolean indicating whether the core schema has been installed to
-    for ``extension``.
+    the database represented by ``engine``.
 
-    If no extension is provided, ``edbob``'s core repository is assumed.
+    If no engine is provided, :attr:`edbob.db.engine` is assumed.
     """
     
-    if not extension:
+    if engine is None:
-        from edbob.db import schema
+        engine = edbob.db.engine
-        return os.path.dirname(schema.__file__)
 
-    return os.path.dirname(extension.schema.__file__)
+    # Check database existence and/or connectivity.
+    try:
+        conn = engine.connect()
+    except sqlalchemy.exc.OperationalError:
+        return False
+    else:
+        conn.close()
 
+    # Issue "bogus" query to verify core table existence.
+    session = edbob.db.Session(bind=engine)
+    try:
+        session.query(ActiveExtension).count()
+    except sqlalchemy.exc.ProgrammingError:
+        return False
+    finally:
+        session.close()
 
-# def get_repository_version(extension=None):
+    return True
-#     """
-#     Returns the version of the SQLAlchemy-Migrate repository for ``extension``.
-
-#     If no extension is provided, ``edbob``'s core repository is assumed.
-#     """
-
-#     return migrate.versioning.api.version(get_repository_path(extension))
 
 
 def install_core_schema(engine=None):
@@ -126,41 +77,6 @@ def install_core_schema(engine=None):
     conn = engine.connect()
     conn.close()
 
-    # # Check DB version to see if core schema is already installed.
-    # try:
-    #     db_version = get_database_version(engine)
-    # except exceptions.CoreSchemaNotInstalled:
-    #     pass
-    # else:
-    #     raise exceptions.CoreSchemaAlreadyInstalled(db_version)
-
     # Create tables for core schema.
-    # metadata = get_metadata()
-    # Base.metadata.create_all(engine)
     meta = edbob.db.get_core_metadata()
     meta.create_all(engine)
-
-    # # Add versioning for core schema.
-    # migrate.versioning.api.version_control(
-    #     str(engine.url), get_repository_path(), get_repository_version())
-
-    # WTF
-    # session = Session(bind=engine)
-    # get_administrator(session)
-    # session.commit()
-    # session.close()
-
-
-# def upgrade_schema(extension=None, engine=None):
-#     """
-#     Upgrades a schema within the database represented by ``engine`` (or
-#     ``rattail.engine`` if none is provided).  If ``extension`` is provided,
-#     then its schema will be upgraded; otherwise the core is assumed.
-#     """
-
-#     if engine is None:
-#         engine = rattail.engine
-#     repo_version = get_repository_version(extension)
-#     db_version = get_database_version(engine, extension)
-#     if db_version < repo_version:
-#         migrate.versioning.api.upgrade(str(engine.url), get_repository_path(extension), repo_version)