def setup_method(self, method):
self.type = CompositeType('category', [
sa.Column('scale', NumericRangeType),
sa.Column('name', sa.String)
])
TestCase.setup_method(self, method)
def setup_method(self, method):
self.type = CompositeType('money_type', [
sa.Column('currency', CurrencyType),
sa.Column('amount', sa.Integer)
])
TestCase.setup_method(self, method)
i18n.get_locale = lambda: i18n.babel.Locale('en')
class TestCompositeTypeInsideArray(TestCase):
dns = 'postgres://postgres@localhost/sqlalchemy_utils_test'
def setup_method(self, method):
self.type = CompositeType('money_type', [
sa.Column('currency', CurrencyType),
sa.Column('amount', sa.Integer)
])
TestCase.setup_method(self, method)
i18n.get_locale = lambda: i18n.babel.Locale('en')
def create_models(self):
class Account(self.Base):
__tablename__ = 'account'
id = sa.Column(sa.Integer, primary_key=True)
balances = sa.Column(CompositeArray(self.type))
self.Account = Account
def test_parameter_processing(self):
account = self.Account(balances=[
self.type.type_cls(Currency('USD'), 15),
self.type.type_cls(Currency('AUD'), 20)
])
self.session.add(account)
self.session.commit()
account = self.session.query(self.Account).first()
assert account.balances[0].currency == Currency('USD')
assert account.balances[0].amount == 15
assert account.balances[1].currency == Currency('AUD')
assert account.balances[1].amount == 20
class Rating(Base):
__tablename__ = 'rating_stay_safe'
id_rating = Column(Integer, primary_key=True)
user = Column(String, ForeignKey(User.username))
id_neighborhood = Column(Integer, ForeignKey(Neighborhood.id_neighborhood))
neighborhood = relationship("Neighborhood", back_populates="rating")
rating_neighborhood = Column(Integer, nullable=False)
details = Column(
CompositeType('details', [
Column('lighting', Boolean),
Column('movement_of_people', Boolean),
Column('police_rounds', Boolean)
]))
def to_dict(self, del_null_attr=True):
# getting the details
details = {}
for field in self.details._fields:
value = self.details.__getattribute__(field)
if del_null_attr:
if value is not None:
details.update({field: value})
else:
details.update({field: value})
rating = {
'details': details,
'id_rating': self.id_rating,
'user': self.user,
'rating_neighborhood': self.rating_neighborhood,
'neighborhood': get_row_dict(self.neighborhood)
}
return rating
class Account(Base):
__tablename__ = 'account'
id = sa.Column(sa.Integer, primary_key=True)
balance = sa.Column(
CompositeType('money_type', [
sa.Column('currency', CurrencyType),
sa.Column('amount', sa.Integer)
]))
def setup_method(self, method):
self.type = CompositeType(
'category',
[
sa.Column('scale', NumericRangeType),
sa.Column('name', sa.String)
]
)
TestCase.setup_method(self, method)
def setup_method(self, method):
self.type = CompositeType(
'category',
[
sa.Column('scale', NumericRangeType),
sa.Column('name', sa.String)
]
)
TestCase.setup_method(self, method)
i18n.get_locale = lambda: babel.Locale('en')
def setup_method(self, method):
self.type = CompositeType(
'money_type',
[
sa.Column('currency', CurrencyType),
sa.Column('amount', sa.Integer)
]
)
TestCase.setup_method(self, method)
i18n.get_locale = lambda: babel.Locale('en')
def Account(self, Base):
pg_composite.registered_composites = {}
type_ = CompositeType('money_type', [
sa.Column('currency', sa.String),
sa.Column('amount', sa.Integer)
])
class Account(Base):
__tablename__ = 'account'
id = sa.Column(sa.Integer, primary_key=True)
balance = sa.Column(type_)
return Account
class TestCompositeTypeInsideArray(TestCase):
dns = 'postgres://postgres@localhost/sqlalchemy_utils_test'
def setup_method(self, method):
self.type = CompositeType(
'money_type',
[
sa.Column('currency', CurrencyType),
sa.Column('amount', sa.Integer)
]
)
TestCase.setup_method(self, method)
i18n.get_locale = lambda: babel.Locale('en')
def create_models(self):
class Account(self.Base):
__tablename__ = 'account'
id = sa.Column(sa.Integer, primary_key=True)
balances = sa.Column(
CompositeArray(self.type)
)
self.Account = Account
def test_parameter_processing(self):
account = self.Account(
balances=[
self.type.type_cls(Currency('USD'), 15),
self.type.type_cls(Currency('AUD'), 20)
]
)
self.session.add(account)
self.session.commit()
account = self.session.query(self.Account).first()
assert account.balances[0].currency == Currency('USD')
assert account.balances[0].amount == 15
assert account.balances[1].currency == Currency('AUD')
assert account.balances[1].amount == 20
def setup_method(self, method):
self.engine = create_engine(self.dns)
self.engine.echo = True
self.connection = self.engine.connect()
self.Base = declarative_base()
pg_composite.registered_composites = {}
self.type = CompositeType('money_type', [
sa.Column('currency', sa.String),
sa.Column('amount', sa.Integer)
])
self.create_models()
sa.orm.configure_mappers()
Session = sessionmaker(bind=self.connection)
self.session = Session()
self.session.execute(
"CREATE TYPE money_type AS (currency VARCHAR, amount INTEGER)")
self.session.execute("""CREATE TABLE account (
id SERIAL, balance MONEY_TYPE, PRIMARY KEY(id)
)""")
register_composites(self.connection)
class TestCompositeTypeWithRangeTypeInsideArray(TestCase):
dns = 'postgres://postgres@localhost/sqlalchemy_utils_test'
def setup_method(self, method):
self.type = CompositeType(
'category',
[
sa.Column('scale', NumericRangeType),
sa.Column('name', sa.String)
]
)
TestCase.setup_method(self, method)
i18n.get_locale = lambda: babel.Locale('en')
def create_models(self):
class Account(self.Base):
__tablename__ = 'account'
id = sa.Column(sa.Integer, primary_key=True)
categories = sa.Column(
CompositeArray(self.type)
)
self.Account = Account
def test_parameter_processing_with_named_tuple(self):
account = self.Account(
categories=[
self.type.type_cls(
intervals.DecimalInterval([15, 18]),
'bad'
),
self.type.type_cls(
intervals.DecimalInterval([18, 20]),
'good'
)
]
)
self.session.add(account)
self.session.commit()
account = self.session.query(self.Account).first()
assert (
account.categories[0].scale == intervals.DecimalInterval([15, 18])
)
assert account.categories[0].name == 'bad'
assert (
account.categories[1].scale == intervals.DecimalInterval([18, 20])
)
assert account.categories[1].name == 'good'
def test_parameter_processing_with_tuple(self):
account = self.Account(
categories=[
(intervals.DecimalInterval([15, 18]), 'bad'),
(intervals.DecimalInterval([18, 20]), 'good')
]
)
self.session.add(account)
self.session.commit()
account = self.session.query(self.Account).first()
assert (
account.categories[0].scale == intervals.DecimalInterval([15, 18])
)
assert account.categories[0].name == 'bad'
assert (
account.categories[1].scale == intervals.DecimalInterval([18, 20])
)
assert account.categories[1].name == 'good'
def type_(self):
return CompositeType('category', [
sa.Column('scale', NumericRangeType),
sa.Column('name', sa.String)
])
def type_(self):
return CompositeType('money_type', [
sa.Column('currency', CurrencyType),
sa.Column('amount', sa.Integer)
])
class TestCompositeTypeWithRangeTypeInsideArray(TestCase):
dns = 'postgres://postgres@localhost/sqlalchemy_utils_test'
def setup_method(self, method):
self.type = CompositeType('category', [
sa.Column('scale', NumericRangeType),
sa.Column('name', sa.String)
])
TestCase.setup_method(self, method)
def create_models(self):
class Account(self.Base):
__tablename__ = 'account'
id = sa.Column(sa.Integer, primary_key=True)
categories = sa.Column(CompositeArray(self.type))
self.Account = Account
def test_parameter_processing_with_named_tuple(self):
account = self.Account(categories=[
self.type.type_cls(intervals.DecimalInterval([15, 18]), 'bad'),
self.type.type_cls(intervals.DecimalInterval([18, 20]), 'good')
])
self.session.add(account)
self.session.commit()
account = self.session.query(self.Account).first()
assert (account.categories[0].scale == intervals.DecimalInterval(
[15, 18]))
assert account.categories[0].name == 'bad'
assert (account.categories[1].scale == intervals.DecimalInterval(
[18, 20]))
assert account.categories[1].name == 'good'
def test_parameter_processing_with_tuple(self):
account = self.Account(
categories=[(intervals.DecimalInterval([15, 18]),
'bad'), (intervals.DecimalInterval([18, 20]),
'good')])
self.session.add(account)
self.session.commit()
account = self.session.query(self.Account).first()
assert (account.categories[0].scale == intervals.DecimalInterval(
[15, 18]))
assert account.categories[0].name == 'bad'
assert (account.categories[1].scale == intervals.DecimalInterval(
[18, 20]))
assert account.categories[1].name == 'good'
def test_parameter_processing_with_nulls_as_composite_fields(self):
account = self.Account(
categories=[(None,
'bad'), (intervals.DecimalInterval([18, 20]), None)])
self.session.add(account)
self.session.commit()
assert account.categories[0].scale is None
assert account.categories[0].name == 'bad'
assert (account.categories[1].scale == intervals.DecimalInterval(
[18, 20]))
assert account.categories[1].name is None
def test_parameter_processing_with_nulls_as_composites(self):
account = self.Account(categories=[(None, None), None])
self.session.add(account)
self.session.commit()
assert account.categories[0].scale is None
assert account.categories[0].name is None
assert account.categories[1] is None
