box: drop space_id for FK referring to same space

It is inconvenient to create self-referencing FK constraints, as the
space ID will only be generated during space creation. This is
especially useful for SQL, since the format for the space is created
at compile time, and the space ID is only obtained at run time.

Closes #7200

@TarantoolBot document
Title: Describe foreign keys referring to the same space
Since: 2.11
Root document: https://www.tarantool.io/en/doc/latest/book/box/data_model/#foreign-keys

It is possible to create a foreign key that refers to the same space (a
child space equals to the parent space).
To do that, omit `space` in the `foreign_key` parameter, or set it to
the id or to the name of the current space.

(cherry picked from commit f21f8e9)

Author: Gumix

changelogs/unreleased/gh-7200-use-0-as-space-id-for-self-fkey.md

@@ -0,0 +1,4 @@
+## feature/core
+
+* Now it is possible to skip space id in the space format for the
+  foreign key referring to the same space (gh-7200).

src/box/lua/schema.lua

@@ -538,17 +538,15 @@ end
 --  foreign field.
 -- If is_complex, field is expected to be a table with local field ->
 --  foreign field mapping.
-local function normalize_foreign_key_one(space_id, space_name, def,
-                                         error_prefix, is_complex)
-    if def.space == nil then
-        box.error(box.error.ILLEGAL_PARAMS,
-                  error_prefix .. "foreign key: space must be specified")
-    end
+-- If fkey_same_space, the foreign key refers to the same space.
+local function normalize_foreign_key_one(def, error_prefix, is_complex,
+                                         fkey_same_space)
     if def.field == nil then
         box.error(box.error.ILLEGAL_PARAMS,
                   error_prefix .. "foreign key: field must be specified")
     end
-    if type(def.space) ~= 'string' and type(def.space) ~= 'number' then
+    if def.space ~= nil and
+       type(def.space) ~= 'string' and type(def.space) ~= 'number' then
         box.error(box.error.ILLEGAL_PARAMS,
                   error_prefix .. "foreign key: space must be string or number")
     end
@@ -598,7 +596,6 @@ local function normalize_foreign_key_one(space_id, space_name, def,
         end
         def.field = setmap(converted)
     end
-    local fkey_same_space = (def.space == space_id or def.space == space_name)
     if not box.space[def.space] and not fkey_same_space then
         box.error(box.error.ILLEGAL_PARAMS,
                   error_prefix .. "foreign key: space " .. tostring(def.space)
@@ -612,7 +609,7 @@ local function normalize_foreign_key_one(space_id, space_name, def,
         end
     end
     if fkey_same_space then
-        return {space = space_id, field = def.field}
+        return {field = def.field}
     else
         return {space = box.space[def.space].id, field = def.field}
     end
@@ -640,18 +637,17 @@ local function normalize_foreign_key(space_id, space_name, fkey, error_prefix,
         box.error(box.error.ILLEGAL_PARAMS,
                   error_prefix .. "foreign key must be a table")
     end
-    if fkey.space ~= nil and fkey.field ~= nil and
+    if fkey.field ~= nil and
         (type(fkey.space) ~= 'table' or type(fkey.field) ~= 'table') then
         -- the first, short form.
-        fkey = normalize_foreign_key_one(space_id, space_name, fkey,
-                                         error_prefix, is_complex)
-        local fkey_same_space = (fkey.space == space_id or
+        local fkey_same_space = (fkey.space == nil or
+                                 fkey.space == space_id or
                                  fkey.space == space_name)
-        if fkey_same_space then
-            return {[space_name] = fkey}
-        else
-            return {[box.space[fkey.space].name] = fkey}
-        end
+        fkey = normalize_foreign_key_one(fkey, error_prefix, is_complex,
+                                         fkey_same_space)
+        local fkey_name = fkey_same_space and space_name or
+                          box.space[fkey.space].name
+        return {[fkey_name] = fkey}
     end
     -- the second, detailed form.
     local result = {}
@@ -666,8 +662,11 @@ local function normalize_foreign_key(space_id, space_name, fkey, error_prefix,
                       error_prefix .. "foreign key definition must be a table "
                       .. "with 'space' and 'field' members")
         end
-        v = normalize_foreign_key_one(space_id, space_name, v, error_prefix,
-                                      is_complex)
+        local fkey_same_space = (v.space == nil or
+                                 v.space == space_id or
+                                 v.space == space_name)
+        v = normalize_foreign_key_one(v, error_prefix, is_complex,
+                                      fkey_same_space)
         result[k] = v
     end
     return result

src/box/lua/space.cc

@@ -309,7 +309,12 @@ lbox_push_space_foreign_key(struct lua_State *L, struct space *space, int i)
 			continue;
 
 		lua_newtable(L);
-		lua_pushnumber(L, c->def.fkey.space_id);
+		if (c->def.fkey.space_id == 0) {
+			/* No space id - no field. */
+			lua_pushnil(L);
+		} else {
+			lua_pushnumber(L, c->def.fkey.space_id);
+		}
 		lua_setfield(L, -2, "space");
 		lua_newtable(L);
 		for (uint32_t j = 0; j < c->def.fkey.field_mapping_size; j++) {

src/box/tuple_constraint_def.c

@@ -239,7 +239,7 @@ tuple_constraint_def_decode_fkey(const char **data,
 {
 	/*
 	 * Expected normal form of foreign keys: {name1=data1, name2=data2..},
-	 * where dataX has form: {space=id, field=id/name}
+	 * where dataX has form: {field=id/name} or {space=id, field=id/name}
 	 */
 	if (mp_typeof(**data) != MP_MAP) {
 		diag_set(ClientError, errcode,
@@ -293,6 +293,7 @@ tuple_constraint_def_decode_fkey(const char **data,
 		new_def[i].fkey.field_mapping_size = 0;
 		uint32_t def_size = mp_decode_map(data);
 		bool has_space = false, has_field = false;
+		struct tuple_constraint_fkey_def *fk = &new_def[i].fkey;
 		for (size_t j = 0; j < def_size; j++) {
 			if (mp_typeof(**data) != MP_STR) {
 				diag_set(ClientError, errcode,
@@ -314,11 +315,10 @@ tuple_constraint_def_decode_fkey(const char **data,
 			} else {
 				diag_set(ClientError, errcode,
 					 "foreign key definition is expected "
-					 "to be {space=.., field=..}");
+					 "to be {[space=..,] field=..}");
 				return -1;
 			}
 			int rc;
-			struct tuple_constraint_fkey_def *fk = &new_def[i].fkey;
 			if (is_space)
 				rc = space_id_decode(data, &fk->space_id,
 						     errcode);
@@ -331,10 +331,12 @@ tuple_constraint_def_decode_fkey(const char **data,
 			if (rc != 0)
 				return rc;
 		}
-		if (!has_space || !has_field) {
+		if (!has_space)
+			fk->space_id = 0;
+		if (!has_field) {
 			diag_set(ClientError, errcode,
 				 "foreign key definition is expected "
-				 "to be {space=.., field=..}");
+				 "to be {[space=..,] field=..}");
 			return -1;
 		}
 	}

src/box/tuple_constraint_fkey.c

@@ -588,8 +588,11 @@ tuple_constraint_fkey_init(struct tuple_constraint *constr,
 	constr->space = space;
 	tuple_constraint_fkey_update_local(constr, field_no);
 
-	bool fkey_same_space = constr->def.fkey.space_id == space->def->id;
-	struct space *foreign_space = space_by_id(constr->def.fkey.space_id);
+	bool fkey_same_space = constr->def.fkey.space_id == 0 ||
+			       constr->def.fkey.space_id == space->def->id;
+	uint32_t space_id = fkey_same_space ? space->def->id :
+			    constr->def.fkey.space_id;
+	struct space *foreign_space = space_by_id(space_id);
 	if (fkey_same_space && foreign_space == NULL)
 		foreign_space = space;
 	enum space_cache_holder_type type = SPACE_HOLDER_FOREIGN_KEY;

test/engine-luatest/gh_6436_field_foreign_key_test.lua

@@ -53,21 +53,11 @@ g.test_bad_foreign_key = function(cg)
             "Illegal parameters, format[2]: foreign key definition must be a table with 'space' and 'field' members",
             function() box.schema.create_space('city', {engine=engine, format=fmt}) end
         )
-        fmt = gen_format({field = 'id'})
-        t.assert_error_msg_content_equals(
-            "Illegal parameters, format[2]: foreign key definition must be a table with 'space' and 'field' members",
-            function() box.schema.create_space('city', {engine=engine, format=fmt}) end
-        )
         fmt = gen_format({fkey={space = 'country'}})
         t.assert_error_msg_content_equals(
             "Illegal parameters, format[2]: foreign key: field must be specified",
             function() box.schema.create_space('city', {engine=engine, format=fmt}) end
         )
-        fmt = gen_format({fkey={field = 'id'}})
-        t.assert_error_msg_content_equals(
-            "Illegal parameters, format[2]: foreign key: space must be specified",
-            function() box.schema.create_space('city', {engine=engine, format=fmt}) end
-        )
         fmt = gen_format({space = 'planet', field = 'id'})
         t.assert_error_msg_content_equals(
             "Illegal parameters, format[2]: foreign key: space planet was not found",

test/engine-luatest/gh_7200_fkey_without_space_id_test.lua

@@ -0,0 +1,108 @@
+local server = require('test.luatest_helpers.server')
+local t = require('luatest')
+local g = t.group('gh-7200-fkey-without-space-id',
+                  {{engine = 'memtx'}, {engine = 'vinyl'}})
+
+g.before_all(function(cg)
+    cg.server = server:new({alias = 'master'})
+    cg.server:start()
+end)
+
+g.after_all(function(cg)
+    cg.server:stop()
+    cg.server = nil
+end)
+
+g.after_each(function(cg)
+    cg.server:exec(function()
+        if box.space.space then box.space.space:drop() end
+        if box.space.complex then box.space.complex:drop() end
+        if box.space.filesystem then box.space.filesystem:drop() end
+    end)
+end)
+
+-- Similar to test_foreign_key_primary in gh_6961_fkey_same_space_test.lua,
+-- but without specifying space id in the format.
+g.test_foreign_key_primary = function(cg)
+    local engine = cg.params.engine
+
+    cg.server:exec(function(engine)
+        local t = require('luatest')
+
+        local fmt = {{name='id', type='unsigned'},
+                     {name='parent_id', type='unsigned',
+                      foreign_key={field='id'}}}
+        local fs = box.schema.create_space('filesystem', {engine=engine,
+                                                          format=fmt})
+        t.assert_equals(fs:format(fs:format()), nil)
+        fs:drop()
+
+        local fmt = {{name='id', type='unsigned'},
+                     {name='parent_id', type='unsigned',
+                      foreign_key={fkey={field='id'}}}}
+        local fs = box.schema.create_space('filesystem', {engine=engine})
+        fs:format(fmt)
+        t.assert_equals(fs:format(), fmt)
+        fs:create_index('pk')
+        fs:create_index('sk', {unique=false, parts={'parent_id'}})
+        t.assert_error_msg_content_equals(
+            "Foreign key constraint 'fkey' failed for field '2 (parent_id)': foreign tuple was not found",
+            function() fs:insert{1, 0} end
+        )
+    end, {engine})
+end
+
+-- Test complex foreign key without specifying space id.
+g.test_complex_foreign_key1 = function(cg)
+    local engine = cg.params.engine
+
+    cg.server:exec(function(engine)
+        local t = require('luatest')
+
+        local fmt = {{name='id1', type='unsigned'},
+                     {name='id2', type='unsigned'}}
+        local fkey = {field={id1='id1', id2='id2'}}
+        local opts = {engine=engine, format=fmt, foreign_key=fkey}
+        local space = box.schema.create_space('complex', opts)
+
+        -- Note that 'space' field is not present in the table
+        t.assert_equals(space.foreign_key,
+                        {complex={field={id1='id1', id2='id2'}}})
+    end, {engine})
+end
+
+g.test_complex_foreign_key2 = function(cg)
+    local engine = cg.params.engine
+
+    cg.server:exec(function(engine)
+        local t = require('luatest')
+
+        local fmt = {{name='id1', type='unsigned'},
+                     {name='id2', type='unsigned'}}
+        local fkey = {name={field={id1='id2', id2='id1'}}}
+        local opts = {engine=engine, format=fmt, foreign_key=fkey}
+        local space = box.schema.create_space('complex', opts)
+
+        -- Note that 'space' field is not present in the table
+        t.assert_equals(space.foreign_key,
+                        {name={field={id1='id2', id2='id1'}}})
+    end, {engine})
+end
+
+-- Test foreign key creation by inserting directly into box.space._space
+g.test_foreign_key_direct_insert = function(cg)
+    local engine = cg.params.engine
+
+    cg.server:exec(function(engine)
+        local t = require('luatest')
+
+        local fmt = {{name = 'i', type = 'integer'},
+                     {name = 'j', type = 'integer'},
+                     {name = 'k', type = 'integer',
+                      foreign_key = {k1 = {field = 'i'}}}}
+        local opts = {foreign_key = {k2 = {field = {i = 'i', j = 'j'}}}}
+        box.space._space:insert{512, 1, 'space', engine, 0, opts, fmt}
+        t.assert_equals(box.space._space:get(512).flags, opts)
+        t.assert_equals(box.space._space:get(512).format, fmt)
+    end, {engine})
+end