~ubuntu-branches/ubuntu/vivid/ruby-sequel/vivid : revision 10

14

@c2 = Tag

15

@dataset = @c2.dataset

16

@dataset._fetch = {:id=>1}

17

MODEL_DB.reset

17

DB.reset

18

end

19

after do

20

Object.send(:remove_const, :Artist)

41

@c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :left_primary_key=>:id3

42

a = @c1.eager(:tags).all

43

a.should == [@c1.load(:id => 1)]

44

MODEL_DB.sqls.should == ['SELECT * FROM artists', "SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (3)))"]

44

DB.sqls.should == ['SELECT * FROM artists', "SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (3)))"]

45

a.first.tags.should == [@c2.load(:id=>4)]

46

MODEL_DB.sqls.should == []

46

DB.sqls.should == []

47

end

48

49

it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup" do

52

@c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_loading_predicate_key=>Sequel./(:albums_artists__artist_id, 3)

53

a = @c1.eager(:tags).all

54

a.should == [@c1.load(:id => 1)]

55

MODEL_DB.sqls.should == ['SELECT * FROM artists', "SELECT tags.*, (albums_artists.artist_id / 3) AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND ((albums_artists.artist_id / 3) IN (1)))"]

55

DB.sqls.should == ['SELECT * FROM artists', "SELECT tags.*, (albums_artists.artist_id / 3) AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND ((albums_artists.artist_id / 3) IN (1)))"]

56

a.first.tags.should == [@c2.load(:id=>4)]

57

end

58

244

end

245

246

it "should support an array for the select option" do

247

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>[:tags.*, :albums__name]

247

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>[Sequel::SQL::ColumnAll.new(:tags), :albums__name]

248

n = @c1.load(:id => 1234)

249

n.tags_dataset.sql.should == 'SELECT tags.*, albums.name FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'

250

n.tags.should == [@c2.load(:id=>1)]

294

it "should provide an array with all members of the association" do

295

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]

296

@c1.load(:id => 1234).tags.should == [@c2.load(:id=>1)]

297

MODEL_DB.sqls.should == ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))']

297

DB.sqls.should == ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))']

298

end

299

300

it "should set cached instance variable when accessed" do

300

it "should populate cache when accessed" do

301

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]

302

n = @c1.load(:id => 1234)

303

n.associations[:tags].should == nil

304

MODEL_DB.sqls.should == []

304

DB.sqls.should == []

305

n.tags.should == [@c2.load(:id=>1)]

306

MODEL_DB.sqls.should == ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))']

306

DB.sqls.should == ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))']

307

n.associations[:tags].should == n.tags

308

MODEL_DB.sqls.length.should == 0

308

DB.sqls.length.should == 0

309

end

310

311

it "should use cached instance variable if available" do

311

it "should use cache if available" do

312

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]

313

n = @c1.load(:id => 1234)

314

n.associations[:tags] = []

315

n.tags.should == []

316

MODEL_DB.sqls.should == []

316

DB.sqls.should == []

317

end

318

319

it "should not use cached instance variable if asked to reload" do

319

it "should not use cache if asked to reload" do

320

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]

321

n = @c1.load(:id => 1234)

322

n.associations[:tags] = []

323

MODEL_DB.sqls.should == []

323

DB.sqls.should == []

324

n.tags(true).should == [@c2.load(:id=>1)]

325

MODEL_DB.sqls.should == ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))']

325

DB.sqls.should == ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))']

326

n.associations[:tags].should == n.tags

327

MODEL_DB.sqls.length.should == 0

327

DB.sqls.length.should == 0

328

end

329

330

it "should not add associations methods directly to class" do

354

end

355

356

it "should support a :uniq option that removes duplicates from the association" do

357

h = []

358

357

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :uniq=>true

359

358

@c2.dataset._fetch = [{:id=>20}, {:id=>30}, {:id=>20}, {:id=>30}]

360

359

@c1.load(:id=>10).tags.should == [@c2.load(:id=>20), @c2.load(:id=>30)]

369

368

end

370

369

class ::Tag < Sequel::Model

371

370

end

372

MODEL_DB.reset

371

DB.reset

373

372

@ar = Artist.association_reflection(:tags)

374

373

end

375

374

after do

453

452

end

454

453

455

454

@c1 = Artist

456

MODEL_DB.reset

455

DB.reset

457

456

end

458

457

after do

459

458

[:Artist, :Tag, :Album, :Track].each{|x| Object.send(:remove_const, x)}

462

461

it "should eagerly load a single many_through_many association" do

463

462

a = @c1.eager(:tags).all

464

463

a.should == [@c1.load(:id=>1)]

465

MODEL_DB.sqls.should == ['SELECT * FROM artists', 'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']

464

DB.sqls.should == ['SELECT * FROM artists', 'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']

466

465

a.first.tags.should == [Tag.load(:id=>2)]

467

MODEL_DB.sqls.length.should == 0

466

DB.sqls.length.should == 0

468

467

end

469

468

470

469

it "should eagerly load multiple associations in a single call" do

471

470

a = @c1.eager(:tags, :albums).all

472

471

a.should == [@c1.load(:id=>1)]

473

sqls = MODEL_DB.sqls

472

sqls = DB.sqls

474

473

sqls.length.should == 3

475

474

sqls[0].should == 'SELECT * FROM artists'

476

475

sqls[1..-1].should(include('SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))'))

478

477

a = a.first

479

478

a.tags.should == [Tag.load(:id=>2)]

480

479

a.albums.should == [Album.load(:id=>3)]

481

MODEL_DB.sqls.length.should == 0

480

DB.sqls.length.should == 0

482

481

end

483

482

484

483

it "should eagerly load multiple associations in separate" do

485

484

a = @c1.eager(:tags).eager(:albums).all

486

485

a.should == [@c1.load(:id=>1)]

487

sqls = MODEL_DB.sqls

486

sqls = DB.sqls

488

487

sqls.length.should == 3

489

488

sqls[0].should == 'SELECT * FROM artists'

490

489

sqls[1..-1].should(include('SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))'))

492

491

a = a.first

493

492

a.tags.should == [Tag.load(:id=>2)]

494

493

a.albums.should == [Album.load(:id=>3)]

495

MODEL_DB.sqls.length.should == 0

494

DB.sqls.length.should == 0

496

495

end

497

496

498

497

it "should allow cascading of eager loading for associations of associated models" do

499

498

a = @c1.eager(:tags=>:tracks).all

500

499

a.should == [@c1.load(:id=>1)]

501

MODEL_DB.sqls.should == ['SELECT * FROM artists',

500

DB.sqls.should == ['SELECT * FROM artists',

502

501

'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))',

503

502

'SELECT tracks.*, albums_tags.tag_id AS x_foreign_key_x FROM tracks INNER JOIN albums ON (albums.id = tracks.album_id) INNER JOIN albums_tags ON ((albums_tags.album_id = albums.id) AND (albums_tags.tag_id IN (2)))']

504

503

a = a.first

505

504

a.tags.should == [Tag.load(:id=>2)]

506

505

a.tags.first.tracks.should == [Track.load(:id=>4)]

507

MODEL_DB.sqls.length.should == 0

506

DB.sqls.length.should == 0

508

507

end

509

508

510

509

it "should cascade eagerly loading when the :eager association option is used" do

511

510

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager=>:tracks

512

511

a = @c1.eager(:tags).all

513

512

a.should == [@c1.load(:id=>1)]

514

MODEL_DB.sqls.should == ['SELECT * FROM artists',

513

DB.sqls.should == ['SELECT * FROM artists',

515

514

'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))',

516

515

'SELECT tracks.*, albums_tags.tag_id AS x_foreign_key_x FROM tracks INNER JOIN albums ON (albums.id = tracks.album_id) INNER JOIN albums_tags ON ((albums_tags.album_id = albums.id) AND (albums_tags.tag_id IN (2)))']

517

516

a = a.first

518

517

a.tags.should == [Tag.load(:id=>2)]

519

518

a.tags.first.tracks.should == [Track.load(:id=>4)]

520

MODEL_DB.sqls.length.should == 0

519

DB.sqls.length.should == 0

521

520

end

522

521

523

522

it "should respect :eager when lazily loading an association" do

524

523

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager=>:tracks

525

524

a = @c1.load(:id=>1)

526

525

a.tags.should == [Tag.load(:id=>2)]

527

MODEL_DB.sqls.should == ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1))',

526

DB.sqls.should == ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1))',

528

527

'SELECT tracks.*, albums_tags.tag_id AS x_foreign_key_x FROM tracks INNER JOIN albums ON (albums.id = tracks.album_id) INNER JOIN albums_tags ON ((albums_tags.album_id = albums.id) AND (albums_tags.tag_id IN (2)))']

529

528

a.tags.first.tracks.should == [Track.load(:id=>4)]

530

MODEL_DB.sqls.length.should == 0

529

DB.sqls.length.should == 0

531

530

end

532

531

533

it "should cascade eagerly loading when the :eager_graph association option is used" do

532

it "should raise error if attempting to eagerly load an association using :eager_graph option" do

534

533

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_graph=>:tracks

535

534

proc{@c1.eager(:tags).all}.should raise_error(Sequel::Error)

536

535

end

545

544

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_graph=>:tracks

546

545

a = @c1.load(:id=>1)

547

546

a.tags

548

MODEL_DB.sqls.should == [ 'SELECT tags.id, tracks.id AS tracks_id FROM (SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1))) AS tags LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums ON (albums.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)']

547

DB.sqls.should == [ 'SELECT tags.id, tracks.id AS tracks_id FROM (SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1))) AS tags LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums ON (albums.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)']

549

548

a.tags.should == [Tag.load(:id=>2)]

550

549

a.tags.first.tracks.should == [Track.load(:id=>4)]

551

MODEL_DB.sqls.length.should == 0

550

DB.sqls.length.should == 0

552

551

end

553

552

554

553

it "should respect :conditions when eagerly loading" do

555

554

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :conditions=>{:a=>32}

556

555

a = @c1.eager(:tags).all

557

556

a.should == [@c1.load(:id=>1)]

558

MODEL_DB.sqls.should == ['SELECT * FROM artists',

557

DB.sqls.should == ['SELECT * FROM artists',

559

558

'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) WHERE (a = 32)']

560

559

a.first.tags.should == [Tag.load(:id=>2)]

561

MODEL_DB.sqls.length.should == 0

560

DB.sqls.length.should == 0

562

561

end

563

562

564

563

it "should respect :order when eagerly loading" do

565

564

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :order=>:blah

566

565

a = @c1.eager(:tags).all

567

566

a.should == [@c1.load(:id=>1)]

568

MODEL_DB.sqls.should == ['SELECT * FROM artists',

567

DB.sqls.should == ['SELECT * FROM artists',

569

568

'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) ORDER BY blah']

570

569

a.first.tags.should == [Tag.load(:id=>2)]

571

MODEL_DB.sqls.length.should == 0

570

DB.sqls.length.should == 0

572

571

end

573

572

574

573

it "should use the association's block when eager loading by default" do

575

574

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]] do |ds| ds.filter(:a) end

576

575

a = @c1.eager(:tags).all

577

576

a.should == [@c1.load(:id=>1)]

578

MODEL_DB.sqls.should == ['SELECT * FROM artists',

577

DB.sqls.should == ['SELECT * FROM artists',

579

578

'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) WHERE a']

580

579

a.first.tags.should == [Tag.load(:id=>2)]

581

MODEL_DB.sqls.length.should == 0

580

DB.sqls.length.should == 0

582

581

end

583

582

584

583

it "should use the :eager_block option when eager loading if given" do

585

584

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_block=>proc{|ds| ds.filter(:b)} do |ds| ds.filter(:a) end

586

585

a = @c1.eager(:tags).all

587

586

a.should == [@c1.load(:id=>1)]

588

MODEL_DB.sqls.should == ['SELECT * FROM artists',

587

DB.sqls.should == ['SELECT * FROM artists',

589

588

'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) WHERE b']

590

589

a.first.tags.should == [Tag.load(:id=>2)]

591

MODEL_DB.sqls.length.should == 0

590

DB.sqls.length.should == 0

592

591

end

593

592

594

593

it "should respect the :limit option on a many_through_many association" do

596

595

Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>5},{:x_foreign_key_x=>1, :id=>6}, {:x_foreign_key_x=>1, :id=>7}]

597

596

a = @c1.eager(:first_two_tags).all

598

597

a.should == [@c1.load(:id=>1)]

599

MODEL_DB.sqls.should == ['SELECT * FROM artists',

598

DB.sqls.should == ['SELECT * FROM artists',

600

599

'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']

601

600

a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]

602

MODEL_DB.sqls.length.should == 0

603

604

@c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1]

605

a = @c1.eager(:first_two_tags).all

606

a.should == [@c1.load(:id=>1)]

607

MODEL_DB.sqls.should == ['SELECT * FROM artists',

601

DB.sqls.length.should == 0

602

603

@c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[1,1]

604

a = @c1.eager(:first_two_tags).all

605

a.should == [@c1.load(:id=>1)]

606

DB.sqls.should == ['SELECT * FROM artists',

607

'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']

608

a.first.first_two_tags.should == [Tag.load(:id=>6)]

609

DB.sqls.length.should == 0

610

611

@c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[nil,1]

612

a = @c1.eager(:first_two_tags).all

613

a.should == [@c1.load(:id=>1)]

614

DB.sqls.should == ['SELECT * FROM artists',

608

615

'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']

609

616

a.first.first_two_tags.should == [Tag.load(:id=>6), Tag.load(:id=>7)]

610

MODEL_DB.sqls.length.should == 0

617

DB.sqls.length.should == 0

611

618

end

612

619

613

620

it "should respect the :limit option on a many_through_many association using a :window_function strategy" do

614

621

Tag.dataset.meta_def(:supports_window_functions?){true}

615

@c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :eager_limit_strategy=>true, :order=>:name

622

@c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :order=>:name

616

623

Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>5},{:x_foreign_key_x=>1, :id=>6}]

617

624

a = @c1.eager(:first_two_tags).all

618

625

a.should == [@c1.load(:id=>1)]

619

MODEL_DB.sqls.should == ['SELECT * FROM artists',

626

DB.sqls.should == ['SELECT * FROM artists',

620

627

'SELECT * FROM (SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x, row_number() OVER (PARTITION BY albums_artists.artist_id ORDER BY name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))) AS t1 WHERE (x_sequel_row_number_x <= 2)']

621

628

a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]

622

MODEL_DB.sqls.length.should == 0

629

DB.sqls.length.should == 0

623

630

624

@c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1], :eager_limit_strategy=>true, :order=>:name

631

@c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1], :order=>:name

625

632

a = @c1.eager(:first_two_tags).all

626

633

a.should == [@c1.load(:id=>1)]

627

MODEL_DB.sqls.should == ['SELECT * FROM artists',

634

DB.sqls.should == ['SELECT * FROM artists',

628

635

'SELECT * FROM (SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x, row_number() OVER (PARTITION BY albums_artists.artist_id ORDER BY name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))) AS t1 WHERE ((x_sequel_row_number_x >= 2) AND (x_sequel_row_number_x < 4))']

629

636

a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]

630

MODEL_DB.sqls.length.should == 0

637

DB.sqls.length.should == 0

638

639

@c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[nil,1], :order=>:name

640

a = @c1.eager(:first_two_tags).all

641

a.should == [@c1.load(:id=>1)]

642

DB.sqls.should == ['SELECT * FROM artists',

643

'SELECT * FROM (SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x, row_number() OVER (PARTITION BY albums_artists.artist_id ORDER BY name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))) AS t1 WHERE (x_sequel_row_number_x >= 2)']

644

a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]

645

DB.sqls.length.should == 0

631

646

end

632

647

633

648

it "should respect the :limit option on a many_through_many association with composite primary keys on the main table using a :window_function strategy" do

634

649

Tag.dataset.meta_def(:supports_window_functions?){true}

635

650

@c1.set_primary_key([:id1, :id2])

636

651

@c1.columns :id1, :id2

637

@c1.many_through_many :first_two_tags, [[:albums_artists, [:artist_id1, :artist_id2], :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :eager_limit_strategy=>true, :order=>:name

652

@c1.many_through_many :first_two_tags, [[:albums_artists, [:artist_id1, :artist_id2], :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :order=>:name

638

653

@c1.dataset._fetch = [{:id1=>1, :id2=>2}]

639

654

Tag.dataset._fetch = [{:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>5}, {:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>6}]

640

655

a = @c1.eager(:first_two_tags).all

641

656

a.should == [@c1.load(:id1=>1, :id2=>2)]

642

MODEL_DB.sqls.should == ['SELECT * FROM artists',

657

DB.sqls.should == ['SELECT * FROM artists',

643

658

'SELECT * FROM (SELECT tags.*, albums_artists.artist_id1 AS x_foreign_key_0_x, albums_artists.artist_id2 AS x_foreign_key_1_x, row_number() OVER (PARTITION BY albums_artists.artist_id1, albums_artists.artist_id2 ORDER BY name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND ((albums_artists.artist_id1, albums_artists.artist_id2) IN ((1, 2))))) AS t1 WHERE (x_sequel_row_number_x <= 2)']

644

659

a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]

645

MODEL_DB.sqls.length.should == 0

660

DB.sqls.length.should == 0

646

661

647

@c1.many_through_many :first_two_tags, [[:albums_artists, [:artist_id1, :artist_id2], :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1], :eager_limit_strategy=>true, :order=>:name

662

@c1.many_through_many :first_two_tags, [[:albums_artists, [:artist_id1, :artist_id2], :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1], :order=>:name

648

663

a = @c1.eager(:first_two_tags).all

649

664

a.should == [@c1.load(:id1=>1, :id2=>2)]

650

MODEL_DB.sqls.should == ['SELECT * FROM artists',

665

DB.sqls.should == ['SELECT * FROM artists',

651

666

'SELECT * FROM (SELECT tags.*, albums_artists.artist_id1 AS x_foreign_key_0_x, albums_artists.artist_id2 AS x_foreign_key_1_x, row_number() OVER (PARTITION BY albums_artists.artist_id1, albums_artists.artist_id2 ORDER BY name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND ((albums_artists.artist_id1, albums_artists.artist_id2) IN ((1, 2))))) AS t1 WHERE ((x_sequel_row_number_x >= 2) AND (x_sequel_row_number_x < 4))']

652

667

a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]

653

MODEL_DB.sqls.length.should == 0

654

end

655

656

it "should respect the :limit option on a many_through_many association using a :correlated_subquery strategy" do

657

@c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :eager_limit_strategy=>:correlated_subquery, :order=>:name

658

Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>5},{:x_foreign_key_x=>1, :id=>6}]

659

a = @c1.eager(:first_two_tags).all

660

a.should == [@c1.load(:id=>1)]

661

MODEL_DB.sqls.should == ['SELECT * FROM artists',

662

'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) WHERE (tags.id IN (SELECT t1.id FROM tags AS t1 INNER JOIN albums_tags ON (albums_tags.tag_id = t1.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists AS t2 ON ((t2.album_id = albums.id) AND (t2.artist_id = albums_artists.artist_id)) ORDER BY name LIMIT 2)) ORDER BY name']

663

a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]

664

MODEL_DB.sqls.length.should == 0

665

666

@c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1], :eager_limit_strategy=>:correlated_subquery, :order=>:name

667

a = @c1.eager(:first_two_tags).all

668

a.should == [@c1.load(:id=>1)]

669

MODEL_DB.sqls.should == ['SELECT * FROM artists',

670

'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) WHERE (tags.id IN (SELECT t1.id FROM tags AS t1 INNER JOIN albums_tags ON (albums_tags.tag_id = t1.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists AS t2 ON ((t2.album_id = albums.id) AND (t2.artist_id = albums_artists.artist_id)) ORDER BY name LIMIT 2 OFFSET 1)) ORDER BY name']

671

a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]

672

MODEL_DB.sqls.length.should == 0

668

DB.sqls.length.should == 0

673

669

end

674

670

675

671

it "should raise an error when attempting to eagerly load an association with the :allow_eager option set to false" do

682

678

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>:tags__name

683

679

a = @c1.eager(:tags).all

684

680

a.should == [@c1.load(:id=>1)]

685

MODEL_DB.sqls.should == ['SELECT * FROM artists',

681

DB.sqls.should == ['SELECT * FROM artists',

686

682

'SELECT tags.name, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']

687

683

a.first.tags.should == [Tag.load(:id=>2)]

688

MODEL_DB.sqls.length.should == 0

684

DB.sqls.length.should == 0

689

685

end

690

686

691

687

it "should respect many_through_many association's :left_primary_key and :right_primary_key options" do

695

691

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :left_primary_key=>:yyy, :right_primary_key=>:tag_id

696

692

a = @c1.eager(:tags).all

697

693

a.should == [@c1.load(:id=>1, :yyy=>8)]

698

MODEL_DB.sqls.should == ['SELECT * FROM artists',

694

DB.sqls.should == ['SELECT * FROM artists',

699

695

'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.tag_id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (8)))']

700

696

a.first.tags.should == [Tag.load(:tag_id=>2)]

701

MODEL_DB.sqls.length.should == 0

697

DB.sqls.length.should == 0

702

698

end

703

699

704

700

it "should handle composite keys" do

708

704

@c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]

709

705

a = @c1.eager(:tags).all

710

706

a.should == [@c1.load(:id=>1, :yyy=>8)]

711

MODEL_DB.sqls.should == ['SELECT * FROM artists',

707

DB.sqls.should == ['SELECT * FROM artists',

712

708

'SELECT tags.*, albums_artists.b1 AS x_foreign_key_0_x, albums_artists.b2 AS x_foreign_key_1_x FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2) AND ((albums_artists.b1, albums_artists.b2) IN ((1, 8))))']

713

709

a.first.tags.should == [Tag.load(:id=>2)]

714

MODEL_DB.sqls.length.should == 0

710

DB.sqls.length.should == 0

715

711

end

716

712

717

713

it "should respect :after_load callbacks on associations when eager loading" do

718

714

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :after_load=>lambda{|o, as| o[:id] *= 2; as.each{|a| a[:id] *= 3}}

719

715

a = @c1.eager(:tags).all

720

716

a.should == [@c1.load(:id=>2)]

721

MODEL_DB.sqls.should == ['SELECT * FROM artists',

717

DB.sqls.should == ['SELECT * FROM artists',

722

718

'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']

723

719

a.first.tags.should == [Tag.load(:id=>6)]

724

MODEL_DB.sqls.length.should == 0

720

DB.sqls.length.should == 0

725

721

end

726

722

727

723

it "should raise an error if called without a symbol or hash" do

731

727

it "should eagerly graph a single many_through_many association" do

732

728

a = @c1.eager_graph(:tags).all

733

729

a.should == [@c1.load(:id=>1)]

734

MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']

730

DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']

735

731

a.first.tags.should == [Tag.load(:id=>2)]

736

MODEL_DB.sqls.length.should == 0

732

DB.sqls.length.should == 0

737

733

end

738

734

739

735

it "should eagerly graph multiple associations in a single call" do

740

736

a = @c1.eager_graph(:tags, :albums).all

741

737

a.should == [@c1.load(:id=>1)]

742

MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, albums_0.id AS albums_0_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id)']

738

DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, albums_0.id AS albums_0_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id)']

743

739

a = a.first

744

740

a.tags.should == [Tag.load(:id=>2)]

745

741

a.albums.should == [Album.load(:id=>3)]

746

MODEL_DB.sqls.length.should == 0

742

DB.sqls.length.should == 0

747

743

end

748

744

749

745

it "should eagerly graph multiple associations in separate calls" do

750

746

a = @c1.eager_graph(:tags).eager_graph(:albums).all

751

747

a.should == [@c1.load(:id=>1)]

752

MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, albums_0.id AS albums_0_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id)']

748

DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, albums_0.id AS albums_0_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id)']

753

749

a = a.first

754

750

a.tags.should == [Tag.load(:id=>2)]

755

751

a.albums.should == [Album.load(:id=>3)]

756

MODEL_DB.sqls.length.should == 0

752

DB.sqls.length.should == 0

757

753

end

758

754

759

755

it "should allow cascading of eager graphing for associations of associated models" do

760

756

a = @c1.eager_graph(:tags=>:tracks).all

761

757

a.should == [@c1.load(:id=>1)]

762

MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, tracks.id AS tracks_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums_0.id)']

758

DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, tracks.id AS tracks_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums_0.id)']

763

759

a = a.first

764

760

a.tags.should == [Tag.load(:id=>2)]

765

761

a.tags.first.tracks.should == [Track.load(:id=>4)]

766

MODEL_DB.sqls.length.should == 0

762

DB.sqls.length.should == 0

767

763

end

768

764

769

765

it "eager graphing should eliminate duplicates caused by cartesian products" do

772

768

ds._fetch = [{:id=>1, :tags_id=>2}, {:id=>1, :tags_id=>3}, {:id=>1, :tags_id=>2}, {:id=>1, :tags_id=>3}]

773

769

a = ds.all

774

770

a.should == [@c1.load(:id=>1)]

775

MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']

771

DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']

776

772

a.first.tags.should == [Tag.load(:id=>2), Tag.load(:id=>3)]

777

MODEL_DB.sqls.length.should == 0

773

DB.sqls.length.should == 0

778

774

end

779

775

780

776

it "should eager graph multiple associations from the same table" do

781

777

a = @c1.eager_graph(:tags, :other_tags).all

782

778

a.should == [@c1.load(:id=>1)]

783

MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, other_tags.id AS other_tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id) LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.album_id = albums_0.id) LEFT OUTER JOIN tags AS other_tags ON (other_tags.id = albums_tags_0.tag_id)']

779

DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, other_tags.id AS other_tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id) LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.album_id = albums_0.id) LEFT OUTER JOIN tags AS other_tags ON (other_tags.id = albums_tags_0.tag_id)']

784

780

a = a.first

785

781

a.tags.should == [Tag.load(:id=>2)]

786

782

a.other_tags.should == [Tag.load(:id=>9)]

787

MODEL_DB.sqls.length.should == 0

783

DB.sqls.length.should == 0

788

784

end

789

785

790

786

it "should eager graph a self_referential association" do

791

787

a = @c1.eager_graph(:tags, :artists).all

792

788

a.should == [@c1.load(:id=>1)]

793

MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, artists_0.id AS artists_0_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id) LEFT OUTER JOIN albums_artists AS albums_artists_1 ON (albums_artists_1.album_id = albums_0.id) LEFT OUTER JOIN artists AS artists_0 ON (artists_0.id = albums_artists_1.artist_id)']

789

DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, artists_0.id AS artists_0_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id) LEFT OUTER JOIN albums_artists AS albums_artists_1 ON (albums_artists_1.album_id = albums_0.id) LEFT OUTER JOIN artists AS artists_0 ON (artists_0.id = albums_artists_1.artist_id)']

794

790

a = a.first

795

791

a.tags.should == [Tag.load(:id=>2)]

796

792

a.artists.should == [@c1.load(:id=>10)]

797

MODEL_DB.sqls.length.should == 0

793

DB.sqls.length.should == 0

798

794

end

799

795

800

796

it "eager graphing should give you a plain hash when called without .all" do

804

800

it "should be able to use eager and eager_graph together" do

805

801

a = @c1.eager_graph(:tags).eager(:albums).all

806

802

a.should == [@c1.load(:id=>1)]

807

MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)',

803

DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)',

808

804

'SELECT albums.*, albums_artists.artist_id AS x_foreign_key_x FROM albums INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']

809

805

a = a.first

810

806

a.tags.should == [Tag.load(:id=>2)]

811

807

a.albums.should == [Album.load(:id=>3)]

812

MODEL_DB.sqls.length.should == 0

808

DB.sqls.length.should == 0

813

809

end

814

810

815

811

it "should handle no associated records when eagerly graphing a single many_through_many association" do

817

813

ds._fetch = {:id=>1, :tags_id=>nil}

818

814

a = ds.all

819

815

a.should == [@c1.load(:id=>1)]

820

MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']

816

DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']

821

817

a.first.tags.should == []

822

MODEL_DB.sqls.length.should == 0

818

DB.sqls.length.should == 0

823

819

end

824

820

825

821

it "should handle no associated records when eagerly graphing multiple many_through_many associations" do

827

823

ds._fetch = [{:id=>1, :tags_id=>nil, :albums_0_id=>3}, {:id=>1, :tags_id=>2, :albums_0_id=>nil}, {:id=>1, :tags_id=>5, :albums_0_id=>6}, {:id=>7, :tags_id=>nil, :albums_0_id=>nil}]

828

824

a = ds.all

829

825

a.should == [@c1.load(:id=>1), @c1.load(:id=>7)]

830

MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, albums_0.id AS albums_0_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id)']

826

DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, albums_0.id AS albums_0_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id)']

831

827

a.first.tags.should == [Tag.load(:id=>2), Tag.load(:id=>5)]

832

828

a.first.albums.should == [Album.load(:id=>3), Album.load(:id=>6)]

833

829

a.last.tags.should == []

834

830

a.last.albums.should == []

835

MODEL_DB.sqls.length.should == 0

831

DB.sqls.length.should == 0

836

832

end

837

833

838

834

it "should handle missing associated records when cascading eager graphing for associations of associated models" do

840

836

ds._fetch = [{:id=>1, :tags_id=>2, :tracks_id=>4}, {:id=>1, :tags_id=>3, :tracks_id=>nil}, {:id=>2, :tags_id=>nil, :tracks_id=>nil}]

841

837

a = ds.all

842

838

a.should == [@c1.load(:id=>1), @c1.load(:id=>2)]

843

MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, tracks.id AS tracks_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums_0.id)']

839

DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, tracks.id AS tracks_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums_0.id)']

844

840

a.last.tags.should == []

845

841

a = a.first

846

842

a.tags.should == [Tag.load(:id=>2), Tag.load(:id=>3)]

847

843

a.tags.first.tracks.should == [Track.load(:id=>4)]

848

844

a.tags.last.tracks.should == []

849

MODEL_DB.sqls.length.should == 0

845

DB.sqls.length.should == 0

850

846

end

851

847

852

848

it "eager graphing should respect :left_primary_key and :right_primary_key options" do

857

853

ds._fetch = {:id=>1, :yyy=>8, :tags_id=>2, :tag_id=>4}

858

854

a = ds.all

859

855

a.should == [@c1.load(:id=>1, :yyy=>8)]

860

MODEL_DB.sqls.should == ['SELECT artists.id, artists.yyy, tags.id AS tags_id, tags.tag_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.yyy) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.tag_id = albums_tags.tag_id)']

856

DB.sqls.should == ['SELECT artists.id, artists.yyy, tags.id AS tags_id, tags.tag_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.yyy) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.tag_id = albums_tags.tag_id)']

861

857

a.first.tags.should == [Tag.load(:id=>2, :tag_id=>4)]

862

MODEL_DB.sqls.length.should == 0

858

DB.sqls.length.should == 0

863

859

end

864

860

865

861

it "eager graphing should respect composite keys" do

870

866

ds._fetch = {:id=>1, :yyy=>8, :tags_id=>2, :tag_id=>4}

871

867

a = ds.all

872

868

a.should == [@c1.load(:id=>1, :yyy=>8)]

873

MODEL_DB.sqls.should == ['SELECT artists.id, artists.yyy, tags.id AS tags_id, tags.tag_id FROM artists LEFT OUTER JOIN albums_artists ON ((albums_artists.b1 = artists.id) AND (albums_artists.b2 = artists.yyy)) LEFT OUTER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) LEFT OUTER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) LEFT OUTER JOIN tags ON ((tags.id = albums_tags.g1) AND (tags.tag_id = albums_tags.g2))']

869

DB.sqls.should == ['SELECT artists.id, artists.yyy, tags.id AS tags_id, tags.tag_id FROM artists LEFT OUTER JOIN albums_artists ON ((albums_artists.b1 = artists.id) AND (albums_artists.b2 = artists.yyy)) LEFT OUTER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) LEFT OUTER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) LEFT OUTER JOIN tags ON ((tags.id = albums_tags.g1) AND (tags.tag_id = albums_tags.g2))']

874

870

a.first.tags.should == [Tag.load(:id=>2, :tag_id=>4)]

875

MODEL_DB.sqls.length.should == 0

871

DB.sqls.length.should == 0

876

872

end

877

873

878

874

it "should respect the association's :graph_select option" do

881

877

ds._fetch = {:id=>1, :b=>2}

882

878

a = ds.all

883

879

a.should == [@c1.load(:id=>1)]

884

MODEL_DB.sqls.should == ['SELECT artists.id, tags.b FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']

880

DB.sqls.should == ['SELECT artists.id, tags.b FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']

885

881

a.first.tags.should == [Tag.load(:b=>2)]

886

MODEL_DB.sqls.length.should == 0

882

DB.sqls.length.should == 0

887

883

end

888

884

889

885

it "should respect the association's :graph_join_type option" do

914

910

end

915

911

916

912

it "should respect the association's :graph_block option" do

917

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :graph_block=>proc{|ja,lja,js| {:active.qualify(ja)=>true}}

913

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :graph_block=>proc{|ja,lja,js| {Sequel.qualify(ja, :active)=>true}}

918

914

@c1.eager_graph(:tags).sql.should == 'SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON ((tags.id = albums_tags.tag_id) AND (tags.active IS TRUE))'

919

915

end

920

916

921

917

it "should respect the association's :block option on through" do

922

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id, :block=>proc{|ja,lja,js| {:active.qualify(ja)=>true}}}, [:albums_tags, :album_id, :tag_id]]

918

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id, :block=>proc{|ja,lja,js| {Sequel.qualify(ja, :active)=>true}}}, [:albums_tags, :album_id, :tag_id]]

923

919

@c1.eager_graph(:tags).sql.should == 'SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON ((albums.id = albums_artists.album_id) AND (albums.active IS TRUE)) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)'

924

920

end

925

921

943

939

end

944

940

945

941

it "should only qualify unqualified symbols, identifiers, or ordered versions in association's :order" do

946

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :order=>[:blah__id.identifier, :blah__id.identifier.desc, :blah__id.desc, :blah__id, :album_id, :album_id.desc, 1, 'RANDOM()'.lit, :a.qualify(:b)]

942

@c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :order=>[Sequel.identifier(:blah__id), Sequel.identifier(:blah__id).desc, Sequel.desc(:blah__id), :blah__id, :album_id, Sequel.desc(:album_id), 1, Sequel.lit('RANDOM()'), Sequel.qualify(:b, :a)]

947

943

@c1.order(:artists__blah2, :artists__blah3).eager_graph(:tags).sql.should == 'SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) ORDER BY artists.blah2, artists.blah3, tags.blah__id, tags.blah__id DESC, blah.id DESC, blah.id, tags.album_id, tags.album_id DESC, 1, RANDOM(), b.a'

948

944

end

949

945