def __str__(self): s = [ op_to_opstr(self.op), "(", str(self.left), ")", ] return "".join(s)
def from_uncoalesced_constraints(table_name, unc_bcs, unc_gcs, objective): """ This method creates a new PackageQuery from sets of uncoalesced constraints and an objective. """ bc_query = "SELECT * FROM {} {}".format( table_name, "WHERE true" if len(unc_bcs) > 0 else "") for attr, op, n in unc_bcs: bc_query += " AND {a} {o} {b}".format(a=attr, o=op_to_opstr(op), b=n) gc_queries = [] gc_ranges = [] for (aggr, attr), op, n in unc_gcs: gc_query = "SELECT {aggr}({attr}) FROM memory_representations".format( aggr=aggr, attr=attr) if op == operator.le: # gc_range = (-sys.maxint, n) gc_range = (-float("inf"), n) elif op == operator.ge: # gc_range = (n, sys.maxint) gc_range = (n, float("inf")) elif op == operator.eq: gc_range = (n, n) else: raise Exception("Operator '{}' not supported yet.".format(op)) gc_queries.append(gc_query) gc_ranges.append(gc_range) return PackageQuery({ "bc": bc_query, "gc": map(lambda x: (x[0], x[1][0], x[1][1]), zip(gc_queries, gc_ranges)), "objective": objective, })
def __str__(self): if self.ugc is not None: return "Linear Constraint {}: {} {} {}".format( self.cid, self.ugc, op_to_opstr(self.ugc.op), self.ugc.rhs) else: return "Linear Constraint {}".format(self.cid)
def get_paql_str(self, redo=False, recompute_gcs=True, coalesced=False): if redo or self._paql_query_str is None or self._paql_query_str_stale: if recompute_gcs: self.coalesced_gcs = get_coalesced_global_constraints( self.gc_queries, self.gc_ranges) self.uncoalesced_gcs = get_uncoalesced_global_constraints( self.coalesced_gcs) self.coalesced_bcs = get_coalesced_base_constraints( self.bc_query) self.uncoalesced_bcs = get_uncoalesced_base_constraints( self.coalesced_bcs) if self.rel_namespace is None: # raise Exception("rel_namespace is None") # return "" self.rel_namespace = {"R": self.table_name} bcs_str = [] gcs_str = [] obj_str = None if not coalesced: if len(self.uncoalesced_bcs) > 0: for attr, op, n in self.uncoalesced_bcs: bcs_str.append("{} {} {}".format( attr, op_to_opstr(op), n)) if len(self.uncoalesced_gcs) > 0: for (aggr, attr), op, n in self.uncoalesced_gcs: gcs_str.append("{}({}) {} {}".format( aggr, attr, op_to_opstr(op), n)) else: if len(self.coalesced_bcs) > 0: for attr, (lb, ub) in self.coalesced_bcs.iteritems(): if float(lb) == -float("inf") and float(ub) == float( "inf"): continue elif float(ub) == float("inf"): bcs_str.append("{} {} {}".format( attr, op_to_opstr(operator.ge), lb)) elif float(lb) == -float("inf"): bcs_str.append("{} {} {}".format( attr, op_to_opstr(operator.le), ub)) elif lb == ub: bcs_str.append("{} {} {}".format( attr, op_to_opstr(operator.eq), ub)) else: bcs_str.append("{} BETWEEN {} AND {}".format( attr, lb, ub)) if len(self.coalesced_gcs) > 0: for (aggr, attr), (lb, ub) in self.coalesced_gcs.iteritems(): if aggr.lower() == "count": lb, ub = int(lb), int(ub) uaggr = aggr.upper() if float(lb) == -float("inf") and float(ub) == float( "inf"): continue elif float(ub) == float("inf"): gcs_str.append("{}({}) {} {}".format( uaggr, attr, op_to_opstr(operator.ge), lb)) elif float(lb) == -float("inf"): gcs_str.append("{}({}) {} {}".format( uaggr, attr, op_to_opstr(operator.le), ub)) elif lb == ub: gcs_str.append("{}({}) {} {}".format( uaggr, attr, op_to_opstr(operator.eq), ub)) else: gcs_str.append("{}({}) BETWEEN {} AND {}".format( uaggr, attr, lb, ub)) if self.objective is not None: if self.objective["type"] == "maximize": obj_str = "MAXIMIZE " elif self.objective["type"] == "minimize": obj_str = "MINIMIZE " else: raise obj_str += self.objective["func"].get_str() self._paql_query_str = \ "SELECT \n\tPACKAGE({pack}) \n" \ "FROM \n\t{tables} {bcs}{gcs}{obj};".format( pack=", ".join(self.rel_namespace.keys()), tables=", ".join("{} {}".format(name, alias) for alias, name in self.rel_namespace.iteritems()), bcs="\nWHERE \n\t{} ".format(" AND\n\t".join(bcs_str)) if bcs_str else "", gcs="\nSUCH THAT \n\t{} ".format(" AND\n\t".join(gcs_str)) if gcs_str else "", obj="\n{}".format(obj_str) if obj_str is not None else "") self._paql_query_str_stale = False return self._paql_query_str
def __str__(self): return " ".join([str(self.expr), op_to_opstr(self.op), str(self.rhs)])