~ubuntu-branches/debian/jessie/sqlalchemy/jessie

« back to all changes in this revision

Viewing changes to test/ext/test_declarative.py

• browse files at revision 26
• compare with another revision
• download diff
• download tarball
• view history from revision 26

Show diffs side-by-side

added

removed

test/ext/test_declarative.py

1

1

 

2

 

from sqlalchemy.test.testing import eq_, assert_raises, \

 

2

from test.lib.testing import eq_, assert_raises, \

3

3

    assert_raises_message

4

4

from sqlalchemy.ext import declarative as decl

5

5

from sqlalchemy import exc

6

6

import sqlalchemy as sa

7

 

from sqlalchemy.test import testing

 

7

from test.lib import testing

8

8

from sqlalchemy import MetaData, Integer, String, ForeignKey, \

9

9

    ForeignKeyConstraint, Index

10

 

from sqlalchemy.test.schema import Table, Column

 

10

from test.lib.schema import Table, Column

11

11

from sqlalchemy.orm import relationship, create_session, class_mapper, \

12

 

    joinedload, compile_mappers, backref, clear_mappers, \

13

 

    polymorphic_union, deferred, column_property

14

 

from sqlalchemy.test.testing import eq_

 

12

    joinedload, configure_mappers, backref, clear_mappers, \

 

13

    polymorphic_union, deferred, column_property, composite,\

 

14

    Session

 

15

from test.lib.testing import eq_

15

16

from sqlalchemy.util import classproperty

16

 

from test.orm._base import ComparableEntity, MappedTest

17

17

from sqlalchemy.ext.declarative import declared_attr

 

18

from test.lib import fixtures

18

19

 

19

 

class DeclarativeTestBase(testing.TestBase, testing.AssertsExecutionResults):

 

20

class DeclarativeTestBase(fixtures.TestBase, testing.AssertsExecutionResults):

20

21

    def setup(self):

21

22

        global Base

22

23

        Base = decl.declarative_base(testing.db)

23

24

 

24

25

    def teardown(self):

 

26

        Session.close_all()

25

27

        clear_mappers()

26

28

        Base.metadata.drop_all()

27

29

 

28

30

class DeclarativeTest(DeclarativeTestBase):

29

31

    def test_basic(self):

30

 

        class User(Base, ComparableEntity):

 

32

        class User(Base, fixtures.ComparableEntity):

31

33

            __tablename__ = 'users'

32

34

 

33

35

            id = Column('id', Integer, primary_key=True,

35

37

            name = Column('name', String(50))

36

38

            addresses = relationship("Address", backref="user")

37

39

 

38

 

        class Address(Base, ComparableEntity):

 

40

        class Address(Base, fixtures.ComparableEntity):

39

41

            __tablename__ = 'addresses'

40

42

 

41

43

            id = Column(Integer, primary_key=True,

118

120

            xyzzy = "magic"

119

121

 

120

122

        # _as_declarative() inspects obj.__class__.__bases__

121

 

        class User(BrokenParent,ComparableEntity):

 

123

        class User(BrokenParent,fixtures.ComparableEntity):

122

124

            __tablename__ = 'users'

123

125

            id = Column('id', Integer, primary_key=True,

124

126

                test_needs_autoincrement=True)

188

190

    def test_string_dependency_resolution(self):

189

191

        from sqlalchemy.sql import desc

190

192

 

191

 

        class User(Base, ComparableEntity):

 

193

        class User(Base, fixtures.ComparableEntity):

192

194

 

193

195

            __tablename__ = 'users'

194

196

            id = Column(Integer, primary_key=True,

202

204

                    primaryjoin='User.id==Address.user_id',

203

205

                    foreign_keys='[Address.user_id]'))

204

206

 

205

 

        class Address(Base, ComparableEntity):

 

207

        class Address(Base, fixtures.ComparableEntity):

206

208

 

207

209

            __tablename__ = 'addresses'

208

210

            id = Column(Integer, primary_key=True,

221

223

            User(name='ed', addresses=[Address(email='xyz'),

222

224

            Address(email='def'), Address(email='abc')]))

223

225

 

224

 

        class Foo(Base, ComparableEntity):

 

226

        class Foo(Base, fixtures.ComparableEntity):

225

227

 

226

228

            __tablename__ = 'foo'

227

229

            id = Column(Integer, primary_key=True)

230

232

 

231

233

        assert_raises_message(exc.InvalidRequestError,

232

234

                              "'addresses' is not an instance of "

233

 

                              "ColumnProperty", compile_mappers)

 

235

                              "ColumnProperty", configure_mappers)

234

236

 

235

237

    def test_string_dependency_resolution_two(self):

236

238

 

237

 

        class User(Base, ComparableEntity):

 

239

        class User(Base, fixtures.ComparableEntity):

238

240

            __tablename__ = 'users'

239

241

            id = Column(Integer, primary_key=True,

240

242

                        test_needs_autoincrement=True)

241

243

            name = Column(String(50))

242

244

 

243

 

        class Bar(Base, ComparableEntity):

 

245

        class Bar(Base, fixtures.ComparableEntity):

244

246

            __tablename__ = 'bar'

245

247

            id = Column(Integer, primary_key=True)

246

248

            rel = relationship('User',

248

250

 

249

251

        assert_raises_message(exc.InvalidRequestError,

250

252

                              "does not have a mapped column named "

251

 

                              "'__table__'", compile_mappers)

 

253

                              "'__table__'", configure_mappers)

252

254

 

253

255

    def test_string_dependency_resolution_no_magic(self):

254

256

        """test that full tinkery expressions work as written"""

255

257

 

256

 

        class User(Base, ComparableEntity):

 

258

        class User(Base, fixtures.ComparableEntity):

257

259

 

258

260

            __tablename__ = 'users'

259

261

            id = Column(Integer, primary_key=True)

261

263

                    primaryjoin='User.id==Address.user_id.prop.columns['

262

264

                    '0]')

263

265

 

264

 

        class Address(Base, ComparableEntity):

 

266

        class Address(Base, fixtures.ComparableEntity):

265

267

 

266

268

            __tablename__ = 'addresses'

267

269

            id = Column(Integer, primary_key=True)

268

270

            user_id = Column(Integer, ForeignKey('users.id'))

269

271

 

270

 

        compile_mappers()

 

272

        configure_mappers()

271

273

        eq_(str(User.addresses.prop.primaryjoin),

272

274

            'users.id = addresses.user_id')

273

275

 

274

276

    def test_string_dependency_resolution_in_backref(self):

275

277

 

276

 

        class User(Base, ComparableEntity):

 

278

        class User(Base, fixtures.ComparableEntity):

277

279

 

278

280

            __tablename__ = 'users'

279

281

            id = Column(Integer, primary_key=True)

282

284

                    primaryjoin='User.id==Address.user_id',

283

285

                    backref='user')

284

286

 

285

 

        class Address(Base, ComparableEntity):

 

287

        class Address(Base, fixtures.ComparableEntity):

286

288

 

287

289

            __tablename__ = 'addresses'

288

290

            id = Column(Integer, primary_key=True)

289

291

            email = Column(String(50))

290

292

            user_id = Column(Integer, ForeignKey('users.id'))

291

293

 

292

 

        compile_mappers()

 

294

        configure_mappers()

293

295

        eq_(str(User.addresses.property.primaryjoin),

294

296

            str(Address.user.property.primaryjoin))

295

297

 

296

298

    def test_string_dependency_resolution_tables(self):

297

299

 

298

 

        class User(Base, ComparableEntity):

 

300

        class User(Base, fixtures.ComparableEntity):

299

301

 

300

302

            __tablename__ = 'users'

301

303

            id = Column(Integer, primary_key=True)

306

308

                                 secondaryjoin='user_to_prop.c.prop_id='

307

309

                                 '=Prop.id', backref='users')

308

310

 

309

 

        class Prop(Base, ComparableEntity):

 

311

        class Prop(Base, fixtures.ComparableEntity):

310

312

 

311

313

            __tablename__ = 'props'

312

314

            id = Column(Integer, primary_key=True)

316

318

                             Column('user_id', Integer,

317

319

                             ForeignKey('users.id')), Column('prop_id',

318

320

                             Integer, ForeignKey('props.id')))

319

 

        compile_mappers()

 

321

        configure_mappers()

 

322

        assert class_mapper(User).get_property('props').secondary \

 

323

            is user_to_prop

 

324

 

 

325

    def test_string_dependency_resolution_schemas(self):

 

326

        Base = decl.declarative_base()

 

327

 

 

328

        class User(Base):

 

329

 

 

330

            __tablename__ = 'users'

 

331

            __table_args__ = {'schema':'fooschema'}

 

332

 

 

333

            id = Column(Integer, primary_key=True)

 

334

            name = Column(String(50))

 

335

            props = relationship('Prop', secondary='fooschema.user_to_prop',

 

336

                         primaryjoin='User.id==fooschema.user_to_prop.c.user_id',

 

337

                         secondaryjoin='fooschema.user_to_prop.c.prop_id==Prop.id', 

 

338

                         backref='users')

 

339

 

 

340

        class Prop(Base):

 

341

 

 

342

            __tablename__ = 'props'

 

343

            __table_args__ = {'schema':'fooschema'}

 

344

 

 

345

            id = Column(Integer, primary_key=True)

 

346

            name = Column(String(50))

 

347

 

 

348

        user_to_prop = Table('user_to_prop', Base.metadata,

 

349

                     Column('user_id', Integer, ForeignKey('fooschema.users.id')), 

 

350

                     Column('prop_id',Integer, ForeignKey('fooschema.props.id')),

 

351

                     schema='fooschema')

 

352

        configure_mappers()

 

353

 

320

354

        assert class_mapper(User).get_property('props').secondary \

321

355

            is user_to_prop

322

356

 

323

357

    def test_uncompiled_attributes_in_relationship(self):

324

358

 

325

 

        class Address(Base, ComparableEntity):

 

359

        class Address(Base, fixtures.ComparableEntity):

326

360

 

327

361

            __tablename__ = 'addresses'

328

362

            id = Column(Integer, primary_key=True,

330

364

            email = Column(String(50))

331

365

            user_id = Column(Integer, ForeignKey('users.id'))

332

366

 

333

 

        class User(Base, ComparableEntity):

 

367

        class User(Base, fixtures.ComparableEntity):

334

368

 

335

369

            __tablename__ = 'users'

336

370

            id = Column(Integer, primary_key=True,

377

411

        # this used to raise an error when accessing User.id but that's

378

412

        # no longer the case since we got rid of _CompileOnAttr.

379

413

 

380

 

        assert_raises(sa.exc.ArgumentError, compile_mappers)

 

414

        assert_raises(sa.exc.ArgumentError, configure_mappers)

381

415

 

382

416

    def test_nice_dependency_error_works_with_hasattr(self):

383

417

 

385

419

 

386

420

            __tablename__ = 'users'

387

421

            id = Column('id', Integer, primary_key=True)

388

 

            addresses = relationship('Addresss')

 

422

            addresses = relationship('Address')

389

423

 

390

424

        # hasattr() on a compile-loaded attribute

391

 

 

392

 

        hasattr(User.addresses, 'property')

 

425

        try:

 

426

            hasattr(User.addresses, 'property')

 

427

        except exc.InvalidRequestError:

 

428

            assert sa.util.compat.py32

393

429

 

394

430

        # the exception is preserved.  Remains the 

395

431

        # same through repeated calls.

398

434

                            "^One or more mappers failed to initialize - "

399

435

                            "can't proceed with initialization of other "

400

436

                            "mappers.  Original exception was: When initializing.*",

401

 

                            compile_mappers)

 

437

                            configure_mappers)

402

438

 

403

439

    def test_custom_base(self):

404

440

        class MyBase(object):

427

463

            master = relationship(Master)

428

464

 

429

465

        Base.metadata.create_all()

430

 

        compile_mappers()

 

466

        configure_mappers()

431

467

        assert class_mapper(Detail).get_property('master'

432

468

                ).strategy.use_get

433

469

        m1 = Master()

454

490

        i = Index('my_index', User.name)

455

491

 

456

492

        # compile fails due to the nonexistent Addresses relationship

457

 

        assert_raises(sa.exc.InvalidRequestError, compile_mappers)

 

493

        assert_raises(sa.exc.InvalidRequestError, configure_mappers)

458

494

 

459

495

        # index configured

460

496

        assert i in User.__table__.indexes

466

502

 

467

503

    def test_add_prop(self):

468

504

 

469

 

        class User(Base, ComparableEntity):

 

505

        class User(Base, fixtures.ComparableEntity):

470

506

 

471

507

            __tablename__ = 'users'

472

508

            id = Column('id', Integer, primary_key=True,

475

511

        User.name = Column('name', String(50))

476

512

        User.addresses = relationship('Address', backref='user')

477

513

 

478

 

        class Address(Base, ComparableEntity):

 

514

        class Address(Base, fixtures.ComparableEntity):

479

515

 

480

516

            __tablename__ = 'addresses'

481

517

            id = Column(Integer, primary_key=True,

502

538

 

503

539

    def test_eager_order_by(self):

504

540

 

505

 

        class Address(Base, ComparableEntity):

 

541

        class Address(Base, fixtures.ComparableEntity):

506

542

 

507

543

            __tablename__ = 'addresses'

508

544

            id = Column('id', Integer, primary_key=True,

510

546

            email = Column('email', String(50))

511

547

            user_id = Column('user_id', Integer, ForeignKey('users.id'))

512

548

 

513

 

        class User(Base, ComparableEntity):

 

549

        class User(Base, fixtures.ComparableEntity):

514

550

 

515

551

            __tablename__ = 'users'

516

552

            id = Column('id', Integer, primary_key=True,

531

567

 

532

568

    def test_order_by_multi(self):

533

569

 

534

 

        class Address(Base, ComparableEntity):

 

570

        class Address(Base, fixtures.ComparableEntity):

535

571

 

536

572

            __tablename__ = 'addresses'

537

573

            id = Column('id', Integer, primary_key=True,

539

575

            email = Column('email', String(50))

540

576

            user_id = Column('user_id', Integer, ForeignKey('users.id'))

541

577

 

542

 

        class User(Base, ComparableEntity):

 

578

        class User(Base, fixtures.ComparableEntity):

543

579

 

544

580

            __tablename__ = 'users'

545

581

            id = Column('id', Integer, primary_key=True,

560

596

 

561

597

    def test_as_declarative(self):

562

598

 

563

 

        class User(ComparableEntity):

 

599

        class User(fixtures.ComparableEntity):

564

600

 

565

601

            __tablename__ = 'users'

566

602

            id = Column('id', Integer, primary_key=True,

568

604

            name = Column('name', String(50))

569

605

            addresses = relationship('Address', backref='user')

570

606

 

571

 

        class Address(ComparableEntity):

 

607

        class Address(fixtures.ComparableEntity):

572

608

 

573

609

            __tablename__ = 'addresses'

574

610

            id = Column('id', Integer, primary_key=True,

589

625

        eq_(sess.query(User).all(), [User(name='u1',

590

626

            addresses=[Address(email='one'), Address(email='two')])])

591

627

 

592

 

    @testing.uses_deprecated()

593

 

    def test_custom_mapper(self):

594

 

 

595

 

        class MyExt(sa.orm.MapperExtension):

596

 

 

597

 

            def create_instance(self):

598

 

                return 'CHECK'

599

 

 

600

 

        def mymapper(cls, tbl, **kwargs):

601

 

            kwargs['extension'] = MyExt()

602

 

            return sa.orm.mapper(cls, tbl, **kwargs)

603

 

 

604

 

        from sqlalchemy.orm.mapper import Mapper

605

 

 

606

 

        class MyMapper(Mapper):

607

 

 

608

 

            def __init__(self, *args, **kwargs):

609

 

                kwargs['extension'] = MyExt()

610

 

                Mapper.__init__(self, *args, **kwargs)

611

 

 

612

 

        from sqlalchemy.orm import scoping

613

 

        ss = scoping.ScopedSession(create_session)

614

 

        ss.extension = MyExt()

615

 

        ss_mapper = ss.mapper

616

 

        for mapperfunc in mymapper, MyMapper, ss_mapper:

617

 

            base = decl.declarative_base()

618

 

 

619

 

            class Foo(base):

620

 

 

621

 

                __tablename__ = 'foo'

622

 

                __mapper_cls__ = mapperfunc

623

 

                id = Column(Integer, primary_key=True)

624

 

 

625

 

            eq_(Foo.__mapper__.compile().extension.create_instance(),

626

 

                'CHECK')

627

 

            base = decl.declarative_base(mapper=mapperfunc)

628

 

 

629

 

            class Foo(base):

630

 

 

631

 

                __tablename__ = 'foo'

632

 

                id = Column(Integer, primary_key=True)

633

 

 

634

 

            eq_(Foo.__mapper__.compile().extension.create_instance(),

635

 

                'CHECK')

 

628

    def test_custom_mapper_attribute(self):

 

629

 

 

630

        def mymapper(cls, tbl, **kwargs):

 

631

            m = sa.orm.mapper(cls, tbl, **kwargs)

 

632

            m.CHECK = True

 

633

            return m

 

634

 

 

635

        base = decl.declarative_base()

 

636

 

 

637

        class Foo(base):

 

638

            __tablename__ = 'foo'

 

639

            __mapper_cls__ = mymapper

 

640

            id = Column(Integer, primary_key=True)

 

641

 

 

642

        eq_(Foo.__mapper__.CHECK, True)

 

643

 

 

644

    def test_custom_mapper_argument(self):

 

645

 

 

646

        def mymapper(cls, tbl, **kwargs):

 

647

            m = sa.orm.mapper(cls, tbl, **kwargs)

 

648

            m.CHECK = True

 

649

            return m

 

650

 

 

651

        base = decl.declarative_base(mapper=mymapper)

 

652

 

 

653

        class Foo(base):

 

654

            __tablename__ = 'foo'

 

655

            id = Column(Integer, primary_key=True)

 

656

 

 

657

        eq_(Foo.__mapper__.CHECK, True)

636

658

 

637

659

    @testing.emits_warning('Ignoring declarative-like tuple value of '

638

660

                           'attribute id')

640

662

 

641

663

        def define():

642

664

 

643

 

            class User(Base, ComparableEntity):

 

665

            class User(Base, fixtures.ComparableEntity):

644

666

 

645

667

                __tablename__ = 'users'

646

668

                id = Column('id', Integer, primary_key=True),

652

674

                              'Mapper Mapper|User|users could not '

653

675

                              'assemble any primary key', define)

654

676

 

655

 

    def test_table_args_bad_format(self):

656

 

 

657

 

        def err():

658

 

            class Foo1(Base):

659

 

 

660

 

                __tablename__ = 'foo'

661

 

                __table_args__ = ForeignKeyConstraint(['id'], ['foo.id'

662

 

                        ]),

663

 

                id = Column('id', Integer, primary_key=True)

664

 

 

665

 

        assert_raises_message(sa.exc.ArgumentError,

666

 

                              'Tuple form of __table_args__ is ', err)

 

677

    def test_table_args_no_dict(self):

 

678

 

 

679

        class Foo1(Base):

 

680

 

 

681

            __tablename__ = 'foo'

 

682

            __table_args__ = ForeignKeyConstraint(['id'], ['foo.bar']),

 

683

            id = Column('id', Integer, primary_key=True)

 

684

            bar = Column('bar', Integer)

 

685

 

 

686

        assert Foo1.__table__.c.id.references(Foo1.__table__.c.bar)

667

687

 

668

688

    def test_table_args_type(self):

669

689

        def err():

715

735

 

716

736

    def test_expression(self):

717

737

 

718

 

        class User(Base, ComparableEntity):

 

738

        class User(Base, fixtures.ComparableEntity):

719

739

 

720

740

            __tablename__ = 'users'

721

741

            id = Column('id', Integer, primary_key=True,

723

743

            name = Column('name', String(50))

724

744

            addresses = relationship('Address', backref='user')

725

745

 

726

 

        class Address(Base, ComparableEntity):

 

746

        class Address(Base, fixtures.ComparableEntity):

727

747

 

728

748

            __tablename__ = 'addresses'

729

749

            id = Column('id', Integer, primary_key=True,

746

766

            addresses=[Address(email='one'), Address(email='two')])])

747

767

 

748

768

    def test_useless_declared_attr(self):

749

 

        class Address(Base, ComparableEntity):

 

769

        class Address(Base, fixtures.ComparableEntity):

750

770

 

751

771

            __tablename__ = 'addresses'

752

772

            id = Column('id', Integer, primary_key=True,

754

774

            email = Column('email', String(50))

755

775

            user_id = Column('user_id', Integer, ForeignKey('users.id'))

756

776

 

757

 

        class User(Base, ComparableEntity):

 

777

        class User(Base, fixtures.ComparableEntity):

758

778

 

759

779

            __tablename__ = 'users'

760

780

            id = Column('id', Integer, primary_key=True,

781

801

 

782

802

    def test_column(self):

783

803

 

784

 

        class User(Base, ComparableEntity):

 

804

        class User(Base, fixtures.ComparableEntity):

785

805

 

786

806

            __tablename__ = 'users'

787

807

            id = Column('id', Integer, primary_key=True,

802

822

 

803

823

    def test_column_properties(self):

804

824

 

805

 

        class Address(Base, ComparableEntity):

 

825

        class Address(Base, fixtures.ComparableEntity):

806

826

 

807

827

            __tablename__ = 'addresses'

808

828

            id = Column(Integer, primary_key=True,

810

830

            email = Column(String(50))

811

831

            user_id = Column(Integer, ForeignKey('users.id'))

812

832

 

813

 

        class User(Base, ComparableEntity):

 

833

        class User(Base, fixtures.ComparableEntity):

814

834

 

815

835

            __tablename__ = 'users'

816

836

            id = Column('id', Integer, primary_key=True,

833

853

 

834

854

    def test_column_properties_2(self):

835

855

 

836

 

        class Address(Base, ComparableEntity):

 

856

        class Address(Base, fixtures.ComparableEntity):

837

857

 

838

858

            __tablename__ = 'addresses'

839

859

            id = Column(Integer, primary_key=True)

840

860

            email = Column(String(50))

841

861

            user_id = Column(Integer, ForeignKey('users.id'))

842

862

 

843

 

        class User(Base, ComparableEntity):

 

863

        class User(Base, fixtures.ComparableEntity):

844

864

 

845

865

            __tablename__ = 'users'

846

866

            id = Column('id', Integer, primary_key=True)

857

877

 

858

878

    def test_deferred(self):

859

879

 

860

 

        class User(Base, ComparableEntity):

 

880

        class User(Base, fixtures.ComparableEntity):

861

881

 

862

882

            __tablename__ = 'users'

863

883

            id = Column(Integer, primary_key=True,

877

897

 

878

898

        self.assert_sql_count(testing.db, go, 1)

879

899

 

 

900

    def test_composite_inline(self):

 

901

        class AddressComposite(fixtures.ComparableEntity):

 

902

            def __init__(self, street, state):

 

903

                self.street = street

 

904

                self.state = state

 

905

            def __composite_values__(self):

 

906

                return [self.street, self.state]

 

907

 

 

908

        class User(Base, fixtures.ComparableEntity):

 

909

            __tablename__ = 'user'

 

910

            id = Column(Integer, primary_key=True, 

 

911

                            test_needs_autoincrement=True)

 

912

            address = composite(AddressComposite, 

 

913

                Column('street', String(50)),

 

914

                Column('state', String(2)),

 

915

            )

 

916

 

 

917

        Base.metadata.create_all()

 

918

        sess = Session()

 

919

        sess.add(User(

 

920

                address=AddressComposite('123 anywhere street', 

 

921

                                'MD')

 

922

                ))

 

923

        sess.commit()

 

924

        eq_(

 

925

            sess.query(User).all(), 

 

926

            [User(address=AddressComposite('123 anywhere street', 

 

927

                                'MD'))]

 

928

        )

 

929

 

 

930

    def test_composite_separate(self):

 

931

        class AddressComposite(fixtures.ComparableEntity):

 

932

            def __init__(self, street, state):

 

933

                self.street = street

 

934

                self.state = state

 

935

            def __composite_values__(self):

 

936

                return [self.street, self.state]

 

937

 

 

938

        class User(Base, fixtures.ComparableEntity):

 

939

            __tablename__ = 'user'

 

940

            id = Column(Integer, primary_key=True, 

 

941

                            test_needs_autoincrement=True)

 

942

            street = Column(String(50))

 

943

            state = Column(String(2))

 

944

            address = composite(AddressComposite, 

 

945

                street, state)

 

946

 

 

947

        Base.metadata.create_all()

 

948

        sess = Session()

 

949

        sess.add(User(

 

950

                address=AddressComposite('123 anywhere street', 

 

951

                                'MD')

 

952

                ))

 

953

        sess.commit()

 

954

        eq_(

 

955

            sess.query(User).all(), 

 

956

            [User(address=AddressComposite('123 anywhere street', 

 

957

                                'MD'))]

 

958

        )

 

959

 

 

960

    def test_mapping_to_join(self):

 

961

        users = Table('users', Base.metadata,

 

962

            Column('id', Integer, primary_key=True)

 

963

        )

 

964

        addresses = Table('addresses', Base.metadata,

 

965

            Column('id', Integer, primary_key=True),

 

966

            Column('user_id', Integer, ForeignKey('users.id'))

 

967

        )

 

968

        usersaddresses = sa.join(users, addresses, users.c.id

 

969

                                 == addresses.c.user_id)

 

970

        class User(Base):

 

971

            __table__ = usersaddresses

 

972

            __table_args__ = {'primary_key':[users.c.id]}

 

973

 

 

974

            # need to use column_property for now

 

975

            user_id = column_property(users.c.id, addresses.c.user_id)

 

976

            address_id = addresses.c.id

 

977

 

 

978

        assert User.__mapper__.get_property('user_id').columns[0] \

 

979

                                is users.c.id

 

980

        assert User.__mapper__.get_property('user_id').columns[1] \

 

981

                                is addresses.c.user_id

 

982

 

880

983

    def test_synonym_inline(self):

881

984

 

882

 

        class User(Base, ComparableEntity):

 

985

        class User(Base, fixtures.ComparableEntity):

883

986

 

884

987

            __tablename__ = 'users'

885

988

            id = Column('id', Integer, primary_key=True,

915

1018

            def __eq__(self, other):

916

1019

                return self.__clause_element__() == other + ' FOO'

917

1020

 

918

 

        class User(Base, ComparableEntity):

 

1021

        class User(Base, fixtures.ComparableEntity):

919

1022

 

920

1023

            __tablename__ = 'users'

921

1024

            id = Column('id', Integer, primary_key=True,

933

1036

 

934

1037

    def test_synonym_added(self):

935

1038

 

936

 

        class User(Base, ComparableEntity):

 

1039

        class User(Base, fixtures.ComparableEntity):

937

1040

 

938

1041

            __tablename__ = 'users'

939

1042

            id = Column('id', Integer, primary_key=True,

960

1063

 

961

1064

    def test_reentrant_compile_via_foreignkey(self):

962

1065

 

963

 

        class User(Base, ComparableEntity):

 

1066

        class User(Base, fixtures.ComparableEntity):

964

1067

 

965

1068

            __tablename__ = 'users'

966

1069

            id = Column('id', Integer, primary_key=True,

968

1071

            name = Column('name', String(50))

969

1072

            addresses = relationship('Address', backref='user')

970

1073

 

971

 

        class Address(Base, ComparableEntity):

 

1074

        class Address(Base, fixtures.ComparableEntity):

972

1075

 

973

1076

            __tablename__ = 'addresses'

974

1077

            id = Column('id', Integer, primary_key=True,

980

1083

        # the User.id inside the ForeignKey but this is no longer the

981

1084

        # case

982

1085

 

983

 

        sa.orm.compile_mappers()

984

 

        eq_(str(Address.user_id.property.columns[0].foreign_keys[0]),

 

1086

        sa.orm.configure_mappers()

 

1087

        eq_(str(list(Address.user_id.property.columns[0].foreign_keys)[0]),

985

1088

            "ForeignKey('users.id')")

986

1089

        Base.metadata.create_all()

987

1090

        u1 = User(name='u1', addresses=[Address(email='one'),

995

1098

 

996

1099

    def test_relationship_reference(self):

997

1100

 

998

 

        class Address(Base, ComparableEntity):

 

1101

        class Address(Base, fixtures.ComparableEntity):

999

1102

 

1000

1103

            __tablename__ = 'addresses'

1001

1104

            id = Column('id', Integer, primary_key=True,

1003

1106

            email = Column('email', String(50))

1004

1107

            user_id = Column('user_id', Integer, ForeignKey('users.id'))

1005

1108

 

1006

 

        class User(Base, ComparableEntity):

 

1109

        class User(Base, fixtures.ComparableEntity):

1007

1110

 

1008

1111

            __tablename__ = 'users'

1009

1112

            id = Column('id', Integer, primary_key=True,

1067

1170

 

1068

1171

    def test_synonym_for(self):

1069

1172

 

1070

 

        class User(Base, ComparableEntity):

 

1173

        class User(Base, fixtures.ComparableEntity):

1071

1174

 

1072

1175

            __tablename__ = 'users'

1073

1176

            id = Column('id', Integer, primary_key=True,

1107

1210

                ):

1108

1211

                return op(self.upperself, other, **kw)

1109

1212

 

1110

 

        class User(Base, ComparableEntity):

 

1213

        class User(Base, fixtures.ComparableEntity):

1111

1214

 

1112

1215

            __tablename__ = 'users'

1113

1216

            id = Column('id', Integer, primary_key=True,

1169

1272

        assert 'inherits' not in Person.__mapper_args__

1170

1273

        assert class_mapper(Engineer).polymorphic_identity is None

1171

1274

        assert class_mapper(Engineer).polymorphic_on is Person.__table__.c.type

1172

 

        

 

1275

 

1173

1276

    def test_we_must_only_copy_column_mapper_args(self):

1174

1277

 

1175

1278

        class Person(Base):

1189

1292

                               }

1190

1293

        assert class_mapper(Person).version_id_col == 'a'

1191

1294

        assert class_mapper(Person).include_properties == set(['id', 'a', 'b'])

1192

 

        

1193

 

        

 

1295

 

 

1296

 

1194

1297

    def test_custom_join_condition(self):

1195

1298

 

1196

1299

        class Foo(Base):

1207

1310

 

1208

1311

        # compile succeeds because inherit_condition is honored

1209

1312

 

1210

 

        compile_mappers()

 

1313

        configure_mappers()

1211

1314

 

1212

1315

    def test_joined(self):

1213

1316

 

1214

 

        class Company(Base, ComparableEntity):

 

1317

        class Company(Base, fixtures.ComparableEntity):

1215

1318

 

1216

1319

            __tablename__ = 'companies'

1217

1320

            id = Column('id', Integer, primary_key=True,

1219

1322

            name = Column('name', String(50))

1220

1323

            employees = relationship('Person')

1221

1324

 

1222

 

        class Person(Base, ComparableEntity):

 

1325

        class Person(Base, fixtures.ComparableEntity):

1223

1326

 

1224

1327

            __tablename__ = 'people'

1225

1328

            id = Column('id', Integer, primary_key=True,

1264

1367

            any(Engineer.primary_language

1265

1368

            == 'cobol')).first(), c2)

1266

1369

 

1267

 

        # ensure that the Manager mapper was compiled with the Person id

1268

 

        # column as higher priority. this ensures that "id" will get

1269

 

        # loaded from the Person row and not the possibly non-present

1270

 

        # Manager row

 

1370

        # ensure that the Manager mapper was compiled with the Manager id

 

1371

        # column as higher priority. this ensures that "Manager.id" 

 

1372

        # is appropriately treated as the "id" column in the "manager"

 

1373

        # table (reversed from 0.6's behavior.)

1271

1374

 

1272

 

        assert Manager.id.property.columns == [Person.__table__.c.id,

1273

 

                Manager.__table__.c.id]

 

1375

        assert Manager.id.property.columns == [Manager.__table__.c.id, Person.__table__.c.id]

1274

1376

 

1275

1377

        # assert that the "id" column is available without a second

1276

 

        # load. this would be the symptom of the previous step not being

1277

 

        # correct.

 

1378

        # load. as of 0.7, the ColumnProperty tests all columns

 

1379

        # in it's list to see which is present in the row.

1278

1380

 

1279

1381

        sess.expunge_all()

1280

1382

 

1281

1383

        def go():

1282

1384

            assert sess.query(Manager).filter(Manager.name == 'dogbert'

1283

1385

                    ).one().id

1284

 

 

1285

1386

        self.assert_sql_count(testing.db, go, 1)

1286

1387

        sess.expunge_all()

1287

1388

 

1293

1394

 

1294

1395

    def test_add_subcol_after_the_fact(self):

1295

1396

 

1296

 

        class Person(Base, ComparableEntity):

 

1397

        class Person(Base, fixtures.ComparableEntity):

1297

1398

 

1298

1399

            __tablename__ = 'people'

1299

1400

            id = Column('id', Integer, primary_key=True,

1322

1423

 

1323

1424

    def test_add_parentcol_after_the_fact(self):

1324

1425

 

1325

 

        class Person(Base, ComparableEntity):

 

1426

        class Person(Base, fixtures.ComparableEntity):

1326

1427

 

1327

1428

            __tablename__ = 'people'

1328

1429

            id = Column('id', Integer, primary_key=True,

1350

1451

 

1351

1452

    def test_add_sub_parentcol_after_the_fact(self):

1352

1453

 

1353

 

        class Person(Base, ComparableEntity):

 

1454

        class Person(Base, fixtures.ComparableEntity):

1354

1455

 

1355

1456

            __tablename__ = 'people'

1356

1457

            id = Column('id', Integer, primary_key=True,

1387

1488

 

1388

1489

    def test_subclass_mixin(self):

1389

1490

 

1390

 

        class Person(Base, ComparableEntity):

 

1491

        class Person(Base, fixtures.ComparableEntity):

1391

1492

 

1392

1493

            __tablename__ = 'people'

1393

1494

            id = Column('id', Integer, primary_key=True)

1414

1515

        """Test that foreign keys that reference a literal 'id' subclass 

1415

1516

        'id' attribute behave intuitively.

1416

1517

 

1417

 

        See ticket 1892.

 

1518

        See [ticket:1892].

1418

1519

 

1419

1520

        """

 

1521

 

1420

1522

        class Booking(Base):

1421

1523

            __tablename__ = 'booking'

1422

1524

            id = Column(Integer, primary_key=True)

1473

1575

            related_child1 = Column('c1', Integer)

1474

1576

            __mapper_args__ = dict(polymorphic_identity='child2')

1475

1577

 

1476

 

        sa.orm.compile_mappers()  # no exceptions here

 

1578

        sa.orm.configure_mappers()  # no exceptions here

 

1579

 

 

1580

    def test_foreign_keys_with_col(self):

 

1581

        """Test that foreign keys that reference a literal 'id' subclass 

 

1582

        'id' attribute behave intuitively.

 

1583

 

 

1584

        See [ticket:1892].

 

1585

 

 

1586

        """

 

1587

 

 

1588

        class Booking(Base):

 

1589

            __tablename__ = 'booking'

 

1590

            id = Column(Integer, primary_key=True)

 

1591

 

 

1592

        class PlanBooking(Booking):

 

1593

            __tablename__ = 'plan_booking'

 

1594

            id = Column(Integer, ForeignKey(Booking.id),

 

1595

                            primary_key=True)

 

1596

 

 

1597

        # referencing PlanBooking.id gives us the column

 

1598

        # on plan_booking, not booking

 

1599

        class FeatureBooking(Booking):

 

1600

            __tablename__ = 'feature_booking'

 

1601

            id = Column(Integer, ForeignKey(Booking.id),

 

1602

                                        primary_key=True)

 

1603

            plan_booking_id = Column(Integer,

 

1604

                                ForeignKey(PlanBooking.id))

 

1605

 

 

1606

            plan_booking = relationship(PlanBooking,

 

1607

                        backref='feature_bookings')

 

1608

 

 

1609

        assert FeatureBooking.__table__.c.plan_booking_id.\

 

1610

                    references(PlanBooking.__table__.c.id)

 

1611

 

 

1612

        assert FeatureBooking.__table__.c.id.\

 

1613

                    references(Booking.__table__.c.id)

 

1614

 

1477

1615

 

1478

1616

    def test_single_colsonbase(self):

1479

1617

        """test single inheritance where all the columns are on the base

1480

1618

        class."""

1481

1619

 

1482

 

        class Company(Base, ComparableEntity):

 

1620

        class Company(Base, fixtures.ComparableEntity):

1483

1621

 

1484

1622

            __tablename__ = 'companies'

1485

1623

            id = Column('id', Integer, primary_key=True,

1487

1625

            name = Column('name', String(50))

1488

1626

            employees = relationship('Person')

1489

1627

 

1490

 

        class Person(Base, ComparableEntity):

 

1628

        class Person(Base, fixtures.ComparableEntity):

1491

1629

 

1492

1630

            __tablename__ = 'people'

1493

1631

            id = Column('id', Integer, primary_key=True,

1536

1674

 

1537

1675

        """

1538

1676

 

1539

 

        class Company(Base, ComparableEntity):

 

1677

        class Company(Base, fixtures.ComparableEntity):

1540

1678

 

1541

1679

            __tablename__ = 'companies'

1542

1680

            id = Column('id', Integer, primary_key=True,

1544

1682

            name = Column('name', String(50))

1545

1683

            employees = relationship('Person')

1546

1684

 

1547

 

        class Person(Base, ComparableEntity):

 

1685

        class Person(Base, fixtures.ComparableEntity):

1548

1686

 

1549

1687

            __tablename__ = 'people'

1550

1688

            id = Column(Integer, primary_key=True,

1602

1740

 

1603

1741

    def test_joined_from_single(self):

1604

1742

 

1605

 

        class Company(Base, ComparableEntity):

 

1743

        class Company(Base, fixtures.ComparableEntity):

1606

1744

 

1607

1745

            __tablename__ = 'companies'

1608

1746

            id = Column('id', Integer, primary_key=True,

1610

1748

            name = Column('name', String(50))

1611

1749

            employees = relationship('Person')

1612

1750

 

1613

 

        class Person(Base, ComparableEntity):

 

1751

        class Person(Base, fixtures.ComparableEntity):

1614

1752

 

1615

1753

            __tablename__ = 'people'

1616

1754

            id = Column(Integer, primary_key=True,

1665

1803

 

1666

1804

    def test_add_deferred(self):

1667

1805

 

1668

 

        class Person(Base, ComparableEntity):

 

1806

        class Person(Base, fixtures.ComparableEntity):

1669

1807

 

1670

1808

            __tablename__ = 'people'

1671

1809

            id = Column('id', Integer, primary_key=True,

1690

1828

 

1691

1829

        """

1692

1830

 

1693

 

        class Person(Base, ComparableEntity):

 

1831

        class Person(Base, fixtures.ComparableEntity):

1694

1832

 

1695

1833

            __tablename__ = 'people'

1696

1834

            id = Column(Integer, primary_key=True,

1706

1844

                    ForeignKey('languages.id'))

1707

1845

            primary_language = relationship('Language')

1708

1846

 

1709

 

        class Language(Base, ComparableEntity):

 

1847

        class Language(Base, fixtures.ComparableEntity):

1710

1848

 

1711

1849

            __tablename__ = 'languages'

1712

1850

            id = Column(Integer, primary_key=True,

1742

1880

 

1743

1881

    def test_single_three_levels(self):

1744

1882

 

1745

 

        class Person(Base, ComparableEntity):

 

1883

        class Person(Base, fixtures.ComparableEntity):

1746

1884

 

1747

1885

            __tablename__ = 'people'

1748

1886

            id = Column(Integer, primary_key=True)

1816

1954

 

1817

1955

    def test_single_no_special_cols(self):

1818

1956

 

1819

 

        class Person(Base, ComparableEntity):

 

1957

        class Person(Base, fixtures.ComparableEntity):

1820

1958

 

1821

1959

            __tablename__ = 'people'

1822

1960

            id = Column('id', Integer, primary_key=True)

1838

1976

 

1839

1977

    def test_single_no_table_args(self):

1840

1978

 

1841

 

        class Person(Base, ComparableEntity):

 

1979

        class Person(Base, fixtures.ComparableEntity):

1842

1980

 

1843

1981

            __tablename__ = 'people'

1844

1982

            id = Column('id', Integer, primary_key=True)

1863

2001

        assert_raises_message(sa.exc.ArgumentError,

1864

2002

                              'place __table_args__', go)

1865

2003

 

 

2004

    @testing.emits_warning("The classname")

 

2005

    def test_dupe_name_in_hierarchy(self):

 

2006

        class A(Base):

 

2007

           __tablename__ = "a"

 

2008

           id = Column( Integer, primary_key=True)

 

2009

        a_1 = A

 

2010

        class A(a_1):

 

2011

           __tablename__ = 'b'

 

2012

 

 

2013

           id = Column(Integer(),ForeignKey(a_1.id), primary_key = True)

 

2014

 

 

2015

        assert A.__mapper__.inherits is a_1.__mapper__

 

2016

 

1866

2017

    def test_concrete(self):

1867

2018

        engineers = Table('engineers', Base.metadata, Column('id',

1868

2019

                          Integer, primary_key=True,

1876

2027

        punion = polymorphic_union({'engineer': engineers, 'manager'

1877

2028

                                   : managers}, 'type', 'punion')

1878

2029

 

1879

 

        class Person(Base, ComparableEntity):

 

2030

        class Person(Base, fixtures.ComparableEntity):

1880

2031

 

1881

2032

            __table__ = punion

1882

2033

            __mapper_args__ = {'polymorphic_on': punion.c.type}

1909

2060

    def test_concrete_inline_non_polymorphic(self):

1910

2061

        """test the example from the declarative docs."""

1911

2062

 

1912

 

        class Person(Base, ComparableEntity):

 

2063

        class Person(Base, fixtures.ComparableEntity):

1913

2064

 

1914

2065

            __tablename__ = 'people'

1915

2066

            id = Column(Integer, primary_key=True,

1950

2101

 

1951

2102

def _produce_test(inline, stringbased):

1952

2103

 

1953

 

    class ExplicitJoinTest(MappedTest):

 

2104

    class ExplicitJoinTest(fixtures.MappedTest):

1954

2105

 

1955

2106

        @classmethod

1956

2107

        def define_tables(cls, metadata):

1957

2108

            global User, Address

1958

2109

            Base = decl.declarative_base(metadata=metadata)

1959

2110

 

1960

 

            class User(Base, ComparableEntity):

 

2111

            class User(Base, fixtures.ComparableEntity):

1961

2112

 

1962

2113

                __tablename__ = 'users'

1963

2114

                id = Column(Integer, primary_key=True,

1964

2115

                            test_needs_autoincrement=True)

1965

2116

                name = Column(String(50))

1966

2117

 

1967

 

            class Address(Base, ComparableEntity):

 

2118

            class Address(Base, fixtures.ComparableEntity):

1968

2119

 

1969

2120

                __tablename__ = 'addresses'

1970

2121

                id = Column(Integer, primary_key=True,

1981

2132

                                == user_id, backref='addresses')

1982

2133

 

1983

2134

            if not inline:

1984

 

                compile_mappers()

 

2135

                configure_mappers()

1985

2136

                if stringbased:

1986

2137

                    Address.user = relationship('User',

1987

2138

                            primaryjoin='User.id==Address.user_id',

2030

2181

        exec '%s = testclass' % testclass.__name__

2031

2182

        del testclass

2032

2183

 

2033

 

class DeclarativeReflectionTest(testing.TestBase):

 

2184

class DeclarativeReflectionTest(fixtures.TestBase):

2034

2185

 

2035

2186

    @classmethod

2036

2187

    def setup_class(cls):

2075

2226

    def test_basic(self):

2076

2227

        meta = MetaData(testing.db)

2077

2228

 

2078

 

        class User(Base, ComparableEntity):

 

2229

        class User(Base, fixtures.ComparableEntity):

2079

2230

 

2080

2231

            __tablename__ = 'users'

2081

2232

            __autoload__ = True

2084

2235

                            test_needs_autoincrement=True)

2085

2236

            addresses = relationship('Address', backref='user')

2086

2237

 

2087

 

        class Address(Base, ComparableEntity):

 

2238

        class Address(Base, fixtures.ComparableEntity):

2088

2239

 

2089

2240

            __tablename__ = 'addresses'

2090

2241

            __autoload__ = True

2107

2258

    def test_rekey(self):

2108

2259

        meta = MetaData(testing.db)

2109

2260

 

2110

 

        class User(Base, ComparableEntity):

 

2261

        class User(Base, fixtures.ComparableEntity):

2111

2262

 

2112

2263

            __tablename__ = 'users'

2113

2264

            __autoload__ = True

2117

2268

            nom = Column('name', String(50), key='nom')

2118

2269

            addresses = relationship('Address', backref='user')

2119

2270

 

2120

 

        class Address(Base, ComparableEntity):

 

2271

        class Address(Base, fixtures.ComparableEntity):

2121

2272

 

2122

2273

            __tablename__ = 'addresses'

2123

2274

            __autoload__ = True

2141

2292

    def test_supplied_fk(self):

2142

2293

        meta = MetaData(testing.db)

2143

2294

 

2144

 

        class IMHandle(Base, ComparableEntity):

 

2295

        class IMHandle(Base, fixtures.ComparableEntity):

2145

2296

 

2146

2297

            __tablename__ = 'imhandles'

2147

2298

            __autoload__ = True

2150

2301

                            test_needs_autoincrement=True)

2151

2302

            user_id = Column('user_id', Integer, ForeignKey('users.id'))

2152

2303

 

2153

 

        class User(Base, ComparableEntity):

 

2304

        class User(Base, fixtures.ComparableEntity):

2154

2305

 

2155

2306

            __tablename__ = 'users'

2156

2307

            __autoload__ = True

2473

2624

        of the superclass checks that the superclass property is a column.

2474

2625

 

2475

2626

        """

 

2627

 

2476

2628

        class General(Base):

2477

2629

            __tablename__ = 'test'

2478

2630

            id = Column(Integer, primary_key=True)

2492

2644

        of the superclass checks that the subclass property is a column.

2493

2645

 

2494

2646

        """

 

2647

 

2495

2648

        def go():

2496

2649

            class General(Base):

2497

2650

                __tablename__ = 'test'

2537

2690

        class Engineer(Person):

2538

2691

            pass

2539

2692

 

2540

 

        compile_mappers()

 

2693

        configure_mappers()

2541

2694

        assert class_mapper(Person).polymorphic_on \

2542

2695

            is Person.__table__.c.type

2543

2696

        eq_(class_mapper(Engineer).polymorphic_identity, 'Engineer')

2564

2717

        class Engineer(Person, ComputedMapperArgs):

2565

2718

            pass

2566

2719

 

2567

 

        compile_mappers()

 

2720

        configure_mappers()

2568

2721

        assert class_mapper(Person).polymorphic_on \

2569

2722

            is Person.__table__.c.type

2570

2723

        eq_(class_mapper(Engineer).polymorphic_identity, 'Engineer')

3023

3176

        eq_(Model.__table__.c.keys(), ['col1', 'col3', 'col2', 'col4',

3024

3177

            'id'])

3025

3178

 

 

3179

    def test_honor_class_mro_one(self):

 

3180

        class HasXMixin(object):

 

3181

            @declared_attr

 

3182

            def x(self):

 

3183

                return Column(Integer)

 

3184

 

 

3185

        class Parent(HasXMixin, Base):

 

3186

            __tablename__ = 'parent'

 

3187

            id = Column(Integer, primary_key=True)

 

3188

 

 

3189

        class Child(Parent):

 

3190

            __tablename__ = 'child'

 

3191

            id = Column(Integer, ForeignKey('parent.id'), primary_key=True)

 

3192

 

 

3193

        assert "x" not in Child.__table__.c

 

3194

 

 

3195

    def test_honor_class_mro_two(self):

 

3196

        class HasXMixin(object):

 

3197

            @declared_attr

 

3198

            def x(self):

 

3199

                return Column(Integer)

 

3200

 

 

3201

        class Parent(HasXMixin, Base):

 

3202

            __tablename__ = 'parent'

 

3203

            id = Column(Integer, primary_key=True)

 

3204

            def x(self):

 

3205

                return "hi"

 

3206

 

 

3207

        class C(Parent):

 

3208

            __tablename__ = 'c'

 

3209

            id = Column(Integer, ForeignKey('parent.id'), primary_key=True)

 

3210

 

 

3211

        assert C().x() == 'hi'

 

3212

 

 

3213

 

3026

3214

class DeclarativeMixinPropertyTest(DeclarativeTestBase):

3027

3215

 

3028

3216

    def test_column_property(self):

3092

3280

            __tablename__ = 'test'

3093

3281

            id = Column(Integer, primary_key=True)

3094

3282

 

3095

 

        compile_mappers()

 

3283

        configure_mappers()

3096

3284

        eq_(MyModel.type_.__doc__, """this is a document.""")

3097

3285

        eq_(MyModel.t2.__doc__, """this is another document.""")

3098

3286

 

3110

3298

            __tablename__ = 'test'

3111

3299

            id = Column(Integer, primary_key=True)

3112

3300

 

3113

 

        compile_mappers()

 

3301

        configure_mappers()

3114

3302

        col = MyModel.__mapper__.polymorphic_on

3115

3303

        eq_(col.name, 'type_')

3116

3304

        assert col.table is not None

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1