Ejemplo n.º 1
0
 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]
Ejemplo n.º 2
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, {}
Ejemplo n.º 3
0
    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)
Ejemplo n.º 4
0
    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, {}
Ejemplo n.º 5
0
    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, {}
Ejemplo n.º 6
0
    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)
Ejemplo n.º 7
0
    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)
Ejemplo n.º 8
0
    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)
Ejemplo n.º 9
0
    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
Ejemplo n.º 10
0
    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)
Ejemplo n.º 11
0
    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)
Ejemplo n.º 12
0
    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, {}
Ejemplo n.º 13
0
    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
Ejemplo n.º 14
0
    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)
Ejemplo n.º 15
0
    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)
Ejemplo n.º 16
0
    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)
Ejemplo n.º 17
0
    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)
Ejemplo n.º 18
0
    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)
Ejemplo n.º 19
0
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)
Ejemplo n.º 20
0
    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, {}
Ejemplo n.º 21
0
 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 ])
Ejemplo n.º 22
0
 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
Ejemplo n.º 23
0
 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)
Ejemplo n.º 24
0
 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)
Ejemplo n.º 25
0
 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]
Ejemplo n.º 26
0
 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]
Ejemplo n.º 27
0
 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)
Ejemplo n.º 28
0
 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 )
Ejemplo n.º 29
0
 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] )
Ejemplo n.º 30
0
 def frob(self, valu, oldval=None):
     if self.frobintfmt and s_compat.isint(valu):
             valu = self.frobintfmt % valu
     return self.norm(valu, oldval=oldval)
Ejemplo n.º 31
0
 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