示例#1
0
    def getSafeQueryPlan(self, init=True):
        # we are interested in whether the separator represents
        # a generic inequality constraint - if so, it doesn't matter which
        # component it occurs in, as it must have the same
        # constraint everywhere

        representativeSeparator = self.separator[0]
        if representativeSeparator.isInequality() and representativeSeparator.getInequalityConstraint().isGeneric():
            self.replacementVal = "generic_%s" % representativeSeparator.getInequalityConstraint().getConstant()
        else:
            self.replacementVal = algorithm.attCounter()

        # for webkb
        if representativeSeparator.domainSize:
            self.effectiveDomainSize = representativeSeparator.domainSize

        d = self.disjunctiveQuery

        self.usedSeparatorVars = d.getUsedSeparators()

        d.applySeparator(self.separator, self.replacementVal)
        if isinstance(d, query_exp.DisjunctiveQuery):
            cons = []
            for c in d.getComponents():
                cons.append(query_exp.ConjunctiveQuery(query_exp.decomposeComponent(c)))
            self.childDNF = query_exp.DNF(cons)
        else:
            self.childDNF = d

        if init:
            self.child = algorithm.getSafeOpenQueryPlanNaive(self.childDNF)
            symbolString = str(algorithm.dom) + "_" + str(representativeSeparator)
            self.lam = symbols(symbolString)* self.child.lam
        else:
            self.child = None
示例#2
0
    def getSafeQueryPlan(self, init=True):
        # we are interested in whether the separator represents
        # a generic inequality constraint - if so, it doesn't matter which
        # component it occurs in, as it must have the same
        # constraint everywhere

        representativeSeparator = self.separator[0]
        if representativeSeparator.isInequality(
        ) and representativeSeparator.getInequalityConstraint().isGeneric():
            self.replacementVal = "generic_%s" % representativeSeparator.getInequalityConstraint(
            ).getConstant()
        else:
            self.replacementVal = algorithm.attCounter()

        # for webkb
        if representativeSeparator.domainSize:
            self.effectiveDomainSize = representativeSeparator.domainSize

        d = self.disjunctiveQuery

        self.usedSeparatorVars = d.getUsedSeparators()

        d.applySeparator(self.separator, self.replacementVal)
        if isinstance(d, query_exp.DisjunctiveQuery):
            cons = []
            for c in d.getComponents():
                cons.append(
                    query_exp.ConjunctiveQuery(
                        query_exp.decomposeComponent(c)))
            self.childDNF = query_exp.DNF(cons)
        else:
            self.childDNF = d

        if init:
            self.child = algorithm.getSafeQueryPlan(self.childDNF)
        else:
            self.child = None
示例#3
0
def getSafeQueryPlan(dnf):
    if isinstance(dnf, query_exp.DNF):
        cnf = dnf.toCNF().minimize()
    else:
        cnf = dnf.minimize()

    symbolComponentsDNF = query_exp.computeSymbolComponentsDNF(dnf)

    if len(symbolComponentsDNF) > 1:
        termList = [query_exp.DNF((list(s))) for s in symbolComponentsDNF]
        return ind_union.IndependentUnion(cnf, termList)

    symbolComponents = query_exp.computeSymbolComponentsCNF(cnf)

    # independent join
    if len(symbolComponents) > 1:
        termList = [query_exp.CNF(list(s)) for s in symbolComponents]
        return ind_join.IndependentJoin(cnf, termList)

    # inclusion/exclusion
    if len(cnf.getDisjuncts()) > 1:
        termList = []
        coeffList = []

        for x in powerset(cnf.getDisjuncts()):
            if len(x):
                termList.append(
                    query_exp.CNF(
                        [query_exp.DisjunctiveQuery(
                            [c.copy() for d in x for c in d.getComponents()]
                        )
                        ]
                    )
                )
                coeffList.append((-1) ** len(x))

        lexpr = nltk.Expression.fromstring
        for i in range(len(termList)):
            if coeffList[i] == 0:
                continue
            for j in range(i + 1, len(termList)):
                if coeffList[j] == 0:
                    continue
                p9termI = lexpr(termList[i].toProver9())
                p9termJ = lexpr(termList[j].toProver9())
                proverItoJ = nltk.Prover9Command(
                    p9termJ, assumptions=[p9termI])
                proverJtoI = nltk.Prover9Command(
                    p9termI, assumptions=[p9termJ])
                if proverItoJ.prove() and proverJtoI.prove():
                    coeffList[i] += coeffList[j]
                    coeffList[j] = 0

        subplans = []
        finalCoeffList = []
        for ind, term in enumerate(termList):
            if coeffList[ind] == 0:
                continue
            subplans.append(term)
            finalCoeffList.append(coeffList[ind])

        return incl_excl.InclusionExclusion(cnf, subplans, finalCoeffList)

    d = cnf.getDisjuncts()[0]
    symbolComponents = query_exp.computeSymbolComponentsDisjunct(d)

    # independent union
    if len(symbolComponents) > 1:
        termList = [
            query_exp.CNF(
                [query_exp.DisjunctiveQuery(list(s))]
            ) for s in symbolComponents]

        return ind_union.IndependentUnion(cnf, termList)

    # ground tuple
    if not d.hasVariables():
        comInd = 0  # only one component in a ground tuple
        rel = d.getComponents()[comInd].getRelations()[comInd]
        return ground_tup.GroundTuple(cnf, d, rel)

    # separator variable
    separator = d.getSeparator()
    if separator:
        return ind_proj.IndependentProject(cnf, d, separator)

    lexpr = nltk.Expression.fromstring
    p9d = lexpr(d.toProver9())

    for x in powerset(d.getRelations()):
        if len(x) > 1:
            proposedComponent = query_exp.Component(x)

            # TODO(ericgribkoff) Fix query R(x,y),R(y,z),~R(z,x)
            # right now prover9 is timing out on:
            # p9 assertion: (R(x,y), ~R(z,x)) p9 kb: exists y x z.(R(x,y) &
            # R(y,z) & -R(z,x))

            # TODO(ericgribkoff) Temporary fix for the above problem
            if any([r.isNegated() for r in x]):
                continue

            p9component = lexpr(proposedComponent.toProver9())
            prover = nltk.Prover9Command(p9d, assumptions=[p9component])
            componentFalse = nltk.Prover9Command(
                lexpr(r'False'), assumptions=[p9component])
            if (prover.prove() and not componentFalse.prove() and not any(
                [proposedComponent.containedIn(c) for c in d.getComponents()]
            )):
                newConjQueries = []
                newConjQueries.append(query_exp.ConjunctiveQuery(
                    query_exp.decomposeComponent(proposedComponent)))
                for c in d.getComponents():
                    newConjQueries.append(query_exp.ConjunctiveQuery([c]))
                newDNF = query_exp.DNF(newConjQueries)
                return getSafeQueryPlan(newDNF)
    raise UnsafeException("FAIL")