KB

java.lang.Object
- amie.data.KB

```
public class KB
extends java.lang.Object
```
Class KB This class implements an in-memory knowledge base (KB) for facts without identifiers. It supports a series of conjunctive queries.

Author:

Fabian M. Suchanek

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class KB.Column

static class KB.Instantiator
Can instantiate a variable in a query with a value

Nested Classes
Modifier and Type	Class and Description
`static class`	`KB.Column`
`static class`	`KB.Instantiator` Can instantiate a variable in a query with a value

Field Summary

Fields
Modifier and Type	Field and Description
`static java.util.regex.Pattern`	`amieTriplePattern` Pattern of a triple
`static javatools.datatypes.ByteString`	`DIFFERENTFROMbs` (X differentFrom Y Z ...) predicate
`static java.lang.String`	`DIFFERENTFROMstr` (X differentFrom Y Z ...) predicate
`static javatools.datatypes.ByteString`	`EQUALSbs` (X equals Y Z ...) predicate
`static java.lang.String`	`EQUALSstr` (X equals Y Z ...) predicate
`static javatools.datatypes.ByteString`	`EXISTSbs` r(X, y') exists for some y', predicate
`static javatools.datatypes.ByteString`	`EXISTSINVbs` r(y', X) exists for some y', predicate
`static java.lang.String`	`EXISTSINVstr` r(y', X) exists for some y', predicate
`static java.lang.String`	`EXISTSstr` r(X, y') exists for some y', predicate
`static int`	`OBJECT2OBJECT`
`protected java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`object2objectOverlap` Object-object overlaps
`protected java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>`	`object2predicate2subject` Index
`protected java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>`	`object2subject2predicate` Index
`protected javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>`	`objectSize` Number of facts per object
`protected java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>`	`predicate2object2subject` Index
`protected java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>`	`predicate2subject2object` Index
`protected javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>`	`relationSize` Number of facts per relation
`protected long`	`size` Number of facts
`static int`	`SUBJECT2OBJECT`
`protected java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>`	`subject2object2predicate` Index
`protected java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`subject2objectOverlap` Subject-object overlaps
`protected java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>`	`subject2predicate2object` Index
`static int`	`SUBJECT2SUBJECT` Identifiers for the overlap maps
`protected java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`subject2subjectOverlap` Subject-subject overlaps
`protected javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>`	`subjectSize` Number of facts per subject
`static java.util.regex.Pattern`	`triplePattern` Pattern of a triple
`static char`	`VariableSign` Variable sign (as defined in SPARQL)

Constructor Summary

Constructors
Constructor and Description

KB()

Constructors
Constructor and Description
`KB()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(javatools.datatypes.ByteString... fact)` Adds a fact to the KB
`protected boolean`	`add(javatools.datatypes.ByteString subject, javatools.datatypes.ByteString relation, javatools.datatypes.ByteString object)` Adds a fact to the KB
`protected boolean`	`add(javatools.datatypes.ByteString subject, javatools.datatypes.ByteString relation, javatools.datatypes.ByteString object, java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> map)` Methods to add single facts to the KB
`boolean`	`add(java.lang.CharSequence... fact)` Adds a fact to the KB
`static long`	`aggregate(java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> bindings)` Counts the number of bindings in the given nested map.
`static javatools.datatypes.Triple<javatools.datatypes.ByteString,javatools.datatypes.ByteString,javatools.datatypes.ByteString>`	`array2Triple(javatools.datatypes.ByteString[] triple)`
`void`	`buildOverlapTables()` It builds the overlap tables for relations.
`double`	`colFunctionality(javatools.datatypes.ByteString relation, KB.Column col)` Functionality of a relation given the position.
`static javatools.datatypes.ByteString`	`compress(java.lang.CharSequence s)` Compresses a string to an internal string
`protected boolean`	`contains(javatools.datatypes.ByteString... fact)` It returns TRUE if the database contains this fact (no variables).
`boolean`	`contains(java.lang.CharSequence... fact)` It returns TRUE if the database contains this fact (no variables).
`static boolean`	`containsVariables(java.util.List<javatools.datatypes.ByteString[]> query)` Determines whether a sequence of triples contains at least one variable
`protected long`	`count(javatools.datatypes.ByteString... triple)` returns number of instances of this triple
`long`	`count(java.lang.CharSequence... triple)` It returns the number of instances (bindings) that satisfy this triple pattern.
`protected javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>`	`countBindings(int pos, javatools.datatypes.ByteString... triple)` Counts, for each binding of the variable at position pos, the number of instantiations of the triple
`long`	`countDistinct(javatools.datatypes.ByteString variable, java.util.List<javatools.datatypes.ByteString[]> query)` returns the number of instances that fulfill a certain condition
`long`	`countDistinct(java.lang.CharSequence variable, java.util.List<java.lang.CharSequence[]> query)` It returns the number of instantiations of variable that fulfill a certain list of triple patterns.
`long`	`countDistinctPairs(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, java.util.List<javatools.datatypes.ByteString[]> query)` returns the number of distinct pairs (var1,var2) for the query
`protected long`	`countOneVariable(javatools.datatypes.ByteString... triple)` Returns the number of distinct results of the triple pattern query with 1 variable.
`long`	`countPairs(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, java.util.List<javatools.datatypes.ByteString[]> query, int[] queryInfo)`
`long`	`countPairs(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, java.util.List<javatools.datatypes.ByteString[]> query, int[] queryInfo, javatools.datatypes.ByteString[] existentialTriple, int nonExistentialPosition)`
`long`	`countPairs(java.lang.CharSequence var1, java.lang.CharSequence var2, java.util.List<javatools.datatypes.ByteString[]> query)` returns the number of distinct pairs (var1,var2) for the query
`long`	`countProjection(javatools.datatypes.ByteString[] projectionTriple, java.util.List<javatools.datatypes.ByteString[]> otherTriples)` Counts the number of instances of the projection triple that exist in joins with the other triples
`long`	`countProjection(java.lang.CharSequence[] projectionTriple, java.util.List<java.lang.CharSequence[]> query)` Counts the number of instances of the projection triple that exist in joins with the query
`javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>`	`countProjectionBindings(javatools.datatypes.ByteString[] projectionTriple, java.util.List<javatools.datatypes.ByteString[]> otherTriples, javatools.datatypes.ByteString variable)` For each instantiation of variable, it returns the number of instances of the projectionTriple satisfy the query.
`javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>`	`countProjectionBindings(java.lang.CharSequence[] projectionTriple, java.util.List<java.lang.CharSequence[]> query, java.lang.CharSequence variable)` Counts, for each binding of the variable the number of instantiations of the projection triple
`protected javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>`	`countProjectionBindings(int pos, javatools.datatypes.ByteString[] projectionTriple, java.util.List<javatools.datatypes.ByteString[]> otherTriples)` Counts for each binding of the variable at pos how many instances of the projection triple exist in the query
`protected long`	`countTwoVariables(javatools.datatypes.ByteString... triple)` Returns the number of distinct results of the triple pattern query with 2 variables.
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>>`	`difference(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, javatools.datatypes.ByteString var3, javatools.datatypes.ByteString var4, java.util.List<javatools.datatypes.ByteString[]> antecedent, javatools.datatypes.ByteString[] head)` Bindings of the projection variables that satisfy the first list of atoms but not the second.
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>`	`difference(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, javatools.datatypes.ByteString var3, java.util.List<javatools.datatypes.ByteString[]> antecedent, javatools.datatypes.ByteString[] head)` Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'
`java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`difference(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, java.util.List<javatools.datatypes.ByteString[]> antecedent, javatools.datatypes.ByteString[] head)` Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'.
`java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`difference(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, java.util.List<javatools.datatypes.ByteString[]> antecedent, java.util.List<javatools.datatypes.ByteString[]> headList)` Bindings of the projection variables that satisfy the first list of atoms but not the second.
`java.util.Set<javatools.datatypes.ByteString>`	`difference(javatools.datatypes.ByteString projectionVariable, java.util.List<javatools.datatypes.ByteString[]> antecedent, java.util.List<javatools.datatypes.ByteString[]> head)` It returns all the bindings of the projection variable that match the antecedent but not the succedent.
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>>`	`difference(java.lang.CharSequence var1, java.lang.CharSequence var2, java.lang.CharSequence var3, java.lang.CharSequence var4, java.util.List<? extends java.lang.CharSequence[]> antecedent, java.lang.CharSequence[] head)` Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>>`	`difference(java.lang.CharSequence var1, java.lang.CharSequence var2, java.lang.CharSequence var3, java.lang.CharSequence var4, java.util.List<? extends java.lang.CharSequence[]> antecedent, java.lang.CharSequence[] head, boolean swap)` Bindings of the projection variables that satisfy the first list of atoms but not the second.
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>`	`difference(java.lang.CharSequence var1, java.lang.CharSequence var2, java.lang.CharSequence var3, java.util.List<? extends java.lang.CharSequence[]> antecedent, java.lang.CharSequence[] head)` Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'.
`java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`difference(java.lang.CharSequence var1, java.lang.CharSequence var2, java.util.List<? extends java.lang.CharSequence[]> antecedent, java.lang.CharSequence[] head)` Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'.
`java.util.Set<javatools.datatypes.ByteString>`	`difference(java.lang.CharSequence projectionVariable, java.util.List<? extends java.lang.CharSequence[]> antecedent, java.lang.CharSequence[] head)` It returns all the bindings of the projection variable that match the antecedent but not the head.
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>>`	`differenceNotVarsInCommon(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, javatools.datatypes.ByteString var3, javatools.datatypes.ByteString var4, java.util.List<javatools.datatypes.ByteString[]> antecedent, javatools.datatypes.ByteString[] head)` It performs set difference for the case where the head contains 2 out of the 4 variables defined in the body.
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>>`	`differenceNotVarsInCommon(java.lang.CharSequence var1, java.lang.CharSequence var2, java.lang.CharSequence var3, java.lang.CharSequence var4, java.util.List<? extends java.lang.CharSequence[]> antecedent, java.lang.CharSequence[] head)` It performs set difference for the case where the head contains 2 out of the 4 variables defined in the body.
`java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`differenceNoVarsInCommon(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, java.util.List<javatools.datatypes.ByteString[]> antecedent, javatools.datatypes.ByteString[] head)` Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'.
`java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`differenceNoVarsInCommon(java.lang.CharSequence var1, java.lang.CharSequence var2, java.util.List<? extends java.lang.CharSequence[]> antecedent, java.lang.CharSequence[] head)` Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'.
`static boolean`	`differentFrom(javatools.datatypes.ByteString... triple)` It returns TRUE if the 0th component is different from the 2n, 3rd, 4th, etc.
`static boolean`	`differentFrom(java.lang.CharSequence... triple)` It returns TRUE if the 0th component is different from the 2n, 3rd, 4th, etc.
`long`	`entitiesSize()` Returns the number of entities in the database.
`static boolean`	`equalTo(javatools.datatypes.ByteString... triple)` It returns TRUE if the 0th component is different from the 2n, 3rd, 4th, etc.
`static boolean`	`equalTo(java.lang.CharSequence... triple)` It returns TRUE if the 0th component is different from the 2n, 3rd, 4th, etc.
`protected boolean`	`exists(java.util.List<java.lang.CharSequence[]> triples)` It returns TRUE if there exists one instantiation that satisfies the query
`protected boolean`	`existsBS(java.util.List<javatools.datatypes.ByteString[]> triples)` It returns TRUE if there exists one instantiation that satisfies the query
`int`	`firstVariableInCommon(javatools.datatypes.ByteString[] t1, javatools.datatypes.ByteString[] t2)` Returns the in the first atom, of the first variable that is found on the second atom.
`static int`	`firstVariablePos(javatools.datatypes.ByteString... fact)` Returns the position of the first variable in the pattern
`javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>`	`frequentBindingsOf(javatools.datatypes.ByteString variable, javatools.datatypes.ByteString projectionVariable, java.util.List<javatools.datatypes.ByteString[]> query)` For each instantiation of variable, it returns the number of different instances of projectionVariable that satisfy the query.
`javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>`	`frequentBindingsOf(java.lang.CharSequence variable, java.lang.CharSequence projectionVariable, java.util.List<java.lang.CharSequence[]> query)` Maps each value of the variable to the number of distinct values of the projection variable
`double`	`functionality(javatools.datatypes.ByteString relation)` It returns the harmonic functionality of a relation, as defined in the PARIS paper https://www.lri.fr/~cr/Publications_Master_2013/Brigitte_Safar/p157_fabianmsuchanek_vldb2011.pdf
`double`	`functionality(javatools.datatypes.ByteString relation, boolean inversed)` It returns the functionality or the inverse functionality of a relation.
`double`	`functionality(java.lang.CharSequence relation)` It returns the harmonic functionality of a relation, as defined in the PARIS paper https://www.lri.fr/~cr/Publications_Master_2013/Brigitte_Safar/p157_fabianmsuchanek_vldb2011.pdf
`protected java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`get(java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> map, javatools.datatypes.ByteString key)` It returns the second and third level values of a map given the keys for the first level.
`protected javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>`	`get(java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> map, javatools.datatypes.ByteString key1, javatools.datatypes.ByteString key2)` It returns the third level values of a map given the keys for the first and second level.
`java.util.Collection<javatools.datatypes.ByteString>`	`getRelations()` Get a collection with all the relations of the KB.
`javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>`	`getRelationsBiggerOrEqualThan(int threshold)` Return all the relations (and their sizes) that are bigger than the given threshold.
`java.util.List<javatools.datatypes.ByteString>`	`getRelationsList()` Get a list of the relations of the KB.
`int[]`	`identifyHardQueryTypeI(java.util.List<javatools.datatypes.ByteString[]> query)` Identifies queries containing the pattern: select ?a ?b where r(?a, ?c) r(?b, ?c) ...
`int[]`	`identifyHardQueryTypeII(java.util.List<javatools.datatypes.ByteString[]> query)` Identifies queries containing the pattern: select ?a ?b where r(?a, ?c) r'(?b, ?c) ...
`int[]`	`identifyHardQueryTypeIII(java.util.List<javatools.datatypes.ByteString[]> query)`
`KB`	`intersect(KB otherKb)` Returns a new FactDatabase containing the triples that are present in the KBs.
`double`	`inverseFunctionality(javatools.datatypes.ByteString relation)` Returns the harmonic inverse functionality, as defined in the PARIS paper https://www.lri.fr/~cr/Publications_Master_2013/Brigitte_Safar/p157_fabianmsuchanek_vldb2011.pdf
`double`	`inverseFunctionality(javatools.datatypes.ByteString relation, boolean inversed)` It returns the functionality or the inverse functionality of a relation.
`double`	`inverseFunctionality(java.lang.CharSequence relation)` Returns the harmonic inverse functionality, as defined in the PARIS paper https://www.lri.fr/~cr/Publications_Master_2013/Brigitte_Safar/p157_fabianmsuchanek_vldb2011.pdf
`static boolean`	`iscompressed(java.util.List<? extends java.lang.CharSequence[]> triples)` TRUE if this query is compressed
`boolean`	`isFunctional(javatools.datatypes.ByteString relation)` Determines whether a relation is functional, i.e., its harmonic functionality is greater than its inverse harmonic functionality.
`static boolean`	`isVariable(java.lang.CharSequence s)` TRUE if the ByteString is a SPARQL variable
`void`	`load(java.io.File... files)` It loads the contents of the given files into the in-memory database.
`protected void`	`load(java.io.File f, java.lang.String message)` It loads the contents of the given file into the in-memory database.
`void`	`load(java.util.List<java.io.File> files)` It loads the contents of the given files into the in-memory database.
`void`	`loadSequential(java.util.List<java.io.File> files)` Loads the files
`protected int`	`mostRestrictiveTriple(java.util.List<javatools.datatypes.ByteString[]> triples)` It returns the index of the most restrictive triple, -1 if most restrictive has count 0.
`protected int`	`mostRestrictiveTriple(java.util.List<javatools.datatypes.ByteString[]> triples, javatools.datatypes.ByteString variable)` It returns the index of the most restrictive triple among those that contain the given variable, -1 if most restrictive has count 0.
`protected int`	`mostRestrictiveTriple(java.util.List<javatools.datatypes.ByteString[]> triples, javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2)` It returns the index of the most restrictive triple among those that contain the given variables, -1 if most restrictive has count 0.
`static int`	`numVariables(java.lang.CharSequence... fact)` Returns number of variable occurrences in a triple.
`int`	`numVarsInCommon(javatools.datatypes.ByteString[] a, javatools.datatypes.ByteString[] b)` Return the number of common variables between 2 atoms.
`int`	`overlap(javatools.datatypes.ByteString relation1, javatools.datatypes.ByteString relation2, int overlap)` Given two relations, it returns the number of entities in common (the overlap) between two of their columns
`void`	`rebuildOverlapTables()` It clears the overlap tables and rebuilds them.
`int`	`relationColumnSize(javatools.datatypes.ByteString relation, KB.Column column)` It returns the number of distinct instance of one of the arguments (columns) of a relation.
`int`	`relationSize(javatools.datatypes.ByteString relation)` It returns the number of facts of a relation in the KB.
`long`	`relationsSize()` Returns the number of relations in the database.
`protected static java.util.List<javatools.datatypes.ByteString[]>`	`remove(int pos, java.util.List<javatools.datatypes.ByteString[]> triples)` Remove a triple from a list of triples.
`protected javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>`	`resultsOneVariable(javatools.datatypes.ByteString... triple)` Returns the results of the triple pattern query, if it contains exactly 1 variable
`java.util.Set<javatools.datatypes.ByteString>`	`resultsOneVariable(java.lang.CharSequence... triple)` Returns the results of the triple pattern query, if it contains exactly 1 variable
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>`	`resultsThreeVariables(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, javatools.datatypes.ByteString var3, javatools.datatypes.ByteString[] triple)` Returns the results of a triple query pattern with three variables as a nested map, firstValue : {secondValue : thirdValue}.
`java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`resultsTwoVariables(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, javatools.datatypes.ByteString[] triple)` Returns the results of a triple query pattern with two variables as a map of first value to set of second values
`java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`resultsTwoVariables(java.lang.CharSequence var1, java.lang.CharSequence var2, java.lang.CharSequence[] triple)` Returns the results of a triple query pattern with two variables as a map of first value to set of second values.
`java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`resultsTwoVariables(int pos1, int pos2, javatools.datatypes.ByteString[] triple)` Returns the results of a triple query pattern with two variables as a map of first value to set of second values
`java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`resultsTwoVariables(int pos1, int pos2, java.lang.CharSequence[] triple)` Returns the results of a triple query pattern with two variables as a map of first value to set of second values.
`static javatools.datatypes.Pair<java.util.List<javatools.datatypes.ByteString[]>,javatools.datatypes.ByteString[]>`	`rule(java.lang.String s)` Parses a rule of the form triple & triple & ...
`static int`	`secondVariablePos(javatools.datatypes.ByteString... fact)` Returns the position of the second variable in the pattern
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>>>`	`selectDistinct(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, javatools.datatypes.ByteString var3, javatools.datatypes.ByteString var4, javatools.datatypes.ByteString var5, java.util.List<javatools.datatypes.ByteString[]> query)`
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>>`	`selectDistinct(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, javatools.datatypes.ByteString var3, javatools.datatypes.ByteString var4, java.util.List<javatools.datatypes.ByteString[]> query)`
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>`	`selectDistinct(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, javatools.datatypes.ByteString var3, java.util.List<javatools.datatypes.ByteString[]> query)`
`java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`selectDistinct(javatools.datatypes.ByteString var1, javatools.datatypes.ByteString var2, java.util.List<javatools.datatypes.ByteString[]> query)` Returns all (distinct) pairs of values that make the query true
`java.util.Set<javatools.datatypes.ByteString>`	`selectDistinct(javatools.datatypes.ByteString variable, java.util.List<javatools.datatypes.ByteString[]> query)` returns the instances that fulfill a certain condition
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>>>`	`selectDistinct(java.lang.CharSequence var1, java.lang.CharSequence var2, java.lang.CharSequence var3, java.lang.CharSequence var4, java.lang.CharSequence var5, java.util.List<? extends java.lang.CharSequence[]> query)`
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>>`	`selectDistinct(java.lang.CharSequence var1, java.lang.CharSequence var2, java.lang.CharSequence var3, java.lang.CharSequence var4, java.util.List<? extends java.lang.CharSequence[]> query)`
`java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>`	`selectDistinct(java.lang.CharSequence var1, java.lang.CharSequence var2, java.lang.CharSequence var3, java.util.List<? extends java.lang.CharSequence[]> query)` Return all triplets of values that make the query true
`java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>`	`selectDistinct(java.lang.CharSequence var1, java.lang.CharSequence var2, java.util.List<? extends java.lang.CharSequence[]> query)` Returns all (distinct) pairs of values that make the query true
`java.util.Set<javatools.datatypes.ByteString>`	`selectDistinct(java.lang.CharSequence variable, java.util.List<java.lang.CharSequence[]> query)` returns the instances that fulfill a certain condition
`long`	`size()` Returns the number of facts in the KB.
`long`	`size(KB.Column column)` Returns the number of distinct entities in one column of the database.
`void`	`summarize(boolean detailRelations)` It outputs statistical information about the KB.
`java.lang.String`	`toString()`
`static java.lang.String`	`toString(java.util.List<javatools.datatypes.ByteString[]> s)` ToString for a query
`static <T> java.lang.String`	`toString(T[] s)` ToString for a triple
`static javatools.datatypes.ByteString[]`	`triple(javatools.datatypes.ByteString... triple)` Makes a triple
`static javatools.datatypes.ByteString[]`	`triple(java.lang.CharSequence... triple)` Makes a triple
`static javatools.datatypes.ByteString[]`	`triple(java.lang.String s)` Parses a triple of the form r(x,y) and turns into a triple of the form [x, r, y]
`static javatools.datatypes.ByteString[]`	`triple2Array(javatools.datatypes.Triple<javatools.datatypes.ByteString,javatools.datatypes.ByteString,javatools.datatypes.ByteString> t)`
`static java.util.List<javatools.datatypes.ByteString[]>`	`triples(javatools.datatypes.ByteString[]... triples)` Makes a list of triples
`static java.util.List<javatools.datatypes.ByteString[]>`	`triples(java.util.List<? extends java.lang.CharSequence[]> triples)` makes triples
`static java.util.ArrayList<javatools.datatypes.ByteString[]>`	`triples(java.lang.String s)` It parses a Datalog query with atoms of the form r(x,y) and turns into a list of AMIE triples of the form [x, r, y].
`static int`	`varpos(javatools.datatypes.ByteString var, javatools.datatypes.ByteString[] triple)` Returns the position of a variable in a triple.
`static int`	`varpos(java.lang.CharSequence var, java.lang.CharSequence[] triple)` Returns the position of a variable in a triple.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

subject2predicate2object

protected final java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> subject2predicate2object

Index

predicate2object2subject

protected final java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> predicate2object2subject

Index

object2subject2predicate

protected final java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> object2subject2predicate

Index

predicate2subject2object

protected final java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> predicate2subject2object

Index

object2predicate2subject

protected final java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> object2predicate2subject

Index

subject2object2predicate

protected final java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> subject2object2predicate

Index

subjectSize

protected final javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> subjectSize

Number of facts per subject

objectSize

protected final javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> objectSize

Number of facts per object

relationSize

protected final javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> relationSize

Number of facts per relation

subject2subjectOverlap

protected final java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> subject2subjectOverlap

Subject-subject overlaps

subject2objectOverlap

protected final java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> subject2objectOverlap

Subject-object overlaps

object2objectOverlap

protected final java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> object2objectOverlap

Object-object overlaps

size
```
protected long size
```
Number of facts

DIFFERENTFROMstr
```
public static final java.lang.String DIFFERENTFROMstr
```
(X differentFrom Y Z ...) predicate

See Also:

Constant Field Values

DIFFERENTFROMbs

public static final javatools.datatypes.ByteString DIFFERENTFROMbs

(X differentFrom Y Z ...) predicate

EQUALSstr
```
public static final java.lang.String EQUALSstr
```
(X equals Y Z ...) predicate

See Also:

Constant Field Values

EQUALSbs

public static final javatools.datatypes.ByteString EQUALSbs

(X equals Y Z ...) predicate

EXISTSstr
```
public static final java.lang.String EXISTSstr
```
r(X, y') exists for some y', predicate

See Also:

Constant Field Values

EXISTSbs

public static final javatools.datatypes.ByteString EXISTSbs

r(X, y') exists for some y', predicate

EXISTSINVstr
```
public static final java.lang.String EXISTSINVstr
```
r(y', X) exists for some y', predicate

See Also:

Constant Field Values

VariableSign
```
public static final char VariableSign
```
Variable sign (as defined in SPARQL)

See Also:

Constant Field Values

EXISTSINVbs

public static final javatools.datatypes.ByteString EXISTSINVbs

r(y', X) exists for some y', predicate

SUBJECT2SUBJECT
```
public static final int SUBJECT2SUBJECT
```
Identifiers for the overlap maps

See Also:

Constant Field Values

SUBJECT2OBJECT
```
public static final int SUBJECT2OBJECT
```
See Also:

Constant Field Values

OBJECT2OBJECT
```
public static final int OBJECT2OBJECT
```
See Also:

Constant Field Values

triplePattern

public static final java.util.regex.Pattern triplePattern

Pattern of a triple

amieTriplePattern

public static final java.util.regex.Pattern amieTriplePattern

Pattern of a triple

Constructor Detail
- KB
```
public KB()
```

Method Detail

add

protected boolean add(javatools.datatypes.ByteString subject,
                      javatools.datatypes.ByteString relation,
                      javatools.datatypes.ByteString object,
                      java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> map)

Methods to add single facts to the KB

add
```
public boolean add(java.lang.CharSequence... fact)
```
Adds a fact to the KB

Parameters:

fact -

Returns:

TRUE if the KB was changed, i.e., the fact did not exist before.

add
```
public boolean add(javatools.datatypes.ByteString... fact)
```
Adds a fact to the KB

Parameters:

fact -

Returns:

TRUE if the KB was changed, i.e., the fact did not exist before.

add

protected boolean add(javatools.datatypes.ByteString subject,
                      javatools.datatypes.ByteString relation,
                      javatools.datatypes.ByteString object)

Adds a fact to the KB

Parameters:: subject -; relation -; object -
Returns:: TRUE if the KB was changed, i.e., the fact did not exist before.

size
```
public long size()
```
Returns the number of facts in the KB.

size
```
public long size(KB.Column column)
```
Returns the number of distinct entities in one column of the database.

Parameters:

column - 0 = Subject, 1 = Relation/Predicate, 2 = Object

Returns:

relationsSize
```
public long relationsSize()
```
Returns the number of relations in the database.

Returns:

entitiesSize
```
public long entitiesSize()
```
Returns the number of entities in the database.

Returns:

isVariable

public static boolean isVariable(java.lang.CharSequence s)

TRUE if the ByteString is a SPARQL variable

rebuildOverlapTables
```
public void rebuildOverlapTables()
```
It clears the overlap tables and rebuilds them. Recommended when new facts has been added to the KB after the initial loading.

buildOverlapTables
```
public void buildOverlapTables()
```
It builds the overlap tables for relations. They contain the number of subjects and objects in common between pairs of relations. They can be used for join cardinality estimation.

load
```
public void load(java.io.File... files)
          throws java.io.IOException
```
It loads the contents of the given files into the in-memory database.

Parameters:

files -

Throws:

java.io.IOException

load
```
public void load(java.util.List<java.io.File> files)
          throws java.io.IOException
```
It loads the contents of the given files into the in-memory database.

Parameters:

files -

Throws:

java.io.IOException

load

protected void load(java.io.File f,
                    java.lang.String message)
             throws java.io.IOException

It loads the contents of the given file into the in-memory database.

Parameters:: f -; message -
Throws:: java.io.IOException

loadSequential

public void loadSequential(java.util.List<java.io.File> files)
                    throws java.io.IOException

Loads the files

Throws:: java.io.IOException

functionality
```
public double functionality(javatools.datatypes.ByteString relation)
```
It returns the harmonic functionality of a relation, as defined in the PARIS paper https://www.lri.fr/~cr/Publications_Master_2013/Brigitte_Safar/p157_fabianmsuchanek_vldb2011.pdf

functionality
```
public double functionality(java.lang.CharSequence relation)
```
It returns the harmonic functionality of a relation, as defined in the PARIS paper https://www.lri.fr/~cr/Publications_Master_2013/Brigitte_Safar/p157_fabianmsuchanek_vldb2011.pdf

inverseFunctionality
```
public double inverseFunctionality(javatools.datatypes.ByteString relation)
```
Returns the harmonic inverse functionality, as defined in the PARIS paper https://www.lri.fr/~cr/Publications_Master_2013/Brigitte_Safar/p157_fabianmsuchanek_vldb2011.pdf

inverseFunctionality
```
public double inverseFunctionality(java.lang.CharSequence relation)
```
Returns the harmonic inverse functionality, as defined in the PARIS paper https://www.lri.fr/~cr/Publications_Master_2013/Brigitte_Safar/p157_fabianmsuchanek_vldb2011.pdf

colFunctionality

public double colFunctionality(javatools.datatypes.ByteString relation,
                               KB.Column col)

Functionality of a relation given the position.

Parameters:: relation -; col - Subject = functionality, Object = Inverse functionality
Returns:

isFunctional
```
public boolean isFunctional(javatools.datatypes.ByteString relation)
```
Determines whether a relation is functional, i.e., its harmonic functionality is greater than its inverse harmonic functionality.

Parameters:

relation -

Returns:

functionality
```
public double functionality(javatools.datatypes.ByteString relation,
                            boolean inversed)
```
It returns the functionality or the inverse functionality of a relation.

Parameters:

relation -

inversed - If true, the method returns the inverse functionality, otherwise it returns the standard functionality.

Returns:

inverseFunctionality
```
public double inverseFunctionality(javatools.datatypes.ByteString relation,
                                   boolean inversed)
```
It returns the functionality or the inverse functionality of a relation.

Parameters:

inversed - If true, the method returns the functionality of a relation, otherwise it returns the inverse functionality.

Returns:

overlap
```
public int overlap(javatools.datatypes.ByteString relation1,
                   javatools.datatypes.ByteString relation2,
                   int overlap)
```
Given two relations, it returns the number of entities in common (the overlap) between two of their columns

Parameters:

relation1 -

relation2 -

overlap - 0 = Subject-Subject, 2 = Subject-Object, 4 = Object-Object

Returns:

relationSize
```
public int relationSize(javatools.datatypes.ByteString relation)
```
It returns the number of facts of a relation in the KB.

Parameters:

relation -

Returns:

relationColumnSize
```
public int relationColumnSize(javatools.datatypes.ByteString relation,
                              KB.Column column)
```
It returns the number of distinct instance of one of the arguments (columns) of a relation.

Parameters:

relation -

column. - Subject or Object

Returns:

differentFrom
```
public static boolean differentFrom(java.lang.CharSequence... triple)
```
It returns TRUE if the 0th component is different from the 2n, 3rd, 4th, etc.

differentFrom
```
public static boolean differentFrom(javatools.datatypes.ByteString... triple)
```
It returns TRUE if the 0th component is different from the 2n, 3rd, 4th, etc.

equalTo
```
public static boolean equalTo(java.lang.CharSequence... triple)
```
It returns TRUE if the 0th component is different from the 2n, 3rd, 4th, etc.

equalTo
```
public static boolean equalTo(javatools.datatypes.ByteString... triple)
```
It returns TRUE if the 0th component is different from the 2n, 3rd, 4th, etc.

get

protected javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> get(java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> map,
                                                                             javatools.datatypes.ByteString key1,
                                                                             javatools.datatypes.ByteString key2)

It returns the third level values of a map given the keys for the first and second level.

Parameters:: key1 -; key2 -; map - A 3-level map
Returns:

get

protected java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> get(java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> map,
                                                                                                                           javatools.datatypes.ByteString key)

It returns the second and third level values of a map given the keys for the first level.

Parameters:: key -; map - A 3-level map
Returns:

resultsOneVariable

public java.util.Set<javatools.datatypes.ByteString> resultsOneVariable(java.lang.CharSequence... triple)

Returns the results of the triple pattern query, if it contains exactly 1 variable

resultsOneVariable

protected javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> resultsOneVariable(javatools.datatypes.ByteString... triple)

Returns the results of the triple pattern query, if it contains exactly 1 variable

contains
```
public boolean contains(java.lang.CharSequence... fact)
```
It returns TRUE if the database contains this fact (no variables). If the fact containst meta-relations (e.g. differentFrom, equals, exists), it returns TRUE if the expression evaluates to TRUE.

Parameters:

fact - A triple without variables, e.g., [Barack_Obama, wasBornIn, Hawaii]

contains
```
protected boolean contains(javatools.datatypes.ByteString... fact)
```
It returns TRUE if the database contains this fact (no variables). If the fact containst meta-relations (e.g. differentFrom, equals, exists), it returns TRUE if the expression evaluates to TRUE.

Parameters:

fact - A triple without variables, e.g., [Barack_Obama, wasBornIn, Hawaii]

resultsTwoVariables

public java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> resultsTwoVariables(java.lang.CharSequence var1,
                                                                                                                                        java.lang.CharSequence var2,
                                                                                                                                        java.lang.CharSequence[] triple)

Returns the results of a triple query pattern with two variables as a map of first value to set of second values.

resultsTwoVariables

public java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> resultsTwoVariables(int pos1,
                                                                                                                                        int pos2,
                                                                                                                                        java.lang.CharSequence[] triple)

Returns the results of a triple query pattern with two variables as a map of first value to set of second values.

resultsTwoVariables

public java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> resultsTwoVariables(javatools.datatypes.ByteString var1,
                                                                                                                                        javatools.datatypes.ByteString var2,
                                                                                                                                        javatools.datatypes.ByteString[] triple)

Returns the results of a triple query pattern with two variables as a map of first value to set of second values

resultsTwoVariables

public java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> resultsTwoVariables(int pos1,
                                                                                                                                        int pos2,
                                                                                                                                        javatools.datatypes.ByteString[] triple)

Returns the results of a triple query pattern with two variables as a map of first value to set of second values

resultsThreeVariables

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> resultsThreeVariables(javatools.datatypes.ByteString var1,
                                                                                                                                                                                        javatools.datatypes.ByteString var2,
                                                                                                                                                                                        javatools.datatypes.ByteString var3,
                                                                                                                                                                                        javatools.datatypes.ByteString[] triple)

Returns the results of a triple query pattern with three variables as a nested map, firstValue : {secondValue : thirdValue}.

Parameters:: var1 -; var2 -; var3 -; triple -
Returns:

countOneVariable
```
protected long countOneVariable(javatools.datatypes.ByteString... triple)
```
Returns the number of distinct results of the triple pattern query with 1 variable.

countTwoVariables
```
protected long countTwoVariables(javatools.datatypes.ByteString... triple)
```
Returns the number of distinct results of the triple pattern query with 2 variables.

numVariables
```
public static int numVariables(java.lang.CharSequence... fact)
```
Returns number of variable occurrences in a triple. Variables start with "?".

containsVariables
```
public static boolean containsVariables(java.util.List<javatools.datatypes.ByteString[]> query)
```
Determines whether a sequence of triples contains at least one variable

Parameters:

query -

Returns:

count
```
public long count(java.lang.CharSequence... triple)
```
It returns the number of instances (bindings) that satisfy this triple pattern.

Parameters:

triple - A triple pattern containing both constants and variables (no restrictions, it can contain only constants).

count

protected long count(javatools.datatypes.ByteString... triple)

returns number of instances of this triple

remove

protected static java.util.List<javatools.datatypes.ByteString[]> remove(int pos,
                                                                         java.util.List<javatools.datatypes.ByteString[]> triples)

Remove a triple from a list of triples.

Parameters:: pos - Index in the list of the triple to be removed.; triples - Target list

mostRestrictiveTriple
```
protected int mostRestrictiveTriple(java.util.List<javatools.datatypes.ByteString[]> triples)
```
It returns the index of the most restrictive triple, -1 if most restrictive has count 0. The most restrictive triple is the one that contains the smallest number of satisfying instantiations.

mostRestrictiveTriple
```
protected int mostRestrictiveTriple(java.util.List<javatools.datatypes.ByteString[]> triples,
                                    javatools.datatypes.ByteString variable)
```
It returns the index of the most restrictive triple among those that contain the given variable, -1 if most restrictive has count 0. The most restrictive triple is the one that contains the smallest number of satisfying instantiations.

Parameters:

triples -

variable - Only triples containing this variable are considered.

mostRestrictiveTriple
```
protected int mostRestrictiveTriple(java.util.List<javatools.datatypes.ByteString[]> triples,
                                    javatools.datatypes.ByteString var1,
                                    javatools.datatypes.ByteString var2)
```
It returns the index of the most restrictive triple among those that contain the given variables, -1 if most restrictive has count 0. The most restrictive triple is the one that contains the smallest number of satisfying instantiations.

Parameters:

triples -

var1 -

var2 -

varpos

public static int varpos(javatools.datatypes.ByteString var,
                         javatools.datatypes.ByteString[] triple)

Returns the position of a variable in a triple.

Parameters:: var -; triple -

varpos

public static int varpos(java.lang.CharSequence var,
                         java.lang.CharSequence[] triple)

Returns the position of a variable in a triple.

Parameters:: var -; triple -

firstVariablePos
```
public static int firstVariablePos(javatools.datatypes.ByteString... fact)
```
Returns the position of the first variable in the pattern

Parameters:

fact -

Returns:

secondVariablePos
```
public static int secondVariablePos(javatools.datatypes.ByteString... fact)
```
Returns the position of the second variable in the pattern

Parameters:

fact -

Returns:

exists
```
protected boolean exists(java.util.List<java.lang.CharSequence[]> triples)
```
It returns TRUE if there exists one instantiation that satisfies the query

Parameters:

triples -

Returns:

existsBS
```
protected boolean existsBS(java.util.List<javatools.datatypes.ByteString[]> triples)
```
It returns TRUE if there exists one instantiation that satisfies the query

Parameters:

triples -

Returns:

countDistinct
```
public long countDistinct(java.lang.CharSequence variable,
                          java.util.List<java.lang.CharSequence[]> query)
```
It returns the number of instantiations of variable that fulfill a certain list of triple patterns.

Parameters:

variable - Projection variable

query - The list of triple patterns

countDistinct

public long countDistinct(javatools.datatypes.ByteString variable,
                          java.util.List<javatools.datatypes.ByteString[]> query)

returns the number of instances that fulfill a certain condition

selectDistinct

public java.util.Set<javatools.datatypes.ByteString> selectDistinct(java.lang.CharSequence variable,
                                                                    java.util.List<java.lang.CharSequence[]> query)

returns the instances that fulfill a certain condition

selectDistinct

public java.util.Set<javatools.datatypes.ByteString> selectDistinct(javatools.datatypes.ByteString variable,
                                                                    java.util.List<javatools.datatypes.ByteString[]> query)

returns the instances that fulfill a certain condition

selectDistinct

public java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> selectDistinct(java.lang.CharSequence var1,
                                                                                                                                   java.lang.CharSequence var2,
                                                                                                                                   java.util.List<? extends java.lang.CharSequence[]> query)

Returns all (distinct) pairs of values that make the query true

selectDistinct

public java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> selectDistinct(javatools.datatypes.ByteString var1,
                                                                                                                                   javatools.datatypes.ByteString var2,
                                                                                                                                   java.util.List<javatools.datatypes.ByteString[]> query)

Returns all (distinct) pairs of values that make the query true

selectDistinct

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> selectDistinct(java.lang.CharSequence var1,
                                                                                                                                                                                 java.lang.CharSequence var2,
                                                                                                                                                                                 java.lang.CharSequence var3,
                                                                                                                                                                                 java.util.List<? extends java.lang.CharSequence[]> query)

Return all triplets of values that make the query true

selectDistinct

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> selectDistinct(javatools.datatypes.ByteString var1,
                                                                                                                                                                                 javatools.datatypes.ByteString var2,
                                                                                                                                                                                 javatools.datatypes.ByteString var3,
                                                                                                                                                                                 java.util.List<javatools.datatypes.ByteString[]> query)

selectDistinct

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>> selectDistinct(java.lang.CharSequence var1,
                                                                                                                                                                                                                               java.lang.CharSequence var2,
                                                                                                                                                                                                                               java.lang.CharSequence var3,
                                                                                                                                                                                                                               java.lang.CharSequence var4,
                                                                                                                                                                                                                               java.util.List<? extends java.lang.CharSequence[]> query)

selectDistinct

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>> selectDistinct(javatools.datatypes.ByteString var1,
                                                                                                                                                                                                                               javatools.datatypes.ByteString var2,
                                                                                                                                                                                                                               javatools.datatypes.ByteString var3,
                                                                                                                                                                                                                               javatools.datatypes.ByteString var4,
                                                                                                                                                                                                                               java.util.List<javatools.datatypes.ByteString[]> query)

selectDistinct

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>>> selectDistinct(java.lang.CharSequence var1,
                                                                                                                                                                                                                                                                             java.lang.CharSequence var2,
                                                                                                                                                                                                                                                                             java.lang.CharSequence var3,
                                                                                                                                                                                                                                                                             java.lang.CharSequence var4,
                                                                                                                                                                                                                                                                             java.lang.CharSequence var5,
                                                                                                                                                                                                                                                                             java.util.List<? extends java.lang.CharSequence[]> query)

selectDistinct

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>>> selectDistinct(javatools.datatypes.ByteString var1,
                                                                                                                                                                                                                                                                             javatools.datatypes.ByteString var2,
                                                                                                                                                                                                                                                                             javatools.datatypes.ByteString var3,
                                                                                                                                                                                                                                                                             javatools.datatypes.ByteString var4,
                                                                                                                                                                                                                                                                             javatools.datatypes.ByteString var5,
                                                                                                                                                                                                                                                                             java.util.List<javatools.datatypes.ByteString[]> query)

frequentBindingsOf

public javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> frequentBindingsOf(java.lang.CharSequence variable,
                                                                                         java.lang.CharSequence projectionVariable,
                                                                                         java.util.List<java.lang.CharSequence[]> query)

Maps each value of the variable to the number of distinct values of the projection variable

frequentBindingsOf

public javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> frequentBindingsOf(javatools.datatypes.ByteString variable,
                                                                                         javatools.datatypes.ByteString projectionVariable,
                                                                                         java.util.List<javatools.datatypes.ByteString[]> query)

For each instantiation of variable, it returns the number of different instances of projectionVariable that satisfy the query.

Returns:: IntHashMap A map of the form {string : frequency}

countBindings

protected javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> countBindings(int pos,
                                                                                       javatools.datatypes.ByteString... triple)

Counts, for each binding of the variable at position pos, the number of instantiations of the triple

countProjectionBindings

protected javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> countProjectionBindings(int pos,
                                                                                                 javatools.datatypes.ByteString[] projectionTriple,
                                                                                                 java.util.List<javatools.datatypes.ByteString[]> otherTriples)

Counts for each binding of the variable at pos how many instances of the projection triple exist in the query

countProjectionBindings

public javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> countProjectionBindings(javatools.datatypes.ByteString[] projectionTriple,
                                                                                              java.util.List<javatools.datatypes.ByteString[]> otherTriples,
                                                                                              javatools.datatypes.ByteString variable)

For each instantiation of variable, it returns the number of instances of the projectionTriple satisfy the query. The projection triple can have either one or two variables.

Returns:: IntHashMap A map of the form {string : frequency}

firstVariableInCommon

public int firstVariableInCommon(javatools.datatypes.ByteString[] t1,
                                 javatools.datatypes.ByteString[] t2)

Returns the in the first atom, of the first variable that is found on the second atom.

Parameters:: t1 -; t2 -
Returns:

numVarsInCommon

public int numVarsInCommon(javatools.datatypes.ByteString[] a,
                           javatools.datatypes.ByteString[] b)

Return the number of common variables between 2 atoms.

Parameters:: a -; b -
Returns:

countProjectionBindings

public javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> countProjectionBindings(java.lang.CharSequence[] projectionTriple,
                                                                                              java.util.List<java.lang.CharSequence[]> query,
                                                                                              java.lang.CharSequence variable)

Counts, for each binding of the variable the number of instantiations of the projection triple

countProjection

public long countProjection(java.lang.CharSequence[] projectionTriple,
                            java.util.List<java.lang.CharSequence[]> query)

Counts the number of instances of the projection triple that exist in joins with the query

countProjection

public long countProjection(javatools.datatypes.ByteString[] projectionTriple,
                            java.util.List<javatools.datatypes.ByteString[]> otherTriples)

Counts the number of instances of the projection triple that exist in joins with the other triples

countPairs

public long countPairs(java.lang.CharSequence var1,
                       java.lang.CharSequence var2,
                       java.util.List<javatools.datatypes.ByteString[]> query)

returns the number of distinct pairs (var1,var2) for the query

identifyHardQueryTypeI
```
public int[] identifyHardQueryTypeI(java.util.List<javatools.datatypes.ByteString[]> query)
```
Identifies queries containing the pattern: select ?a ?b where r(?a, ?c) r(?b, ?c) ... select ?a ?b where r(?c, ?a) r(?c, ?b) ...

Parameters:

query -

Returns:

identifyHardQueryTypeII
```
public int[] identifyHardQueryTypeII(java.util.List<javatools.datatypes.ByteString[]> query)
```
Identifies queries containing the pattern: select ?a ?b where r(?a, ?c) r'(?b, ?c) ... select ?a ?b where r(?c, ?a) r'(?c, ?b) ...

Parameters:

query -

Returns:

identifyHardQueryTypeIII

public int[] identifyHardQueryTypeIII(java.util.List<javatools.datatypes.ByteString[]> query)

countPairs

public long countPairs(javatools.datatypes.ByteString var1,
                       javatools.datatypes.ByteString var2,
                       java.util.List<javatools.datatypes.ByteString[]> query,
                       int[] queryInfo)

countPairs

public long countPairs(javatools.datatypes.ByteString var1,
                       javatools.datatypes.ByteString var2,
                       java.util.List<javatools.datatypes.ByteString[]> query,
                       int[] queryInfo,
                       javatools.datatypes.ByteString[] existentialTriple,
                       int nonExistentialPosition)

countDistinctPairs

public long countDistinctPairs(javatools.datatypes.ByteString var1,
                               javatools.datatypes.ByteString var2,
                               java.util.List<javatools.datatypes.ByteString[]> query)

returns the number of distinct pairs (var1,var2) for the query

toString

public static <T> java.lang.String toString(T[] s)

ToString for a triple

toString

public static java.lang.String toString(java.util.List<javatools.datatypes.ByteString[]> s)

ToString for a query

compress

public static javatools.datatypes.ByteString compress(java.lang.CharSequence s)

Compresses a string to an internal string

triples

public static java.util.List<javatools.datatypes.ByteString[]> triples(javatools.datatypes.ByteString[]... triples)

Makes a list of triples

triples

public static java.util.List<javatools.datatypes.ByteString[]> triples(java.util.List<? extends java.lang.CharSequence[]> triples)

makes triples

triple2Array

public static javatools.datatypes.ByteString[] triple2Array(javatools.datatypes.Triple<javatools.datatypes.ByteString,javatools.datatypes.ByteString,javatools.datatypes.ByteString> t)

array2Triple

public static javatools.datatypes.Triple<javatools.datatypes.ByteString,javatools.datatypes.ByteString,javatools.datatypes.ByteString> array2Triple(javatools.datatypes.ByteString[] triple)

iscompressed

public static boolean iscompressed(java.util.List<? extends java.lang.CharSequence[]> triples)

TRUE if this query is compressed

triple

public static javatools.datatypes.ByteString[] triple(javatools.datatypes.ByteString... triple)

Makes a triple

triple

public static javatools.datatypes.ByteString[] triple(java.lang.CharSequence... triple)

Makes a triple

triple
```
public static javatools.datatypes.ByteString[] triple(java.lang.String s)
```
Parses a triple of the form r(x,y) and turns into a triple of the form [x, r, y]

Parameters:

s -

Returns:

triples
```
public static java.util.ArrayList<javatools.datatypes.ByteString[]> triples(java.lang.String s)
```
It parses a Datalog query with atoms of the form r(x,y) and turns into a list of AMIE triples of the form [x, r, y].

Parameters:

s -

Returns:

rule
```
public static javatools.datatypes.Pair<java.util.List<javatools.datatypes.ByteString[]>,javatools.datatypes.ByteString[]> rule(java.lang.String s)
```
Parses a rule of the form triple & triple & ... => triple or triple :- triple & triple & ...

Returns:

A pair where the first element is the list of body atoms (left-hand side of the rule) and the second element is triple pattern, the head of the rule.

difference

public java.util.Set<javatools.datatypes.ByteString> difference(java.lang.CharSequence projectionVariable,
                                                                java.util.List<? extends java.lang.CharSequence[]> antecedent,
                                                                java.lang.CharSequence[] head)

It returns all the bindings of the projection variable that match the antecedent but not the head.

Parameters:: projectionVariable -; antecedent -; head -
Returns:

difference

public java.util.Set<javatools.datatypes.ByteString> difference(javatools.datatypes.ByteString projectionVariable,
                                                                java.util.List<javatools.datatypes.ByteString[]> antecedent,
                                                                java.util.List<javatools.datatypes.ByteString[]> head)

It returns all the bindings of the projection variable that match the antecedent but not the succedent.

Parameters:: projectionVariable -; antecedent -; head -
Returns:

difference

public java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> difference(java.lang.CharSequence var1,
                                                                                                                               java.lang.CharSequence var2,
                                                                                                                               java.util.List<? extends java.lang.CharSequence[]> antecedent,
                                                                                                                               java.lang.CharSequence[] head)

Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'.

Parameters:: var1 -; var2 -; antecedent -; head -
Returns:

difference

public java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> difference(javatools.datatypes.ByteString var1,
                                                                                                                               javatools.datatypes.ByteString var2,
                                                                                                                               java.util.List<javatools.datatypes.ByteString[]> antecedent,
                                                                                                                               javatools.datatypes.ByteString[] head)

Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'.

Parameters:: var1 -; var2 -; antecedent -; head -
Returns:

differenceNoVarsInCommon

public java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> differenceNoVarsInCommon(java.lang.CharSequence var1,
                                                                                                                                             java.lang.CharSequence var2,
                                                                                                                                             java.util.List<? extends java.lang.CharSequence[]> antecedent,
                                                                                                                                             java.lang.CharSequence[] head)

Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'.

Parameters:: var1 -; var2 -; antecedent -; head -
Returns:

differenceNoVarsInCommon

public java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> differenceNoVarsInCommon(javatools.datatypes.ByteString var1,
                                                                                                                                             javatools.datatypes.ByteString var2,
                                                                                                                                             java.util.List<javatools.datatypes.ByteString[]> antecedent,
                                                                                                                                             javatools.datatypes.ByteString[] head)

Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'. Special case of the difference where the head atom does not contain the projection variables.

Parameters:: var1 -; var2 -; antecedent -; head -
Returns:

difference

public java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> difference(javatools.datatypes.ByteString var1,
                                                                                                                               javatools.datatypes.ByteString var2,
                                                                                                                               java.util.List<javatools.datatypes.ByteString[]> antecedent,
                                                                                                                               java.util.List<javatools.datatypes.ByteString[]> headList)

Bindings of the projection variables that satisfy the first list of atoms but not the second.

Parameters:: var1 -; var2 -; antecedent -; headList -
Returns:

difference

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> difference(java.lang.CharSequence var1,
                                                                                                                                                                             java.lang.CharSequence var2,
                                                                                                                                                                             java.lang.CharSequence var3,
                                                                                                                                                                             java.util.List<? extends java.lang.CharSequence[]> antecedent,
                                                                                                                                                                             java.lang.CharSequence[] head)

Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'.

Parameters:: var1 -; var2 -; var3 -; antecedent -; head -
Returns:

difference

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>> difference(javatools.datatypes.ByteString var1,
                                                                                                                                                                             javatools.datatypes.ByteString var2,
                                                                                                                                                                             javatools.datatypes.ByteString var3,
                                                                                                                                                                             java.util.List<javatools.datatypes.ByteString[]> antecedent,
                                                                                                                                                                             javatools.datatypes.ByteString[] head)

Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'

Parameters:: var1 -; var2 -; var3 -; antecedent -; head -
Returns:

difference

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>> difference(java.lang.CharSequence var1,
                                                                                                                                                                                                                           java.lang.CharSequence var2,
                                                                                                                                                                                                                           java.lang.CharSequence var3,
                                                                                                                                                                                                                           java.lang.CharSequence var4,
                                                                                                                                                                                                                           java.util.List<? extends java.lang.CharSequence[]> antecedent,
                                                                                                                                                                                                                           java.lang.CharSequence[] head)

Bindings of the projection variables that satisfy the first list of atoms but not the atom 'head'

Parameters:: var1 -; var2 -; var3 -; var4 -; antecedent -; head -
Returns:

difference

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>> difference(java.lang.CharSequence var1,
                                                                                                                                                                                                                           java.lang.CharSequence var2,
                                                                                                                                                                                                                           java.lang.CharSequence var3,
                                                                                                                                                                                                                           java.lang.CharSequence var4,
                                                                                                                                                                                                                           java.util.List<? extends java.lang.CharSequence[]> antecedent,
                                                                                                                                                                                                                           java.lang.CharSequence[] head,
                                                                                                                                                                                                                           boolean swap)

Bindings of the projection variables that satisfy the first list of atoms but not the second.

Parameters:: var1 -; var2 -; antecedent -; head -; swap -
Returns:

difference

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>> difference(javatools.datatypes.ByteString var1,
                                                                                                                                                                                                                           javatools.datatypes.ByteString var2,
                                                                                                                                                                                                                           javatools.datatypes.ByteString var3,
                                                                                                                                                                                                                           javatools.datatypes.ByteString var4,
                                                                                                                                                                                                                           java.util.List<javatools.datatypes.ByteString[]> antecedent,
                                                                                                                                                                                                                           javatools.datatypes.ByteString[] head)

Bindings of the projection variables that satisfy the first list of atoms but not the second.

Parameters:: var1 -; var2 -; antecedent -; head -
Returns:

differenceNotVarsInCommon

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>> differenceNotVarsInCommon(java.lang.CharSequence var1,
                                                                                                                                                                                                                                          java.lang.CharSequence var2,
                                                                                                                                                                                                                                          java.lang.CharSequence var3,
                                                                                                                                                                                                                                          java.lang.CharSequence var4,
                                                                                                                                                                                                                                          java.util.List<? extends java.lang.CharSequence[]> antecedent,
                                                                                                                                                                                                                                          java.lang.CharSequence[] head)

It performs set difference for the case where the head contains 2 out of the 4 variables defined in the body.

Parameters:: var1 - First variable, not occurring in the head; var2 - Second variable, not occuring in the head; var3 - First Variable occurring in both body and head; var4 - Second Variable occuring in both body and head; antecedent -; head -
Returns:

differenceNotVarsInCommon

public java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>>>> differenceNotVarsInCommon(javatools.datatypes.ByteString var1,
                                                                                                                                                                                                                                          javatools.datatypes.ByteString var2,
                                                                                                                                                                                                                                          javatools.datatypes.ByteString var3,
                                                                                                                                                                                                                                          javatools.datatypes.ByteString var4,
                                                                                                                                                                                                                                          java.util.List<javatools.datatypes.ByteString[]> antecedent,
                                                                                                                                                                                                                                          javatools.datatypes.ByteString[] head)

It performs set difference for the case where the head contains 2 out of the 4 variables defined in the body.

Parameters:: var1 - First variable, not occurring in the head; var2 - Second variable, not occurring in the head; var3 - First Variable occurring in both body and head; var4 - Second Variable occurring in both body and head; antecedent -; head -
Returns:

aggregate

public static long aggregate(java.util.Map<javatools.datatypes.ByteString,javatools.datatypes.IntHashMap<javatools.datatypes.ByteString>> bindings)

Counts the number of bindings in the given nested map.

Parameters:: bindings -
Returns:

getRelations

public java.util.Collection<javatools.datatypes.ByteString> getRelations()

Get a collection with all the relations of the KB.

Returns:

getRelationsBiggerOrEqualThan
```
public javatools.datatypes.IntHashMap<javatools.datatypes.ByteString> getRelationsBiggerOrEqualThan(int threshold)
```
Return all the relations (and their sizes) that are bigger than the given threshold.

Parameters:

threshold -

Returns:

getRelationsList

public java.util.List<javatools.datatypes.ByteString> getRelationsList()

Get a list of the relations of the KB.

Returns:

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

intersect
```
public KB intersect(KB otherKb)
```
Returns a new FactDatabase containing the triples that are present in the KBs.

Parameters:

otherKb -

Returns:

summarize
```
public void summarize(boolean detailRelations)
```
It outputs statistical information about the KB.

Parameters:

detailRelations - If true, print also information about the relations

Class KB

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

subject2predicate2object

predicate2object2subject

object2subject2predicate

predicate2subject2object

object2predicate2subject

subject2object2predicate

subjectSize

objectSize

relationSize

subject2subjectOverlap

subject2objectOverlap

object2objectOverlap

size

DIFFERENTFROMstr

DIFFERENTFROMbs

EQUALSstr

EQUALSbs

EXISTSstr

EXISTSbs

EXISTSINVstr

VariableSign

EXISTSINVbs

SUBJECT2SUBJECT

SUBJECT2OBJECT

OBJECT2OBJECT

triplePattern

amieTriplePattern

Constructor Detail

KB

Method Detail

add

add

add

add

size

size

relationsSize

entitiesSize

isVariable

rebuildOverlapTables

buildOverlapTables

load

load

load

loadSequential

functionality

functionality

inverseFunctionality

inverseFunctionality

colFunctionality

isFunctional

functionality

inverseFunctionality

overlap

relationSize

relationColumnSize

differentFrom

differentFrom

equalTo

equalTo

get

get

resultsOneVariable

resultsOneVariable

contains

contains

resultsTwoVariables

resultsTwoVariables

resultsTwoVariables

resultsTwoVariables

resultsThreeVariables

countOneVariable

countTwoVariables