def test_many_to_many(self): ab_table = Table('a_b', self.base_cls.metadata, Column('a_id', Integer, ForeignKey('a.id')), Column('b_id', Integer, ForeignKey('b.id'))) class A(self.base_cls): name = Column(String) b_list = relationship('B', secondary=ab_table) class B(self.base_cls): name = Column(String) a_list = relationship('A', secondary=ab_table) session = self.init() a1, a2, a3, a4 = A(name='a1'), A(name='a2'), A(name='a3'), A(name='a4') b1, b2, b3, b4 = B(name='b1'), B(name='b2'), B(name='b3'), B(name='b4') a1.b_list = [b2, b3, b4] a2.b_list = [b1, b3, b4] a3.b_list = [b1, b2, b4] a4.b_list = [b1, b2, b3] session.add_all([a1, a2, a3, a4]) session.commit() q1 = (ConstructQuery({ 'a_name': A.name, 'b_names': map_(apply_(capitalize, [B.name]), A.b_list), }).with_session(session.registry()).order_by(A.name)) self.assertEqual( tuple((obj.a_name, set(obj.b_names)) for obj in q1.all()), ( ('a1', {'B2', 'B3', 'B4'}), ('a2', {'B1', 'B3', 'B4'}), ('a3', {'B1', 'B2', 'B4'}), ('a4', {'B1', 'B2', 'B3'}), )) q2 = (ConstructQuery({ 'b_name': B.name, 'a_names': map_(apply_(capitalize, [A.name]), B.a_list), }).with_session(session.registry()).order_by(B.name)) self.assertEqual( tuple((obj.b_name, set(obj.a_names)) for obj in q2.all()), ( ('b1', {'A2', 'A3', 'A4'}), ('b2', {'A1', 'A3', 'A4'}), ('b3', {'A1', 'A2', 'A4'}), ('b4', {'A1', 'A2', 'A3'}), ), )
def test_one_to_many(self): class A(self.base_cls): name = Column(String) b_list = relationship('B') @hybrid_property def just_b_list(self): return self.b_list class B(self.base_cls): name = Column(String) a_id = Column(Integer, ForeignKey('a.id')) session = self.init() session.add_all([ A(name='a1', b_list=[B(name='b1'), B(name='b2'), B(name='b3')]), A(name='a2', b_list=[B(name='b4'), B(name='b5'), B(name='b6')]), A(name='a3', b_list=[B(name='b7'), B(name='b8'), B(name='b9')]), ]) session.commit() query = ( ConstructQuery({ 'a_name': A.name, 'b_names': map_(apply_(capitalize, [B.name]), A.b_list), }) .with_session(session.registry()) ) self.assertEqual( tuple(dict(obj) for obj in query.all()), ({'a_name': 'a1', 'b_names': ['B1', 'B2', 'B3']}, {'a_name': 'a2', 'b_names': ['B4', 'B5', 'B6']}, {'a_name': 'a3', 'b_names': ['B7', 'B8', 'B9']}), ) query = ( ConstructQuery({ 'a_name': A.name, 'b_names': map_(apply_(capitalize, [B.name]), A.just_b_list), }) .with_session(session.registry()) ) self.assertEqual( tuple(dict(obj) for obj in query.all()), ({'a_name': 'a1', 'b_names': ['B1', 'B2', 'B3']}, {'a_name': 'a2', 'b_names': ['B4', 'B5', 'B6']}, {'a_name': 'a3', 'b_names': ['B7', 'B8', 'B9']}), )
def test_one_to_one(self): class A(self.base_cls): name = Column(String) b = relationship('B', uselist=False) class B(self.base_cls): name = Column(String) a_id = Column(Integer, ForeignKey('a.id')) session = self.init() session.add_all([ A(name='a1', b=B(name='b1')), A(name='a2'), B(name='b2'), A(name='a3', b=B(name='b3')), ]) session.commit() query = ( ConstructQuery({ 'a_name': A.name, 'b_name': get_(if_(B.id, apply_(capitalize, [B.name]), '~'), A.b), }) .with_session(session.registry()) ) self.assertEqual( tuple(dict(obj) for obj in query.all()), ({'a_name': 'a1', 'b_name': 'B1'}, {'a_name': 'a2', 'b_name': '~'}, {'a_name': 'a3', 'b_name': 'B3'}), )
def test_defined_calls(self): c1 = self.a_cls.__table__.c.id c2 = self.a_cls.__table__.c.name c3 = self.b_cls.__table__.c.id c4 = self.b_cls.__table__.c.name self.assertEqual( defined_func(self.a_cls(id=1, name='foo'), self.b_cls(id=2, name='bar'), extra_id=3, extra_name='baz'), (1 + 2 + 3, 'foo' + 'bar' + 'baz'), ) apl1 = defined_func.defn(self.a_cls, self.b_cls, extra_id=3, extra_name='baz') self.assertTrue(isinstance(apl1, apply_), type(apl1)) self.assertEquals(columns_set(apl1), {c1, c2, c3, c4}) self.assertEqual( proceed(apl1, {c1: 1, c2: 'foo', c3: 2, c4: 'bar'}), (1 + 2 + 3, 'foo' + 'bar' + 'baz'), ) apl2 = defined_func.defn(self.a_cls, self.b_cls, extra_id=c1, extra_name=c2) self.assertTrue(isinstance(apl2, apply_), type(apl2)) self.assertEquals(columns_set(apl2), {c1, c2, c3, c4}) self.assertEqual( proceed(apl2, {c1: 1, c2: 'foo', c3: 2, c4: 'bar'}), (1 + 2 + 1, 'foo' + 'bar' + 'foo'), ) apl3 = defined_func.defn(self.a_cls, self.b_cls, extra_id=apply_(operator.add, [c1, c3]), extra_name=apply_(operator.concat, [c2, c4])) self.assertTrue(isinstance(apl3, apply_), type(apl3)) self.assertEquals(columns_set(apl3), {c1, c2, c3, c4}) self.assertEqual( proceed(apl3, {c1: 1, c2: 'foo', c3: 2, c4: 'bar'}), (1 + 2 + (1 + 2), 'foo' + 'bar' + ('foo' + 'bar')), ) self.assertEqual( defined_func.func(1, 'foo', 2, 'bar', 3, 'baz'), (1 + 2 + 3, 'foo' + 'bar' + 'baz'), )
def test_nested_construct(self): struct = Construct({ 'a_id': apply_(operator.add, [self.a_cls.id, 5]), 'a_name': apply_(operator.concat, [self.a_cls.name, '-test']), }) self.assertEqual(set(struct._columns), { self.a_cls.__table__.c.id, self.a_cls.__table__.c.name, }) result = { self.a_cls.__table__.c.id: 1, self.a_cls.__table__.c.name: 'a1', } row = [result[col] for col in struct._columns] s = struct._from_row(row) self.assertEqual(s.a_id, 1 + 5) self.assertEqual(s.a_name, 'a1' + '-test')
def test_nested_apply(self): c1 = self.a_cls.__table__.c.id c2 = self.b_cls.__table__.c.id add = lambda a, b: a + b apl = apply_( add, [ apply_( add, [ apply_(add, [ 0, 1, ]), apply_( add, [ 2, apply_( add, [ 3, c1, # 4 ]), ]), ]), apply_( add, [ apply_( add, [ apply_( add, [ c2, # 5 6, ]), 7, ]), apply_(add, [ 8, 9, ]), ]), ]) self.assertEqual(columns_set(apl), {c1, c2}) self.assertEqual(proceed(apl, {c1: 4, c2: 5}), sum(range(10)))
def test_pipe_operator(self): struct = Construct({ 'a_name_hash': apply_(capitalize, [self.a_cls.name]) | hash, }) s1, s2 = self.session.query(struct).order_by(self.a_cls.name).all() self.assertEqual(s1.a_name_hash, hash('A1')) self.assertEqual(s2.a_name_hash, hash('A2'))
def test_apply_with_columns(self): f1 = self.a_cls.id f2 = self.b_cls.id c1 = self.a_cls.__table__.c.id c2 = self.b_cls.__table__.c.id fn1 = func.count(self.a_cls.id) fn2 = func.count(self.b_cls.id) add = lambda a, b: a + b apl1 = apply_(add, [f1], {'b': f2}) self.assertEqual(columns_set(apl1), {c1, c2}) self.assertEqual(proceed(apl1, {c1: 3, c2: 4}), 3 + 4) apl2 = apply_(add, [c1], {'b': c2}) self.assertEqual(columns_set(apl2), {c1, c2}) self.assertEqual(proceed(apl1, {c1: 4, c2: 5}), 4 + 5) apl3 = apply_(add, [fn1], {'b': fn2}) self.assertEqual(columns_set(apl3), {fn1, fn2}) self.assertEqual(proceed(apl3, {fn1: 5, fn2: 6}), 5 + 6)
def test_apply(self): add = lambda a, b, c=30, d=400: a + b + c + d min_pos_apply = apply_(add, [1, 2]) self.assertEqual(columns_set(min_pos_apply), set()) self.assertEqual(proceed(min_pos_apply, {}), 1 + 2 + 30 + 400) min_kw_apply = apply_(add, [], {'a': 1, 'b': 2}) self.assertEqual(columns_set(min_kw_apply), set()) self.assertEqual(proceed(min_kw_apply, {}), 1 + 2 + 30 + 400) max_pos_apply = apply_(add, [1, 2, 33, 444]) self.assertEqual(columns_set(max_pos_apply), set()) self.assertEqual(proceed(max_pos_apply, {}), 1 + 2 + 33 + 444) max_kw_apply = apply_(add, [], {'a': 1, 'b': 2, 'c': 33, 'd': 444}) self.assertEqual(columns_set(max_kw_apply), set()) self.assertEqual(proceed(max_kw_apply, {}), 1 + 2 + 33 + 444) mixed_apply = apply_(add, [1, 2], {'c': 33, 'd': 444}) self.assertEqual(columns_set(mixed_apply), set()) self.assertEqual(proceed(mixed_apply, {}), 1 + 2 + 33 + 444)
def test_if(self): add = lambda a, b: a + b c1 = self.a_cls.__table__.c.id c2 = self.a_cls.__table__.c.name c3 = self.b_cls.__table__.c.id c4 = self.b_cls.__table__.c.name if1 = if_(True, then_=1, else_=2) self.assertEqual(columns_set(if1), set()) self.assertEqual(proceed(if1, {}), 1) if2 = if_(False, then_=1, else_=2) self.assertEqual(columns_set(if2), set()) self.assertEqual(proceed(if2, {}), 2) if3 = if_(c1, then_=c2, else_=c3) self.assertEqual(columns_set(if3), {c1, c2, c3}) self.assertEqual(proceed(if3, {c1: 0, c2: 3, c3: 6}), 6) self.assertEqual(proceed(if3, {c1: 1, c2: 3, c3: 6}), 3) if4 = if_(c1, then_=apply_(add, [c2, c3]), else_=apply_(add, [c3, c4])) self.assertEqual(columns_set(if4), {c1, c2, c3, c4}) self.assertEqual(proceed(if4, {c1: 0, c2: 2, c3: 3, c4: 4}), 3 + 4) self.assertEqual(proceed(if4, {c1: 1, c2: 2, c3: 3, c4: 4}), 2 + 3)
def test_nested_apply(self): c1 = self.a_cls.__table__.c.id c2 = self.b_cls.__table__.c.id add = lambda a, b: a + b apl = apply_(add, [ apply_(add, [ apply_(add, [ 0, 1, ]), apply_(add, [ 2, apply_(add, [ 3, c1, # 4 ]), ]), ]), apply_(add, [ apply_(add, [ apply_(add, [ c2, # 5 6, ]), 7, ]), apply_(add, [ 8, 9, ]), ]), ]) self.assertEqual(columns_set(apl), {c1, c2}) self.assertEqual(proceed(apl, {c1: 4, c2: 5}), sum(range(10)))
def test_one_to_many(self): class A(self.base_cls): name = Column(String) b_list = relationship('B') class B(self.base_cls): name = Column(String) a_id = Column(Integer, ForeignKey('a.id')) session = self.init() session.add_all([ A(name='a1', b_list=[B(name='b1'), B(name='b2'), B(name='b3')]), A(name='a2', b_list=[B(name='b4'), B(name='b5'), B(name='b6')]), A(name='a3', b_list=[B(name='b7'), B(name='b8'), B(name='b9')]), ]) session.commit() query = (ConstructQuery({ 'a_name': A.name, 'b_names': map_(apply_(capitalize, [B.name]), A.b_list), }).with_session(session.registry())) self.assertEqual( tuple(dict(obj) for obj in query.all()), ({ 'a_name': 'a1', 'b_names': ['B1', 'B2', 'B3'] }, { 'a_name': 'a2', 'b_names': ['B4', 'B5', 'B6'] }, { 'a_name': 'a3', 'b_names': ['B7', 'B8', 'B9'] }), )
def test_one_to_one(self): class A(self.base_cls): name = Column(String) b = relationship('B', uselist=False) class B(self.base_cls): name = Column(String) a_id = Column(Integer, ForeignKey('a.id')) session = self.init() session.add_all([ A(name='a1', b=B(name='b1')), A(name='a2'), B(name='b2'), A(name='a3', b=B(name='b3')), ]) session.commit() query = (ConstructQuery({ 'a_name': A.name, 'b_name': get_(if_(B.id, apply_(capitalize, [B.name]), '~'), A.b), }).with_session(session.registry())) self.assertEqual( tuple(dict(obj) for obj in query.all()), ({ 'a_name': 'a1', 'b_name': 'B1' }, { 'a_name': 'a2', 'b_name': '~' }, { 'a_name': 'a3', 'b_name': 'B3' }), )
def test_defined_calls(self): c1 = self.a_cls.__table__.c.id c2 = self.a_cls.__table__.c.name c3 = self.b_cls.__table__.c.id c4 = self.b_cls.__table__.c.name self.assertEqual( defined_func(self.a_cls(id=1, name='foo'), self.b_cls(id=2, name='bar'), extra_id=3, extra_name='baz'), (1, 2, 3, 'foo', 'bar', 'baz'), ) self.assertEqual( defined_func(self.a_cls(id=1, name='foo'), None, extra_id=3, extra_name='baz'), (1, None, 3, 'foo', None, 'baz'), ) self.assertEqual( defined_func(None, self.b_cls(id=2, name='bar'), extra_id=3, extra_name='baz'), (None, 2, 3, None, 'bar', 'baz'), ) apl1 = defined_func.defn(self.a_cls, self.b_cls, extra_id=3, extra_name='baz') self.assertTrue(isinstance(apl1, apply_), type(apl1)) self.assertEqual(columns_set(apl1), {c1, c2, c3, c4}) self.assertEqual( proceed(apl1, { c1: 1, c2: 'foo', c3: 2, c4: 'bar' }), (1, 2, 3, 'foo', 'bar', 'baz'), ) apl2 = defined_func.defn(self.a_cls, self.b_cls, extra_id=c1, extra_name=c2) self.assertTrue(isinstance(apl2, apply_), type(apl2)) self.assertEqual(columns_set(apl2), {c1, c2, c3, c4}) self.assertEqual( proceed(apl2, { c1: 1, c2: 'foo', c3: 2, c4: 'bar' }), (1, 2, 1, 'foo', 'bar', 'foo'), ) apl3 = defined_func.defn(self.a_cls, self.b_cls, extra_id=apply_(operator.add, [c1, c3]), extra_name=apply_(operator.concat, [c2, c4])) self.assertTrue(isinstance(apl3, apply_), type(apl3)) self.assertEqual(columns_set(apl3), {c1, c2, c3, c4}) self.assertEqual( proceed(apl3, { c1: 1, c2: 'foo', c3: 2, c4: 'bar' }), (1, 2, (1 + 2), 'foo', 'bar', ('foo' + 'bar')), ) self.assertEqual( defined_func.func(1, 'foo', 2, 'bar', 3, 'baz'), (1, 2, 3, 'foo', 'bar', 'baz'), )
def test_many_to_many(self): ab_table = Table( 'a_b', self.base_cls.metadata, Column('a_id', Integer, ForeignKey('a.id')), Column('b_id', Integer, ForeignKey('b.id')) ) class A(self.base_cls): name = Column(String) b_list = relationship('B', secondary=ab_table) class B(self.base_cls): name = Column(String) a_list = relationship('A', secondary=ab_table) session = self.init() a1, a2, a3, a4 = A(name='a1'), A(name='a2'), A(name='a3'), A(name='a4') b1, b2, b3, b4 = B(name='b1'), B(name='b2'), B(name='b3'), B(name='b4') a1.b_list = [b2, b3, b4] a2.b_list = [b1, b3, b4] a3.b_list = [b1, b2, b4] a4.b_list = [b1, b2, b3] session.add_all([a1, a2, a3, a4]) session.commit() q1 = ( ConstructQuery({ 'a_name': A.name, 'b_names': map_(apply_(capitalize, [B.name]), A.b_list), }) .with_session(session.registry()) .order_by(A.name) ) self.assertEqual( tuple((obj.a_name, set(obj.b_names)) for obj in q1.all()), ( ('a1', {'B2', 'B3', 'B4'}), ('a2', {'B1', 'B3', 'B4'}), ('a3', {'B1', 'B2', 'B4'}), ('a4', {'B1', 'B2', 'B3'}), ) ) q2 = ( ConstructQuery({ 'b_name': B.name, 'a_names': map_(apply_(capitalize, [A.name]), B.a_list), }) .with_session(session.registry()) .order_by(B.name) ) self.assertEqual( tuple((obj.b_name, set(obj.a_names)) for obj in q2.all()), ( ('b1', {'A2', 'A3', 'A4'}), ('b2', {'A1', 'A3', 'A4'}), ('b3', {'A1', 'A2', 'A4'}), ('b4', {'A1', 'A2', 'A3'}), ), )