def _fixture(self): Base = declarative_base() class UCComparator(hybrid.Comparator): def __eq__(self, other): if other is None: return self.expression is None else: return func.upper(self.expression) == func.upper(other) class A(Base): __tablename__ = "a" id = Column(Integer, primary_key=True) _value = Column("value", String) @hybrid.hybrid_property def value(self): "This is a docstring" return self._value - 5 @value.comparator def value(cls): return UCComparator(cls._value) @value.setter def value(self, v): self._value = v + 5 return A
def _relationship_fixture(self): Base = declarative_base() class A(Base): __tablename__ = "a" id = Column(Integer, primary_key=True) b_id = Column("bid", Integer, ForeignKey("b.id")) _value = Column("value", String) @hybrid.hybrid_property def value(self): return int(self._value) - 5 @value.expression def value(cls): return func.foo(cls._value) + cls.bar_value @value.setter def value(self, v): self._value = v + 5 @hybrid.hybrid_property def bar_value(cls): return func.bar(cls._value) class B(Base): __tablename__ = "b" id = Column(Integer, primary_key=True) as_ = relationship("A") return A, B
def _fixture(self): Base = declarative_base() class A(Base): __tablename__ = "a" id = Column(Integer, primary_key=True) _value = Column("value", String) @hybrid.hybrid_property def value(self): "This is an instance-level docstring" return int(self._value) - 5 @value.expression def value(cls): "This is a class-level docstring" return func.foo(cls._value) + cls.bar_value @value.setter def value(self, v): self._value = v + 5 @hybrid.hybrid_property def bar_value(cls): return func.bar(cls._value) return A
def test_optimized_get(self): from sqlalchemy_1_3.ext.declarative import declarative_base Base = declarative_base(metadata=self.metadata) class Employee(Base): __tablename__ = "employee" id = Column(Integer, primary_key=True, test_needs_autoincrement=True) type = Column(String(10)) __mapper_args__ = {"polymorphic_on": type} class Engineer(Employee): __tablename__ = " engineer" id = Column(ForeignKey("employee.id"), primary_key=True) engineer_name = Column(String(50)) __mapper_args__ = {"polymorphic_identity": "engineer"} Base.metadata.create_all(testing.db) s = Session(testing.db) s.add(Engineer(engineer_name="wally")) s.commit() s.close() @assert_cycles() def go(): e1 = s.query(Employee).first() e1.engineer_name go()
def test_pj_deannotates(self): from sqlalchemy_1_3.ext.declarative import declarative_base Base = declarative_base() class A(Base): __tablename__ = "a" id = Column(Integer, primary_key=True) class B(Base): __tablename__ = "b" id = Column(Integer, primary_key=True) a_id = Column(ForeignKey(A.id)) a = relationship(A) eq_( B.a.property.primaryjoin.left._annotations, { "parentmapper": A.__mapper__, "remote": True }, ) eq_( B.a.property.primaryjoin.right._annotations, { "foreign": True, "local": True, "parentmapper": B.__mapper__ }, )
def _fixture(self): Base = declarative_base() class A(Base): __tablename__ = "a" id = Column(Integer, primary_key=True) _value = Column("value", String) @hybrid.hybrid_method def value(self, x): "This is an instance-level docstring" return int(self._value) + x @value.expression def value(cls, value): "This is a class-level docstring" return func.foo(cls._value, value) + value @hybrid.hybrid_method def other_value(self, x): "This is an instance-level docstring" return int(self._value) + x @other_value.expression def other_value(cls, value): return func.foo(cls._value, value) + value return A
def _fixture(self): Base = declarative_base() class Foo(Base): __tablename__ = "foo" id = Column(Integer, primary_key=True) return Foo
def test_all_orm_descriptors_pep520_noinh(self): from sqlalchemy_1_3.ext.declarative import declarative_base Base = declarative_base() glbls = {} names, MyClass = self._ordered_name_fixture(glbls, "MyClass", Base, Base) eq_(MyClass.__mapper__.all_orm_descriptors.keys(), names)
def test_get_attribute_error(self): Base = declarative_base() class A(Base): __tablename__ = "a" id = Column("id", Integer, primary_key=True) array = Column("_array", ARRAY(Integer)) first = index_property("array", 1) a = A(array=[]) assert_raises(AttributeError, lambda: a.first)
def test_value_is_none_attributeerror(self): Base = declarative_base() class A(Base): __tablename__ = "a" id = Column("id", Integer, primary_key=True) array = Column("_array", ARRAY(Integer)) first = index_property("array", 1) a = A() assert_raises(AttributeError, getattr, a, "first") assert_raises(AttributeError, delattr, a, "first")
def define_tables(cls, metadata): from sqlalchemy_1_3.ext.declarative import declarative_base from sqlalchemy_1_3.sql.sqltypes import ARRAY MutableList = cls._type_fixture() Base = declarative_base(metadata=metadata) class Mixin(object): data = Column(MutableList.as_mutable(ARRAY(Integer))) class Foo(Mixin, Base): __tablename__ = "foo" id = Column(Integer, primary_key=True)
def _fixture(self): Base = declarative_base() class A(Base): __tablename__ = "a" id = Column(Integer, primary_key=True) _value = Column("value", String) @hybrid.hybrid_property def value(self): "This is an instance-level docstring" return self._value return A
def test_set_immutable(self): Base = declarative_base() class A(Base): __tablename__ = "a" id = Column(Integer, primary_key=True) array = Column(ARRAY(Integer)) first = index_property("array", 1, mutable=False) a = A() def set_(): a.first = 10 assert_raises(AttributeError, set_)
def test_all_orm_descriptors_pep520_onelevel_inh(self): from sqlalchemy_1_3.ext.declarative import declarative_base Base = declarative_base() glbls = {} base_names, MyClass = self._ordered_name_fixture( glbls, "MyClass", Base, Base) sub_names, SubClass = self._ordered_name_fixture( glbls, "SubClass", Base, MyClass) eq_( SubClass.__mapper__.all_orm_descriptors.keys(), sub_names + base_names, )
def test_json(self): Base = declarative_base() class J(Base): __tablename__ = "j" id = Column("id", Integer, primary_key=True) json = Column("_json", JSON, default={}) field = index_property("json", "field") j = J(json={"a": 1, "b": 2}) assert_raises(AttributeError, lambda: j.field) j.field = "test" eq_(j.field, "test") eq_(j.json, {"a": 1, "b": 2, "field": "test"}) j2 = J(field="test") eq_(j2.json, {"field": "test"}) eq_(j2.field, "test")
def test_array_longinit(self): Base = declarative_base() class A(Base): __tablename__ = "a" id = Column("id", Integer, primary_key=True) array = Column("_array", ARRAY(Integer), default=[]) first = index_property("array", 0) fifth = index_property("array", 4) a1 = A(fifth=10) a2 = A(first=5) eq_(a1.array, [None, None, None, None, 10]) eq_(a2.array, [5]) assert_raises(IndexError, setattr, a2, "fifth", 10)
def test_set_mutable_dict(self): Base = declarative_base() class J(Base): __tablename__ = "j" id = Column(Integer, primary_key=True) json = Column(JSON, default={}) field = index_property("json", "field") j = J() j.field = 10 j.json = {} assert_raises(AttributeError, lambda: j.field) assert_raises(AttributeError, delattr, j, "field") j.field = 10 eq_(j.field, 10)
def _fixture(self, assignable): Base = declarative_base() class A(Base): __tablename__ = "a" id = Column(Integer, primary_key=True) _value = Column("value", String) @hybrid.hybrid_property def value(self): return self._value - 5 if assignable: @value.setter def value(self, v): self._value = v + 5 return A
def test_concurrent_create(self): for i in range(50): Base = declarative_base() clear_mappers() self.make_a(Base) result = [False] threads = [ threading.Thread(target=self.make_b, args=(Base, )), threading.Thread(target=self.query_a, args=(Base, result)), ] for t in threads: t.start() for t in threads: t.join() if isinstance(result[0], orm_exc.UnmappedClassError): raise result[0]
def test_array(self): Base = declarative_base() class A(Base): __tablename__ = "a" id = Column("id", Integer, primary_key=True) array = Column("_array", ARRAY(Integer), default=[]) first = index_property("array", 0) tenth = index_property("array", 9) a = A(array=[1, 2, 3]) eq_(a.first, 1) assert_raises(AttributeError, lambda: a.tenth) a.first = 100 eq_(a.first, 100) eq_(a.array, [100, 2, 3]) del a.first eq_(a.first, 2) a2 = A(first=5) eq_(a2.first, 5) eq_(a2.array, [5])
def define_tables(cls, metadata): import json from sqlalchemy_1_3.ext.declarative import declarative_base class JSONEncodedDict(TypeDecorator): impl = VARCHAR(50) def process_bind_param(self, value, dialect): if value is not None: value = json.dumps(value) return value def process_result_value(self, value, dialect): if value is not None: value = json.loads(value) return value MutableDict = cls._type_fixture() Base = declarative_base(metadata=metadata) class AbstractFoo(Base): __abstract__ = True id = Column(Integer, primary_key=True, test_needs_autoincrement=True) data = Column(MutableDict.as_mutable(JSONEncodedDict)) non_mutable_data = Column(JSONEncodedDict) unrelated_data = Column(String(50)) class Foo(AbstractFoo): __tablename__ = "foo" column_prop = column_property( func.lower(AbstractFoo.unrelated_data)) assert Foo.data.property.columns[0].type is not AbstractFoo.data.type
def test_get_default_value(self): Base = declarative_base() class J(Base): __tablename__ = "j" id = Column(Integer, primary_key=True) json = Column(JSON, default={}) default = index_property("json", "field", default="default") none = index_property("json", "field", default=None) j = J() assert j.json is None assert j.default == "default" assert j.none is None j.json = {} assert j.default == "default" assert j.none is None j.default = None assert j.default is None assert j.none is None j.none = 10 assert j.default == 10 assert j.none == 10
def setup_class(cls): from sqlalchemy_1_3 import literal symbols = ("usd", "gbp", "cad", "eur", "aud") currency_lookup = dict( ((currency_from, currency_to), Decimal(str(rate))) for currency_to, values in zip( symbols, [ (1, 1.59009, 0.988611, 1.37979, 1.02962), (0.628895, 1, 0.621732, 0.867748, 0.647525), (1.01152, 1.6084, 1, 1.39569, 1.04148), (0.724743, 1.1524, 0.716489, 1, 0.746213), (0.971228, 1.54434, 0.960166, 1.34009, 1), ], ) for currency_from, rate in zip(symbols, values)) class Amount(object): def __init__(self, amount, currency): self.currency = currency self.amount = amount def __add__(self, other): return Amount( self.amount + other.as_currency(self.currency).amount, self.currency, ) def __sub__(self, other): return Amount( self.amount - other.as_currency(self.currency).amount, self.currency, ) def __lt__(self, other): return self.amount < other.as_currency(self.currency).amount def __gt__(self, other): return self.amount > other.as_currency(self.currency).amount def __eq__(self, other): return self.amount == other.as_currency(self.currency).amount def as_currency(self, other_currency): return Amount( currency_lookup[(self.currency, other_currency)] * self.amount, other_currency, ) def __clause_element__(self): # helper method for SQLAlchemy to interpret # the Amount object as a SQL element if isinstance(self.amount, (float, int, Decimal)): return literal(self.amount) else: return self.amount def __str__(self): return "%2.4f %s" % (self.amount, self.currency) def __repr__(self): return "Amount(%r, %r)" % (self.amount, self.currency) Base = declarative_base() class BankAccount(Base): __tablename__ = "bank_account" id = Column(Integer, primary_key=True) _balance = Column("balance", Numeric) @hybrid.hybrid_property def balance(self): """Return an Amount view of the current balance.""" return Amount(self._balance, "usd") @balance.setter def balance(self, value): self._balance = value.as_currency("usd").amount cls.Amount = Amount cls.BankAccount = BankAccount
def _fixture(self): Base = declarative_base() class Person(Base): __tablename__ = "person" id = Column(Integer, primary_key=True) _name = Column(String) @hybrid.hybrid_property def name(self): return self._name @name.setter def name(self, value): self._name = value.title() class OverrideSetter(Person): __tablename__ = "override_setter" id = Column(Integer, ForeignKey("person.id"), primary_key=True) other = Column(String) @Person.name.setter def name(self, value): self._name = value.upper() class OverrideGetter(Person): __tablename__ = "override_getter" id = Column(Integer, ForeignKey("person.id"), primary_key=True) other = Column(String) @Person.name.getter def name(self): return "Hello " + self._name class OverrideExpr(Person): __tablename__ = "override_expr" id = Column(Integer, ForeignKey("person.id"), primary_key=True) other = Column(String) @Person.name.overrides.expression def name(self): return func.concat("Hello", self._name) class FooComparator(hybrid.Comparator): def __clause_element__(self): return func.concat("Hello", self.expression._name) class OverrideComparator(Person): __tablename__ = "override_comp" id = Column(Integer, ForeignKey("person.id"), primary_key=True) other = Column(String) @Person.name.overrides.comparator def name(self): return FooComparator(self) return ( Person, OverrideSetter, OverrideGetter, OverrideExpr, OverrideComparator, )
from sqlalchemy_1_3.ext.declarative import declarative_base from sqlalchemy_1_3.orm import relationship from sqlalchemy_1_3.orm import Session warnings.filterwarnings("ignore", r".*Decimal objects natively") # noqa # speed up cdecimal if available try: import cdecimal import sys sys.modules["decimal"] = cdecimal except ImportError: pass Base = declarative_base() class Employee(Base): __tablename__ = "employee" id = Column(Integer, primary_key=True) name = Column(String(100), nullable=False) type = Column(String(50), nullable=False) __mapper_args__ = {"polymorphic_on": type} class Boss(Employee): __tablename__ = "boss"
def setup(self): global Base Base = decl.declarative_base(testing.db)