github.com/paweljw/pop/v5@v5.4.6/finders_test.go (about) 1 package pop 2 3 import ( 4 "testing" 5 6 "github.com/gobuffalo/nulls" 7 "github.com/gofrs/uuid" 8 "github.com/stretchr/testify/require" 9 ) 10 11 func Test_Find(t *testing.T) { 12 if PDB == nil { 13 t.Skip("skipping integration tests") 14 } 15 transaction(func(tx *Connection) { 16 r := require.New(t) 17 tCases := []string{ 18 "Mark", 19 "💩", 20 } 21 22 for _, tc := range tCases { 23 user := User{Name: nulls.NewString(tc)} 24 err := tx.Create(&user) 25 r.NoError(err) 26 27 u := User{} 28 err = tx.Find(&u, user.ID) 29 r.NoError(err) 30 31 r.NotEqual(u.ID, 0) 32 r.Equal(u.Name.String, tc) 33 } 34 }) 35 } 36 37 func Test_Create_MissingID(t *testing.T) { 38 if PDB == nil { 39 t.Skip("skipping integration tests") 40 } 41 transaction(func(tx *Connection) { 42 r := require.New(t) 43 client := Client{ClientID: "client-0001"} 44 err := tx.Create(&client) 45 r.Error(err) 46 r.Contains(err.Error(), "model *pop.Client is missing required field ID") 47 }) 48 } 49 50 func Test_Find_MissingID(t *testing.T) { 51 if PDB == nil { 52 t.Skip("skipping integration tests") 53 } 54 transaction(func(tx *Connection) { 55 r := require.New(t) 56 r.NoError(tx.RawQuery("INSERT INTO clients (id) VALUES (?)", "client-0001").Exec()) 57 58 u := Client{} 59 r.EqualError(tx.Find(&u, "client-0001"), "model *pop.Client is missing required field ID") 60 }) 61 } 62 63 func Test_Find_LeadingZeros(t *testing.T) { 64 if PDB == nil { 65 t.Skip("skipping integration tests") 66 } 67 transaction(func(tx *Connection) { 68 r := require.New(t) 69 70 labels := []string{ 71 "0", 72 "01", 73 "001", 74 "123", 75 } 76 77 for _, v := range labels { 78 label := Label{ID: v} 79 err := tx.Create(&label) 80 r.NoError(err) 81 82 l := Label{} 83 err = tx.Find(&l, v) 84 r.NoError(err) 85 86 r.Equal(l.ID, v) 87 } 88 }) 89 } 90 91 func Test_Select(t *testing.T) { 92 if PDB == nil { 93 t.Skip("skipping integration tests") 94 } 95 transaction(func(tx *Connection) { 96 r := require.New(t) 97 98 user := User{Name: nulls.NewString("Mark"), Email: "mark@gobuffalo.io"} 99 err := tx.Create(&user) 100 r.NoError(err) 101 102 q := tx.Select("name", "email", "\n", "\t\n", "") 103 104 sm := NewModel(new(User), tx.Context()) 105 sql, _ := q.ToSQL(sm) 106 r.Equal(tx.Dialect.TranslateSQL("SELECT email, name FROM users AS users"), sql) 107 108 u := User{} 109 err = q.Find(&u, user.ID) 110 r.NoError(err) 111 112 r.Equal(u.Email, "mark@gobuffalo.io") 113 r.Equal(u.Name.String, "Mark") 114 r.Zero(u.ID) 115 }) 116 } 117 118 func Test_Find_Eager_Has_Many(t *testing.T) { 119 if PDB == nil { 120 t.Skip("skipping integration tests") 121 } 122 transaction(func(tx *Connection) { 123 r := require.New(t) 124 125 user := User{Name: nulls.NewString("Mark")} 126 err := tx.Create(&user) 127 r.NoError(err) 128 129 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 130 err = tx.Create(&book) 131 r.NoError(err) 132 133 u := User{} 134 err = tx.Eager("Books").Find(&u, user.ID) 135 r.NoError(err) 136 137 r.NotEqual(u.ID, 0) 138 r.Equal(u.Name.String, "Mark") 139 books := u.Books 140 r.NotEqual(len(books), 0) 141 r.Equal(books[0].Title, book.Title) 142 }) 143 } 144 145 func Test_All_Eager_Preload_Mode(t *testing.T) { 146 if PDB == nil { 147 t.Skip("skipping integration tests") 148 } 149 transaction(func(tx *Connection) { 150 r := require.New(t) 151 152 for _, name := range []string{"Mark", "Joe", "Jane"} { 153 user := User{Name: nulls.NewString(name)} 154 err := tx.Create(&user) 155 r.NoError(err) 156 157 if name == "Mark" { 158 for _, title := range []string{"Pop Book", "My Pop Book", "Asociations Book"} { 159 book := Book{Title: title, Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 160 err = tx.Create(&book) 161 r.NoError(err) 162 } 163 } 164 } 165 166 u := Users{} 167 err := tx.EagerPreload().All(&u) 168 r.NoError(err) 169 r.Equal(len(u), 3) 170 r.Equal(len(u[0].Books), 3) 171 r.Equal(u[0].Books[0].Title, "Asociations Book") 172 r.Equal(u[0].Books[1].Title, "My Pop Book") 173 r.Equal(u[0].Books[2].Title, "Pop Book") 174 }) 175 } 176 177 func Test_Find_Eager_Has_Many_Order_By(t *testing.T) { 178 if PDB == nil { 179 t.Skip("skipping integration tests") 180 } 181 transaction(func(tx *Connection) { 182 r := require.New(t) 183 184 user := User{Name: nulls.NewString("Mark")} 185 err := tx.Create(&user) 186 r.NoError(err) 187 188 book1 := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 189 err = tx.Create(&book1) 190 r.NoError(err) 191 192 book2 := Book{Title: "New Pop Book", Isbn: "PB2", UserID: nulls.NewInt(user.ID)} 193 err = tx.Create(&book2) 194 r.NoError(err) 195 196 u := User{} 197 err = tx.Eager().Find(&u, user.ID) 198 r.NoError(err) 199 200 r.Equal(len(u.Books), 2) 201 r.Equal(book2.Title, u.Books[0].Title) 202 }) 203 } 204 205 func Test_Find_Eager_Belongs_To(t *testing.T) { 206 if PDB == nil { 207 t.Skip("skipping integration tests") 208 } 209 transaction(func(tx *Connection) { 210 r := require.New(t) 211 212 user := User{Name: nulls.NewString("Mark"), UserName: "mark"} 213 err := tx.Create(&user) 214 r.NoError(err) 215 216 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 217 err = tx.Create(&book) 218 r.NoError(err) 219 220 b := Book{} 221 err = tx.Eager().Find(&b, book.ID) 222 r.NoError(err) 223 224 r.NotEqual(b.ID, 0) 225 r.NotEqual(b.User.ID, 0) 226 r.Equal(b.User.ID, user.ID) 227 228 userAttr := UserAttribute{UserName: "mark", NickName: "Mark Z."} 229 err = tx.Create(&userAttr) 230 r.NoError(err) 231 232 uA := UserAttribute{} 233 err = tx.Eager().Find(&uA, userAttr.ID) 234 r.NoError(err) 235 r.Equal(uA.User.ID, user.ID) 236 }) 237 } 238 239 func Test_Find_Eager_Belongs_To_Nulls(t *testing.T) { 240 if PDB == nil { 241 t.Skip("skipping integration tests") 242 } 243 transaction(func(tx *Connection) { 244 r := require.New(t) 245 246 user := User{Name: nulls.NewString("Mark")} 247 err := tx.Create(&user) 248 r.NoError(err) 249 250 book := Book{Title: "Pop Book", Isbn: "PB1"} 251 err = tx.Create(&book) 252 r.NoError(err) 253 254 b := Book{} 255 err = tx.Eager().Find(&b, book.ID) 256 r.NoError(err) 257 }) 258 } 259 260 func Test_Find_Eager_Belongs_To_Pointers(t *testing.T) { 261 if PDB == nil { 262 t.Skip("skipping integration tests") 263 } 264 transaction(func(tx *Connection) { 265 r := require.New(t) 266 267 body := Body{} 268 err := tx.Create(&body) 269 r.NoError(err) 270 271 head := Head{BodyID: body.ID} 272 err = tx.Create(&head) 273 r.NoError(err) 274 275 b := Body{} 276 err = tx.Eager().Find(&b, body.ID) 277 r.NoError(err) 278 }) 279 } 280 281 func Test_Find_Eager_Has_One(t *testing.T) { 282 if PDB == nil { 283 t.Skip("skipping integration tests") 284 } 285 transaction(func(tx *Connection) { 286 r := require.New(t) 287 288 user := User{Name: nulls.NewString("Mark")} 289 err := tx.Create(&user) 290 r.NoError(err) 291 292 coolSong := Song{Title: "Hook - Blues Traveler", UserID: user.ID} 293 err = tx.Create(&coolSong) 294 r.NoError(err) 295 296 u := User{} 297 err = tx.Eager().Find(&u, user.ID) 298 r.NoError(err) 299 300 r.NotEqual(u.ID, 0) 301 r.Equal(u.Name.String, "Mark") 302 r.Equal(u.FavoriteSong.ID, coolSong.ID) 303 304 // eager should work with rawquery 305 uid := u.ID 306 u = User{} 307 err = tx.RawQuery("select * from users where id=?", uid).First(&u) 308 r.NoError(err) 309 r.Equal(u.FavoriteSong.ID, uuid.Nil) 310 311 err = tx.RawQuery("select * from users where id=?", uid).Eager("FavoriteSong").First(&u) 312 r.NoError(err) 313 r.Equal(u.FavoriteSong.ID, coolSong.ID) 314 }) 315 } 316 317 func Test_Find_Eager_Has_One_With_Inner_Associations_Struct(t *testing.T) { 318 if PDB == nil { 319 t.Skip("skipping integration tests") 320 } 321 transaction(func(tx *Connection) { 322 r := require.New(t) 323 324 user := User{Name: nulls.NewString("Mark")} 325 err := tx.Create(&user) 326 r.NoError(err) 327 328 composer := Composer{Name: "Blues Traveler"} 329 err = tx.Create(&composer) 330 r.NoError(err) 331 332 coolSong := Song{Title: "Hook", UserID: user.ID, ComposedByID: composer.ID} 333 err = tx.Create(&coolSong) 334 r.NoError(err) 335 336 u := User{} 337 err = tx.Eager("FavoriteSong.ComposedBy").Find(&u, user.ID) 338 r.NoError(err) 339 340 r.NotEqual(u.ID, 0) 341 r.Equal(u.Name.String, "Mark") 342 r.Equal(u.FavoriteSong.ID, coolSong.ID) 343 r.Equal(u.FavoriteSong.ComposedBy.Name, composer.Name) 344 }) 345 } 346 347 func Test_Find_Eager_Has_One_With_Inner_Associations_Slice(t *testing.T) { 348 if PDB == nil { 349 t.Skip("skipping integration tests") 350 } 351 transaction(func(tx *Connection) { 352 r := require.New(t) 353 354 user := User{Name: nulls.NewString("Mark")} 355 err := tx.Create(&user) 356 r.NoError(err) 357 358 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 359 err = tx.Create(&book) 360 r.NoError(err) 361 362 writer := Writer{Name: "Mark Bates", BookID: book.ID} 363 err = tx.Create(&writer) 364 r.NoError(err) 365 366 u := User{} 367 err = tx.Eager("Books.Writers").Find(&u, user.ID) 368 r.NoError(err) 369 370 r.NotEqual(u.ID, 0) 371 r.Equal(u.Name.String, "Mark") 372 r.Equal(len(u.Books), 1) 373 r.Equal(len(u.Books[0].Writers), 1) 374 375 r.Equal(u.Books[0].Title, book.Title) 376 r.Equal(u.Books[0].Writers[0].Name, writer.Name) 377 r.Zero(u.Books[0].Writers[0].Book.ID) 378 }) 379 } 380 381 func Test_Eager_Bad_Format(t *testing.T) { 382 if PDB == nil { 383 t.Skip("skipping integration tests") 384 } 385 transaction(func(tx *Connection) { 386 r := require.New(t) 387 388 user := User{Name: nulls.NewString("Mark")} 389 err := tx.Create(&user) 390 r.NoError(err) 391 392 u := User{} 393 err = tx.Eager("Books.").First(&u) 394 r.Error(err) 395 396 err = tx.Eager("Books.*").First(&u) 397 r.Error(err) 398 399 err = tx.Eager(".*").First(&u) 400 r.Error(err) 401 402 err = tx.Eager(".").First(&u) 403 r.Error(err) 404 }) 405 } 406 407 func Test_Find_Eager_Many_To_Many(t *testing.T) { 408 if PDB == nil { 409 t.Skip("skipping integration tests") 410 } 411 transaction(func(tx *Connection) { 412 r := require.New(t) 413 414 user := User{Name: nulls.NewString("Mark")} 415 err := tx.Create(&user) 416 r.NoError(err) 417 418 address := Address{Street: "Pop Avenue", HouseNumber: 1} 419 err = tx.Create(&address) 420 r.NoError(err) 421 422 ownerProperty := UsersAddress{UserID: user.ID, AddressID: address.ID} 423 err = tx.Create(&ownerProperty) 424 r.NoError(err) 425 426 u := User{} 427 err = tx.Eager("Houses").Find(&u, user.ID) 428 r.NoError(err) 429 430 r.NotEqual(u.ID, 0) 431 r.Equal(u.Name.String, "Mark") 432 433 r.Equal(len(u.Houses), 1) 434 r.Equal(u.Houses[0].Street, address.Street) 435 436 address2 := Address{Street: "Pop Avenue 2", HouseNumber: 1} 437 err = tx.Create(&address2) 438 r.NoError(err) 439 440 user2 := User{Name: nulls.NewString("Mark 2")} 441 err = tx.Create(&user2) 442 r.NoError(err) 443 444 ownerProperty2 := UsersAddress{UserID: user2.ID, AddressID: address2.ID} 445 err = tx.Create(&ownerProperty2) 446 r.NoError(err) 447 448 // eager should work with rawquery 449 uid := u.ID 450 u = User{} 451 err = tx.RawQuery("select * from users where id=?", uid).Eager("Houses").First(&u) 452 r.NoError(err) 453 r.Equal(1, len(u.Houses)) 454 455 // eager ALL 456 var users []User 457 err = tx.RawQuery("select * from users order by created_at asc").Eager("Houses").All(&users) 458 r.NoError(err) 459 r.Equal(2, len(users)) 460 461 u = users[0] 462 r.Equal(u.Name.String, "Mark") 463 r.Equal(1, len(u.Houses)) 464 r.Equal(u.Houses[0].Street, "Pop Avenue") 465 466 u = users[1] 467 r.Equal(u.Name.String, "Mark 2") 468 r.Equal(1, len(u.Houses)) 469 r.Equal(u.Houses[0].Street, "Pop Avenue 2") 470 }) 471 } 472 473 func Test_Load_Associations_Loaded_Model(t *testing.T) { 474 if PDB == nil { 475 t.Skip("skipping integration tests") 476 } 477 transaction(func(tx *Connection) { 478 r := require.New(t) 479 480 user := User{Name: nulls.NewString("Mark")} 481 err := tx.Create(&user) 482 r.NoError(err) 483 484 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 485 err = tx.Create(&book) 486 r.NoError(err) 487 488 u := User{} 489 err = tx.Find(&u, user.ID) 490 491 r.NoError(err) 492 r.Zero(len(u.Books)) 493 494 err = tx.Load(&u) 495 496 r.NoError(err) 497 r.Equal(len(u.Books), 1) 498 r.Equal(u.Books[0].Title, book.Title) 499 }) 500 } 501 502 func Test_First(t *testing.T) { 503 if PDB == nil { 504 t.Skip("skipping integration tests") 505 } 506 transaction(func(tx *Connection) { 507 r := require.New(t) 508 509 first := User{Name: nulls.NewString("Mark")} 510 err := tx.Create(&first) 511 r.NoError(err) 512 513 last := User{Name: nulls.NewString("Mark")} 514 err = tx.Create(&last) 515 r.NoError(err) 516 517 u := User{} 518 err = tx.Where("name = 'Mark'").First(&u) 519 r.NoError(err) 520 521 r.Equal(first.ID, u.ID) 522 }) 523 } 524 525 func Test_Last(t *testing.T) { 526 if PDB == nil { 527 t.Skip("skipping integration tests") 528 } 529 transaction(func(tx *Connection) { 530 r := require.New(t) 531 532 first := User{Name: nulls.NewString("Mark")} 533 err := tx.Create(&first) 534 r.NoError(err) 535 536 last := User{Name: nulls.NewString("Mark")} 537 err = tx.Create(&last) 538 r.NoError(err) 539 540 u := User{} 541 err = tx.Where("name = 'Mark'").Last(&u) 542 r.NoError(err) 543 544 r.Equal(last.ID, u.ID) 545 }) 546 } 547 548 func Test_All(t *testing.T) { 549 if PDB == nil { 550 t.Skip("skipping integration tests") 551 } 552 transaction(func(tx *Connection) { 553 r := require.New(t) 554 555 for _, name := range []string{"Mark", "Joe", "Jane"} { 556 user := User{Name: nulls.NewString(name)} 557 err := tx.Create(&user) 558 r.NoError(err) 559 } 560 561 u := Users{} 562 err := tx.All(&u) 563 r.NoError(err) 564 r.Equal(len(u), 3) 565 566 u = Users{} 567 err = tx.Where("name = 'Mark'").All(&u) 568 r.NoError(err) 569 r.Equal(len(u), 1) 570 }) 571 } 572 573 func Test_All_Eager_Slice_With_All(t *testing.T) { 574 if PDB == nil { 575 t.Skip("skipping integration tests") 576 } 577 transaction(func(tx *Connection) { 578 r := require.New(t) 579 580 for _, name := range []string{"Mark", "Joe", "Jane"} { 581 user := User{Name: nulls.NewString(name)} 582 err := tx.Create(&user) 583 r.NoError(err) 584 585 book := Book{Title: "Book of " + user.Name.String, UserID: nulls.NewInt(user.ID)} 586 err = tx.Create(&book) 587 r.NoError(err) 588 } 589 590 u := Users{} 591 err := tx.Eager("Books.User").All(&u) 592 r.NoError(err) 593 r.Equal(len(u), 3) 594 595 r.Equal(u[0].ID, u[0].Books[0].User.ID) 596 r.Equal(u[1].ID, u[1].Books[0].User.ID) 597 r.Equal(u[2].ID, u[2].Books[0].User.ID) 598 }) 599 } 600 601 func Test_All_Eager(t *testing.T) { 602 if PDB == nil { 603 t.Skip("skipping integration tests") 604 } 605 transaction(func(tx *Connection) { 606 r := require.New(t) 607 608 for _, name := range []string{"Mark", "Joe", "Jane"} { 609 user := User{Name: nulls.NewString(name)} 610 err := tx.Create(&user) 611 r.NoError(err) 612 613 if name == "Mark" { 614 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 615 err = tx.Create(&book) 616 r.NoError(err) 617 } 618 } 619 620 u := Users{} 621 err := tx.Eager(" Books ", " ").Where("name = 'Mark'").All(&u) 622 r.NoError(err) 623 r.Equal(len(u), 1) 624 r.Equal(len(u[0].Books), 1) 625 }) 626 } 627 628 func Test_All_Eager_For_Query(t *testing.T) { 629 if PDB == nil { 630 t.Skip("skipping integration tests") 631 } 632 transaction(func(tx *Connection) { 633 r := require.New(t) 634 635 user := User{Name: nulls.NewString("Mark")} 636 err := tx.Create(&user) 637 r.NoError(err) 638 639 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 640 err = tx.Create(&book) 641 r.NoError(err) 642 643 u := Users{} 644 q := tx.Q() 645 err = q.Eager("Books").Where("name = 'Mark'").All(&u) 646 r.NoError(err) 647 r.Equal(len(u), 1) 648 r.Equal(len(u[0].Books), 1) 649 }) 650 } 651 652 func Test_All_Eager_Field_Not_Found_Error(t *testing.T) { 653 if PDB == nil { 654 t.Skip("skipping integration tests") 655 } 656 transaction(func(tx *Connection) { 657 r := require.New(t) 658 659 user := User{Name: nulls.NewString("Mark")} 660 err := tx.Create(&user) 661 r.NoError(err) 662 663 u := Users{} 664 err = tx.Eager("FieldNotFound").Where("name = 'Mark'").All(&u) 665 r.Error(err) 666 r.Equal("could not retrieve associations: field FieldNotFound does not exist in model User", err.Error()) 667 }) 668 } 669 670 func Test_All_Eager_Allow_Chain_Call(t *testing.T) { 671 if PDB == nil { 672 t.Skip("skipping integration tests") 673 } 674 transaction(func(tx *Connection) { 675 r := require.New(t) 676 677 user := User{Name: nulls.NewString("Mark")} 678 err := tx.Create(&user) 679 r.NoError(err) 680 681 coolSong := Song{Title: "Hook - Blues Traveler", UserID: user.ID} 682 err = tx.Create(&coolSong) 683 r.NoError(err) 684 685 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 686 err = tx.Create(&book) 687 r.NoError(err) 688 689 u := Users{} 690 err = tx.Eager("Books").Eager("FavoriteSong").Where("name = 'Mark'").All(&u) 691 r.NoError(err) 692 r.Equal(len(u), 1) 693 r.Equal(len(u[0].Books), 1) 694 r.Equal(u[0].FavoriteSong.Title, coolSong.Title) 695 }) 696 } 697 698 func Test_Count(t *testing.T) { 699 if PDB == nil { 700 t.Skip("skipping integration tests") 701 } 702 transaction(func(tx *Connection) { 703 r := require.New(t) 704 705 user := User{Name: nulls.NewString("Mark")} 706 err := tx.Create(&user) 707 r.NoError(err) 708 c, err := tx.Count(&user) 709 r.NoError(err) 710 r.Equal(c, 1) 711 712 c, err = tx.Where("1=1").CountByField(&user, "distinct id") 713 r.NoError(err) 714 r.Equal(c, 1) 715 // should ignore order in count 716 717 c, err = tx.Order("id desc").Count(&user) 718 r.NoError(err) 719 r.Equal(c, 1) 720 721 var uAQ []UsersAddressQuery 722 _, err = Q(tx).Select("users_addresses.*").LeftJoin("users", "users.id=users_addresses.user_id").Count(&uAQ) 723 r.NoError(err) 724 725 _, err = Q(tx).Select("users_addresses.*", "users.name", "users.email").LeftJoin("users", "users.id=users_addresses.user_id").Count(&uAQ) 726 r.NoError(err) 727 }) 728 } 729 730 func Test_Count_Disregards_Pagination(t *testing.T) { 731 if PDB == nil { 732 t.Skip("skipping integration tests") 733 } 734 transaction(func(tx *Connection) { 735 r := require.New(t) 736 737 names := []string{ 738 "Jack", 739 "Hurley", 740 "Charlie", 741 "Desmond", 742 "Juliet", 743 "Locke", 744 "Sawyer", 745 "Kate", 746 "Benjamin Linus", 747 } 748 749 for _, name := range names { 750 user := User{Name: nulls.NewString(name)} 751 err := tx.Create(&user) 752 r.NoError(err) 753 } 754 755 firstUsers := Users{} 756 secondUsers := Users{} 757 758 q := tx.Paginate(1, 3) 759 r.NoError(q.All(&firstUsers)) 760 r.Equal(len(names), q.Paginator.TotalEntriesSize) // ensure paginator populates count 761 r.Equal(3, len(firstUsers)) 762 763 firstUsers = Users{} 764 q = tx.RawQuery("select * from users").Paginate(1, 3) 765 r.NoError(q.All(&firstUsers)) 766 r.Equal(1, q.Paginator.Page) 767 r.Equal(3, q.Paginator.PerPage) 768 r.Equal(len(names), q.Paginator.TotalEntriesSize) // ensure paginator populates count 769 770 r.Equal(3, len(firstUsers)) 771 totalFirstPage := q.Paginator.TotalPages 772 773 q = tx.Paginate(2, 3) 774 r.NoError(q.All(&secondUsers)) 775 776 r.Equal(3, len(secondUsers)) 777 totalSecondPage := q.Paginator.TotalPages 778 779 r.NotEqual(0, totalFirstPage) 780 r.NotEqual(0, totalSecondPage) 781 r.Equal(totalFirstPage, totalSecondPage) 782 783 firstUsers = Users{} 784 q = tx.RawQuery("select * from users limit 2").Paginate(1, 5) 785 err := q.All(&firstUsers) 786 r.NoError(err) 787 r.Equal(2, len(firstUsers)) // raw query limit applies 788 789 firstUsers = Users{} 790 q = tx.RawQuery("select * from users limit 2 offset 1").Paginate(1, 5) 791 err = q.All(&firstUsers) 792 r.NoError(err) 793 r.Equal(2, len(firstUsers)) 794 795 firstUsers = Users{} 796 q = tx.RawQuery("select * from users limit 2 offset\t1").Paginate(1, 5) 797 err = q.All(&firstUsers) 798 r.NoError(err) 799 r.Equal(2, len(firstUsers)) 800 801 firstUsers = Users{} 802 q = tx.RawQuery(`select * from users limit 2 offset 803 1`).Paginate(1, 5) 804 err = q.All(&firstUsers) 805 r.NoError(err) 806 r.Equal(2, len(firstUsers)) 807 808 firstUsers = Users{} 809 q = tx.RawQuery(`select * from users limit 2 offset 810 1 811 `).Paginate(1, 5) // ending space and tab 812 err = q.All(&firstUsers) 813 r.NoError(err) 814 r.Equal(2, len(firstUsers)) 815 816 if tx.Dialect.Name() == "sqlite" { 817 firstUsers = Users{} 818 q = tx.RawQuery("select * from users limit 2,1").Paginate(1, 5) 819 err = q.All(&firstUsers) 820 r.NoError(err) 821 r.Equal(2, len(firstUsers)) 822 823 firstUsers = Users{} 824 q = tx.RawQuery("select * from users limit 2 , 1").Paginate(1, 5) 825 err = q.All(&firstUsers) 826 r.NoError(err) 827 r.Equal(2, len(firstUsers)) 828 } 829 830 if tx.Dialect.Name() == "postgresql" { 831 firstUsers = Users{} 832 q = tx.RawQuery("select * from users FETCH FIRST 3 rows only").Paginate(1, 5) 833 err = q.All(&firstUsers) 834 r.NoError(err) 835 r.Equal(3, len(firstUsers)) // should fetch only 3 836 } 837 }) 838 } 839 840 func Test_Count_RawQuery(t *testing.T) { 841 if PDB == nil { 842 t.Skip("skipping integration tests") 843 } 844 transaction(func(tx *Connection) { 845 r := require.New(t) 846 847 user := User{Name: nulls.NewString("Mark")} 848 err := tx.Create(&user) 849 r.NoError(err) 850 851 c, err := tx.RawQuery("select * from users as users").Count(nil) 852 r.NoError(err) 853 r.Equal(c, 1) 854 855 c, err = tx.RawQuery("select * from users as users where id = -1").Count(nil) 856 r.NoError(err) 857 r.Equal(c, 0) 858 859 c, err = tx.RawQuery("select name, max(created_at) from users as users group by name").Count(nil) 860 r.NoError(err) 861 r.Equal(c, 1) 862 863 c, err = tx.RawQuery("select name from users order by name asc limit 5").Count(nil) 864 r.NoError(err) 865 r.Equal(c, 1) 866 867 c, err = tx.RawQuery("select name from users order by name asc limit 5 offset 0").Count(nil) 868 r.NoError(err) 869 r.Equal(c, 1) 870 }) 871 } 872 873 func Test_Exists(t *testing.T) { 874 if PDB == nil { 875 t.Skip("skipping integration tests") 876 } 877 transaction(func(tx *Connection) { 878 r := require.New(t) 879 880 t, _ := tx.Where("id = ?", 0).Exists("users") 881 r.False(t) 882 883 user := User{Name: nulls.NewString("Mark")} 884 err := tx.Create(&user) 885 r.NoError(err) 886 887 t, _ = tx.Where("id = ?", user.ID).Exists("users") 888 r.True(t) 889 }) 890 } 891 892 func Test_FindManyToMany(t *testing.T) { 893 if PDB == nil { 894 t.Skip("skipping integration tests") 895 } 896 transaction(func(tx *Connection) { 897 r := require.New(t) 898 parent := &Parent{} 899 r.NoError(tx.Create(parent)) 900 901 student := &Student{} 902 r.NoError(tx.Create(student)) 903 904 r.NoError(tx.RawQuery("INSERT INTO parents_students (student_id, parent_id) VALUES(?,?)", student.ID, parent.ID).Exec()) 905 906 p := &Parent{} 907 err := tx.Eager("Students").Find(p, parent.ID) 908 r.NoError(err) 909 }) 910 } 911 912 func Test_FindMultipleInnerHasMany(t *testing.T) { 913 if PDB == nil { 914 t.Skip("skipping integration tests") 915 } 916 transaction(func(tx *Connection) { 917 r := require.New(t) 918 919 user := User{Name: nulls.NewString("Mark")} 920 err := tx.Create(&user) 921 r.NoError(err) 922 923 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 924 err = tx.Create(&book) 925 r.NoError(err) 926 927 writer := Writer{Name: "Jhon", BookID: book.ID} 928 err = tx.Create(&writer) 929 r.NoError(err) 930 931 friend := Friend{FirstName: "Frank", LastName: "Kafka", WriterID: writer.ID} 932 err = tx.Create(&friend) 933 r.NoError(err) 934 935 address := Address{Street: "St 27", HouseNumber: 27, WriterID: writer.ID} 936 err = tx.Create(&address) 937 r.NoError(err) 938 939 u := User{} 940 err = tx.Eager("Books.Writers.Addresses", "Books.Writers.Friends").Find(&u, user.ID) 941 r.NoError(err) 942 943 r.Len(u.Books, 1) 944 r.Len(u.Books[0].Writers, 1) 945 r.Len(u.Books[0].Writers[0].Addresses, 1) 946 r.Equal(u.Books[0].Writers[0].Addresses[0].HouseNumber, 27) 947 r.Len(u.Books[0].Writers[0].Friends, 1) 948 r.Equal(u.Books[0].Writers[0].Friends[0].FirstName, "Frank") 949 }) 950 }