def from_key(key, subject, predicate, object, contexts_value):
"Takes a key and subject, predicate, object; returns tuple for yield"
parts = b(key).split(b("^"))
if subject is None:
# TODO: i & 1: # dis assemble and/or measure to see which is
# faster
# subject is None or i & 1
s = from_string(parts[(3-i+0)%3+1])
else:
s = subject
if predicate is None:#i & 2:
p = from_string(parts[(3-i+1)%3+1])
else:
p = predicate
if object is None:#i & 4:
o = from_string(parts[(3-i+2)%3+1])
else:
o = object
return (s, p, o), (from_string(c)
for c in contexts_value.split(b("^")) if c)
def __len__(self, context=None):
assert self.__open, "The Store must be open."
if context is not None:
if context == self:
context = None
if context is None:
prefix = b("^")
else:
prefix = bb("%s^" % self._to_string(context))
return len([key for key in self.__indices[0]
if key.startswith(prefix)])
def contexts(self, triple=None):
_from_string = self._from_string
_to_string = self._to_string
if triple:
s, p, o = triple
s = _to_string(s)
p = _to_string(p)
o = _to_string(o)
contexts = self.__indices[0].get(bb("%s^%s^%s^%s^" % ("", s, p, o)))
if contexts:
for c in contexts.split(b("^")):
if c:
yield _from_string(c)
else:
for key in self.__contexts:
yield _from_string(key)
def open(self, path, create=True):
self.db_env = NoopMethods()
self.create = create
self.path = homeDir = path
if not exists(homeDir):
if create:
mkdir(homeDir)
else:
raise ValueError("graph path %r does not exist" % homeDir)
if self.identifier is None:
self.__identifier = URIRef(pathname2url(abspath(homeDir)))
def dbOpen(name):
db = DB()
dbpathname = abspath(self.path) + '/' + name + ".kch"
if self.create:
# if not db.open(abspath(self.path) + '/' + name + ".kch",
# DB.OWRITER | DB.OCREATE | DB.OAUTOSYNC | DB.OAUTOTRAN):
if not db.open(dbpathname, DB.OWRITER | DB.OCREATE):
raise IOError("open error: %s %s" % (dbpathname, str(db.error()))) #pragma: NO COVER
return db
else:
# if not db.open(abspath(self.path) + '/' + name + ".kch",
# DB.OWRITER | DB.OAUTOSYNC | DB.OAUTOTRAN):
if not db.open(dbpathname, DB.OWRITER): #pragma: NO COVER
raise IOError("open error: %s %s" % (dbpathname, str(db.error()))) #pragma: NO COVER
return db
# create and open the DBs
self.__indices = [None,] * 3
self.__indices_info = [None,] * 3
for i in xrange(0, 3):
index_name = to_key_func(i)((b("s"), b("p"), b("o")), b("c")).decode()
index = dbOpen(index_name)
self.__indices[i] = index
self.__indices_info[i] = (index, to_key_func(i), from_key_func(i))
lookup = {}
for i in xrange(0, 8):
results = []
for start in xrange(0, 3):
score = 1
len = 0
for j in xrange(start, start+3):
if i & (1<<(j%3)):
score = score << 1
len += 1
else:
break
tie_break = 2-start
results.append(((score, tie_break), start, len))
results.sort()
score, start, len = results[-1]
def get_prefix_func(start, end):
def get_prefix(triple, context):
if context is None:
yield ""
else:
yield context
i = start
while i<end:
yield triple[i%3]
i += 1
yield ""
return get_prefix
lookup[i] = (self.__indices[start],
get_prefix_func(start, start + len),
from_key_func(start),
results_from_key_func(start, self._from_string))
self.__lookup_dict = lookup
# these 3 were btree mode in sleepycat, but currently i'm using tc hash
self.__contexts = dbOpen("contexts")
self.__namespace = dbOpen("namespace")
self.__prefix = dbOpen("prefix")
self.__k2i = dbOpen("k2i")
self.__i2k = dbOpen("i2k") # was DB_RECNO mode
self.__journal = NoopMethods() # was DB_RECNO mode
self.__needs_sync = False
# # Inherited from SleepyCat, not relevant to Kyoto Cabinet
# t = Thread(target=self.__sync_run)
# t.setDaemon(True)
# t.start()
# self.__sync_thread = t
self.__sync_thread = NoopMethods()
# self.synchronize()
self.__open = True
return VALID_STORE
def from_key(key):
"Takes a key; returns string"
parts = b(key).split(b("^"))
return parts[0], parts[(3-i+0)%3+1], \
parts[(3-i+1)%3+1], parts[(3-i+2)%3+1]
def to_key(triple, context):
"Takes a string; returns key"
return b("^").join((context, triple[i%3],
triple[(i+1)%3], triple[(i+2)%3], b(""))
) # "" to tac on the trailing ^
Store.add(self, (subject, predicate, object), context, quoted)
_to_string = self._to_string
s = _to_string(subject)
p = _to_string(predicate)
o = _to_string(object)
c = _to_string(context)
cspo, cpos, cosp = self.__indices
value = cspo.get(bb("%s^%s^%s^%s^" % (c, s, p, o)))
if value is None:
self.__contexts.set(bb(c), "")
contexts_value = cspo.get(bb("%s^%s^%s^%s^" % ("", s, p, o))) or b("")
contexts = set(contexts_value.split(b("^")))
contexts.add(bb(c))
contexts_value = b("^").join(contexts)
assert contexts_value!=None
cspo.set(bb("%s^%s^%s^%s^" % (c, s, p, o)), "")
cpos.set(bb("%s^%s^%s^%s^" % (c, p, o, s)), "")
cosp.set(bb("%s^%s^%s^%s^" % (c, o, s, p)), "")
if not quoted:
cspo.set(bb("%s^%s^%s^%s^" % ("", s, p, o)), contexts_value)
cpos.set(bb("%s^%s^%s^%s^" % ("", p, o, s)), contexts_value)
cosp.set(bb("%s^%s^%s^%s^" % ("", o, s, p)), contexts_value)
self.__needs_sync = True
# self.__contexts.synchronize()
# for dbindex in self.__indices:
