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)