1 from types import StringTypes
4 and_, or_, inv, add, mul, sub, mod, truediv, lt, le, ne, gt, ge, eq, neg
7 # Define the inclusion operators
8 class contains(type): pass
9 class included(type): pass
12 # New modifier: { contains
24 'CONTAINS' : contains,
41 def __init__(self, *args, **kwargs):
43 \brief Build a predicate (left, operator, right)
45 - three args (left, operator, right)
46 - one argument (list or tuple) containing three elements (variable, operator, value)
47 "operator" is a String defined in operators or in operators_short and refers
48 tMao a binary operation.
49 "left" and "right" refers to a variable/constant involved in the Predicate.
53 elif len(args) == 1 and isinstance(args[0], (tuple,list)) and len(args[0]) == 3:
54 key, op, value = args[0]
55 elif len(args) == 1 and isinstance(args[0], Predicate):
56 key, op, value = args[0].get_tuple()
58 raise Exception, "Bad initializer for Predicate (args=%r)" % args
60 assert not isinstance(value, (frozenset, dict, set)), "Invalid value type (the only valid containers are tuples and lists) (type = %r)" % type(value)
61 if isinstance(value, list):
65 if isinstance(op, StringTypes):
67 if op in self.operators.keys():
68 self.op = self.operators[op]
69 elif op in self.operators_short.keys():
70 self.op = self.operators_short[op]
74 if isinstance(value, list):
75 self.value = tuple(value)
80 key, op, value = self.get_str_tuple()
81 if isinstance(value, (tuple, list, set, frozenset)):
82 value = [repr(v) for v in value]
83 value = "[%s]" % ", ".join(value)
84 return "%s %s %r" % (key, op, value)
87 return "Predicate<%s %s %r>" % self.get_str_tuple()
90 return hash(self.get_tuple())
92 def __eq__(self, predicate):
95 return self.get_tuple() == predicate.get_tuple()
100 def set_key(self, key):
109 def set_value(self, value):
113 return (self.key, self.op, self.value)
115 def get_str_op(self):
116 op_str = [s for s, op in self.operators.iteritems() if op == self.op]
119 def get_str_tuple(self):
120 return (self.key, self.get_str_op(), self.value,)
122 def match(self, dic, ignore_missing=False):
123 if isinstance(self.key, tuple):
124 print "PREDICATE MATCH", self.key
126 print "-----------------------------"
129 if self.key not in dic:
130 return ignore_missing
133 if isinstance(self.value, list):
134 return (dic[self.key] in self.value) # array ?
136 return (dic[self.key] == self.value)
138 if isinstance(self.value, list):
139 return (dic[self.key] not in self.value) # array ?
141 return (dic[self.key] != self.value) # array ?
143 if isinstance(self.value, StringTypes):
145 return dic[self.key].startswith('%s.' % self.value)
147 return (dic[self.key] < self.value)
149 if isinstance(self.value, StringTypes):
150 return dic[self.key] == self.value or dic[self.key].startswith('%s.' % self.value)
152 return (dic[self.key] <= self.value)
154 if isinstance(self.value, StringTypes):
156 return self.value.startswith('%s.' % dic[self.key])
158 return (dic[self.key] > self.value)
160 if isinstance(self.value, StringTypes):
162 return dic[self.key] == self.value or self.value.startswith('%s.' % dic[self.key])
164 return (dic[self.key] >= self.value)
165 elif self.op == and_:
166 return (dic[self.key] & self.value) # array ?
168 return (dic[self.key] | self.value) # array ?
169 elif self.op == contains:
170 method, subfield = self.key.split('.', 1)
171 return not not [ x for x in dic[method] if x[subfield] == self.value]
172 elif self.op == included:
173 return dic[self.key] in self.value
175 raise Exception, "Unexpected table format: %r" % dic
177 def filter(self, dic):
179 Filter dic according to the current predicate.
184 method, subfield = self.key.split('.', 1)
185 if not method in dic:
188 if isinstance(dic[method], dict):
189 # We have a 1..1 relationship: apply the same filter to the dict
190 subpred = Predicate(subfield, self.op, self.value)
191 match = subpred.match(dic[method])
192 return dic if match else None
194 elif isinstance(dic[method], (list, tuple)):
197 if self.op == contains:
198 return dic if self.match(dic) else None
200 subpred = Predicate(subfield, self.op, self.value)
201 dic[method] = subpred.filter(dic[method])
204 raise Exception, "Unexpected table format: %r", dic
208 # Individual field operations: this could be simplified, since we are now using operators_short !!
210 print "current predicate", self
211 print "matching", dic
213 return dic if self.match(dic) else None
215 def get_field_names(self):
216 if isinstance(self.key, (list, tuple, set, frozenset)):
219 return set([self.key])
221 def get_value_names(self):
222 if isinstance(self.value, (list, tuple, set, frozenset)):
223 return set(self.value)
225 return set([self.value])