def test_parameter_failures(self): from datetime import datetime, date, time values = { "datetime": ["2011-01-01"], "time": ["12:32 "], "date": ["2011-01-01-", datetime(2011, 1, 1, 12, 32, 11), "2011-01-01H12:32:11"], "integer": ["112", date(2011, 1, 1)], "float": [11, "11", None], "boolean": ["Untrue", None], "string": [999, None]} for type, vals in values.iteritems(): for val in vals: param_class = parameter_for_type(type) self.assertRaises(TypeError, param_class, "test", val) values = { "datetime": ["2011-01-01"], "time": ["12:32 "], "date": ["2011-01-01-", datetime(2011, 1, 1, 12, 32, 11), "2011-01-01H12:32:11"], "integer": ["112", date(2011, 1, 1)], "float": [11, "11", None], "boolean": ["Untrue", None], "string": [] } for type, vals in values.iteritems(): for val in vals: param_class = parameter_for_type(type) self.assertRaises(StringConversionError, param_class.from_string, "test")
def _saveParam(k, v): try: parameter_type = cls.declared_params[k] except KeyError: raise KeyError("%s has no parameter with key '%s'." % (cls.__original_class_name__, k)) # get the correct parameter class parameter_class = parameter_for_type(parameter_type) return parameter_class(name=k, value=v)
def __setitem__(self, key, val): # TODO: Make more consistent parameter_name = self.owning.declared_params[key] parameter_class = parameter_for_type(parameter_name) # TODO: Maybe put the None check inside the from_string methods if val is None: raise ValueError("Attempted to set None on a parameter.") typed_val = parameter_class.from_string(val) self.owning.params[key] = typed_val
def test_parameters(self): from datetime import datetime, date, time values = { "datetime": [datetime(2011, 1, 1, 12, 32, 11)], "time": [time(12, 32, 11)], "date": [date(2011, 1, 1)], "integer": [112, 20010213322], "float": [11.2, 200.10213322], "boolean": [True, False], "string": [u"Kleiner Text", u"äöü", u"Юникод"]} for type, vals in values.iteritems(): for val in vals: param_class = parameter_for_type(type) param_val = param_class("test", val) self.assertEqual(val, param_class.from_string(param_val.value_string)) # testing str and repr as well str(param_val) repr(param_val)
def makeParam(key, value): """ Takes a value list as input and concatenates with OR. This means that {age: [1, 12, 13]} will yield a result if age == 1 OR age == 12 OR age == 13. """ if not (isinstance(value, list) or isinstance(value, tuple)): value = [value] or_clause = [] # Ask for the type of the parameter according to the entity parameter_class = parameter_for_type(entity.declared_params[key]) for val in value: if callable(val): # we’ve been given a function or_clause.append(val(parameter_class.value)) elif parameter_class == StringParameter: # test string using ‘like’ if not options["strict"]: val = "%" + val + "%" or_clause.append(parameter_class.value.like(val)) else: if options["convert_string"]: try: val = parameter_class.from_string(val) except StringConversionError: if parameter_class == DateParameter: # Here, we want to match a certain YEAR, a certain # combination of YEAR-MONTH or a certain combination # YEAR-MONTH-DAY from a date. # Therefore, we need to extract YEAR, MONTH and DAY # from a date and match those separately. # Unfortunately, there is no common SQL function for # this task, so we're left with ``date_part('year', date)`` # for Postgres and ``strftime('%Y', date)`` for Sqlite. # We check the `engine_name` and generate the respective # methods. # get year month day ymd = val.split('-') clauses = [] from sqlalchemy.sql.expression import func if self.connection.engine_name == "postgresql": year_part = lambda value: func.date_part('year', value) month_part = lambda value: func.date_part('month', value) day_part = lambda value: func.date_part('day', value) elif self.connection.engine_name == "sqlite": year_part = lambda value: func.strftime('%Y', value) month_part = lambda value: func.strftime('%m', value) day_part = lambda value: func.strftime('%d', value) else: raise ValueError("Unsupported operation: Unknown engine name %r." % self.connection.engine_name) if len(ymd) > 0: clauses.append(year_part(parameter_class.value) == ymd[0]) if len(ymd) > 1: clauses.append(month_part(parameter_class.value) == ymd[1]) if len(ymd) > 2: clauses.append(day_part(parameter_class.value) == ymd[2]) clause = (and_(*clauses)) or_clause.append(clause) else: raise else: or_clause.append(parameter_class.value == val) # FIXME return entity._params.of_type(parameter_class).any(or_(*or_clause))