github.com/ravendb/ravendb-go-client@v0.0.0-20240229102137-4474ee7aa0fa/tests/query_streaming_test.go (about)

     1  package tests
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/json"
     6  	"fmt"
     7  	"io"
     8  	"testing"
     9  	"time"
    10  
    11  	ravendb "github.com/ravendb/ravendb-go-client"
    12  	"github.com/stretchr/testify/assert"
    13  )
    14  
    15  func queryStreamingCanStreamQueryResults(t *testing.T, driver *RavenTestDriver) {
    16  	var err error
    17  	store := driver.getDocumentStoreMust(t)
    18  	defer store.Close()
    19  
    20  	index := NewUsersByName2()
    21  	err = index.Execute(store, nil, "")
    22  	assert.NoError(t, err)
    23  
    24  	{
    25  		session := openSessionMust(t, store)
    26  		for i := 0; i < 200; i++ {
    27  			err = session.Store(&User{})
    28  			assert.NoError(t, err)
    29  		}
    30  		err = session.SaveChanges()
    31  		assert.NoError(t, err)
    32  	}
    33  	err = driver.waitForIndexing(store, store.GetDatabase(), 0)
    34  	assert.NoError(t, err)
    35  
    36  	count := 0
    37  	{
    38  		session := openSessionMust(t, store)
    39  		query := session.QueryIndex(index.IndexName)
    40  		stream, err := session.Advanced().StreamQuery(query, nil)
    41  		assert.NoError(t, err)
    42  		for {
    43  			var u *User
    44  			_, err = stream.Next(&u)
    45  			if err != nil {
    46  				break
    47  			}
    48  			count++
    49  			assert.NotNil(t, u)
    50  		}
    51  		if err == io.EOF {
    52  			err = nil
    53  		}
    54  		assert.NoError(t, err)
    55  		err = stream.Close()
    56  		assert.NoError(t, err)
    57  		assert.Equal(t, 200, count)
    58  	}
    59  }
    60  
    61  func queryStreamingCanStreamQueryResultsWithQueryStatistics(t *testing.T, driver *RavenTestDriver) {
    62  	var err error
    63  	store := driver.getDocumentStoreMust(t)
    64  	defer store.Close()
    65  
    66  	index := NewUsersByName2()
    67  	err = index.Execute(store, nil, "")
    68  	assert.NoError(t, err)
    69  
    70  	{
    71  		session := openSessionMust(t, store)
    72  		for i := 0; i < 100; i++ {
    73  			err = session.Store(&User{})
    74  			assert.NoError(t, err)
    75  		}
    76  		err = session.SaveChanges()
    77  		assert.NoError(t, err)
    78  	}
    79  	err = driver.waitForIndexing(store, store.GetDatabase(), 0)
    80  	assert.NoError(t, err)
    81  
    82  	{
    83  		session := openSessionMust(t, store)
    84  		query := session.QueryIndex(index.IndexName)
    85  		statsRef := &ravendb.StreamQueryStatistics{}
    86  
    87  		stream, err := session.Advanced().StreamQuery(query, statsRef)
    88  		assert.NoError(t, err)
    89  		for {
    90  			var u *User
    91  			_, err = stream.Next(&u)
    92  			if err != nil {
    93  				break
    94  			}
    95  			assert.NotNil(t, u)
    96  		}
    97  		if err == io.EOF {
    98  			err = nil
    99  		}
   100  		assert.NoError(t, err)
   101  		err = stream.Close()
   102  		assert.NoError(t, err)
   103  
   104  		assert.Equal(t, statsRef.IndexName, index.IndexName)
   105  		assert.Equal(t, statsRef.TotalResults, 100)
   106  		assert.Equal(t, statsRef.IndexTimestamp.Year(), time.Now().Year())
   107  	}
   108  }
   109  
   110  func queryStreamingCanStreamRawQueryResults(t *testing.T, driver *RavenTestDriver) {
   111  	var err error
   112  	store := driver.getDocumentStoreMust(t)
   113  	defer store.Close()
   114  
   115  	index := NewUsersByName2()
   116  	err = index.Execute(store, nil, "")
   117  	assert.NoError(t, err)
   118  
   119  	{
   120  		session := openSessionMust(t, store)
   121  		for i := 0; i < 200; i++ {
   122  			err = session.Store(&User{})
   123  			assert.NoError(t, err)
   124  		}
   125  		err = session.SaveChanges()
   126  		assert.NoError(t, err)
   127  	}
   128  	err = driver.waitForIndexing(store, store.GetDatabase(), 0)
   129  	assert.NoError(t, err)
   130  
   131  	count := 0
   132  	{
   133  		session := openSessionMust(t, store)
   134  		qs := fmt.Sprintf(`from index '%s'`, index.IndexName)
   135  		query := session.Advanced().RawQuery(qs)
   136  		stream, err := session.Advanced().StreamRawQuery(query, nil)
   137  		assert.NoError(t, err)
   138  		for {
   139  			var u *User
   140  			_, err = stream.Next(&u)
   141  			if err != nil {
   142  				break
   143  			}
   144  			count++
   145  			assert.NotNil(t, u)
   146  		}
   147  		if err == io.EOF {
   148  			err = nil
   149  		}
   150  		assert.NoError(t, err)
   151  		err = stream.Close()
   152  		assert.NoError(t, err)
   153  		assert.Equal(t, 200, count)
   154  	}
   155  }
   156  
   157  func queryStreamingCanStreamRawQueryResultsWithQueryStatistics(t *testing.T, driver *RavenTestDriver) {
   158  	var err error
   159  	store := driver.getDocumentStoreMust(t)
   160  	defer store.Close()
   161  
   162  	index := NewUsersByName2()
   163  	err = index.Execute(store, nil, "")
   164  	assert.NoError(t, err)
   165  
   166  	{
   167  		session := openSessionMust(t, store)
   168  		for i := 0; i < 100; i++ {
   169  			err = session.Store(&User{})
   170  			assert.NoError(t, err)
   171  		}
   172  		err = session.SaveChanges()
   173  		assert.NoError(t, err)
   174  	}
   175  	err = driver.waitForIndexing(store, store.GetDatabase(), 0)
   176  	assert.NoError(t, err)
   177  
   178  	{
   179  		session := openSessionMust(t, store)
   180  		statsRef := &ravendb.StreamQueryStatistics{}
   181  		qs := fmt.Sprintf(`from index '%s'`, index.IndexName)
   182  		query := session.Advanced().RawQuery(qs)
   183  		stream, err := session.Advanced().StreamRawQuery(query, statsRef)
   184  		assert.NoError(t, err)
   185  		for {
   186  			var u *User
   187  			_, err = stream.Next(&u)
   188  			if err != nil {
   189  				break
   190  			}
   191  			assert.NotNil(t, u)
   192  		}
   193  		if err == io.EOF {
   194  			err = nil
   195  		}
   196  		assert.NoError(t, err)
   197  		err = stream.Close()
   198  		assert.NoError(t, err)
   199  
   200  		assert.Equal(t, statsRef.IndexName, index.IndexName)
   201  		assert.Equal(t, statsRef.TotalResults, 100)
   202  		assert.Equal(t, statsRef.IndexTimestamp.Year(), time.Now().Year())
   203  	}
   204  }
   205  
   206  func queryStreamingCanStreamRawQueryIntoStream(t *testing.T, driver *RavenTestDriver) {
   207  	var err error
   208  	store := driver.getDocumentStoreMust(t)
   209  	defer store.Close()
   210  
   211  	index := NewUsersByName2()
   212  	err = index.Execute(store, nil, "")
   213  	assert.NoError(t, err)
   214  
   215  	{
   216  		session := openSessionMust(t, store)
   217  		err = session.Store(&User{})
   218  		assert.NoError(t, err)
   219  		err = session.SaveChanges()
   220  		assert.NoError(t, err)
   221  	}
   222  	err = driver.waitForIndexing(store, store.GetDatabase(), 0)
   223  	assert.NoError(t, err)
   224  
   225  	{
   226  		var buf bytes.Buffer
   227  		session := openSessionMust(t, store)
   228  		qs := fmt.Sprintf(`from index '%s'`, index.IndexName)
   229  		query := session.Advanced().RawQuery(qs)
   230  		err = session.Advanced().StreamRawQueryInto(query, &buf)
   231  		assert.NoError(t, err)
   232  
   233  		var m map[string]interface{}
   234  		err = json.Unmarshal(buf.Bytes(), &m)
   235  		assert.NoError(t, err)
   236  		_, ok := m["Results"]
   237  		assert.True(t, ok)
   238  	}
   239  }
   240  
   241  func queryStreamingCanStreamQueryIntoStream(t *testing.T, driver *RavenTestDriver) {
   242  	var err error
   243  	store := driver.getDocumentStoreMust(t)
   244  	defer store.Close()
   245  
   246  	index := NewUsersByName2()
   247  	err = index.Execute(store, nil, "")
   248  	assert.NoError(t, err)
   249  
   250  	{
   251  		session := openSessionMust(t, store)
   252  		err = session.Store(&User{})
   253  		assert.NoError(t, err)
   254  		err = session.SaveChanges()
   255  		assert.NoError(t, err)
   256  	}
   257  	err = driver.waitForIndexing(store, store.GetDatabase(), 0)
   258  	assert.NoError(t, err)
   259  
   260  	{
   261  		var buf bytes.Buffer
   262  		session := openSessionMust(t, store)
   263  		query := session.QueryIndex(index.IndexName)
   264  		err = session.Advanced().StreamQueryInto(query, &buf)
   265  		assert.NoError(t, err)
   266  
   267  		var m map[string]interface{}
   268  		err = json.Unmarshal(buf.Bytes(), &m)
   269  		assert.NoError(t, err)
   270  		_, ok := m["Results"]
   271  		assert.True(t, ok)
   272  	}
   273  }
   274  
   275  // avoid conflicts with NewUsers_ByName in indexes_from_client_test.go
   276  func NewUsersByName2() *ravendb.IndexCreationTask {
   277  	res := ravendb.NewIndexCreationTask("NewUsers_ByName2")
   278  	res.Map = "from u in docs.Users select new { u.name, lastName = u.lastName.Boost(10) }"
   279  	res.Index("name", ravendb.FieldIndexingSearch)
   280  	res.IndexSuggestions = append(res.IndexSuggestions, "name")
   281  	res.Store("name", ravendb.FieldStorageYes)
   282  	return res
   283  }
   284  
   285  func TestQueryStreaming(t *testing.T) {
   286  	driver := createTestDriver(t)
   287  	destroy := func() { destroyDriver(t, driver) }
   288  	defer recoverTest(t, destroy)
   289  
   290  	// matches order of Java tests
   291  	queryStreamingCanStreamQueryIntoStream(t, driver)
   292  	queryStreamingCanStreamQueryResultsWithQueryStatistics(t, driver)
   293  	queryStreamingCanStreamQueryResults(t, driver)
   294  	queryStreamingCanStreamRawQueryResults(t, driver)
   295  	queryStreamingCanStreamRawQueryIntoStream(t, driver)
   296  	queryStreamingCanStreamRawQueryResultsWithQueryStatistics(t, driver)
   297  }