github.com/altipla-consulting/ravendb-go-client@v0.1.3/tests/ravendb_8761_test.go (about)

     1  package tests
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  
     7  	ravendb "github.com/altipla-consulting/ravendb-go-client"
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  func ravendb8761canGroupByArrayValues(t *testing.T, driver *RavenTestDriver) {
    12  	store := driver.getDocumentStoreMust(t)
    13  	defer store.Close()
    14  
    15  	ravendb8761putDocs(t, store)
    16  
    17  	{
    18  		session := openSessionMust(t, store)
    19  
    20  		var productCounts1 []*ProductCount
    21  		q := session.Advanced().RawQuery(`from Orders group by lines[].product
    22    order by count()
    23    select key() as productName, count() as count`)
    24  		q = q.WaitForNonStaleResults()
    25  		err := q.GetResults(&productCounts1)
    26  		assert.NoError(t, err)
    27  
    28  		q2 := session.Advanced().QueryCollectionForType(reflect.TypeOf(&Order{}))
    29  		q3 := q2.GroupBy("lines[].product")
    30  		q3 = q3.SelectKeyWithNameAndProjectedName("", "productName")
    31  		q2 = q3.SelectCount()
    32  		var productCounts2 []*ProductCount
    33  		err = q2.GetResults(&productCounts2)
    34  		assert.NoError(t, err)
    35  
    36  		combined := [][]*ProductCount{productCounts1, productCounts2}
    37  		for _, products := range combined {
    38  			assert.Equal(t, len(products), 2)
    39  
    40  			product := products[0]
    41  			assert.Equal(t, product.ProductName, "products/1")
    42  			assert.Equal(t, product.Count, 1)
    43  
    44  			product = products[1]
    45  			assert.Equal(t, product.ProductName, "products/2")
    46  			assert.Equal(t, product.Count, 2)
    47  		}
    48  
    49  		session.Close()
    50  	}
    51  
    52  	{
    53  		session := openSessionMust(t, store)
    54  
    55  		var productCounts1 []*ProductCount
    56  		q := session.Advanced().RawQuery("from Orders\n" +
    57  			" group by lines[].product, shipTo.country\n" +
    58  			" order by count() \n" +
    59  			" select lines[].product as productName, shipTo.country as country, count() as count")
    60  		err := q.GetResults(&productCounts1)
    61  		assert.NoError(t, err)
    62  
    63  		var productCounts2 []*ProductCount
    64  		q2 := session.Advanced().QueryCollectionForType(reflect.TypeOf(&Order{}))
    65  		assert.NoError(t, err)
    66  		q3 := q2.GroupBy("lines[].product", "shipTo.country")
    67  		q3 = q3.SelectKeyWithNameAndProjectedName("lines[].product", "productName")
    68  		q3 = q3.SelectKeyWithNameAndProjectedName("shipTo.country", "country")
    69  		q2 = q3.SelectCount()
    70  		err = q2.GetResults(&productCounts2)
    71  		assert.NoError(t, err)
    72  
    73  		combined := [][]*ProductCount{productCounts1, productCounts2}
    74  		for _, products := range combined {
    75  			assert.Equal(t, len(products), 2)
    76  
    77  			product := products[0]
    78  			assert.Equal(t, product.ProductName, "products/1")
    79  			assert.Equal(t, product.Count, 1)
    80  			assert.Equal(t, product.Country, "USA")
    81  
    82  			product = products[1]
    83  			assert.Equal(t, product.ProductName, "products/2")
    84  			assert.Equal(t, product.Count, 2)
    85  			assert.Equal(t, product.Country, "USA")
    86  		}
    87  
    88  		session.Close()
    89  	}
    90  
    91  	{
    92  		session := openSessionMust(t, store)
    93  
    94  		var productCounts1 []*ProductCount
    95  		q := session.Advanced().RawQuery("from Orders\n" +
    96  			" group by lines[].product, lines[].quantity\n" +
    97  			" order by lines[].quantity\n" +
    98  			" select lines[].product as productName, lines[].quantity as quantity, count() as count")
    99  		err := q.GetResults(&productCounts1)
   100  		assert.NoError(t, err)
   101  
   102  		var productCounts2 []*ProductCount
   103  		q2 := session.Advanced().QueryCollectionForType(reflect.TypeOf(&Order{}))
   104  		q3 := q2.GroupBy("lines[].product", "lines[].quantity")
   105  		q3 = q3.SelectKeyWithNameAndProjectedName("lines[].product", "productName")
   106  		q3 = q3.SelectKeyWithNameAndProjectedName("lines[].quantity", "quantity")
   107  		q2 = q3.SelectCount()
   108  		err = q2.GetResults(&productCounts2)
   109  		assert.NoError(t, err)
   110  
   111  		combined := [][]*ProductCount{productCounts1, productCounts2}
   112  		for _, products := range combined {
   113  			assert.Equal(t, len(products), 3)
   114  
   115  			product := products[0]
   116  			assert.Equal(t, product.ProductName, "products/1")
   117  
   118  			assert.Equal(t, product.Count, 1)
   119  			assert.Equal(t, product.Quantity, 1)
   120  
   121  			product = products[1]
   122  			assert.Equal(t, product.ProductName, "products/2")
   123  			assert.Equal(t, product.Count, 1)
   124  			assert.Equal(t, product.Quantity, 2)
   125  
   126  			product = products[2]
   127  			assert.Equal(t, product.ProductName, "products/2")
   128  			assert.Equal(t, product.Count, 1)
   129  			assert.Equal(t, product.Quantity, 3)
   130  		}
   131  
   132  		session.Close()
   133  	}
   134  }
   135  
   136  func ravendb8761canGroupByArrayContent(t *testing.T, driver *RavenTestDriver) {
   137  	var err error
   138  	store := driver.getDocumentStoreMust(t)
   139  	defer store.Close()
   140  
   141  	ravendb8761putDocs(t, store)
   142  
   143  	{
   144  		session := openSessionMust(t, store)
   145  
   146  		orderLine1 := &OrderLine{
   147  			Product:  "products/1",
   148  			Quantity: 1,
   149  		}
   150  
   151  		orderLine2 := &OrderLine{
   152  			Product:  "products/2",
   153  			Quantity: 2,
   154  		}
   155  
   156  		address := &Address{
   157  			Country: "USA",
   158  		}
   159  
   160  		order := &Order{
   161  			ShipTo: address,
   162  			Lines:  []*OrderLine{orderLine1, orderLine2},
   163  		}
   164  
   165  		err = session.Store(order)
   166  		assert.NoError(t, err)
   167  		err = session.SaveChanges()
   168  		assert.NoError(t, err)
   169  
   170  		session.Close()
   171  	}
   172  
   173  	{
   174  		session := openSessionMust(t, store)
   175  
   176  		var productCounts1 []*ProductCount
   177  		q := session.Advanced().RawQuery("from Orders group by array(lines[].product)\n" +
   178  			" order by count()\n" +
   179  			" select key() as products, count() as count")
   180  		q = q.WaitForNonStaleResults()
   181  		err = q.GetResults(&productCounts1)
   182  		assert.NoError(t, err)
   183  
   184  		q2 := session.Advanced().QueryCollectionForType(reflect.TypeOf(&Order{}))
   185  		q3 := q2.GroupByFieldWithMethod(ravendb.NewGroupByArray("lines[].product"))
   186  		q3 = q3.SelectKeyWithNameAndProjectedName("", "products")
   187  		q2 = q3.SelectCount()
   188  		q2 = q2.OrderBy("count")
   189  		var productCounts2 []*ProductCount
   190  		err = q2.GetResults(&productCounts2)
   191  		assert.NoError(t, err)
   192  
   193  		combined := [][]*ProductCount{productCounts1, productCounts2}
   194  		for _, products := range combined {
   195  			assert.Equal(t, len(products), 2)
   196  
   197  			product := products[0]
   198  			assert.Equal(t, product.Products, []string{"products/2"})
   199  			assert.Equal(t, product.Count, 1)
   200  
   201  			product = products[1]
   202  			assert.Equal(t, product.Products, []string{"products/1", "products/2"})
   203  
   204  			assert.Equal(t, product.Count, 2)
   205  		}
   206  
   207  		session.Close()
   208  	}
   209  
   210  	{
   211  		session := openSessionMust(t, store)
   212  
   213  		var productCounts1 []*ProductCount
   214  		q := session.Advanced().RawQuery("from Orders\n" +
   215  			" group by array(lines[].product), shipTo.country\n" +
   216  			" order by count()\n" +
   217  			" select lines[].product as products, shipTo.country as country, count() as count")
   218  		q = q.WaitForNonStaleResults()
   219  		err = q.GetResults(&productCounts1)
   220  		assert.NoError(t, err)
   221  
   222  		q2 := session.Advanced().QueryCollectionForType(reflect.TypeOf(&Order{}))
   223  		assert.NoError(t, err)
   224  		q3 := q2.GroupByFieldWithMethod(ravendb.NewGroupByArray("lines[].product"), ravendb.NewGroupByField("shipTo.country"))
   225  		q3 = q3.SelectKeyWithNameAndProjectedName("lines[].product", "products")
   226  		q2 = q3.SelectCount()
   227  		q2 = q2.OrderBy("count")
   228  		var productCounts2 []*ProductCount
   229  		err = q2.GetResults(&productCounts2)
   230  		assert.NoError(t, err)
   231  
   232  		combined := [][]*ProductCount{productCounts1, productCounts2}
   233  		for _, products := range combined {
   234  			assert.Equal(t, len(products), 2)
   235  
   236  			product := products[0]
   237  			assert.Equal(t, product.Products, []string{"products/2"})
   238  			assert.Equal(t, product.Count, 1)
   239  
   240  			product = products[1]
   241  			assert.Equal(t, product.Products, []string{"products/1", "products/2"})
   242  
   243  			assert.Equal(t, product.Count, 2)
   244  		}
   245  
   246  		session.Close()
   247  	}
   248  
   249  	{
   250  		session := openSessionMust(t, store)
   251  
   252  		var productCounts1 []*ProductCount
   253  		q := session.Advanced().RawQuery(`from Orders
   254  group by array(lines[].product), array(lines[].quantity)
   255  order by lines[].quantity
   256  select lines[].product as products, lines[].quantity as quantities, count() as count`)
   257  		assert.NoError(t, err)
   258  		q = q.WaitForNonStaleResults()
   259  		err = q.GetResults(&productCounts1)
   260  		assert.NoError(t, err)
   261  
   262  		q2 := session.Advanced().QueryCollectionForType(reflect.TypeOf(&Order{}))
   263  		assert.NoError(t, err)
   264  		q3 := q2.GroupByFieldWithMethod(ravendb.NewGroupByArray("lines[].product"), ravendb.NewGroupByArray("lines[].quantity"))
   265  		q3 = q3.SelectKeyWithNameAndProjectedName("lines[].product", "products")
   266  		q3 = q3.SelectKeyWithNameAndProjectedName("lines[].quantity", "quantities")
   267  		q2 = q3.SelectCount()
   268  		q2 = q2.OrderBy("count")
   269  		var productCounts2 []*ProductCount
   270  		err = q2.GetResults(&productCounts2)
   271  		assert.NoError(t, err)
   272  
   273  		combined := [][]*ProductCount{productCounts1, productCounts2}
   274  		for _, products := range combined {
   275  			assert.Equal(t, len(products), 2)
   276  
   277  			product := products[0]
   278  			assert.Equal(t, product.Products, []string{"products/2"})
   279  
   280  			assert.Equal(t, product.Count, 1)
   281  			assert.Equal(t, product.Quantities, []int{3})
   282  
   283  			product = products[1]
   284  			assert.Equal(t, product.Products, []string{"products/1", "products/2"})
   285  			assert.Equal(t, product.Count, 2)
   286  			assert.Equal(t, product.Quantities, []int{1, 2})
   287  
   288  		}
   289  
   290  		session.Close()
   291  	}
   292  }
   293  
   294  type ProductCount struct {
   295  	ProductName string   `json:"productName"`
   296  	Count       int      `json:"count"`
   297  	Country     string   `json:"country"`
   298  	Quantity    int      `json:"quantity"`
   299  	Products    []string `json:"products"`
   300  	Quantities  []int    `json:"quantities"`
   301  }
   302  
   303  func ravendb8761putDocs(t *testing.T, store *ravendb.DocumentStore) {
   304  	var err error
   305  
   306  	session := openSessionMust(t, store)
   307  	order1 := &Order{}
   308  
   309  	orderLine11 := &OrderLine{
   310  		Product:  "products/1",
   311  		Quantity: 1,
   312  	}
   313  
   314  	orderLine12 := &OrderLine{
   315  		Product:  "products/2",
   316  		Quantity: 2,
   317  	}
   318  
   319  	order1.Lines = []*OrderLine{orderLine11, orderLine12}
   320  
   321  	address1 := &Address{
   322  		Country: "USA",
   323  	}
   324  
   325  	order1.ShipTo = address1
   326  
   327  	err = session.Store(order1)
   328  	assert.NoError(t, err)
   329  
   330  	orderLine21 := &OrderLine{
   331  		Product:  "products/2",
   332  		Quantity: 3,
   333  	}
   334  
   335  	address2 := &Address{
   336  		Country: "USA",
   337  	}
   338  	order2 := &Order{
   339  		Lines:  []*OrderLine{orderLine21},
   340  		ShipTo: address2,
   341  	}
   342  
   343  	err = session.Store(order2)
   344  	assert.NoError(t, err)
   345  
   346  	err = session.SaveChanges()
   347  	assert.NoError(t, err)
   348  
   349  	session.Close()
   350  }
   351  
   352  func TestRavenDB8761(t *testing.T) {
   353  	driver := createTestDriver(t)
   354  	destroy := func() { destroyDriver(t, driver) }
   355  	defer recoverTest(t, destroy)
   356  
   357  	// matches the order of Java tests
   358  	ravendb8761canGroupByArrayContent(t, driver)
   359  
   360  	ravendb8761canGroupByArrayValues(t, driver)
   361  }