示例#1
0
    def _queryJoinPivotTags(self, query, oper, take=None):
        args = oper[1].get('args', ())
        opts = dict(oper[1].get('kwlist'))
        core = self.getStormCore()

        limt = self.getLiftLimitHelp(opts.get('limit'))
        if isinstance(limt.limit, int) and limt.limit < 0:
                raise s_common.BadOperArg(oper=oper[0], name='limit', mesg='limit must be >= 0')

        if take:
            nodes = query.take()
        else:
            nodes = query.data()

        if limt.limit == 0:
            return

        forms = sorted(set(args))
        tags = sorted({tag for node in nodes for tag in s_tufo.tags(node, leaf=True)})

        if not forms:
            forms = [None]

        for form in forms:
            for tag in tags:

                qlimt = query.size() + limt.get() if limt.get() else None
                nodes = core.getTufosByTag(tag, form=form, limit=qlimt)
                for n in nodes:
                    if query.add(n):
                        if limt.dec():
                            return
示例#2
0
    def _stormOperToTags(self, query, oper):
        opts = dict(oper[1].get('kwlist'))
        nodes = query.take()
        core = self.getStormCore()

        leaf = opts.get('leaf', True)
        limt = self.getLiftLimitHelp(opts.get('limit'))
        limtv = limt.get()

        if limtv and limtv < 0:
            raise s_common.BadOperArg(oper='totags', name='limit', mesg='limit must be >= 0')

        tags = list({tag for node in nodes for tag in s_tufo.tags(node, leaf=leaf)})

        [query.add(tufo) for tufo in core.getTufosBy('in', 'syn:tag', tags, limit=limtv)]
示例#3
0
    def _stormOperPivot(self, query, oper):
        args = oper[1].get('args')
        opts = dict(oper[1].get('kwlist'))

        if len(args) is 1:
            srcp, dstp = None, args[0]

        elif len(args) is 2:
            srcp, dstp = args[0], args[1]

        else:
            raise s_common.BadSyntaxError(mesg='pivot(<srcprop>,<dstprop>)')

        limit = opts.get('limit')
        if limit is not None and limit < 0:
            raise s_common.BadOperArg(oper='pivot', name='limit', mesg='must be >= 0')

        self._runPivotOper(query, srcp, dstp, limit)
示例#4
0
 def _reqOperArg(self, oper, name):
     valu = oper[1].get(name)
     if valu is None:
         raise s_common.BadOperArg(oper=oper, name=name, mesg='not found')
     return valu
示例#5
0
    def _stormOperTree(self, query, oper):

        args = oper[1].get('args')
        opts = dict(oper[1].get('kwlist'))

        if not args:
            raise s_common.BadSyntaxError(mesg='tree([<srcprop>], <destprop>, [recurlim=<limit>])')

        limt = self.getLiftLimitHelp(opts.get('limit'))

        core = self.getStormCore()

        # Prevent infinite pivots
        try:
            recurlim, _ = core.getTypeNorm('int', opts.get('recurlim', 20))
        except s_common.BadTypeValu as e:
            raise s_common.BadOperArg(oper='tree', name='recurlim', mesg=e.errinfo.get('mesg'))

        if recurlim < 0:
            raise s_common.BadOperArg(oper='tree', name='recurlim', mesg='must be >= 0')

        srcp = None
        dstp = args[0]

        if len(args) > 1:
            srcp = args[0]
            dstp = args[1]

        # do we have a relative source property?
        relsrc = srcp is not None and srcp.startswith(':')

        tufs = query.data()

        queried_vals = set()

        while True:

            vals = set()

            if srcp is not None and not relsrc:

                for tufo in tufs:
                    valu = tufo[1].get(srcp)
                    if valu is not None:
                        vals.add(valu)

            elif not relsrc:

                for tufo in tufs:
                    form, valu = s_tufo.ndef(tufo)
                    if valu is not None:
                        vals.add(valu)

            else:
                for tufo in tufs:
                    form, _ = s_tufo.ndef(tufo)
                    valu = tufo[1].get(form + srcp)
                    if valu is not None:
                        vals.add(valu)

            qvals = list(vals - queried_vals)
            if not qvals:
                break

            nodes = core.stormTufosBy('in', dstp, qvals, limit=limt.get())

            [query.add(n) for n in nodes]

            if limt.dec(len(nodes)):
                break

            queried_vals = queried_vals.union(vals)

            if recurlim > 0:
                recurlim -= 1
                if recurlim < 1:
                    break

            tufs = query.data()