def test_sql_query(self): """Test the SqlQuery class.""" q = SqlQuery("my_table", COLS, DTYPES, "alias") self.assertEqual(q.order, ["alias"]) self.assertEqual(q.tables, {"alias": "my_table"}) self.assertEqual(q._columns, {"alias": EXPANDED_COLS}) self.assertEqual(q.datatypes, {"alias": EXPANDED_DTYPES}) self.assertEqual(q.condition, None) # test WHERE c1 = EqualsCondition("my_table", "1", VALS[0], DTYPES["1"]) c2 = EqualsCondition("my_table", "2", VALS[1], DTYPES["2"]) c21 = EqualsCondition("my_table", "2___0", VALS[1][0], EXPANDED_DTYPES["2___0"]) c22 = EqualsCondition("my_table", "2___1", VALS[1][1], EXPANDED_DTYPES["2___1"]) c3 = EqualsCondition("my_table", "3", VALS[2], DTYPES["2"]) c3 = AndCondition(c1, c2, c3) q.where(c1) self.assertEqual(q.condition, c1) q.condition = None q.where(c2) self.assertIsInstance(q.condition, AndCondition) self.assertEqual(len(q.condition.conditions), 2) self.assertEqual(q.condition, AndCondition(c21, c22)) q.condition = None q.where(c1) q.where(c2) self.assertIsInstance(q.condition, AndCondition) self.assertEqual(len(q.condition.conditions), 3) self.assertEqual(q.condition, AndCondition(c1, c21, c22)) q.condition = None q.where(c2) q.where(c1) self.assertIsInstance(q.condition, AndCondition) self.assertEqual(len(q.condition.conditions), 3) self.assertEqual(q.condition, AndCondition(c1, c21, c22)) q.condition = None q.where(c1) q.where(c1) self.assertIsInstance(q.condition, AndCondition) self.assertEqual(len(q.condition.conditions), 1) self.assertEqual(q.condition, AndCondition(c1)) # test JOIN c4 = JoinCondition("alias", "1", "alias2", "1") q.join("2ndTable", COLS, DTYPES, alias="alias2") self.assertEqual(q.order, ["alias", "alias2"]) self.assertEqual(q.tables, {"alias": "my_table", "alias2": "2ndTable"}) self.assertEqual(q._columns, { "alias": EXPANDED_COLS, "alias2": EXPANDED_COLS }) self.assertEqual(q.datatypes, { "alias": EXPANDED_DTYPES, "alias2": EXPANDED_DTYPES }) self.assertEqual(q.condition, AndCondition(c1)) q.where(c4) self.assertEqual(q.condition, AndCondition(c1, c4))
def test_construct_remove_condition(self): """Test construction a remove condition.""" # from rel table r = sorted(self.session._queries( pattern=(iri_from_uid(uuid.UUID(int=1)), city.hasInhabitant.iri, iri_from_uid(uuid.UUID(int=2))), mode="delete"), key=lambda x: x[1]) self.assertEqual(len(r), 1) self.assertEqual(r[0][1], RELATIONSHIP_TABLE) self.assertEqual(r[0][2], rdflib.XSD.integer) self.assertEqual( r[0][0], AndCondition( EqualsCondition(RELATIONSHIP_TABLE, "s", 1, rdflib.XSD.integer), EqualsCondition(RELATIONSHIP_TABLE, "p", 42, rdflib.XSD.integer), EqualsCondition(RELATIONSHIP_TABLE, "o", 2, rdflib.XSD.integer))) # from types table r = sorted(self.session._queries(pattern=(iri_from_uid( uuid.UUID(int=1)), rdflib.RDF.type, city.City.iri), mode="delete"), key=lambda x: x[1]) self.assertEqual(len(r), 1) self.assertEqual(r[0][1], TYPES_TABLE) self.assertEqual(r[0][2], rdflib.XSD.integer) self.assertEqual( r[0][0], AndCondition( EqualsCondition(TYPES_TABLE, "s", 1, rdflib.XSD.integer), EqualsCondition(TYPES_TABLE, "o", 42, rdflib.XSD.integer)))
def test_check_characters(self): """Test character check.""" c1 = EqualsCondition("c", "d", "e", rdflib.XSD.string) c2 = EqualsCondition("c;", "d", "e", rdflib.XSD.string) c3 = EqualsCondition("c", "d;", "e", rdflib.XSD.string) c4 = JoinCondition("g", "h", "i", "j") c5 = JoinCondition("g;", "h", "i", "j") c6 = JoinCondition("g", "h;", "i", "j") c7 = JoinCondition("g", "h", "i;", "j") c8 = JoinCondition("g", "h", "i", "j;") x = {"key": ["a", ("b", AndCondition(c1, c4))]} x1 = {"key;": ["a", ("b", AndCondition(c1, c4))]} x2 = {"key": ["a;", ("b", AndCondition(c1, c4))]} x3 = {"key": ["a", ("b;", AndCondition(c1, c4))]} x4 = {"key": ["a", ("b", AndCondition(c2, c4))]} x5 = {"key": ["a", ("b", AndCondition(c3, c4))]} x6 = {"key": ["a", ("b", AndCondition(c1, c5))]} x7 = {"key": ["a", ("b", AndCondition(c1, c6))]} x8 = {"key": ["a", ("b", AndCondition(c1, c7))]} x9 = {"key": ["a", ("b", AndCondition(c1, c8))]} check_characters(x) self.assertRaises(ValueError, check_characters, x1) self.assertRaises(ValueError, check_characters, x2) self.assertRaises(ValueError, check_characters, x3) self.assertRaises(ValueError, check_characters, x4) self.assertRaises(ValueError, check_characters, x5) self.assertRaises(ValueError, check_characters, x6) self.assertRaises(ValueError, check_characters, x7) self.assertRaises(ValueError, check_characters, x8) self.assertRaises(ValueError, check_characters, x9)
def _get_entity_idx(self, ns_idx, name): c = self._default_select( self.ENTITIES_TABLE, condition=AndCondition( EqualsCondition( self.ENTITIES_TABLE, "ns_idx", ns_idx, datatype=rdflib.XSD.integer, ), EqualsCondition( self.ENTITIES_TABLE, "name", name, datatype=rdflib.XSD.string, ), ), ) for entity_idx, ns_idx, name in c: return entity_idx return self._do_db_insert( table_name=self.ENTITIES_TABLE, columns=["ns_idx", "name"], values=[ns_idx, name], datatypes=self.DATATYPES[self.ENTITIES_TABLE], )
def _get_conditions(self, triple, table_name, object_datatype): conditions = [] s, p, o = triple if s is not None: uid = self._split_namespace(s) conditions += [EqualsCondition("ts", "uid", uid, "UUID")] if p is not None and table_name != self.TYPES_TABLE: ns_idx, name = self._split_namespace(p) conditions += [ EqualsCondition("tp", "ns_idx", ns_idx, rdflib.XSD.integer), EqualsCondition("tp", "name", name, rdflib.XSD.string) ] if o is not None and table_name == self.RELATIONSHIP_TABLE: uid = self._split_namespace(o) conditions += [EqualsCondition("to", "uid", uid, "UUID")] elif o is not None and table_name == self.TYPES_TABLE: ns_idx, name = self._split_namespace(o) conditions += [ EqualsCondition("to", "ns_idx", ns_idx, rdflib.XSD.integer), EqualsCondition("to", "name", name, rdflib.XSD.string) ] elif o is not None: conditions += [ EqualsCondition(table_name, "o", o.toPython(), object_datatype) ] return AndCondition(*conditions)
def _construct_remove_condition(self, pattern, table, object_datatype): conditions = list() s, p, o = pattern if s is not None: s = self._get_cuds_idx(self._split_namespace(s)) conditions += [ EqualsCondition(table, column="s", value=s, datatype=rdflib.XSD.integer) ] if table == self.TYPES_TABLE: if o is not None: o = self._get_entity_idx(*self._split_namespace(o)) conditions += [ EqualsCondition(table, column="o", value=o, datatype=rdflib.XSD.integer) ] return AndCondition(*conditions) if p is not None: p = self._get_entity_idx(*self._split_namespace(p)) conditions += [ EqualsCondition(table, column="p", value=p, datatype=rdflib.XSD.integer) ] if o is not None: o = o.toPython() if table == self.RELATIONSHIP_TABLE: o = self._get_cuds_idx(self._split_namespace(o)) conditions += [ EqualsCondition(table, column="o", value=o, datatype=object_datatype) ] return AndCondition(*conditions)
def _get_cuds_idx(self, uid): c = self._default_select(self.CUDS_TABLE, condition=EqualsCondition(self.CUDS_TABLE, "uid", uid, datatype="UUID")) for cuds_idx, uid in c: return cuds_idx return self._do_db_insert( table_name=self.CUDS_TABLE, columns=["uid"], values=[uid], datatypes=self.DATATYPES[self.CUDS_TABLE], )
def test_queries_subject_given(self): """Test computing the queries corresponding to a triple pattern.""" r = sorted( self.session._queries(pattern=(iri_from_uid(uuid.UUID(int=1)), None, None)), key=lambda x: x[1]) self.assertEqual(len(r), 4) self.assertEqual(r[0][1], data_tbl("VECTOR-2-2")) self.assertEqual(r[1][1], data_tbl("XSD_string")) self.assertEqual(r[2][1], RELATIONSHIP_TABLE) self.assertEqual(r[3][1], TYPES_TABLE) self.assertEqual(r[0][2], rdflib_cuba["_datatypes/VECTOR-2-2"]) self.assertEqual(r[1][2], rdflib.XSD.string) self.assertEqual(r[2][2], rdflib.XSD.integer) self.assertEqual(r[3][2], rdflib.XSD.integer) self.assertEqual(r[0][0].order, ["ts", "tp", data_tbl("VECTOR-2-2")]) # first query self.assertEqual( r[0][0]._columns, { "ts": ["uid"], "tp": ["ns_idx", "name"], data_tbl("VECTOR-2-2"): ["o___0", "o___1", "o___2", "o___3"] }) self.assertEqual( r[0][0].condition, AndCondition( JoinCondition(data_tbl("VECTOR-2-2"), "s", "ts", "cuds_idx"), JoinCondition(data_tbl("VECTOR-2-2"), "p", "tp", "entity_idx"), EqualsCondition("ts", "uid", str(uuid.UUID(int=1)), "UUID"))) self.assertEqual( r[0][0].datatypes, { data_tbl("VECTOR-2-2"): { "o": rdflib_cuba["_datatypes/VECTOR-2-2"], "o___0": rdflib.XSD.float, "o___1": rdflib.XSD.float, "o___2": rdflib.XSD.float, "o___3": rdflib.XSD.float }, "ts": { "uid": "UUID", "cuds_idx": rdflib.XSD.integer }, "tp": { "name": rdflib.XSD.string, "ns_idx": rdflib.XSD.integer, "entity_idx": rdflib.XSD.integer } }) self.assertEqual( r[0][0].tables, { "ts": CUDS_TABLE, "tp": ENTITIES_TABLE, data_tbl("VECTOR-2-2"): data_tbl("VECTOR-2-2") }) # second query self.assertEqual(r[1][0]._columns, { "ts": ["uid"], "tp": ["ns_idx", "name"], data_tbl("XSD_string"): ["o"] }) self.assertEqual( r[1][0].condition, AndCondition( JoinCondition(data_tbl("XSD_string"), "s", "ts", "cuds_idx"), JoinCondition(data_tbl("XSD_string"), "p", "tp", "entity_idx"), EqualsCondition("ts", "uid", str(uuid.UUID(int=1)), "UUID"))) self.assertEqual( r[1][0].datatypes, { data_tbl("XSD_string"): { "o": rdflib.XSD.string }, "ts": { "uid": "UUID", "cuds_idx": rdflib.XSD.integer }, "tp": { "name": rdflib.XSD.string, "ns_idx": rdflib.XSD.integer, "entity_idx": rdflib.XSD.integer } }) self.assertEqual( r[1][0].tables, { "ts": CUDS_TABLE, "tp": ENTITIES_TABLE, data_tbl("XSD_string"): data_tbl("XSD_string") }) # third query self.assertEqual( r[2][0]._columns, { "ts": ["uid"], "tp": ["ns_idx", "name"], RELATIONSHIP_TABLE: [], "to": ["uid"] }) self.assertEqual( r[2][0].condition, AndCondition( JoinCondition(RELATIONSHIP_TABLE, "s", "ts", "cuds_idx"), JoinCondition(RELATIONSHIP_TABLE, "p", "tp", "entity_idx"), JoinCondition(RELATIONSHIP_TABLE, "o", "to", "cuds_idx"), EqualsCondition("ts", "uid", str(uuid.UUID(int=1)), "UUID"))) self.assertEqual( r[2][0].datatypes, { "ts": { "uid": "UUID", "cuds_idx": rdflib.XSD.integer }, "tp": { "name": rdflib.XSD.string, "ns_idx": rdflib.XSD.integer, "entity_idx": rdflib.XSD.integer }, "to": { "uid": "UUID", "cuds_idx": rdflib.XSD.integer }, RELATIONSHIP_TABLE: {} }) self.assertEqual( r[2][0].tables, { "ts": CUDS_TABLE, "tp": ENTITIES_TABLE, "to": CUDS_TABLE, RELATIONSHIP_TABLE: RELATIONSHIP_TABLE }) # fourth query self.assertEqual(r[3][0]._columns, { "ts": ["uid"], TYPES_TABLE: [], "to": ["ns_idx", "name"] }) self.assertEqual( r[3][0].condition, AndCondition( JoinCondition(TYPES_TABLE, "s", "ts", "cuds_idx"), JoinCondition(TYPES_TABLE, "o", "to", "entity_idx"), EqualsCondition("ts", "uid", str(uuid.UUID(int=1)), "UUID"))) self.assertEqual( r[3][0].datatypes, { "ts": { "uid": "UUID", "cuds_idx": rdflib.XSD.integer }, "to": { "name": rdflib.XSD.string, "ns_idx": rdflib.XSD.integer, "entity_idx": rdflib.XSD.integer }, TYPES_TABLE: {} }) self.assertEqual(r[3][0].tables, { "ts": CUDS_TABLE, "to": ENTITIES_TABLE, TYPES_TABLE: TYPES_TABLE })
def test_queries_object_given(self): """Test the _queries method when the object is given.""" # type given r = sorted(self.session._queries(pattern=(None, None, city.City.iri)), key=lambda x: x[1]) self.assertEqual(len(r), 1) self.assertEqual(r[0][1:], (TYPES_TABLE, rdflib.XSD.integer)) self.assertEqual(r[0][0]._columns, { "ts": ["uid"], "to": ["ns_idx", "name"], TYPES_TABLE: [] }) self.assertEqual( r[0][0].condition, AndCondition( JoinCondition(TYPES_TABLE, "s", "ts", "cuds_idx"), JoinCondition(TYPES_TABLE, "o", "to", "entity_idx"), EqualsCondition("to", "ns_idx", 2, rdflib.XSD.integer), EqualsCondition("to", "name", "City", rdflib.XSD.string))) self.assertEqual( r[0][0].datatypes, { "ts": { "uid": "UUID", "cuds_idx": rdflib.XSD.integer }, "to": { "name": rdflib.XSD.string, "ns_idx": rdflib.XSD.integer, "entity_idx": rdflib.XSD.integer }, TYPES_TABLE: {} }) self.assertEqual(r[0][0].tables, { "ts": CUDS_TABLE, "to": ENTITIES_TABLE, TYPES_TABLE: TYPES_TABLE }) # UUID given r = sorted( self.session._queries(pattern=(None, None, iri_from_uid(uuid.UUID(int=1)))), key=lambda x: x[1]) self.assertEqual(len(r), 1) self.assertEqual(r[0][1:], (RELATIONSHIP_TABLE, rdflib.XSD.integer)) self.assertEqual( r[0][0]._columns, { "ts": ["uid"], "tp": ["ns_idx", "name"], RELATIONSHIP_TABLE: [], "to": ["uid"] }) self.assertEqual( r[0][0].condition, AndCondition( JoinCondition(RELATIONSHIP_TABLE, "s", "ts", "cuds_idx"), JoinCondition(RELATIONSHIP_TABLE, "p", "tp", "entity_idx"), JoinCondition(RELATIONSHIP_TABLE, "o", "to", "cuds_idx"), EqualsCondition("to", "uid", str(uuid.UUID(int=1)), "UUID"))) self.assertEqual( r[0][0].datatypes, { "ts": { "uid": "UUID", "cuds_idx": rdflib.XSD.integer }, "tp": { "name": rdflib.XSD.string, "ns_idx": rdflib.XSD.integer, "entity_idx": rdflib.XSD.integer }, "to": { "uid": "UUID", "cuds_idx": rdflib.XSD.integer }, RELATIONSHIP_TABLE: {} }) self.assertEqual( r[0][0].tables, { "ts": CUDS_TABLE, "tp": ENTITIES_TABLE, "to": CUDS_TABLE, RELATIONSHIP_TABLE: RELATIONSHIP_TABLE })
def test_queries_predicate_given(self): """Test the _queries method with a given relationship.""" # object property r = sorted(self.session._queries(pattern=(None, cuba.activeRelationship.iri, None)), key=lambda x: x[1]) self.assertEqual(len(r), 1) self.assertEqual(r[0][1:], (RELATIONSHIP_TABLE, rdflib.XSD.integer)) self.assertEqual( r[0][0]._columns, { "ts": ["uid"], "tp": ["ns_idx", "name"], RELATIONSHIP_TABLE: [], "to": ["uid"] }) self.assertEqual( r[0][0].condition, AndCondition( JoinCondition(RELATIONSHIP_TABLE, "s", "ts", "cuds_idx"), JoinCondition(RELATIONSHIP_TABLE, "p", "tp", "entity_idx"), JoinCondition(RELATIONSHIP_TABLE, "o", "to", "cuds_idx"), EqualsCondition("tp", "ns_idx", 1, rdflib.XSD.integer), EqualsCondition("tp", "name", "activeRelationship", rdflib.XSD.string))) self.assertEqual( r[0][0].datatypes, { "ts": { "uid": "UUID", "cuds_idx": rdflib.XSD.integer }, "tp": { "name": rdflib.XSD.string, "ns_idx": rdflib.XSD.integer, "entity_idx": rdflib.XSD.integer }, "to": { "uid": "UUID", "cuds_idx": rdflib.XSD.integer }, RELATIONSHIP_TABLE: {} }) self.assertEqual( r[0][0].tables, { "ts": CUDS_TABLE, "tp": ENTITIES_TABLE, "to": CUDS_TABLE, RELATIONSHIP_TABLE: RELATIONSHIP_TABLE }) # type r = sorted(self.session._queries(pattern=(None, rdflib.RDF.type, None)), key=lambda x: x[1]) self.assertEqual(len(r), 1) self.assertEqual(r[0][1:], (TYPES_TABLE, rdflib.XSD.integer)) self.assertEqual(r[0][0]._columns, { "ts": ["uid"], TYPES_TABLE: [], "to": ["ns_idx", "name"] }) self.assertEqual( r[0][0].condition, AndCondition(JoinCondition(TYPES_TABLE, "s", "ts", "cuds_idx"), JoinCondition(TYPES_TABLE, "o", "to", "entity_idx"))) self.assertEqual( r[0][0].datatypes, { "ts": { "uid": "UUID", "cuds_idx": rdflib.XSD.integer }, "to": { "name": rdflib.XSD.string, "ns_idx": rdflib.XSD.integer, "entity_idx": rdflib.XSD.integer }, TYPES_TABLE: {} }) self.assertEqual(r[0][0].tables, { "ts": CUDS_TABLE, "to": ENTITIES_TABLE, TYPES_TABLE: TYPES_TABLE }) # data r = sorted(self.session._queries(pattern=(None, city.coordinates.iri, None)), key=lambda x: x[1]) self.assertEqual(len(r), 1) self.assertEqual( r[0][1:], (data_tbl("VECTOR-INT-2"), rdflib_cuba["_datatypes/VECTOR-INT-2"])) self.assertEqual( r[0][0]._columns, { "ts": ["uid"], "tp": ["ns_idx", "name"], data_tbl("VECTOR-INT-2"): ["o___0", "o___1"] }) self.assertEqual( r[0][0].condition, AndCondition( JoinCondition(data_tbl("VECTOR-INT-2"), "s", "ts", "cuds_idx"), JoinCondition(data_tbl("VECTOR-INT-2"), "p", "tp", "entity_idx"), EqualsCondition("tp", "ns_idx", 2, rdflib.XSD.integer), EqualsCondition("tp", "name", "coordinates", rdflib.XSD.string))) self.assertEqual( r[0][0].datatypes, { data_tbl("VECTOR-INT-2"): { "o": rdflib_cuba["_datatypes/VECTOR-INT-2"], "o___1": rdflib.XSD.integer, "o___0": rdflib.XSD.integer }, "ts": { "uid": "UUID", "cuds_idx": rdflib.XSD.integer }, "tp": { "name": rdflib.XSD.string, "ns_idx": rdflib.XSD.integer, "entity_idx": rdflib.XSD.integer } }) self.assertEqual( r[0][0].tables, { "ts": CUDS_TABLE, "tp": ENTITIES_TABLE, data_tbl("VECTOR-INT-2"): data_tbl("VECTOR-INT-2") }) # data with value dtype = rdflib_cuba["_datatypes/VECTOR-INT-2"] r = sorted(self.session._queries( pattern=(None, city.coordinates.iri, rdflib.Literal(np.array([1, 1]), datatype=dtype))), key=lambda x: x[1]) self.assertEqual(len(r), 1) self.assertEqual( r[0][1:], (data_tbl("VECTOR-INT-2"), rdflib_cuba["_datatypes/VECTOR-INT-2"])) self.assertEqual( r[0][0]._columns, { "ts": ["uid"], "tp": ["ns_idx", "name"], data_tbl("VECTOR-INT-2"): ["o___0", "o___1"] }) self.assertEqual( r[0][0].condition, AndCondition( JoinCondition(data_tbl("VECTOR-INT-2"), "s", "ts", "cuds_idx"), JoinCondition(data_tbl("VECTOR-INT-2"), "p", "tp", "entity_idx"), EqualsCondition("tp", "ns_idx", 2, rdflib.XSD.integer), EqualsCondition("tp", "name", "coordinates", rdflib.XSD.string), AndCondition( EqualsCondition(data_tbl("VECTOR-INT-2"), "o___0", 1, rdflib.XSD.integer), EqualsCondition(data_tbl("VECTOR-INT-2"), "o___1", 1, rdflib.XSD.integer), ))) self.assertEqual( r[0][0].datatypes, { data_tbl("VECTOR-INT-2"): { "o": rdflib_cuba["_datatypes/VECTOR-INT-2"], "o___0": rdflib.XSD.integer, "o___1": rdflib.XSD.integer }, "ts": { "uid": "UUID", "cuds_idx": rdflib.XSD.integer }, "tp": { "name": rdflib.XSD.string, "ns_idx": rdflib.XSD.integer, "entity_idx": rdflib.XSD.integer } }) self.assertEqual( r[0][0].tables, { "ts": CUDS_TABLE, "tp": ENTITIES_TABLE, data_tbl("VECTOR-INT-2"): data_tbl("VECTOR-INT-2") })