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