def get_pattern_for(self, node):
"""
Get the SQL pattern of the query, as tuple (pattern, values)
"""
if isinstance(node, config.orm.node_class):
if node.negated:
node.negated = False
pattern, values = self.get_pattern_for(node)
node.negated = True
pattern = "NOT (%s)" % pattern
return pattern, values
patterns = []
values = []
for child in node.children:
pattern, vals = self.get_pattern_for(child)
values.extend(list(vals))
patterns.append(pattern)
connector = ') %s (' % node.connector
pattern = '(' + connector.join(patterns) + ')'
return pattern, values
query, value = node
if "__" in query:
field, method = query.split("__", 1)
else:
field = query
method = "default"
field = fieldmap.get_field(field)
method = getattr(field, "get_" + method)
return method(value)
def _get_smart_query(self):
"""
Get the template for performing smart queries
"""
table = self.get_table_name()
pattern, values = self.get_pattern()
o_pattern, o_values = self.get_order()
classes = self.get_classes()
l_pattern, l_values = fieldmap.get_field("classname").get_in(classes)
l_order, _ = self.get_order(limit = 1)
cursor = config.orm.cursor()
#
# We need to do some query optimization, since postgresql will not
# handle well the cases of many matches
#
smartquery = """SELECT %s
FROM (SELECT * FROM %s WHERE %s ORDER BY %s LIMIT {SESQL_SMART_LIMIT}) subquery
WHERE %s ORDER BY %s LIMIT {SESQL_THE_LIMIT}""" % (', '.join(self.fields),
table, l_pattern, l_order,
pattern, o_pattern)
return smartquery, l_values + values + o_values
def get_pattern_for(self, node):
"""
Get the SQL pattern of the query, as tuple (pattern, values)
"""
if isinstance(node, config.orm.node_class):
if node.negated:
node.negated = False
pattern, values = self.get_pattern_for(node)
node.negated = True
pattern = "NOT (%s)" % pattern
return pattern, values
patterns = []
values = []
for child in node.children:
pattern, vals = self.get_pattern_for(child)
values.extend(list(vals))
patterns.append(pattern)
connector = ') %s (' % node.connector
pattern = '(' + connector.join(patterns) + ')'
return pattern, values
query, value = node
if "__" in query:
field, method = query.split("__", 1)
else:
field = query
method = "default"
field = fieldmap.get_field(field)
method = getattr(field, "get_" + method)
return method(value)
def lemmatize(words, index=None):
"""
Give a lemmatized version of those words
Use the configuration for the given index, or the default one if
index is None
"""
if index is None:
index = fieldmap.primary
if index is None:
raise ValueError, "Not index given and no primary one"
words = [index.marshall(word) for word in words]
index = fieldmap.get_field(index)
return lemmatize_for(words, index.dictionnary)
def lemmatize(words, index = None):
"""
Give a lemmatized version of those words
Use the configuration for the given index, or the default one if
index is None
"""
if index is None:
index = fieldmap.primary
if index is None:
raise ValueError, "Not index given and no primary one"
words = [ index.marshall(word) for word in words ]
index = fieldmap.get_field(index)
return lemmatize_for(words, index.dictionnary)
def _get_smart_query(self):
"""
Get the template for performing smart queries
"""
table = self.get_table_name()
pattern, values = self.get_pattern()
o_pattern, o_values = self.get_order()
classes = self.get_classes()
l_pattern, l_values = fieldmap.get_field("classname").get_in(classes)
l_order, _ = self.get_order(limit=1)
cursor = config.orm.cursor()
#
# We need to do some query optimization, since postgresql will not
# handle well the cases of many matches
#
smartquery = """SELECT %s
FROM (SELECT * FROM %s WHERE %s ORDER BY %s LIMIT {SESQL_SMART_LIMIT}) subquery
WHERE %s ORDER BY %s LIMIT {SESQL_THE_LIMIT}""" % (', '.join(
self.fields), table, l_pattern, l_order, pattern, o_pattern)
return smartquery, l_values + values + o_values
