9
9
from sqlalchemy.ext.associationproxy import _AssociationList
10
10
from sqlalchemy.testing import assert_raises_message
11
11
from sqlalchemy.testing.util import gc_collect
12
from sqlalchemy.sql import not_
13
12
from sqlalchemy.testing import fixtures, AssertsCompiledSQL
14
13
from sqlalchemy import testing
15
14
from sqlalchemy.testing.schema import Table, Column
139
138
self.assert_(len(p1._children) == 0)
140
139
self.assert_(len(p1.children) == 0)
142
p1.children = ['a','b','c']
141
p1.children = ['a', 'b', 'c']
143
142
self.assert_(len(p1._children) == 3)
144
143
self.assert_(len(p1.children) == 3)
324
323
self.assert_(len(p1._children) == 3)
325
324
self.assert_(len(p1.children) == 3)
327
self.assert_(set(p1.children) == set(['d','e','f']))
326
self.assert_(set(p1.children) == set(['d', 'e', 'f']))
330
329
p1 = self.roundtrip(p1)
407
406
self.assert_(len(p1._children) == 0)
408
407
self.assert_(len(p1.children) == 0)
410
p1.children = ['a','b','c']
409
p1.children = ['a', 'b', 'c']
411
410
self.assert_(len(p1._children) == 3)
412
411
self.assert_(len(p1.children) == 3)
421
420
self.assert_('b' in p1.children)
422
421
self.assert_('d' not in p1.children)
424
self.assert_(p1.children == set(['a','b','c']))
423
self.assert_(p1.children == set(['a', 'b', 'c']))
427
p1.children.remove('d')
427
p1.children.remove, "d"
432
430
self.assert_(len(p1.children) == 3)
433
431
p1.children.discard('d')
442
440
self.assert_(len(p1.children) == 2)
443
441
self.assert_(popped not in p1.children)
445
p1.children = ['a','b','c']
443
p1.children = ['a', 'b', 'c']
446
444
p1 = self.roundtrip(p1)
447
self.assert_(p1.children == set(['a','b','c']))
445
self.assert_(p1.children == set(['a', 'b', 'c']))
449
447
p1.children.discard('b')
450
448
p1 = self.roundtrip(p1)
476
474
Parent, Child = self.Parent, self.Child
478
476
p1 = Parent('P1')
479
p1.children = ['a','b','c']
480
control = set(['a','b','c'])
477
p1.children = ['a', 'b', 'c']
478
control = set(['a', 'b', 'c'])
482
for other in (set(['a','b','c']), set(['a','b','c','d']),
483
set(['a']), set(['a','b']),
484
set(['c','d']), set(['e', 'f', 'g']),
480
for other in (set(['a', 'b', 'c']), set(['a', 'b', 'c', 'd']),
481
set(['a']), set(['a', 'b']),
482
set(['c', 'd']), set(['e', 'f', 'g']),
487
485
eq_(p1.children.union(other),
499
497
eq_(p1.children.issuperset(other),
500
498
control.issuperset(other))
502
self.assert_((p1.children == other) == (control == other))
503
self.assert_((p1.children != other) == (control != other))
504
self.assert_((p1.children < other) == (control < other))
505
self.assert_((p1.children <= other) == (control <= other))
506
self.assert_((p1.children > other) == (control > other))
507
self.assert_((p1.children >= other) == (control >= other))
500
self.assert_((p1.children == other) == (control == other))
501
self.assert_((p1.children != other) == (control != other))
502
self.assert_((p1.children < other) == (control < other))
503
self.assert_((p1.children <= other) == (control <= other))
504
self.assert_((p1.children > other) == (control > other))
505
self.assert_((p1.children >= other) == (control >= other))
509
507
def test_set_mutation(self):
510
508
Parent, Child = self.Parent, self.Child
513
511
for op in ('update', 'intersection_update',
514
512
'difference_update', 'symmetric_difference_update'):
515
513
for base in (['a', 'b', 'c'], []):
516
for other in (set(['a','b','c']), set(['a','b','c','d']),
517
set(['a']), set(['a','b']),
518
set(['c','d']), set(['e', 'f', 'g']),
514
for other in (set(['a', 'b', 'c']), set(['a', 'b', 'c', 'd']),
515
set(['a']), set(['a', 'b']),
516
set(['c', 'd']), set(['e', 'f', 'g']),
521
519
p.children = base[:]
544
542
# in-place mutations
545
543
for op in ('|=', '-=', '&=', '^='):
546
544
for base in (['a', 'b', 'c'], []):
547
for other in (set(['a','b','c']), set(['a','b','c','d']),
548
set(['a']), set(['a','b']),
549
set(['c','d']), set(['e', 'f', 'g']),
545
for other in (set(['a', 'b', 'c']), set(['a', 'b', 'c', 'd']),
546
set(['a']), set(['a', 'b']),
547
set(['c', 'd']), set(['e', 'f', 'g']),
550
548
frozenset(['e', 'f', 'g']),
1025
1019
def define_tables(cls, metadata):
1026
1020
Table('userkeywords', metadata,
1027
Column('keyword_id', Integer,ForeignKey('keywords.id'), primary_key=True),
1021
Column('keyword_id', Integer, ForeignKey('keywords.id'), primary_key=True),
1028
1022
Column('user_id', Integer, ForeignKey('users.id'))
1030
1024
Table('users', metadata,
1089
1083
cls.classes.Singular)
1091
1085
mapper(User, users, properties={
1092
'singular':relationship(Singular)
1086
'singular': relationship(Singular)
1094
1088
mapper(Keyword, keywords, properties={
1095
'user_keyword':relationship(UserKeyword, uselist=False)
1089
'user_keyword': relationship(UserKeyword, uselist=False)
1098
1092
mapper(UserKeyword, userkeywords, properties={
1099
'user' : relationship(User, backref='user_keywords'),
1100
'keyword' : relationship(Keyword)
1093
'user': relationship(User, backref='user_keywords'),
1094
'keyword': relationship(Keyword)
1102
1096
mapper(Singular, singular, properties={
1103
1097
'keywords': relationship(Keyword)
1205
1199
self._equivalent(
1206
1200
self.session.query(User).\
1207
filter(User.singular_keywords.any(Keyword.keyword=='jumped')),
1201
filter(User.singular_keywords.any(Keyword.keyword == 'jumped')),
1208
1202
self.session.query(User).\
1210
1204
User.singular.has(
1211
Singular.keywords.any(Keyword.keyword=='jumped')
1205
Singular.keywords.any(Keyword.keyword == 'jumped')
1254
1248
def test_filter_eq_null_nul_nul(self):
1255
1249
UserKeyword, Keyword = self.classes.UserKeyword, self.classes.Keyword
1257
self._equivalent(self.session.query(Keyword).filter(Keyword.user
1259
self.session.query(Keyword).
1260
filter(Keyword.user_keyword.has(UserKeyword.user
1252
self.session.query(Keyword).filter(Keyword.user == None),
1253
self.session.query(Keyword).
1254
filter(Keyword.user_keyword.has(UserKeyword.user == None)))
1263
1256
def test_filter_scalar_contains_fails_nul_nul(self):
1264
1257
Keyword = self.classes.Keyword
1266
assert_raises(exc.InvalidRequestError, lambda : \
1267
Keyword.user.contains(self.u))
1259
assert_raises(exc.InvalidRequestError,
1260
lambda: Keyword.user.contains(self.u))
1269
1262
def test_filter_scalar_any_fails_nul_nul(self):
1270
1263
Keyword = self.classes.Keyword
1272
assert_raises(exc.InvalidRequestError, lambda : \
1273
Keyword.user.any(name='user2'))
1265
assert_raises(exc.InvalidRequestError,
1266
lambda: Keyword.user.any(name='user2'))
1275
1268
def test_filter_collection_has_fails_ul_nul(self):
1276
1269
User = self.classes.User
1278
assert_raises(exc.InvalidRequestError, lambda : \
1279
User.keywords.has(keyword='quick'))
1271
assert_raises(exc.InvalidRequestError,
1272
lambda: User.keywords.has(keyword='quick'))
1281
1274
def test_filter_collection_eq_fails_ul_nul(self):
1282
1275
User = self.classes.User
1284
assert_raises(exc.InvalidRequestError, lambda : \
1285
User.keywords == self.kw)
1277
assert_raises(exc.InvalidRequestError,
1278
lambda: User.keywords == self.kw)
1287
1280
def test_filter_collection_ne_fails_ul_nul(self):
1288
1281
User = self.classes.User
1290
assert_raises(exc.InvalidRequestError, lambda : \
1291
User.keywords != self.kw)
1283
assert_raises(exc.InvalidRequestError,
1284
lambda: User.keywords != self.kw)
1293
1286
def test_join_separate_attr(self):
1294
1287
User = self.classes.User
1330
1323
b = Table('b', m, Column('id', Integer, primary_key=True),
1331
1324
Column('aid', Integer, ForeignKey('a.id')))
1332
1325
mapper(A, a, properties={
1333
'orig':relationship(B, collection_class=attribute_mapped_collection('key'))
1326
'orig': relationship(B, collection_class=attribute_mapped_collection('key'))
1339
1332
def test_update_one_elem_dict(self):
1341
1334
a1.elements.update({("B", 3): 'elem2'})
1342
eq_(a1.elements, {("B",3):'elem2'})
1335
eq_(a1.elements, {("B", 3): 'elem2'})
1344
1337
def test_update_multi_elem_dict(self):
1346
1339
a1.elements.update({("B", 3): 'elem2', ("C", 4): "elem3"})
1347
eq_(a1.elements, {("B",3):'elem2', ("C", 4): "elem3"})
1340
eq_(a1.elements, {("B", 3): 'elem2', ("C", 4): "elem3"})
1349
1342
def test_update_one_elem_list(self):
1351
1344
a1.elements.update([(("B", 3), 'elem2')])
1352
eq_(a1.elements, {("B",3):'elem2'})
1345
eq_(a1.elements, {("B", 3): 'elem2'})
1354
1347
def test_update_multi_elem_list(self):
1356
1349
a1.elements.update([(("B", 3), 'elem2'), (("C", 4), "elem3")])
1357
eq_(a1.elements, {("B",3):'elem2', ("C", 4): "elem3"})
1350
eq_(a1.elements, {("B", 3): 'elem2', ("C", 4): "elem3"})
1359
1352
def test_update_one_elem_varg(self):