github.com/ravendb/ravendb-go-client@v0.0.0-20240229102137-4474ee7aa0fa/tests/query_test.go (about) 1 package tests 2 3 import ( 4 "fmt" 5 "reflect" 6 "sort" 7 "strings" 8 "testing" 9 "time" 10 11 ravendb "github.com/ravendb/ravendb-go-client" 12 "github.com/stretchr/testify/assert" 13 ) 14 15 func queryQuerySimple(t *testing.T, driver *RavenTestDriver) { 16 var err error 17 store := driver.getDocumentStoreMust(t) 18 defer store.Close() 19 20 { 21 session := openSessionMust(t, store) 22 23 user1 := &User{} 24 user1.setName("John") 25 26 user2 := &User{} 27 user2.setName("Jane") 28 29 user3 := &User{} 30 user3.setName("Tarzan") 31 32 err = session.StoreWithID(user1, "users/1") 33 assert.NoError(t, err) 34 err = session.StoreWithID(user2, "users/2") 35 assert.NoError(t, err) 36 err = session.StoreWithID(user3, "users/3") 37 assert.NoError(t, err) 38 err = session.SaveChanges() 39 assert.NoError(t, err) 40 41 q := session.Advanced().QueryCollection("users") 42 var queryResult []*User 43 err = q.GetResults(&queryResult) 44 assert.NoError(t, err) 45 assert.Equal(t, len(queryResult), 3) 46 47 session.Close() 48 } 49 } 50 51 func queryQueryLazily(t *testing.T, driver *RavenTestDriver) { 52 var err error 53 store := driver.getDocumentStoreMust(t) 54 defer store.Close() 55 56 { 57 session := openSessionMust(t, store) 58 user1 := &User{} 59 user1.setName("John") 60 61 user2 := &User{} 62 user2.setName("Jane") 63 64 user3 := &User{} 65 user3.setName("Tarzan") 66 67 err = session.StoreWithID(user1, "users/1") 68 assert.NoError(t, err) 69 err = session.StoreWithID(user2, "users/2") 70 assert.NoError(t, err) 71 err = session.StoreWithID(user3, "users/3") 72 assert.NoError(t, err) 73 err = session.SaveChanges() 74 assert.NoError(t, err) 75 q := session.QueryCollectionForType(userType) 76 lazyQuery, err := q.Lazily() 77 assert.NoError(t, err) 78 var queryResult []*User 79 err = lazyQuery.GetValue(&queryResult) 80 assert.NoError(t, err) 81 assert.Equal(t, 3, len(queryResult)) 82 83 assert.Equal(t, *queryResult[0].Name, "John") 84 assert.Equal(t, *queryResult[1].Name, "Jane") 85 assert.Equal(t, *queryResult[2].Name, "Tarzan") 86 } 87 } 88 89 func queryCollectionsStats(t *testing.T, driver *RavenTestDriver) { 90 var err error 91 store := driver.getDocumentStoreMust(t) 92 defer store.Close() 93 94 { 95 session := openSessionMust(t, store) 96 user1 := &User{} 97 user1.setName("John") 98 99 user2 := &User{} 100 user2.setName("Jane") 101 102 err = session.StoreWithID(user1, "users/1") 103 assert.NoError(t, err) 104 err = session.StoreWithID(user2, "users/2") 105 assert.NoError(t, err) 106 err = session.SaveChanges() 107 assert.NoError(t, err) 108 109 session.Close() 110 } 111 112 op := ravendb.NewGetCollectionStatisticsOperation() 113 err = store.Maintenance().Send(op) 114 assert.NoError(t, err) 115 stats := op.Command.Result 116 assert.Equal(t, stats.CountOfDocuments, 2) 117 coll := stats.Collections["Users"] 118 assert.Equal(t, coll, 2) 119 } 120 121 func queryQueryWithWhereClause(t *testing.T, driver *RavenTestDriver) { 122 var err error 123 store := driver.getDocumentStoreMust(t) 124 defer store.Close() 125 126 { 127 session := openSessionMust(t, store) 128 129 user1 := &User{} 130 user1.setName("John") 131 132 user2 := &User{} 133 user2.setName("Jane") 134 135 user3 := &User{} 136 user3.setName("Tarzan") 137 138 err = session.StoreWithID(user1, "users/1") 139 assert.NoError(t, err) 140 err = session.StoreWithID(user2, "users/2") 141 assert.NoError(t, err) 142 err = session.StoreWithID(user3, "users/3") 143 assert.NoError(t, err) 144 err = session.SaveChanges() 145 assert.NoError(t, err) 146 147 var queryResult []*User 148 q := session.QueryCollection("users") 149 q = q.WhereStartsWith("name", "J") 150 err = q.GetResults(&queryResult) 151 assert.NoError(t, err) 152 153 var queryResult2 []*User 154 q2 := session.QueryCollection("users") 155 q2 = q2.WhereEquals("name", "Tarzan") 156 err = q2.GetResults(&queryResult2) 157 assert.NoError(t, err) 158 159 var queryResult3 []*User 160 q3 := session.QueryCollection("users") 161 q3 = q3.WhereEndsWith("name", "n") 162 err = q3.GetResults(&queryResult3) 163 assert.NoError(t, err) 164 165 assert.Equal(t, len(queryResult), 2) 166 assert.Equal(t, len(queryResult2), 1) 167 assert.Equal(t, len(queryResult3), 2) 168 169 session.Close() 170 } 171 } 172 173 func queryQueryMapReduceWithCount(t *testing.T, driver *RavenTestDriver) { 174 store := driver.getDocumentStoreMust(t) 175 defer store.Close() 176 177 queryAddUsers(t, store, driver) 178 179 { 180 session := openSessionMust(t, store) 181 182 var results []*ReduceResult 183 q := session.QueryCollectionForType(reflect.TypeOf(&User{})) 184 q2 := q.GroupBy("name") 185 q2 = q2.SelectKey() 186 q = q2.SelectCount() 187 q = q.OrderByDescending("count") 188 err := q.GetResults(&results) 189 assert.NoError(t, err) 190 191 { 192 result := results[0] 193 assert.Equal(t, result.Count, 2) 194 assert.Equal(t, result.Name, "John") 195 } 196 197 { 198 result := results[1] 199 assert.Equal(t, result.Count, 1) 200 assert.Equal(t, result.Name, "Tarzan") 201 } 202 203 session.Close() 204 } 205 } 206 207 func queryQueryMapReduceWithSum(t *testing.T, driver *RavenTestDriver) { 208 store := driver.getDocumentStoreMust(t) 209 defer store.Close() 210 211 queryAddUsers(t, store, driver) 212 213 { 214 session := openSessionMust(t, store) 215 216 var results []*ReduceResult 217 q := session.QueryCollectionForType(reflect.TypeOf(&User{})) 218 q2 := q.GroupBy("name") 219 q2 = q2.SelectKey() 220 f := &ravendb.GroupByField{ 221 FieldName: "age", 222 } 223 q = q2.SelectSum(f) 224 q = q.OrderByDescending("age") 225 err := q.GetResults(&results) 226 assert.NoError(t, err) 227 228 { 229 result := results[0] 230 assert.Equal(t, result.Age, 8) 231 assert.Equal(t, result.Name, "John") 232 } 233 234 { 235 result := results[1] 236 assert.Equal(t, result.Age, 2) 237 assert.Equal(t, result.Name, "Tarzan") 238 } 239 240 session.Close() 241 } 242 } 243 244 func queryQueryMapReduceIndex(t *testing.T, driver *RavenTestDriver) { 245 store := driver.getDocumentStoreMust(t) 246 defer store.Close() 247 248 queryAddUsers(t, store, driver) 249 250 { 251 session := openSessionMust(t, store) 252 253 var results []*ReduceResult 254 q := session.QueryIndex("UsersByName") 255 q = q.OrderByDescending("count") 256 err := q.GetResults(&results) 257 assert.NoError(t, err) 258 259 { 260 result := results[0] 261 assert.Equal(t, result.Count, 2) 262 assert.Equal(t, result.Name, "John") 263 } 264 265 { 266 result := results[1] 267 assert.Equal(t, result.Count, 1) 268 assert.Equal(t, result.Name, "Tarzan") 269 } 270 271 session.Close() 272 } 273 } 274 275 func queryQuerySingleProperty(t *testing.T, driver *RavenTestDriver) { 276 store := driver.getDocumentStoreMust(t) 277 defer store.Close() 278 279 queryAddUsers(t, store, driver) 280 281 { 282 session := openSessionMust(t, store) 283 284 q := session.QueryCollectionForType(reflect.TypeOf(&User{})) 285 q = q.AddOrderWithOrdering("age", true, ravendb.OrderingTypeLong) 286 projType := reflect.TypeOf(int(0)) 287 q = q.SelectFields(projType, "age") 288 var ages []int 289 err := q.GetResults(&ages) 290 assert.NoError(t, err) 291 292 assert.Equal(t, len(ages), 3) 293 294 for i, n := range []int{5, 3, 2} { 295 assert.Equal(t, ages[i], n) 296 } 297 298 session.Close() 299 } 300 } 301 302 func queryQueryWithSelect(t *testing.T, driver *RavenTestDriver) { 303 store := driver.getDocumentStoreMust(t) 304 defer store.Close() 305 306 queryAddUsers(t, store, driver) 307 308 { 309 session := openSessionMust(t, store) 310 311 q := session.QueryCollectionForType(userType) 312 projType := reflect.TypeOf("") 313 q = q.SelectFields(projType, "age") 314 var usersAge []*User 315 err := q.GetResults(&usersAge) 316 assert.NoError(t, err) 317 318 for _, user := range usersAge { 319 assert.True(t, user.Age >= 0) 320 assert.NotEmpty(t, user.ID) 321 } 322 323 session.Close() 324 } 325 } 326 327 func queryQueryWithWhereIn(t *testing.T, driver *RavenTestDriver) { 328 store := driver.getDocumentStoreMust(t) 329 defer store.Close() 330 331 queryAddUsers(t, store, driver) 332 333 { 334 session := openSessionMust(t, store) 335 336 var users []*User 337 q := session.QueryCollectionForType(userType) 338 q = q.WhereIn("name", []interface{}{"Tarzan", "no_such"}) 339 err := q.GetResults(&users) 340 assert.NoError(t, err) 341 342 assert.Equal(t, len(users), 1) 343 344 session.Close() 345 } 346 } 347 348 func queryQueryWithWhereBetween(t *testing.T, driver *RavenTestDriver) { 349 store := driver.getDocumentStoreMust(t) 350 defer store.Close() 351 352 queryAddUsers(t, store, driver) 353 354 { 355 session := openSessionMust(t, store) 356 357 var users []*User 358 q := session.QueryCollectionForType(userType) 359 q = q.WhereBetween("age", 4, 5) 360 err := q.GetResults(&users) 361 assert.NoError(t, err) 362 363 assert.Equal(t, len(users), 1) 364 365 user := users[0] 366 assert.Equal(t, *user.Name, "John") 367 368 session.Close() 369 } 370 } 371 372 func queryQueryWithWhereLessThan(t *testing.T, driver *RavenTestDriver) { 373 store := driver.getDocumentStoreMust(t) 374 defer store.Close() 375 376 queryAddUsers(t, store, driver) 377 378 { 379 session := openSessionMust(t, store) 380 381 var users []*User 382 q := session.QueryCollectionForType(userType) 383 q = q.WhereLessThan("age", 3) 384 err := q.GetResults(&users) 385 assert.NoError(t, err) 386 387 assert.Equal(t, len(users), 1) 388 389 user := users[0] 390 assert.Equal(t, *user.Name, "Tarzan") 391 392 session.Close() 393 } 394 } 395 396 func queryQueryWithWhereLessThanOrEqual(t *testing.T, driver *RavenTestDriver) { 397 store := driver.getDocumentStoreMust(t) 398 defer store.Close() 399 400 queryAddUsers(t, store, driver) 401 402 { 403 session := openSessionMust(t, store) 404 405 var users []*User 406 q := session.QueryCollectionForType(userType) 407 q = q.WhereLessThanOrEqual("age", 3) 408 err := q.GetResults(&users) 409 assert.NoError(t, err) 410 411 assert.Equal(t, len(users), 2) 412 413 session.Close() 414 } 415 } 416 417 func queryQueryWithWhereGreaterThan(t *testing.T, driver *RavenTestDriver) { 418 store := driver.getDocumentStoreMust(t) 419 defer store.Close() 420 421 queryAddUsers(t, store, driver) 422 423 { 424 session := openSessionMust(t, store) 425 426 var users []*User 427 q := session.QueryCollectionForType(userType) 428 q = q.WhereGreaterThan("age", 3) 429 err := q.GetResults(&users) 430 assert.NoError(t, err) 431 432 assert.Equal(t, len(users), 1) 433 434 user := users[0] 435 assert.Equal(t, *user.Name, "John") 436 437 session.Close() 438 } 439 } 440 441 func queryQueryWithWhereGreaterThanOrEqual(t *testing.T, driver *RavenTestDriver) { 442 store := driver.getDocumentStoreMust(t) 443 defer store.Close() 444 445 queryAddUsers(t, store, driver) 446 447 { 448 session := openSessionMust(t, store) 449 450 var users []*User 451 q := session.QueryCollectionForType(userType) 452 q = q.WhereGreaterThanOrEqual("age", 3) 453 err := q.GetResults(&users) 454 assert.NoError(t, err) 455 456 assert.Equal(t, len(users), 2) 457 458 session.Close() 459 } 460 } 461 462 type UserProjection struct { 463 ID string 464 // Note: this annotation is important because UsersByName 465 // index uses lowercase "name" property 466 Name string `json:"name"` 467 } 468 469 func queryQueryWithProjection(t *testing.T, driver *RavenTestDriver) { 470 store := driver.getDocumentStoreMust(t) 471 defer store.Close() 472 473 queryAddUsers(t, store, driver) 474 475 { 476 session := openSessionMust(t, store) 477 478 q := session.QueryCollectionForType(reflect.TypeOf(&User{})) 479 fields := ravendb.FieldsFor(&UserProjection{}) 480 projType := reflect.TypeOf(&UserProjection{}) 481 q = q.SelectFields(projType, fields...) 482 var projections []*UserProjection 483 err := q.GetResults(&projections) 484 assert.NoError(t, err) 485 486 assert.Equal(t, len(projections), 3) 487 488 expectedNames := []string{"John", "John", "Tarzan"} 489 for i, projection := range projections { 490 expectedID := fmt.Sprintf("users/%d", i+1) 491 assert.Equal(t, projection.ID, expectedID) 492 assert.Equal(t, projection.Name, expectedNames[i]) 493 } 494 495 session.Close() 496 } 497 } 498 499 func queryQueryWithProjection2(t *testing.T, driver *RavenTestDriver) { 500 store := driver.getDocumentStoreMust(t) 501 defer store.Close() 502 503 queryAddUsers(t, store, driver) 504 505 { 506 session := openSessionMust(t, store) 507 508 q := session.QueryCollectionForType(reflect.TypeOf(&User{})) 509 projType := reflect.TypeOf(&UserProjection{}) 510 q = q.SelectFields(projType, "lastName") 511 var projections []*UserProjection 512 err := q.GetResults(&projections) 513 assert.NoError(t, err) 514 515 assert.Equal(t, len(projections), 3) 516 517 for _, projection := range projections { 518 assert.NotEmpty(t, projection.ID) 519 520 assert.Empty(t, projection.Name) // we didn't specify this field in mapping 521 } 522 523 session.Close() 524 } 525 } 526 527 func queryQueryDistinct(t *testing.T, driver *RavenTestDriver) { 528 store := driver.getDocumentStoreMust(t) 529 defer store.Close() 530 531 queryAddUsers(t, store, driver) 532 533 { 534 session := openSessionMust(t, store) 535 536 q := session.QueryCollectionForType(reflect.TypeOf(&User{})) 537 projType := reflect.TypeOf("") 538 q = q.SelectFields(projType, "name") 539 540 q = q.Distinct() 541 var uniqueNames []string 542 err := q.GetResults(&uniqueNames) 543 assert.NoError(t, err) 544 545 assert.Equal(t, len(uniqueNames), 2) 546 // TODO: not sure if order guaranteed. maybe sort before compare? 547 assert.Equal(t, uniqueNames[0], "John") 548 assert.Equal(t, uniqueNames[1], "Tarzan") 549 550 session.Close() 551 } 552 } 553 554 func queryQuerySearchWithOr(t *testing.T, driver *RavenTestDriver) { 555 store := driver.getDocumentStoreMust(t) 556 defer store.Close() 557 558 queryAddUsers(t, store, driver) 559 560 { 561 session := openSessionMust(t, store) 562 563 var uniqueNames []*User 564 q := session.QueryCollectionForType(userType) 565 q = q.SearchWithOperator("name", "Tarzan John", ravendb.SearchOperatorOr) 566 err := q.GetResults(&uniqueNames) 567 assert.NoError(t, err) 568 569 assert.Equal(t, len(uniqueNames), 3) 570 571 session.Close() 572 } 573 } 574 575 func queryQueryNoTracking(t *testing.T, driver *RavenTestDriver) { 576 store := driver.getDocumentStoreMust(t) 577 defer store.Close() 578 579 queryAddUsers(t, store, driver) 580 581 { 582 session := openSessionMust(t, store) 583 584 var users []*User 585 q := session.QueryCollectionForType(userType) 586 q = q.NoTracking() 587 err := q.GetResults(&users) 588 assert.NoError(t, err) 589 590 assert.Equal(t, len(users), 3) 591 592 for _, user := range users { 593 isLoaded := session.IsLoaded(user.ID) 594 assert.False(t, isLoaded) 595 } 596 597 session.Close() 598 } 599 } 600 601 func queryQuerySkipTake(t *testing.T, driver *RavenTestDriver) { 602 store := driver.getDocumentStoreMust(t) 603 defer store.Close() 604 605 queryAddUsers(t, store, driver) 606 607 { 608 session := openSessionMust(t, store) 609 610 var users []*User 611 q := session.QueryCollectionForType(userType) 612 q = q.OrderBy("name") 613 q = q.Skip(2) 614 q = q.Take(1) 615 err := q.GetResults(&users) 616 assert.NoError(t, err) 617 618 assert.Equal(t, len(users), 1) 619 620 user := users[0] 621 assert.Equal(t, *user.Name, "Tarzan") 622 623 session.Close() 624 } 625 } 626 627 func queryRawQuerySkipTake(t *testing.T, driver *RavenTestDriver) { 628 store := driver.getDocumentStoreMust(t) 629 defer store.Close() 630 631 queryAddUsers(t, store, driver) 632 633 { 634 session := openSessionMust(t, store) 635 636 var users []*User 637 q := session.RawQuery("from users") 638 q = q.Skip(2) 639 q = q.Take(1) 640 err := q.GetResults(&users) 641 assert.NoError(t, err) 642 643 assert.Equal(t, len(users), 1) 644 user := users[0] 645 assert.Equal(t, *user.Name, "Tarzan") 646 647 session.Close() 648 } 649 } 650 651 func queryParametersInRawQuery(t *testing.T, driver *RavenTestDriver) { 652 store := driver.getDocumentStoreMust(t) 653 defer store.Close() 654 655 queryAddUsers(t, store, driver) 656 657 { 658 session := openSessionMust(t, store) 659 660 var users []*User 661 q := session.RawQuery("from users where age == $p0") 662 q = q.AddParameter("p0", 5) 663 err := q.GetResults(&users) 664 assert.NoError(t, err) 665 666 assert.Equal(t, len(users), 1) 667 user := users[0] 668 assert.Equal(t, *user.Name, "John") 669 670 session.Close() 671 } 672 } 673 674 func queryQueryLucene(t *testing.T, driver *RavenTestDriver) { 675 store := driver.getDocumentStoreMust(t) 676 defer store.Close() 677 678 queryAddUsers(t, store, driver) 679 680 { 681 session := openSessionMust(t, store) 682 683 var users []*User 684 q := session.QueryCollectionForType(userType) 685 q = q.WhereLucene("name", "Tarzan") 686 err := q.GetResults(&users) 687 assert.NoError(t, err) 688 689 assert.Equal(t, len(users), 1) 690 691 for _, user := range users { 692 assert.Equal(t, *user.Name, "Tarzan") 693 } 694 695 session.Close() 696 } 697 } 698 699 func queryQueryWhereExact(t *testing.T, driver *RavenTestDriver) { 700 store := driver.getDocumentStoreMust(t) 701 defer store.Close() 702 703 queryAddUsers(t, store, driver) 704 705 { 706 session := openSessionMust(t, store) 707 708 { 709 var users []*User 710 q := session.QueryCollectionForType(userType) 711 q = q.WhereEquals("name", "tarzan") 712 err := q.GetResults(&users) 713 assert.NoError(t, err) 714 715 assert.Equal(t, len(users), 1) 716 } 717 718 { 719 var users []*User 720 q := session.QueryCollectionForType(userType) 721 q = q.WhereEquals("name", "tarzan").Exact() 722 err := q.GetResults(&users) 723 assert.NoError(t, err) 724 725 assert.Equal(t, len(users), 0) // we queried for tarzan with exact 726 } 727 728 { 729 var users []*User 730 q := session.QueryCollectionForType(userType) 731 q = q.WhereEquals("name", "Tarzan").Exact() 732 err := q.GetResults(&users) 733 assert.NoError(t, err) 734 735 assert.Equal(t, len(users), 1) // we queried for Tarzan with exact 736 } 737 738 session.Close() 739 } 740 } 741 742 func queryQueryWhereNot(t *testing.T, driver *RavenTestDriver) { 743 store := driver.getDocumentStoreMust(t) 744 defer store.Close() 745 746 queryAddUsers(t, store, driver) 747 748 { 749 session := openSessionMust(t, store) 750 751 { 752 var res []*User 753 q := session.QueryCollectionForType(userType) 754 q = q.Not() 755 q = q.WhereEquals("name", "tarzan") 756 err := q.GetResults(&res) 757 758 assert.NoError(t, err) 759 760 assert.Equal(t, len(res), 2) 761 } 762 763 { 764 var res []*User 765 q := session.QueryCollectionForType(userType) 766 q = q.WhereNotEquals("name", "tarzan") 767 err := q.GetResults(&res) 768 769 assert.NoError(t, err) 770 771 assert.Equal(t, len(res), 2) 772 } 773 774 { 775 var res []*User 776 q := session.QueryCollectionForType(userType) 777 q = q.WhereNotEquals("name", "Tarzan").Exact() 778 err := q.GetResults(&res) 779 assert.NoError(t, err) 780 781 assert.Equal(t, len(res), 2) 782 } 783 784 session.Close() 785 } 786 } 787 788 /* 789 TODO: is this used? 790 static class Result { 791 long delay 792 793 long getDelay() { 794 return delay 795 } 796 797 setDelay(long delay) { 798 this.delay = delay 799 } 800 } 801 */ 802 803 func NewOrderTime() *ravendb.IndexCreationTask { 804 res := ravendb.NewIndexCreationTask("OrderTime") 805 res.Map = `from order in docs.Orders 806 select new { 807 delay = order.shippedAt - ((DateTime?)order.orderedAt) 808 }` 809 return res 810 } 811 812 func queryQueryWithDuration(t *testing.T, driver *RavenTestDriver) { 813 var err error 814 store := driver.getDocumentStoreMust(t) 815 defer store.Close() 816 817 now := ravendb.Time(time.Now()) 818 819 index := NewOrderTime() 820 err = store.ExecuteIndex(index, "") 821 assert.NoError(t, err) 822 823 { 824 session := openSessionMust(t, store) 825 826 order1 := &Order{ 827 Company: "hours", 828 OrderedAt: addHours(now, -2), 829 ShippedAt: now, 830 } 831 832 err = session.Store(order1) 833 assert.NoError(t, err) 834 835 order2 := &Order{ 836 Company: "days", 837 OrderedAt: addDays(now, -2), 838 ShippedAt: now, 839 } 840 err = session.Store(order2) 841 assert.NoError(t, err) 842 843 order3 := &Order{ 844 Company: "minutes", 845 OrderedAt: addMinutes(now, -2), 846 ShippedAt: now, 847 } 848 849 err = session.Store(order3) 850 assert.NoError(t, err) 851 852 err = session.SaveChanges() 853 assert.NoError(t, err) 854 855 session.Close() 856 } 857 858 err = driver.waitForIndexing(store, "", 0) 859 assert.NoError(t, err) 860 { 861 session := openSessionMust(t, store) 862 863 { 864 var orders []*Order 865 q := session.QueryIndex(NewOrderTime().IndexName) 866 q = q.WhereLessThan("delay", time.Hour*3) 867 err := q.GetResults(&orders) 868 assert.NoError(t, err) 869 870 var delay []string 871 for _, order := range orders { 872 company := order.Company 873 delay = append(delay, company) 874 } 875 sort.Strings(delay) 876 stringArrayEq(delay, []string{"hours", "minutes"}) 877 } 878 879 { 880 var orders []*Order 881 q := session.QueryIndex(NewOrderTime().IndexName) 882 q = q.WhereGreaterThan("delay", time.Hour*3) 883 err := q.GetResults(&orders) 884 assert.NoError(t, err) 885 886 var delay2 []string 887 for _, order := range orders { 888 company := order.Company 889 delay2 = append(delay2, company) 890 } 891 sort.Strings(delay2) 892 stringArrayEq(delay2, []string{"days"}) 893 894 } 895 896 session.Close() 897 } 898 } 899 900 func queryQueryFirst(t *testing.T, driver *RavenTestDriver) { 901 store := driver.getDocumentStoreMust(t) 902 defer store.Close() 903 904 queryAddUsers(t, store, driver) 905 { 906 session := openSessionMust(t, store) 907 908 { 909 var first *User 910 q := session.QueryCollectionForType(userType) 911 err := q.First(&first) 912 assert.NoError(t, err) 913 assert.NotNil(t, first) 914 assert.Equal(t, first.ID, "users/1") 915 } 916 917 { 918 var single *User 919 q := session.QueryCollectionForType(userType) 920 q = q.WhereEquals("name", "Tarzan") 921 err := q.Single(&single) 922 assert.NoError(t, err) 923 assert.NotNil(t, single) 924 assert.Equal(t, *single.Name, "Tarzan") 925 } 926 927 { 928 var single *User 929 q := session.QueryCollectionForType(userType) 930 err := q.Single(&single) 931 assert.Nil(t, single) 932 _ = err.(*ravendb.IllegalStateError) 933 } 934 935 session.Close() 936 } 937 } 938 939 func queryQueryParameters(t *testing.T, driver *RavenTestDriver) { 940 store := driver.getDocumentStoreMust(t) 941 defer store.Close() 942 943 queryAddUsers(t, store, driver) 944 { 945 session := openSessionMust(t, store) 946 947 q := session.RawQuery("from Users where name = $name") 948 q = q.AddParameter("name", "Tarzan") 949 count, err := q.Count() 950 assert.NoError(t, err) 951 952 assert.Equal(t, count, 1) 953 954 session.Close() 955 } 956 } 957 958 func queryQueryRandomOrder(t *testing.T, driver *RavenTestDriver) { 959 store := driver.getDocumentStoreMust(t) 960 defer store.Close() 961 962 queryAddUsers(t, store, driver) 963 { 964 session := openSessionMust(t, store) 965 { 966 var res []*User 967 q := session.QueryCollectionForType(userType) 968 q = q.RandomOrdering() 969 err := q.GetResults(&res) 970 assert.NoError(t, err) 971 assert.Equal(t, len(res), 3) 972 } 973 974 { 975 var res []*User 976 q := session.QueryCollectionForType(userType) 977 q = q.RandomOrderingWithSeed("123") 978 err := q.GetResults(&res) 979 assert.NoError(t, err) 980 assert.Equal(t, len(res), 3) 981 } 982 983 session.Close() 984 } 985 } 986 987 func queryQueryWhereExists(t *testing.T, driver *RavenTestDriver) { 988 store := driver.getDocumentStoreMust(t) 989 defer store.Close() 990 991 queryAddUsers(t, store, driver) 992 { 993 session := openSessionMust(t, store) 994 995 { 996 var res []*User 997 q := session.QueryCollectionForType(userType) 998 q = q.WhereExists("name") 999 err := q.GetResults(&res) 1000 assert.NoError(t, err) 1001 assert.Equal(t, len(res), 3) 1002 } 1003 1004 { 1005 var res []*User 1006 q := session.QueryCollectionForType(userType) 1007 q = q.WhereExists("name") 1008 q = q.AndAlso() 1009 q = q.Not() 1010 q = q.WhereExists("no_such_field") 1011 err := q.GetResults(&res) 1012 assert.NoError(t, err) 1013 assert.Equal(t, len(res), 3) 1014 } 1015 1016 session.Close() 1017 } 1018 } 1019 1020 func queryQueryWithBoost(t *testing.T, driver *RavenTestDriver) { 1021 store := driver.getDocumentStoreMust(t) 1022 defer store.Close() 1023 1024 queryAddUsers(t, store, driver) 1025 { 1026 session := openSessionMust(t, store) 1027 1028 var users []*User 1029 q := session.QueryCollectionForType(userType) 1030 q = q.WhereEquals("name", "Tarzan") 1031 q = q.Boost(5) 1032 q = q.OrElse() 1033 q = q.WhereEquals("name", "John") 1034 q = q.Boost(2) 1035 q = q.OrderByScore() 1036 err := q.GetResults(&users) 1037 assert.NoError(t, err) 1038 1039 assert.Equal(t, len(users), 3) 1040 1041 var names []string 1042 for _, user := range users { 1043 names = append(names, *user.Name) 1044 } 1045 assert.True(t, stringArrayContainsSequence(names, []string{"Tarzan", "John", "John"})) 1046 1047 users = nil 1048 q = session.QueryCollectionForType(userType) 1049 q = q.WhereEquals("name", "Tarzan") 1050 q = q.Boost(2) 1051 q = q.OrElse() 1052 q = q.WhereEquals("name", "John") 1053 q = q.Boost(5) 1054 q = q.OrderByScore() 1055 err = q.GetResults(&users) 1056 assert.NoError(t, err) 1057 1058 assert.Equal(t, len(users), 3) 1059 1060 names = nil 1061 for _, user := range users { 1062 names = append(names, *user.Name) 1063 } 1064 1065 assert.True(t, stringArrayContainsSequence(names, []string{"John", "John", "Tarzan"})) 1066 1067 session.Close() 1068 } 1069 } 1070 1071 func makeUsersByNameIndex() *ravendb.IndexCreationTask { 1072 res := ravendb.NewIndexCreationTask("UsersByName") 1073 res.Map = "from c in docs.Users select new " + 1074 " {" + 1075 " c.name, " + 1076 " count = 1" + 1077 "}" 1078 res.Reduce = "from result in results " + 1079 "group result by result.name " + 1080 "into g " + 1081 "select new " + 1082 "{ " + 1083 " name = g.Key, " + 1084 " count = g.Sum(x => x.count) " + 1085 "}" 1086 return res 1087 } 1088 1089 func queryAddUsers(t *testing.T, store *ravendb.DocumentStore, driver *RavenTestDriver) { 1090 var err error 1091 1092 { 1093 session := openSessionMust(t, store) 1094 user1 := &User{} 1095 user1.setName("John") 1096 user1.Age = 3 1097 1098 user2 := &User{} 1099 user2.setName("John") 1100 user2.Age = 5 1101 1102 user3 := &User{} 1103 user3.setName("Tarzan") 1104 user3.Age = 2 1105 1106 err = session.StoreWithID(user1, "users/1") 1107 assert.NoError(t, err) 1108 err = session.StoreWithID(user2, "users/2") 1109 assert.NoError(t, err) 1110 err = session.StoreWithID(user3, "users/3") 1111 assert.NoError(t, err) 1112 err = session.SaveChanges() 1113 assert.NoError(t, err) 1114 1115 session.Close() 1116 } 1117 1118 err = store.ExecuteIndex(makeUsersByNameIndex(), "") 1119 assert.NoError(t, err) 1120 err = driver.waitForIndexing(store, "", 0) 1121 assert.NoError(t, err) 1122 } 1123 1124 func queryQueryWithCustomize(t *testing.T, driver *RavenTestDriver) { 1125 store := driver.getDocumentStoreMust(t) 1126 defer store.Close() 1127 1128 err := store.ExecuteIndex(makeDogsIndex(), "") 1129 assert.NoError(t, err) 1130 1131 { 1132 newSession := openSessionMust(t, store) 1133 queryCreateDogs(t, newSession) 1134 err = newSession.SaveChanges() 1135 assert.NoError(t, err) 1136 1137 newSession.Close() 1138 } 1139 1140 { 1141 newSession := openSessionMust(t, store) 1142 1143 q := newSession.Advanced().QueryIndex("DogsIndex") 1144 q = q.WaitForNonStaleResults(0) 1145 q = q.OrderByWithOrdering("name", ravendb.OrderingTypeAlphaNumeric) 1146 q = q.WhereGreaterThan("age", 2) 1147 var queryResult []*DogsIndex_Result 1148 err := q.GetResults(&queryResult) 1149 assert.NoError(t, err) 1150 1151 assert.Equal(t, len(queryResult), 4) 1152 1153 r := queryResult[0] 1154 assert.Equal(t, r.Name, "Brian") 1155 1156 r = queryResult[1] 1157 assert.Equal(t, r.Name, "Django") 1158 1159 r = queryResult[2] 1160 assert.Equal(t, r.Name, "Lassie") 1161 1162 r = queryResult[3] 1163 assert.Equal(t, r.Name, "Snoopy") 1164 1165 newSession.Close() 1166 } 1167 } 1168 1169 func queryCreateDogs(t *testing.T, newSession *ravendb.DocumentSession) { 1170 var err error 1171 1172 dog1 := NewDog() 1173 dog1.Name = "Snoopy" 1174 dog1.Breed = "Beagle" 1175 dog1.Color = "White" 1176 dog1.Age = 6 1177 dog1.IsVaccinated = true 1178 1179 err = newSession.StoreWithID(dog1, "docs/1") 1180 assert.NoError(t, err) 1181 1182 dog2 := NewDog() 1183 dog2.Name = "Brian" 1184 dog2.Breed = "Labrador" 1185 dog2.Color = "White" 1186 dog2.Age = 12 1187 dog2.IsVaccinated = false 1188 1189 err = newSession.StoreWithID(dog2, "docs/2") 1190 assert.NoError(t, err) 1191 1192 dog3 := NewDog() 1193 dog3.Name = "Django" 1194 dog3.Breed = "Jack Russel" 1195 dog3.Color = "Black" 1196 dog3.Age = 3 1197 dog3.IsVaccinated = true 1198 1199 err = newSession.StoreWithID(dog3, "docs/3") 1200 assert.NoError(t, err) 1201 1202 dog4 := NewDog() 1203 dog4.Name = "Beethoven" 1204 dog4.Breed = "St. Bernard" 1205 dog4.Color = "Brown" 1206 dog4.Age = 1 1207 dog4.IsVaccinated = false 1208 1209 err = newSession.StoreWithID(dog4, "docs/4") 1210 assert.NoError(t, err) 1211 1212 dog5 := NewDog() 1213 dog5.Name = "Scooby Doo" 1214 dog5.Breed = "Great Dane" 1215 dog5.Color = "Brown" 1216 dog5.Age = 0 1217 dog5.IsVaccinated = false 1218 1219 err = newSession.StoreWithID(dog5, "docs/5") 1220 assert.NoError(t, err) 1221 1222 dog6 := NewDog() 1223 dog6.Name = "Old Yeller" 1224 dog6.Breed = "Black Mouth Cur" 1225 dog6.Color = "White" 1226 dog6.Age = 2 1227 dog6.IsVaccinated = true 1228 1229 err = newSession.StoreWithID(dog6, "docs/6") 1230 assert.NoError(t, err) 1231 1232 dog7 := NewDog() 1233 dog7.Name = "Benji" 1234 dog7.Breed = "Mixed" 1235 dog7.Color = "White" 1236 dog7.Age = 0 1237 dog7.IsVaccinated = false 1238 1239 err = newSession.StoreWithID(dog7, "docs/7") 1240 assert.NoError(t, err) 1241 1242 dog8 := NewDog() 1243 dog8.Name = "Lassie" 1244 dog8.Breed = "Collie" 1245 dog8.Color = "Brown" 1246 dog8.Age = 6 1247 dog8.IsVaccinated = true 1248 1249 err = newSession.StoreWithID(dog8, "docs/8") 1250 assert.NoError(t, err) 1251 } 1252 1253 type Dog struct { 1254 ID string 1255 Name string `json:"name"` 1256 Breed string `json:"breed"` 1257 Color string `json:"color"` 1258 Age int `json:"age"` 1259 IsVaccinated bool `json:"vaccinated"` 1260 } 1261 1262 func NewDog() *Dog { 1263 return &Dog{} 1264 } 1265 1266 type DogsIndex_Result struct { 1267 Name string `json:"name"` 1268 Age int `json:"age"` 1269 IsVaccinated bool `json:"vaccinated"` 1270 } 1271 1272 func makeDogsIndex() *ravendb.IndexCreationTask { 1273 res := ravendb.NewIndexCreationTask("DogsIndex") 1274 res.Map = "from dog in docs.dogs select new { dog.name, dog.age, dog.vaccinated }" 1275 return res 1276 } 1277 1278 func queryQueryLongRequest(t *testing.T, driver *RavenTestDriver) { 1279 var err error 1280 store := driver.getDocumentStoreMust(t) 1281 defer store.Close() 1282 1283 { 1284 newSession := openSessionMust(t, store) 1285 1286 longName := strings.Repeat("x", 2048) 1287 user := &User{} 1288 user.setName(longName) 1289 err = newSession.StoreWithID(user, "users/1") 1290 assert.NoError(t, err) 1291 1292 err = newSession.SaveChanges() 1293 assert.NoError(t, err) 1294 1295 q := newSession.Advanced().QueryCollection("Users") 1296 q = q.WhereEquals("name", longName) 1297 var queryResult []*User 1298 err := q.GetResults(&queryResult) 1299 assert.NoError(t, err) 1300 assert.Equal(t, len(queryResult), 1) 1301 1302 newSession.Close() 1303 } 1304 } 1305 1306 func queryQueryByIndex(t *testing.T, driver *RavenTestDriver) { 1307 var err error 1308 store := driver.getDocumentStoreMust(t) 1309 defer store.Close() 1310 1311 err = store.ExecuteIndex(makeDogsIndex(), "") 1312 assert.NoError(t, err) 1313 1314 { 1315 newSession := openSessionMust(t, store) 1316 queryCreateDogs(t, newSession) 1317 1318 err = newSession.SaveChanges() 1319 assert.NoError(t, err) 1320 1321 err = driver.waitForIndexing(store, store.GetDatabase(), 0) 1322 assert.NoError(t, err) 1323 1324 newSession.Close() 1325 } 1326 1327 { 1328 newSession := openSessionMust(t, store) 1329 1330 q := newSession.Advanced().QueryIndex("DogsIndex") 1331 q = q.WhereGreaterThan("age", 2) 1332 q = q.AndAlso() 1333 q = q.WhereEquals("vaccinated", false) 1334 var queryResult []*DogsIndex_Result 1335 err := q.GetResults(&queryResult) 1336 assert.NoError(t, err) 1337 1338 assert.Equal(t, len(queryResult), 1) 1339 r := queryResult[0] 1340 assert.Equal(t, r.Name, "Brian") 1341 1342 q = newSession.Advanced().QueryIndex("DogsIndex") 1343 q = q.WhereLessThanOrEqual("age", 2) 1344 q = q.AndAlso() 1345 q = q.WhereEquals("vaccinated", false) 1346 var queryResult2 []*DogsIndex_Result 1347 err = q.GetResults(&queryResult2) 1348 assert.NoError(t, err) 1349 1350 assert.Equal(t, len(queryResult2), 3) 1351 1352 var names []string 1353 for _, dir := range queryResult2 { 1354 name := dir.Name 1355 names = append(names, name) 1356 } 1357 sort.Strings(names) 1358 1359 assert.True(t, stringArrayContainsSequence(names, []string{"Beethoven", "Benji", "Scooby Doo"})) 1360 newSession.Close() 1361 } 1362 } 1363 1364 type ReduceResult struct { 1365 Count int `json:"count"` 1366 Name string `json:"name"` 1367 Age int `json:"age"` 1368 } 1369 1370 func TestQuery(t *testing.T) { 1371 driver := createTestDriver(t) 1372 destroy := func() { destroyDriver(t, driver) } 1373 defer recoverTest(t, destroy) 1374 1375 // matches order of Java tests 1376 queryQueryWhereExists(t, driver) 1377 queryQuerySearchWithOr(t, driver) 1378 queryRawQuerySkipTake(t, driver) 1379 queryQueryWithDuration(t, driver) 1380 queryQueryWithWhereClause(t, driver) 1381 queryQueryMapReduceIndex(t, driver) 1382 queryQueryLazily(t, driver) 1383 queryQueryLucene(t, driver) 1384 queryQueryWithWhereGreaterThan(t, driver) 1385 queryQuerySimple(t, driver) 1386 queryQueryWithSelect(t, driver) 1387 queryCollectionsStats(t, driver) 1388 queryQueryWithWhereBetween(t, driver) 1389 queryQueryRandomOrder(t, driver) 1390 queryQueryNoTracking(t, driver) 1391 queryQueryLongRequest(t, driver) 1392 queryQueryWithProjection2(t, driver) 1393 queryQueryWhereNot(t, driver) 1394 queryQuerySkipTake(t, driver) 1395 queryQueryWithProjection(t, driver) 1396 queryQueryFirst(t, driver) 1397 queryQuerySingleProperty(t, driver) 1398 queryParametersInRawQuery(t, driver) 1399 queryQueryWithWhereLessThan(t, driver) 1400 queryQueryMapReduceWithCount(t, driver) 1401 queryQueryWithWhereGreaterThanOrEqual(t, driver) 1402 queryQueryWithCustomize(t, driver) 1403 queryQueryWithBoost(t, driver) 1404 queryQueryMapReduceWithSum(t, driver) 1405 queryQueryWhereExact(t, driver) 1406 queryQueryParameters(t, driver) 1407 queryQueryByIndex(t, driver) 1408 queryQueryWithWhereIn(t, driver) 1409 queryQueryDistinct(t, driver) 1410 queryQueryWithWhereLessThanOrEqual(t, driver) 1411 }