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)
