def next(self):
writer = None
evid = EVID.fromEvent(self.event)
try:
# store the event
writer = yield self.index.newWriter()
if not IWriter.providedBy(writer):
raise TypeError("index writer does not implement IWriter")
fields = dict([(fn, v) for fn, ft, v in self.event])
logger.trace("[writer %s] creating event %s" % (self, evid))
yield writer.newEvent(evid, fields)
# process the value of each field in the event
for fieldname, fieldtype, value in self.event:
logger.trace("[writer %s] using field %s:%s" %
(self, fieldname, fieldtype))
field = yield writer.getField(fieldname, fieldtype)
# store a posting for each term in each field
for term, meta in field.parseValue(value):
logger.trace("[writer %s] creating posting %s:%s:%s" %
(self, field, term, evid))
yield writer.newPosting(field, term, evid, meta)
logger.debug("[writer %s] committed event %s" % (self, str(evid)))
finally:
if writer != None:
yield writer.close()
def writeEventToIndex(event, index):
"""
:param event:
:type event:
:param index:
:type index:
:returns: The EVID of the new event.
:rtype: :class:`terane.bier.evid.EVID`
"""
# verify that the index provides the appropriate interface
if not IIndex.providedBy(index):
raise TypeError("index does not implement IIndex")
# get the current schema
schema = index.getSchema()
if not ISchema.providedBy(schema):
raise TypeError("index schema does not implement ISchema")
# create a new transactional writer
writer = index.newWriter()
if not IWriter.providedBy(writer):
raise TypeError("index writer does not implement IWriter")
writer.begin()
# update the index in the context of a writer
try:
# create a new event identifier
evid = EVID.fromEvent(event)
# process the value of each field in the event
fields = {}
for fieldname, fieldtype, value in event:
if not schema.hasField(fieldname, fieldtype):
schema.addField(fieldname, fieldtype)
field = schema.getField(fieldname, fieldtype)
# update the field with the event value
for term, meta in field.parseValue(value):
writer.newPosting(field, term, evid, meta)
fields[fieldname] = value
# store the document data
writer.newEvent(evid, fields)
# if an exception was raised, then abort the transaction
except:
writer.abort()
raise
# otherwise commit the transaction and return the event id
writer.commit()
return evid
def next(self):
writer = None
evid = EVID.fromEvent(self.event)
try:
# store the event
writer = yield self.index.newWriter()
if not IWriter.providedBy(writer):
raise TypeError("index writer does not implement IWriter")
fields = dict([(fn,v) for fn,ft,v in self.event])
logger.trace("[writer %s] creating event %s" % (self,evid))
yield writer.newEvent(evid, fields)
# process the value of each field in the event
for fieldname, fieldtype, value in self.event:
logger.trace("[writer %s] using field %s:%s" % (self,fieldname,fieldtype))
field = yield writer.getField(fieldname, fieldtype)
# store a posting for each term in each field
for term,meta in field.parseValue(value):
logger.trace("[writer %s] creating posting %s:%s:%s" % (self,field,term,evid))
yield writer.newPosting(field, term, evid, meta)
logger.debug("[writer %s] committed event %s" % (self,str(evid)))
finally:
if writer != None:
yield writer.close()
