#
# Thierry Parmentelat - INRIA
#
-from types import StringTypes
-try:
- set
-except NameError:
- from sets import Set
- set = Set
-
import time
from PLC.Faults import *
from PLC.Parameter import Parameter, Mixed, python_type
+from PLC.Logger import logger
class Filter(Parameter, dict):
"""
A type of parameter that represents a filter on one or more
columns of a database table.
Special features provide support for negation, upper and lower bounds,
- as well as sorting and clipping.
+ sorting and clipping and more...
fields should be a dictionary of field names and types.
example : filter = { 'hostname' : '*.edu' , site_id : [34,54] }
- Whether the filter represents an intersection (AND) or a union (OR)
- of these criteria is determined as follows:
- * if the dictionnary has the '-AND' or the '-OR' key, this is chosen
- * otherwise, the join_with argument, as provided to the sql method below,
- is expected to hold the 'AND' or 'OR' string
- this argument defaults to 'AND' and in most of the code, this default applies
- as the join_with argument is left unspecified
-
-
Special features:
- * a field starting with '&' or '|' should refer to a sequence type
- the semantic is then that the object value (expected to be a list)
- should contain all (&) or any (|) value specified in the corresponding
- filter value. See other examples below.
- example : filter = { '|role_ids' : [ 20, 40 ] }
- example : filter = { '|roles' : ['tech', 'pi'] }
- example : filter = { '&roles' : ['admin', 'tech'] }
- example : filter = { '&roles' : 'tech' }
-
* a field starting with the ~ character means negation.
example : filter = { '~peer_id' : None }
SQL wildcard character.
example : filter = { 'hostname' : '*.jp' }
+ * a field starting with '&' or '|' should refer to a sequence type
+ the semantics is then that the object value (expected to be a list)
+ should contain all (&) or any (|) value specified in the corresponding
+ filter value. See other examples below.
+ example : filter = { '|role_ids' : [ 20, 40 ] }
+ example : filter = { '|roles' : ['tech', 'pi'] }
+ example : filter = { '&roles' : ['admin', 'tech'] }
+ example : filter = { '&roles' : 'tech' }
+
* the filter's keys starting with '-' are special and relate to sorting and clipping
- * '-SORT' : a field name, or an ordered list of field names that are used for sorting
- these fields may start with + (default) or - for denoting increasing or decreasing order
+ * '-SORT' : a field name, or an ordered list of field names that are used for sorting
+ these fields may start with + (default) or - for denoting increasing or decreasing order
example : filter = { '-SORT' : [ '+node_id', '-hostname' ] }
- * '-OFFSET' : the number of first rows to be ommitted
- * '-LIMIT' : the amount of rows to be returned
+ * '-OFFSET' : the number of first rows to be ommitted
+ * '-LIMIT' : the amount of rows to be returned
example : filter = { '-OFFSET' : 100, '-LIMIT':25}
+ * similarly the two special keys below allow to change the semantics of multi-keys filters
+ * '-AND' : select rows that match ALL the criteria (default)
+ * '-OR' : select rows that match ANY criteria
+ The value attached to these keys is ignored.
+ Please note however that because a Filter is a dict, you cannot provide two criteria on a given key.
+
Here are a few realistic examples
# either a value or a list of values for each of the specified
# fields.
self.fields = dict ( [ ( field, Mixed (expected, [expected]))
- for (field,expected) in fields.iteritems() ] )
+ for (field,expected) in fields.items() ] )
# Null filter means no filter
Parameter.__init__(self, self.fields, doc = doc, nullok = True)
Returns a SQL conditional that represents this filter.
"""
- if self.has_key('-AND'):
+ if '-AND' in self:
del self['-AND']
join_with='AND'
- if self.has_key('-OR'):
+ if '-OR' in self:
del self['-OR']
join_with='OR'
sorts = []
clips = []
- for field, value in self.iteritems():
+ for field, value in self.items():
# handle negation, numeric comparisons
# simple, 1-depth only mechanism
'&' : False, '|' : False,
}
def check_modifiers(field):
- if field[0] in modifiers.keys():
+ if field[0] in list(modifiers.keys()):
modifiers[field[0]] = True
field = field[1:]
return check_modifiers(field)
# filter on fields
if not modifiers['-']:
if field not in self.fields:
- raise PLCInvalidArgument, "Invalid filter field '%s'" % field
+ raise PLCInvalidArgument("Invalid filter field '%s'" % field)
# handling array fileds always as compound values
if modifiers['&'] or modifiers['|']:
if value is None:
operator = "IS"
value = "NULL"
- elif isinstance(value, StringTypes) and \
+ elif isinstance(value, str) and \
(value.find("*") > -1 or value.find("%") > -1):
operator = "ILIKE"
# insert *** in pattern instead of either * or %
else:
vals[base_op] = [val]
subclauses = []
- for operator in vals.keys():
+ for operator in list(vals.keys()):
if operator == '=':
if modifiers['&']:
subclauses.append("(%s @> ARRAY[%s])" % (field, ",".join(vals[operator])))
# sorting and clipping
else:
if field not in ('SORT','OFFSET','LIMIT'):
- raise PLCInvalidArgument, "Invalid filter, unknown sort and clip field %r"%field
+ raise PLCInvalidArgument("Invalid filter, unknown sort and clip field %r"%field)
# sorting
if field == 'SORT':
if not isinstance(value,(list,tuple,set)):
field = field[1:]
order = 'DESC'
if field not in self.fields:
- raise PLCInvalidArgument, "Invalid field %r in SORT filter"%field
+ raise PLCInvalidArgument("Invalid field %r in SORT filter"%field)
sorts.append("%s %s"%(field,order))
# clipping
elif field == 'OFFSET':
clip_part += " ORDER BY " + ",".join(sorts)
if clips:
clip_part += " " + " ".join(clips)
- if Filter.debug: print 'Filter.sql: where_part=',where_part,'clip_part',clip_part
- return (where_part,clip_part)
+ if Filter.debug:
+ logger.debug('Filter.sql: where_part={} - clip_part={}'
+ .format(where_part, clip_part))
+ return where_part, clip_part
git://git.onelab.eu / plcapi.git / blobdiff