statistics mixin

Author: adamhadani

rdflib_sqlalchemy/base.py

@@ -10,8 +10,8 @@
 )
 
 
-class SQLGenerator(object):
-    """SQL statement generator."""
+class SQLGeneratorMixin(object):
+    """SQL statement generator mixin for the SQLAlchemy store."""
 
     def _build_type_sql_command(self, member, klass, context):
         """Build an insert command for a type table."""

rdflib_sqlalchemy/statistics.py

@@ -0,0 +1,46 @@
+"""Statistical summary of store statements mixin"""
+from sqlalchemy.orm.session import Session
+from sqlalchemy.sql import func
+
+
+def get_group_by_count(session, group_by_column):
+    """
+    Construct SQL query to get counts for distinct values using GROUP BY.
+
+    :param session - sqlalchemy `Session` instance
+    :param group_by_column sqlalchemy `Column` instance
+    :returns {dict} dictionary mapping from value to count
+
+    """
+    return dict(
+        session.query(
+            group_by_column,
+            func.count(group_by_column)
+        ).group_by(group_by_column).all()
+    )
+
+
+class StatisticsMixin(object):
+
+    def statistics(self, asserted_statements=True, literals=True, types=True):
+        """Store statistics."""
+        statistics = dict(
+            total_num_statements=len(self),
+        )
+
+        with self.engine.connect() as connection:
+            session = Session(bind=connection)
+            if asserted_statements:
+                table = self.tables["asserted_statements"]
+                group_by_column = table.c.predicate
+                statistics["asserted_statements"] = get_group_by_count(session, group_by_column)
+            if literals:
+                table = self.tables["literal_statements"]
+                group_by_column = table.c.predicate
+                statistics["literals"] = get_group_by_count(session, group_by_column)
+            if types:
+                table = self.tables["type_statements"]
+                group_by_column = table.c.klass
+                statistics["types"] = get_group_by_count(session, group_by_column)
+
+        return statistics

rdflib_sqlalchemy/store.py

@@ -1,6 +1,4 @@
 """SQLAlchemy-based RDF store."""
-from __future__ import with_statement
-
 import hashlib
 import logging
 
@@ -19,37 +17,38 @@
 from six.moves import reduce
 from sqlalchemy import MetaData
 from sqlalchemy.engine import reflection
-from sqlalchemy.sql import select, expression
+from sqlalchemy.sql import expression, select
 
 from rdflib_sqlalchemy.constants import (
-    CONTEXT_SELECT,
-    COUNT_SELECT,
-    INTERNED_PREFIX,
     ASSERTED_LITERAL_PARTITION,
     ASSERTED_NON_TYPE_PARTITION,
     ASSERTED_TYPE_PARTITION,
+    CONTEXT_SELECT,
+    COUNT_SELECT,
+    INTERNED_PREFIX,
     QUOTED_PARTITION,
     TRIPLE_SELECT_NO_ORDER,
 )
 from rdflib_sqlalchemy.tables import (
-    get_table_names,
     create_asserted_statements_table,
     create_literal_statements_table,
     create_namespace_binds_table,
     create_quoted_statements_table,
     create_type_statements_table,
+    get_table_names,
 )
-from rdflib_sqlalchemy.base import SQLGenerator
-from rdflib_sqlalchemy.termutils import extract_triple
+from rdflib_sqlalchemy.base import SQLGeneratorMixin
 from rdflib_sqlalchemy.sql import union_select
+from rdflib_sqlalchemy.statistics import StatisticsMixin
+from rdflib_sqlalchemy.termutils import extract_triple
 
 
 _logger = logging.getLogger(__name__)
 
 Any = None
 
 
-class SQLAlchemy(Store, SQLGenerator):
+class SQLAlchemy(Store, SQLGeneratorMixin, StatisticsMixin):
     """
     SQL-92 formula-aware implementation of an rdflib Store.
 
@@ -124,14 +123,11 @@ def __repr__(self):
         literal_table = self.tables["literal_statements"]
 
         selects = [
-            (expression.alias(asserted_type_table, "typetable"),
-                None, ASSERTED_TYPE_PARTITION),
-            (expression.alias(quoted_table, "quoted"),
-                None, QUOTED_PARTITION),
-            (expression.alias(asserted_table, "asserted"),
-                None, ASSERTED_NON_TYPE_PARTITION),
-            (expression.alias(literal_table, "literal"),
-                None, ASSERTED_LITERAL_PARTITION), ]
+            (expression.alias(asserted_type_table, "typetable"), None, ASSERTED_TYPE_PARTITION),
+            (expression.alias(quoted_table, "quoted"), None, QUOTED_PARTITION),
+            (expression.alias(asserted_table, "asserted"), None, ASSERTED_NON_TYPE_PARTITION),
+            (expression.alias(literal_table, "literal"), None, ASSERTED_LITERAL_PARTITION),
+        ]
         q = union_select(selects, distinct=False, select_type=COUNT_SELECT)
         if hasattr(self, "engine"):
             with self.engine.connect() as connection:
@@ -678,6 +674,8 @@ def namespaces(self):
             for prefix, uri in res.fetchall():
                 yield prefix, uri
 
+    # Private methods
+
     def _create_table_definitions(self):
         self.metadata = MetaData()
         self.tables = {