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