Merge pull request #25 from RDFLib/feature/ah-literals-lang-key

Fix unique constraints to take into account object language tag for literal / quoted statements

Author: Adam Ever-Hadani

rdflib_sqlalchemy/base.py

@@ -21,7 +21,8 @@ def _build_type_sql_command(self, member, klass, context):
             "member": member,
             "klass": klass,
             "context": context.identifier,
-            "termComb": int(type_to_term_combination(member, klass, context))}
+            "termComb": int(type_to_term_combination(member, klass, context))
+        }
 
     def _build_literal_triple_sql_command(self, subject, predicate, obj, context):
         """
@@ -70,10 +71,8 @@ def _build_triple_sql_command(self, subject, predicate, obj, context, quoted):
                 "object": obj,
                 "context": context.identifier,
                 "termComb": triple_pattern,
-                "objLanguage": isinstance(
-                    obj, Literal) and obj.language or None,
-                "objDatatype": isinstance(
-                    obj, Literal) and obj.datatype or None
+                "objLanguage": isinstance(obj, Literal) and obj.language or None,
+                "objDatatype": isinstance(obj, Literal) and obj.datatype or None
             }
         else:
             params = {
@@ -89,18 +88,18 @@ def build_clause(self, table, subject, predicate, obj, context=None, typeTable=F
         """Build WHERE clauses for the supplied terms and, context."""
         if typeTable:
             clauseList = [
-                self.buildTypeMemberClause(subject, table),
-                self.buildTypeClassClause(obj, table),
-                self.buildContextClause(context, table)
+                self.build_type_member_clause(subject, table),
+                self.build_type_class_clause(obj, table),
+                self.build_context_clause(context, table)
             ]
         else:
             clauseList = [
-                self.buildSubjClause(subject, table),
-                self.buildPredClause(predicate, table),
-                self.buildObjClause(obj, table),
-                self.buildContextClause(context, table),
-                self.buildLitDTypeClause(obj, table),
-                self.buildLitLanguageClause(obj, table)
+                self.build_subject_clause(subject, table),
+                self.build_predicate_clause(predicate, table),
+                self.build_object_clause(obj, table),
+                self.build_context_clause(context, table),
+                self.build_literal_datatype_clause(obj, table),
+                self.build_literal_language_clause(obj, table)
             ]
 
         clauseList = [clause for clause in clauseList if clause is not None]
@@ -109,14 +108,14 @@ def build_clause(self, table, subject, predicate, obj, context=None, typeTable=F
         else:
             return None
 
-    def buildLitDTypeClause(self, obj, table):
+    def build_literal_datatype_clause(self, obj, table):
         """Build Literal and datatype clause."""
         if isinstance(obj, Literal) and obj.datatype is not None:
             return table.c.objDatatype == obj.datatype
         else:
             return None
 
-    def buildLitLanguageClause(self, obj, table):
+    def build_literal_language_clause(self, obj, table):
         """Build Literal and language clause."""
         if isinstance(obj, Literal) and obj.language is not None:
             return table.c.objLanguage == obj.language
@@ -126,25 +125,25 @@ def buildLitLanguageClause(self, obj, table):
     # Where Clause  utility Functions
     # The predicate and object clause builders are modified in order
     # to optimize subjects and objects utility functions which can
-    # take lists as their last argument (object, predicate -
-    # respectively)
-    def buildSubjClause(self, subject, table):
+    # take lists as their last argument (object, predicate - respectively)
+
+    def build_subject_clause(self, subject, table):
         """Build Subject clause."""
         if isinstance(subject, REGEXTerm):
             # TODO: this work only in mysql. Must adapt for postgres and sqlite
             return table.c.subject.op("REGEXP")(subject)
         elif isinstance(subject, list):
             # clauseStrings = [] --- unused
             return expression.or_(
-                *[self.buildSubjClause(s, table) for s in subject if s])
+                *[self.build_subject_clause(s, table) for s in subject if s])
         elif isinstance(subject, (QuotedGraph, Graph)):
             return table.c.subject == subject.identifier
         elif subject is not None:
             return table.c.subject == subject
         else:
             return None
 
-    def buildPredClause(self, predicate, table):
+    def build_predicate_clause(self, predicate, table):
         """
         Build Predicate clause.
 
@@ -157,13 +156,13 @@ def buildPredClause(self, predicate, table):
             return table.c.predicate.op("REGEXP")(predicate)
         elif isinstance(predicate, list):
             return expression.or_(
-                *[self.buildPredClause(p, table) for p in predicate if p])
+                *[self.build_predicate_clause(p, table) for p in predicate if p])
         elif predicate is not None:
             return table.c.predicate == predicate
         else:
             return None
 
-    def buildObjClause(self, obj, table):
+    def build_object_clause(self, obj, table):
         """
         Build Object clause.
 
@@ -176,15 +175,15 @@ def buildObjClause(self, obj, table):
             return table.c.object.op("REGEXP")(obj)
         elif isinstance(obj, list):
             return expression.or_(
-                *[self.buildObjClause(o, table) for o in obj if o])
+                *[self.build_object_clause(o, table) for o in obj if o])
         elif isinstance(obj, (QuotedGraph, Graph)):
             return table.c.object == obj.identifier
         elif obj is not None:
             return table.c.object == obj
         else:
             return None
 
-    def buildContextClause(self, context, table):
+    def build_context_clause(self, context, table):
         """Build Context clause."""
         if isinstance(context, REGEXTerm):
             # TODO: this work only in mysql. Must adapt for postgres and sqlite
@@ -194,27 +193,27 @@ def buildContextClause(self, context, table):
         else:
             return None
 
-    def buildTypeMemberClause(self, subject, table):
+    def build_type_member_clause(self, subject, table):
         """Build Type Member clause."""
         if isinstance(subject, REGEXTerm):
             # TODO: this work only in mysql. Must adapt for postgres and sqlite
             return table.c.member.op("regexp")(subject)
         elif isinstance(subject, list):
             return expression.or_(
-                *[self.buildTypeMemberClause(s, table) for s in subject if s])
+                *[self.build_type_member_clause(s, table) for s in subject if s])
         elif subject is not None:
             return table.c.member == subject
         else:
             return None
 
-    def buildTypeClassClause(self, obj, table):
+    def build_type_class_clause(self, obj, table):
         """Build Type Class clause."""
         if isinstance(obj, REGEXTerm):
             # TODO: this work only in mysql. Must adapt for postgres and sqlite
             return table.c.klass.op("regexp")(obj)
         elif isinstance(obj, list):
             return expression.or_(
-                *[self.buildTypeClassClause(o, table) for o in obj if o])
+                *[self.build_type_class_clause(o, table) for o in obj if o])
         elif obj is not None:
             return obj and table.c.klass == obj
         else:

rdflib_sqlalchemy/store.py

@@ -48,6 +48,13 @@
 Any = None
 
 
+def generate_interned_id(identifier):
+    return "{prefix}{identifier_hash}".format(
+        prefix=INTERNED_PREFIX,
+        identifier_hash=hashlib.sha1(identifier.encode("utf8")).hexdigest()[:10],
+    )
+
+
 class SQLAlchemy(Store, SQLGeneratorMixin, StatisticsMixin):
     """
     SQL-92 formula-aware implementation of an rdflib Store.
@@ -84,10 +91,7 @@ def __init__(self, identifier=None, configuration=None, engine=None):
         self.engine = engine
 
         # Use only the first 10 bytes of the digest
-        self._interned_id = "{prefix}{identifier_hash}".format(
-            prefix=INTERNED_PREFIX,
-            identifier_hash=hashlib.sha1(self.identifier.encode("utf8")).hexdigest()[:10],
-        )
+        self._interned_id = generate_interned_id(self.identifier)
 
         # This parameter controls how exlusively the literal table is searched
         # If true, the Literal partition is searched *exclusively* if the
@@ -159,10 +163,10 @@ def __len__(self, context=None):
         asserted = expression.alias(asserted_table, "asserted")
         literal = expression.alias(literal_table, "literal")
 
-        quotedContext = self.buildContextClause(context, quoted)
-        assertedContext = self.buildContextClause(context, asserted)
-        typeContext = self.buildContextClause(context, typetable)
-        literalContext = self.buildContextClause(context, literal)
+        quotedContext = self.build_context_clause(context, quoted)
+        assertedContext = self.build_context_clause(context, asserted)
+        typeContext = self.build_context_clause(context, typetable)
+        literalContext = self.build_context_clause(context, literal)
 
         if context is not None:
             selects = [
@@ -745,7 +749,7 @@ def _remove_context(self, identifier):
             try:
                 for table in [quoted_table, asserted_table,
                               asserted_type_table, literal_table]:
-                    clause = self.buildContextClause(identifier, table)
+                    clause = self.build_context_clause(identifier, table)
                     connection.execute(table.delete(clause))
                 trans.commit()
             except Exception:

rdflib_sqlalchemy/tables.py

@@ -142,6 +142,7 @@ def create_literal_statements_table(interned_id, metadata):
             "subject",
             "predicate",
             "object",
+            "objLanguage",
             "context",
             unique=True,
             mysql_length=MYSQL_MAX_INDEX_LENGTH,
@@ -190,6 +191,7 @@ def create_quoted_statements_table(interned_id, metadata):
             "subject",
             "predicate",
             "object",
+            "objLanguage",
             "context",
             unique=True,
             mysql_length=MYSQL_MAX_INDEX_LENGTH,

rdflib_sqlalchemy/termutils.py

@@ -189,7 +189,8 @@ def extract_triple(tupleRt, store, hardCodedContext=None):
 
     Take a tuple which represents an entry in a result set and
     converts it to a tuple of terms using the termComb integer
-    to interpret how to instantiate each term
+    to interpret how to instantiate each term.
+
     """
     try:
         id, subject, predicate, obj, rtContext, termComb, \