Merge branch 'master' into ligurio/gh-166-sharding-keys

Author: ligurio

CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+### Added
+
+* `crud.len()` function to calculate the number of tuples
+  in the space for memtx engine and calculate the maximum
+  approximate number of tuples in the space for vinyl engine.
+
 ## [0.8.0] - 02-07-21
 
 ### Fixed

README.md

@@ -487,6 +487,54 @@ crud.truncate('customers', {timeout = 2})
 ...
 ```
 
+### Len
+
+```lua
+-- Calculates the number of tuples in the space for memtx engine
+-- Calculates the maximum approximate number of tuples in the space for vinyl engine
+local result, err = crud.len(space_name, opts)
+```
+
+where:
+
+* `space_name` (`string|number`) - name of the space as well
+  as numerical id of the space
+* `opts`:
+  * `timeout` (`?number`) - `vshard.call` timeout (in seconds)
+
+Returns number or nil with error.
+
+**Example:**
+
+Using `memtx`:
+
+```lua
+#crud.select('customers')
+---
+- 5
+...
+crud.len('customers', {timeout = 2})
+---
+- 5
+...
+```
+
+Using `vinyl`:
+
+```lua
+crud.len('customers')
+---
+- 0
+...
+crud.delete('customers', 1)
+---
+...
+crud.len('customers')
+---
+- 1
+...
+```
+
 ## Cartridge roles
 
 `cartridge.roles.crud-storage` is a Tarantool Cartridge role that depends on the

crud.lua

@@ -10,6 +10,7 @@ local upsert = require('crud.upsert')
 local delete = require('crud.delete')
 local select = require('crud.select')
 local truncate = require('crud.truncate')
+local len = require('crud.len')
 local borders = require('crud.borders')
 local utils = require('crud.common.utils')
 
@@ -70,6 +71,10 @@ crud.unflatten_rows = utils.unflatten_rows
 -- @function truncate
 crud.truncate = truncate.call
 
+-- @refer len.call
+-- @function len
+crud.len = len.call
+
 -- @refer borders.min
 -- @function min
 crud.min = borders.min
@@ -106,6 +111,7 @@ function crud.init_storage()
     delete.init()
     select.init()
     truncate.init()
+    len.init()
     borders.init()
 end
 

crud/len.lua

@@ -0,0 +1,67 @@
+local checks = require('checks')
+local errors = require('errors')
+local vshard = require('vshard')
+
+local utils = require('crud.common.utils')
+local dev_checks = require('crud.common.dev_checks')
+
+local LenError = errors.new_class('LenError',  {capture_stack = false})
+
+local len = {}
+
+local LEN_FUNC_NAME = '_crud.len_on_storage'
+
+local function len_on_storage(space_name)
+    dev_checks('string|number')
+
+    return box.space[space_name]:len()
+end
+
+function len.init()
+    _G._crud.len_on_storage = len_on_storage
+end
+
+--- Calculates the number of tuples in the space for memtx engine
+--- Calculates the maximum approximate number of tuples in the space for vinyl engine
+--
+-- @function call
+--
+-- @param string|number space_name
+--  A space name as well as numerical id
+--
+-- @tparam ?number opts.timeout
+--  Function call timeout
+--
+-- @return[1] number
+-- @treturn[2] nil
+-- @treturn[2] table Error description
+--
+function len.call(space_name, opts)
+    checks('string|number', {
+        timeout = '?number',
+    })
+
+    opts = opts or {}
+
+    local space = utils.get_space(space_name, vshard.router.routeall())
+    if space == nil then
+        return nil, LenError:new("Space %q doesn't exist", space_name)
+    end
+
+    local results, err = vshard.router.map_callrw(LEN_FUNC_NAME, {space_name}, opts)
+
+    if err ~= nil then
+        return nil, LenError:new("Failed to call len on storage-side: %s", err)
+    end
+
+    local total_len = 0
+    for _, replicaset_results in pairs(results) do
+        if replicaset_results[1] ~= nil then
+            total_len = total_len + replicaset_results[1]
+        end
+    end
+
+    return total_len
+end
+
+return len

test/integration/len_test.lua

@@ -0,0 +1,64 @@
+local fio = require('fio')
+
+local t = require('luatest')
+
+local helpers = require('test.helper')
+
+local pgroup = helpers.pgroup.new('len', {
+    engine = {'memtx'},
+})
+
+pgroup:set_before_all(function(g)
+    g.cluster = helpers.Cluster:new({
+        datadir = fio.tempdir(),
+        server_command = helpers.entrypoint('srv_select'),
+        use_vshard = true,
+        replicasets = helpers.get_test_replicasets(),
+        env = {
+            ['ENGINE'] = g.params.engine,
+        },
+    })
+
+    g.cluster:start()
+end)
+
+pgroup:set_after_all(function(g) helpers.stop_cluster(g.cluster) end)
+
+pgroup:set_before_each(function(g)
+    helpers.truncate_space_on_cluster(g.cluster, 'customers')
+end)
+
+pgroup:add('test_len_non_existent_space', function(g)
+    local result, err = g.cluster.main_server.net_box:call('crud.len', {'non_existent_space'})
+
+    t.assert_equals(result, nil)
+    t.assert_str_contains(err.err, "Space \"non_existent_space\" doesn't exist")
+end)
+
+pgroup:add('test_len', function(g)
+    local customers = {}
+    local expected_len = 100
+
+    -- let's insert a large number of tuples in a simple loop that gives
+    -- really high probability that there is at least one tuple on each storage
+    for i = 1, expected_len do
+        table.insert(customers, {
+            id = i, name = tostring(i), last_name = tostring(i),
+            age = i, city = tostring(i),
+        })
+    end
+
+    helpers.insert_objects(g, 'customers', customers)
+
+    local result, err = g.cluster.main_server.net_box:call('crud.len', {'customers'})
+
+    t.assert_equals(err, nil)
+    t.assert_equals(result, expected_len)
+end)
+
+pgroup:add('test_len_empty_space', function(g)
+    local result, err = g.cluster.main_server.net_box:call('crud.len', {'customers'})
+
+    t.assert_equals(err, nil)
+    t.assert_equals(result, 0)
+end)