def _sizeByRange(self, prop, valu, limit=None):
# HACK: for speed
data = [0]
def inc():
data[0] += 1
[ inc() for r in self.rowsbyprop.get(prop,()) if isint(r[2]) and r[2] >= valu[0] and r[2] < valu[1] ]
return data[0]
def norm(self, valu, oldval=None):
if self.frobintfmt and s_compat.isint(valu):
valu = self.frobintfmt % valu
if not s_compat.isstr(valu):
self._raiseBadValu(valu)
if self.info.get('lower'):
valu = valu.lower()
if valu == self.nullval:
return valu, {}
if self.restrip:
valu = self.restrip.sub('', valu)
if self.strip:
valu = valu.strip()
if self.envals is not None and valu not in self.envals:
self._raiseBadValu(valu, enums=self.info.get('enums'))
if self.regex is not None and not self.regex.match(valu):
self._raiseBadValu(valu, regex=self.info.get('regex'))
return valu, {}
def _delRowsByIdProp(self, iden, prop, valu=None):
if valu is None:
return self.delete(self._q_delrows_by_iden_prop, iden=iden, prop=prop)
if s_compat.isint(valu):
return self.delete(self._q_delrows_by_iden_prop_intval, iden=iden, prop=prop, valu=valu)
else:
return self.delete(self._q_delrows_by_iden_prop_strval, iden=iden, prop=prop, valu=valu)
def norm(self, valu, oldval=None):
if s_compat.isstr(valu):
return self._norm_str(valu, oldval=oldval)
if not s_compat.isint(valu):
self._raiseBadValu(valu)
return valu & 0xffffffff, {}
def norm(self, valu, oldval=None):
if not s_compat.isint(valu):
self._raiseBadValu(valu)
if oldval != None and self.minmax:
valu = self.minmax(valu, oldval)
return valu, {}
def _setRowsByIdProp(self, ident, prop, valu):
if s_compat.isint(valu):
count = self.update( self._q_uprows_by_id_prop_int, (valu,ident,prop) )
else:
count = self.update( self._q_uprows_by_id_prop_str, (valu,ident,prop) )
if count == 0:
rows = [ (ident,prop,valu,int(time.time())), ]
self._addRows(rows)
def _setRowsByIdProp(self, iden, prop, valu):
if s_compat.isint(valu):
count = self.update(self._q_uprows_by_iden_prop_int, iden=iden, prop=prop, valu=valu)
else:
count = self.update(self._q_uprows_by_iden_prop_str, iden=iden, prop=prop, valu=valu)
if count == 0:
rows = [(iden, prop, valu, s_common.now()), ]
self._addRows(rows)
def _tufosByRange(self, prop, valu, limit=None):
if len(valu) != 2:
return []
minvalu, maxvalu = valu
if not s_compat.isint(minvalu) or not s_compat.isint(maxvalu):
raise Exception('by "range" requires (int,int)')
limit = self._getDbLimit(limit)
rows = self.select(self._q_getjoin_by_range_int,
prop=prop,
minvalu=minvalu,
maxvalu=maxvalu,
limit=limit)
rows = self._foldTypeCols(rows)
return self._rowsToTufos(rows)
def norm(self, valu, oldval=None):
if not s_compat.isint(valu):
self._raiseBadValu(valu)
if oldval != None and self.minmax:
valu = self.minmax(valu,oldval)
return valu
def getRowsByIdProp(self, iden, prop, valu=None):
if valu is None:
rows = self.select(self._q_getrows_by_iden_prop, iden=iden, prop=prop)
return self._foldTypeCols(rows)
if s_compat.isint(valu):
rows = self.select(self._q_getrows_by_iden_prop_intval, iden=iden, prop=prop, valu=valu)
else:
rows = self.select(self._q_getrows_by_iden_prop_strval, iden=iden, prop=prop, valu=valu)
return self._foldTypeCols(rows)
def _addRows(self, rows):
args = []
for i, p, v, t in rows:
if s_compat.isint(v):
args.append({'iden': i, 'prop': p, 'intval': v, 'strval': None, 'tstamp': t})
else:
args.append({'iden': i, 'prop': p, 'intval': None, 'strval': v, 'tstamp': t})
with self.getCoreXact() as xact:
xact.cursor.executemany(self._q_addrows, args)
def norm(self, valu, oldval=None):
if s_compat.isstr(valu):
return self._norm_str(valu, oldval=oldval)
if not s_compat.isint(valu):
self._raiseBadValu(valu)
if oldval is not None and self.minmax:
valu = self.minmax(valu, oldval)
return valu, {}
def rowsByRange(self, prop, valu, limit=None):
minval, maxval = valu[0], valu[1]
# HACK: for speed
ret = [
r for r in self.rowsbyprop.get(prop, ())
if isint(r[2]) and r[2] >= minval and r[2] < maxval
]
if limit is not None:
ret = ret[:limit]
return ret
def _setRowsByIdProp(self, ident, prop, valu):
if s_compat.isint(valu):
count = self.update(self._q_uprows_by_id_prop_int,
(valu, ident, prop))
else:
count = self.update(self._q_uprows_by_id_prop_str,
(valu, ident, prop))
if count == 0:
rows = [
(ident, prop, valu, int(time.time())),
]
self._addRows(rows)
def _joinsByIn(self, prop, valus, limit=None):
if len(valus) == 0:
return []
limit = self._getDbLimit(limit)
if s_compat.isint(valus[0]):
q = self._q_getjoin_by_in_int
else:
q = self._q_getjoin_by_in_str
valus = [md5(v) for v in valus]
rows = self.select(q, prop=prop, valu=tuple(valus), limit=limit)
return self._foldTypeCols(rows)
def _tufosByRange(self, prop, valus, limit=None):
if len(valus) != 2:
return [] # TODO: Raise exception?
limit = self._getDbLimit(limit)
if s_compat.isint(valus[0]):
q = self._q_getjoin_by_range_int
else:
q = self._q_getjoin_by_range_str
args = [ prop, valus[0], valus[1], limit ]
rows = self.select(q,args)
rows = self._foldTypeCols(rows)
return self._rowsToTufos(rows)
def _tufosByRange(self, prop, valus, limit=None):
if len(valus) != 2:
return [] # TODO: Raise exception?
limit = self._getDbLimit(limit)
if s_compat.isint(valus[0]):
q = self._q_getjoin_by_range_int
else:
q = self._q_getjoin_by_range_str
args = [prop, valus[0], valus[1], limit]
rows = self.select(q, args)
rows = self._foldTypeCols(rows)
return self._rowsToTufos(rows)
def _elem_iter(self):
# special case for dictionaries
# to iterate children and keep track
# of their names...
if type(self._d_item) == dict:
for name, item in self._d_item.items():
yield initelem((name, item), name=self.name(), parent=self)
return
if s_compat.isint(self._d_item):
return
if s_compat.isstr(self._d_item):
return
for i, item in enumerate(self._d_item):
yield initelem(item, name=str(i), parent=self)
def _encValKey(v):
'''
Encode a value as used in a key.
Non-negative numbers are msgpack encoded. Negative numbers are encoded as a marker, then the
encoded negative of that value, so that the ordering of the encodings is easily mapped to the
ordering of the negative numbers. Strings too long are hashed. Note that this scheme prevents
interleaving of value types: all string encodings compare larger than all negative number
encodings compare larger than all nonnegative encodings.
'''
if s_compat.isint(v):
if v >= 0:
return s_common.msgenpack(v)
else:
return NEGATIVE_VAL_MARKER_ENC + s_common.msgenpack(-v)
else:
if len(v) >= LARGE_STRING_SIZE:
return (HASH_VAL_MARKER_ENC + s_common.msgenpack(xxhash.xxh64(v).intdigest()))
else:
return STRING_VAL_MARKER_ENC + s_common.msgenpack(v)
def norm(self, valu, oldval=None):
if s_compat.isstr(valu):
try:
valu = int(valu, 0)
except ValueError as e:
self._raiseBadValu(valu)
if not s_compat.isint(valu):
self._raiseBadValu(valu)
if oldval is not None and self.minmax:
valu = self.minmax(valu, oldval)
if self.minval is not None and valu < self.minval:
self._raiseBadValu(valu, minval=self.minval)
if self.maxval is not None and valu > self.maxval:
self._raiseBadValu(valu, maxval=self.maxval)
return valu, {}
def _sizeByLe(self, prop, valu, limit=None):
return len([ r for r in self.rowsbyprop.get(prop,()) if isint(r[2]) and r[2] <= valu ])
def _rowsByRange(self, prop, valu, limit=None):
# HACK: for speed
ret = [ r for r in self.rowsbyprop.get(prop,()) if isint(r[2]) and r[2] >= valu[0] and r[2] < valu[1] ]
if limit != None:
ret = ret[:limit]
return ret
def sizeByGe(self, prop, valu, limit=None):
return sum(1 for r in self.rowsbyprop.get(prop, ())
if isint(r[2]) and r[2] >= valu)
def sizeByRange(self, prop, valu, limit=None):
minval, maxval = valu[0], valu[1]
return sum(1 for r in self.rowsbyprop.get(prop, ())
if isint(r[2]) and r[2] >= minval and r[2] < maxval)
def rowsByLe(self, prop, valu, limit=None):
return [
r for r in self.rowsbyprop.get(prop, ())
if isint(r[2]) and r[2] <= valu
][:limit]
def _rowsByLe(self, prop, valu, limit=None):
return [ r for r in self.rowsbyprop.get(prop,()) if isint(r[2]) and r[2] <= valu ][:limit]
def _addRows(self, rows):
rows = [(i, p, None, v, t) if s_compat.isint(v) else (i, p, v, None, t)
for i, p, v, t in rows]
with self.cursor() as c:
c.executemany(self._q_addrows, rows)
def _addRows(self, rows):
rows = [ (i,p,None,v,t) if s_compat.isint(v) else (i,p,v,None,t) for i,p,v,t in rows ]
with self.cursor() as c:
c.executemany( self._q_addrows, rows )
def _sizeByRange(self, prop, valu, limit=None):
return sum( 1 for r in self.rowsbyprop.get(prop,()) if isint(r[2]) and r[2] >= valu[0] and r[2] < valu[1] )
def frob(self, valu, oldval=None):
if self.frobintfmt and s_compat.isint(valu):
valu = self.frobintfmt % valu
return self.norm(valu, oldval=oldval)
def _rowsByRange(self, prop, valu, limit=None):
# HACK: for speed
ret = [ r for r in self.rowsbyprop.get(prop,()) if isint(r[2]) and r[2] >= valu[0] and r[2] < valu[1] ]
if limit != None:
ret = ret[:limit]
return ret
