Bug: Equal Condition (#18)

Author: dokshina

crud/select.lua

@@ -158,9 +158,13 @@ local function build_select_iterator(space_name, user_conditions, opts)
         return nil, SelectError:new("Failed to get replicasets to select from: %s", err)
     end
 
-    local key_parts = space.index[plan.scanner.index_id].parts
+    local scan_index = space.index[plan.scanner.index_id]
+    local primary_index = space.index[0]
+
+    local cmp_key_parts = utils.merge_primary_key_parts(scan_index.parts, primary_index.parts)
+    local cmp_operator = select_comparators.get_cmp_operator(plan.scanner.iter)
     local tuples_comparator, err = select_comparators.gen_tuples_comparator(
-        plan.scanner.operator, key_parts
+        cmp_operator, cmp_key_parts
     )
     if err ~= nil then
         return nil, SelectError:new("Failed to generate comparator function: %s", err)
@@ -169,7 +173,6 @@ local function build_select_iterator(space_name, user_conditions, opts)
     local iter = Iterator.new({
         space_name = space_name,
         space_format = space_format,
-        key_parts = key_parts,
         iteration_func = select_iteration,
         comparator = tuples_comparator,
 

crud/select/comparators.lua

@@ -150,6 +150,15 @@ local function gen_array_cmp_func(target, key_parts)
     end
 end
 
+local cmp_operators_by_tarantool_iter = {
+    [box.index.GT] = operators.GT,
+    [box.index.GE] = operators.GT,
+    [box.index.EQ] = operators.GT,
+    [box.index.LT] = operators.LT,
+    [box.index.LE] = operators.LT,
+    [box.index.REQ] = operators.LT,
+}
+
 local array_cmp_funcs_by_operators = {
     [operators.EQ] = array_eq,
     [operators.LT] = array_lt,
@@ -158,23 +167,35 @@ local array_cmp_funcs_by_operators = {
     [operators.GE] = array_ge,
 }
 
-function comparators.gen_func(operator, key_parts)
-    local cmp_func = array_cmp_funcs_by_operators[operator]
+--[=[
+    Each tarantool iterator returns tuples in a strictly defined order
+    (scan key merged with primary key is used to guarantee that)
+    GE, GT and EQ interators return tuples in ascending order
+    LE, LT and REQ - in descending
+--]=]
+function comparators.get_cmp_operator(tarantool_iter)
+    local cmp_operator = cmp_operators_by_tarantool_iter[tarantool_iter]
+    assert(cmp_operator ~= nil, 'Unknown Tarantool iterator %q', tarantool_iter)
+
+    return cmp_operator
+end
 
+function comparators.gen_func(cmp_operator, key_parts)
+    local cmp_func = array_cmp_funcs_by_operators[cmp_operator]
     if cmp_func == nil then
-        return nil, ComparatorsError:new('Unsupported operator %q', operator)
+        return nil, ComparatorsError:new('Unsupported operator %q', cmp_operator)
     end
 
     local func, err = gen_array_cmp_func(cmp_func, key_parts)
     if err ~= nil then
-        return nil, ComparatorsError:new('Failed to generate comparator function %q', operator)
+        return nil, ComparatorsError:new('Failed to generate comparator function %q', cmp_operator)
     end
 
     return func
 end
 
-function comparators.gen_tuples_comparator(operator, key_parts)
-    local keys_comparator, err = comparators.gen_func(operator, key_parts)
+function comparators.gen_tuples_comparator(cmp_operator, key_parts)
+    local keys_comparator, err = comparators.gen_func(cmp_operator, key_parts)
     if err ~= nil then
         return nil, ComparatorsError:new("Failed to generate comparator function: %s", err)
     end

crud/select/conditions.lua

@@ -22,26 +22,6 @@ local tarantool_iter_by_cond_operators = {
     [conditions.operators.GE] = box.index.GE,
 }
 
-function conditions.get_scroll_operator(operator)
-    if operator == conditions.operators.GE or operator == conditions.GT or operator == conditions.EQ then
-        return conditions.operators.GT
-    end
-
-    if operator == conditions.operators.LE or operator == conditions.LT or operator == conditions.REQ then
-        return conditions.operators.LT
-    end
-
-    return operator
-end
-
-function conditions.is_greater(operator)
-    return operator == conditions.operators.GE or operator == conditions.operators.GT
-end
-
-function conditions.is_less(operator)
-    return operator == conditions.operators.LE or operator == conditions.operators.LT
-end
-
 function _G.checkers.condition_operator(p)
     for _, op in pairs(conditions.operators) do
         if op == p then

crud/select/executor.lua

@@ -3,7 +3,6 @@ local log = require('log')
 
 local select_filters = require('crud.select.filters')
 local select_comparators = require('crud.select.comparators')
-local select_conditions = require('crud.select.conditions')
 
 local utils = require('crud.common.utils')
 
@@ -16,10 +15,10 @@ local function scroll_to_after_tuple(gen, param, state, space, scanner)
     local scan_index = space.index[scanner.index_id]
     local primary_index = space.index[0]
 
-    local scroll_operator = select_conditions.get_scroll_operator(scanner.operator)
     local scroll_key_parts = utils.merge_primary_key_parts(scan_index.parts, primary_index.parts)
 
-    local scroll_comparator, err = select_comparators.gen_tuples_comparator(scroll_operator, scroll_key_parts)
+    local cmp_operator = select_comparators.get_cmp_operator(scanner.iter)
+    local scroll_comparator, err = select_comparators.gen_tuples_comparator(cmp_operator, scroll_key_parts)
     if err ~= nil then
         return nil, ScrollToAfterError:new("Failed to generate comparator to scroll: %s", err)
     end
@@ -59,9 +58,10 @@ function executor.execute(plan)
         if scan_value == nil then
             scan_value = scanner.after_tuple
         else
-            local scan_comparator, err = select_comparators.gen_tuples_comparator(scanner.operator, index.parts)
+            local cmp_operator = select_comparators.get_cmp_operator(scanner.iter)
+            local scan_comparator, err = select_comparators.gen_tuples_comparator(cmp_operator, index.parts)
             if err ~= nil then
-                log.warnf("Failed to generate comparator to scan value: %s", err)
+                log.warn("Failed to generate comparator for scan value: %s", err)
             elseif scan_comparator(scanner.after_tuple, scan_value) then
                 local after_tuple_key = utils.extract_key(scanner.after_tuple, index.parts)
                 scan_value = after_tuple_key

crud/select/iterator.lua

@@ -20,7 +20,6 @@ function Iterator.new(opts)
     checks({
         space_name = 'string',
         space_format = 'table',
-        key_parts = 'table',
         comparator = 'function',
         iteration_func = 'function',
 

crud/select/plan.lua

@@ -259,7 +259,11 @@ local function validate_conditions(conditions, space_indexes, space_format)
     return true
 end
 
-local function is_scan_by_full_sharding_key_eq(plan, scan_index_parts, sharding_key_parts)
+local function is_scan_by_full_sharding_key_eq(plan, scan_index, sharding_index)
+    if scan_index.id ~= sharding_index.id then
+        return false
+    end
+
     if plan.scanner.value == nil then
         return false
     end
@@ -269,13 +273,13 @@ local function is_scan_by_full_sharding_key_eq(plan, scan_index_parts, sharding_
     end
 
     local scan_index_fieldnos = {}
-    for _, part in ipairs(scan_index_parts) do
+    for _, part in ipairs(scan_index.parts) do
         scan_index_fieldnos[part.fieldno] = true
     end
 
     -- check that sharding key is included in the scan index fields
-    for part_num, sharding_key_part in ipairs(sharding_key_parts) do
-        local fieldno = sharding_key_part.fieldno
+    for part_num, sharding_index_part in ipairs(sharding_index.parts) do
+        local fieldno = sharding_index_part.fieldno
         if scan_index_fieldnos[fieldno] == nil or plan.scanner.value[part_num] == nil then
             return false
         end
@@ -317,9 +321,9 @@ function select_plan.new(space, conditions, opts)
         filter_conditions = filter_conditions,
     }
 
-    local scan_index_parts = space_indexes[scanner.index_id]
-    local sharding_key_parts = space_indexes[0] -- XXX: only sharding by primary key is supported
-    if is_scan_by_full_sharding_key_eq(plan, scan_index_parts, sharding_key_parts) then
+    local scan_index = space_indexes[scanner.index_id]
+    local sharding_index = space_indexes[0] -- XXX: only sharding by primary key is supported
+    if is_scan_by_full_sharding_key_eq(plan, scan_index, sharding_index) then
         plan.scanner.limit = 1
         plan.is_scan_by_full_sharding_key_eq = true
     end

test/integration/select_test.lua

@@ -294,6 +294,68 @@ add('test_select_all_with_batch_size', function(g)
     t.assert_equals(objects, get_by_ids(customers, {1, 2, 3, 4, 5, 6}))
 end)
 
+add('test_eq_condition_with_index', function(g)
+    local customers = insert_customers(g, {
+        {
+            id = 1, name = "Elizabeth", last_name = "Jackson",
+            age = 33, city = "New York",
+        }, {
+            id = 2, name = "Mary", last_name = "Brown",
+            age = 46, city = "Los Angeles",
+        }, {
+            id = 3, name = "David", last_name = "Smith",
+            age = 33, city = "Los Angeles",
+        }, {
+            id = 4, name = "William", last_name = "Smith",
+            age = 81, city = "Chicago",
+        },{
+            id = 5, name = "Hector", last_name = "Barbossa",
+            age = 33, city = "Chicago",
+        },{
+            id = 6, name = "William", last_name = "White",
+            age = 81, city = "Chicago",
+        },{
+            id = 7, name = "Jack", last_name = "Sparrow",
+            age = 33, city = "Chicago",
+        },
+    })
+
+    table.sort(customers, function(obj1, obj2) return obj1.id < obj2.id end)
+
+    local conditions = {
+        {'==', 'age', 33},
+    }
+
+    -- no after
+    local objects, err = g.cluster.main_server.net_box:eval([[
+        local crud = require('crud')
+
+        local conditions = ...
+
+        local objects, err = crud.select('customers', conditions)
+        return objects, err
+    ]], {conditions})
+
+    t.assert_equals(err, nil)
+    t.assert_equals(objects, get_by_ids(customers, {1, 3, 5, 7})) -- in id order
+
+    -- after obj 3
+    local after = customers[3]
+    local objects, err = g.cluster.main_server.net_box:eval([[
+        local crud = require('crud')
+
+        local conditions, after = ...
+
+        local objects, err = crud.select('customers', conditions, {
+            after = after,
+        })
+        return objects, err
+    ]], {conditions, after})
+
+    t.assert_equals(err, nil)
+    t.assert_equals(objects, get_by_ids(customers, {5, 7})) -- in id order
+end)
+
 add('test_ge_condition_with_index', function(g)
     local customers = insert_customers(g, {
         {