Add link Table API

db/links/operations/create.py

@@ -0,0 +1,67 @@
+from alembic.operations import Operations
+from alembic.migration import MigrationContext
+from sqlalchemy import MetaData
+
+from db.columns.base import MathesarColumn
+from db.constraints.utils import naming_convention
+from db.tables.operations.select import reflect_table_from_oid, reflect_tables_from_oids
+from db.tables.utils import get_primary_key_column
+
+
+def create_foreign_key_link(engine, schema, column_name, referrer_table_oid, referent_table_oid, unique_link=False):
+    with engine.begin() as conn:
+        referent_table = reflect_table_from_oid(referent_table_oid, engine, conn)
+        referrer_table = reflect_table_from_oid(referrer_table_oid, engine, conn)
+        primary_key_column = get_primary_key_column(referent_table)
+        metadata = MetaData(bind=engine, schema=schema, naming_convention=naming_convention)
+        opts = {
+            'target_metadata': metadata
+        }
+        ctx = MigrationContext.configure(conn, opts=opts)
+        op = Operations(ctx)
+        column = MathesarColumn(
+            column_name, primary_key_column.type
+        )
+        op.add_column(referrer_table.name, column, schema=schema)
+        if unique_link:
+            op.create_unique_constraint(None, referrer_table.name, [column_name], schema=schema)
+        op.create_foreign_key(
+            None,
+            referrer_table.name,
+            referent_table.name,
+            [column.name],
+            [primary_key_column.name],
+            source_schema=schema,
+            referent_schema=schema
+        )
+
+
+def create_many_to_many_link(engine, schema, map_table_name, referents):
+    with engine.begin() as conn:
+        referent_tables_oid = [referent['referent_table'] for referent in referents]
+        referent_tables = reflect_tables_from_oids(referent_tables_oid, engine, conn)
+        metadata = MetaData(bind=engine, schema=schema, naming_convention=naming_convention)
+        opts = {
+            'target_metadata': metadata
+        }
+        ctx = MigrationContext.configure(conn, opts=opts)
+        op = Operations(ctx)
+        op.create_table(map_table_name, schema=schema)
+        for referent in referents:
+            referent_table_oid = referent['referent_table']
+            referent_table = referent_tables[referent_table_oid]
+            col_name = referent['column_name']
+            primary_key_column = get_primary_key_column(referent_table)
+            column = MathesarColumn(
+                col_name, primary_key_column.type
+            )
+            op.add_column(map_table_name, column, schema=schema)
+            op.create_foreign_key(
+                None,
+                map_table_name,
+                referent_table.name,
+                [column.name],
+                [primary_key_column.name],
+                source_schema=schema,
+                referent_schema=schema
+            )

db/tables/operations/select.py

@@ -35,6 +35,31 @@ def reflect_table_from_oid(oid, engine, connection_to_use=None):
     return reflect_table(table_name, schema, engine, connection_to_use=connection_to_use)
 
 
+def reflect_tables_from_oids(oids, engine, connection_to_use=None):
+    metadata = MetaData()
+
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", message="Did not recognize type")
+        pg_class = Table("pg_class", metadata, autoload_with=engine)
+        pg_namespace = Table("pg_namespace", metadata, autoload_with=engine)
+    sel = (
+        select(pg_namespace.c.nspname, pg_class.c.relname, pg_class.c.oid)
+        .select_from(
+            join(
+                pg_class,
+                pg_namespace,
+                pg_class.c.relnamespace == pg_namespace.c.oid
+            )
+        )
+        .where(pg_class.c.oid.in_(oids))
+    )
+    results = execute_statement(engine, sel, connection_to_use).fetchall()
+    tables = {}
+    for (schema, table_name, table_oid) in results:
+        tables[table_oid] = reflect_table(table_name, schema, engine, connection_to_use=connection_to_use)
+    return tables
+
+
 def get_table_oids_from_schema(schema_oid, engine):
     metadata = MetaData()
 

mathesar/api/db/viewsets/__init__.py

@@ -5,3 +5,4 @@
 from mathesar.api.db.viewsets.records import RecordViewSet # noqa
 from mathesar.api.db.viewsets.schemas import SchemaViewSet # noqa
 from mathesar.api.db.viewsets.tables import TableViewSet # noqa
+from mathesar.api.db.viewsets.links import LinkViewSet # noqa

mathesar/api/db/viewsets/links.py

@@ -0,0 +1,12 @@
+from rest_framework.mixins import CreateModelMixin, ListModelMixin
+from rest_framework.viewsets import GenericViewSet
+from mathesar.api.pagination import DefaultLimitOffsetPagination
+from mathesar.api.serializers.links import LinksMappingSerializer
+
+
+class LinkViewSet(CreateModelMixin, ListModelMixin, GenericViewSet):
+    serializer_class = LinksMappingSerializer
+    pagination_class = DefaultLimitOffsetPagination
+
+    def get_queryset(self):
+        return []

mathesar/api/serializers/links.py

@@ -0,0 +1,83 @@
+from rest_framework import serializers
+
+from db.links.operations.create import create_foreign_key_link, create_many_to_many_link
+from mathesar.api.exceptions.mixins import MathesarErrorMessageMixin
+from mathesar.api.exceptions.validation_exceptions.exceptions import ColumnSizeMismatchAPIException
+from mathesar.api.serializers.shared_serializers import (
+    MathesarPolymorphicErrorMixin,
+    ReadWritePolymorphicSerializerMappingMixin,
+)
+from mathesar.models import Table
+
+
+class OneToOneSerializer(MathesarErrorMessageMixin, serializers.Serializer):
+    referent_column_name = serializers.CharField()
+    reference_table = serializers.PrimaryKeyRelatedField(queryset=Table.current_objects.all())
+    referent_table = serializers.PrimaryKeyRelatedField(queryset=Table.current_objects.all())
+
+    def is_link_unique(self):
+        return True
+
+    def create(self, validated_data):
+        reference_table = validated_data['reference_table']
+        create_foreign_key_link(
+            reference_table.schema._sa_engine,
+            reference_table._sa_table.schema,
+            validated_data.get('referent_column_name'),
+            reference_table.oid,
+            validated_data.get('referent_table').oid,
+            unique_link=self.is_link_unique()
+        )
+        return validated_data
+
+
+class OneToManySerializer(OneToOneSerializer):
+
+    def is_link_unique(self):
+        return False
+
+
+class MapColumnSerializer(serializers.Serializer):
+    column_name = serializers.CharField()
+    referent_table = serializers.PrimaryKeyRelatedField(queryset=Table.current_objects.all())
+
+
+class ManyToManySerializer(MathesarErrorMessageMixin, serializers.Serializer):
+    referents = MapColumnSerializer(many=True)
+    mapping_table_name = serializers.CharField()
+
+    def create(self, validated_data):
+        referents = validated_data['referents']
+        referent_tables_oid = [
+            {'referent_table': map_table_obj['referent_table'].oid, 'column_name': map_table_obj['column_name']} for
+            map_table_obj in validated_data['referents']]
+        create_many_to_many_link(
+            referents[0]['referent_table'].schema._sa_engine,
+            referents[0]['referent_table']._sa_table.schema,
+            validated_data.get('mapping_table_name'),
+            referent_tables_oid,
+        )
+        return validated_data
+
+
+class LinksMappingSerializer(
+    MathesarPolymorphicErrorMixin,
+    ReadWritePolymorphicSerializerMappingMixin,
+    serializers.Serializer
+):
+    def create(self, validated_data):
+        serializer = self.serializers_mapping.get(self.get_mapping_field())
+        return serializer.create(validated_data)
+
+    serializers_mapping = {
+        "one-to-one": OneToOneSerializer,
+        "one-to-many": OneToManySerializer,
+        "many-to-many": ManyToManySerializer
+    }
+    link_type = serializers.CharField(required=True)
+
+    def get_mapping_field(self):
+        link_type = self.initial_data.get('link_type', None)
+        if link_type is None:
+            raise ColumnSizeMismatchAPIException()
+        return link_type

mathesar/tests/api/conftest.py

@@ -38,6 +38,57 @@ def _create_table(table_name, schema='Data Types'):
     return _create_table
 
 
+@pytest.fixture
+def create_self_referential_table(self_referential_filename, create_schema):
+    with open(self_referential_filename, 'rb') as csv_file:
+        data_file = DataFile.objects.create(file=File(csv_file))
+
+    def _create_table(table_name, schema='Patents'):
+        schema_model = create_schema(schema)
+        return create_table_from_csv(data_file, table_name, schema_model)
+
+    return _create_table
+
+
+@pytest.fixture
+def create_related_table(create_schema):
+    def read_table(related_csv_filename_tuple):
+        with open(related_csv_filename_tuple[0], 'rb') as csv_file:
+            data_file = DataFile.objects.create(file=File(csv_file))
+        with open(related_csv_filename_tuple[1], 'rb') as ref_csv_file:
+            ref_data_file = DataFile.objects.create(file=File(ref_csv_file))
+
+        def _create_table(table_name, ref_table_name, schema='Patents'):
+            schema_model = create_schema(schema)
+            return create_table_from_csv(data_file, table_name, schema_model), create_table_from_csv(
+                ref_data_file,
+                ref_table_name,
+                schema_model
+            )
+
+        return _create_table
+
+    return read_table
+
+
+@pytest.fixture
+def create_foreign_key_table(foreign_key_csv_filename_tuple, create_related_table):
+    return create_related_table(foreign_key_csv_filename_tuple)
+
+
+@pytest.fixture
+def create_multi_column_foreign_key_table(multi_column_foreign_key_csv_filename_tuple, create_related_table):
+    return create_related_table(multi_column_foreign_key_csv_filename_tuple)
+
+
+@pytest.fixture
+def create_invalid_related_data_foreign_key_table(
+        invalid_related_data_foreign_key_csv_filename_tuple,
+        create_related_table
+):
+    return create_related_table(invalid_related_data_foreign_key_csv_filename_tuple)
+
+
 @pytest.fixture
 def table_for_reflection(test_db_name):
     engine = create_mathesar_engine(test_db_name)

mathesar/tests/api/test_constraint_api.py

@@ -10,6 +10,15 @@ def _verify_primary_and_unique_constraints(response):
     assert set(['unique', 'primary']) == set([constraint_data['type'] for constraint_data in constraints_data])
 
 
+def _verify_foreign_key_constraint(constraint_data, columns, name, referent_table, referent_columns):
+    assert constraint_data['referent']['table'] == referent_table
+    assert constraint_data['columns'] == columns
+    assert constraint_data['referent']['columns'] == referent_columns
+    assert constraint_data['name'] == name
+    assert constraint_data['type'] == 'foreignkey'
+    assert 'id' in constraint_data and type(constraint_data['id']) == int
+
+
 def _verify_unique_constraint(constraint_data, columns, name):
     assert constraint_data['columns'] == columns
     assert constraint_data['name'] == name

mathesar/tests/api/test_links.py

@@ -0,0 +1,115 @@
+import pytest
+from sqlalchemy import Column, Integer, MetaData, String
+from sqlalchemy import Table as SATable
+from django.core.cache import cache
+
+from db.tables.operations.select import get_oid_from_table
+from db.tests.types import fixtures
+from mathesar import models
+
+engine_with_types = fixtures.engine_with_types
+engine_email_type = fixtures.engine_email_type
+temporary_testing_schema = fixtures.temporary_testing_schema
+
+
+@pytest.fixture
+def column_test_table(patent_schema):
+    engine = patent_schema._sa_engine
+    column_list_in = [
+        Column("mycolumn0", Integer, primary_key=True),
+        Column("mycolumn1", Integer, nullable=False),
+        Column("mycolumn2", Integer, server_default="5"),
+        Column("mycolumn3", String),
+    ]
+    db_table = SATable(
+        "anewtable",
+        MetaData(bind=engine),
+        *column_list_in,
+        schema=patent_schema.name
+    )
+    db_table.create()
+    db_table_oid = get_oid_from_table(db_table.name, db_table.schema, engine)
+    table = models.Table.current_objects.create(oid=db_table_oid, schema=patent_schema)
+    return table
+
+
+def test_one_to_one_link_create(column_test_table, client, create_table):
+    cache.clear()
+    table_2 = create_table('Table 2')
+    data = {
+        "link_type": "one-to-one",
+        "referent_column_name": "col_1",
+        "reference_table": table_2.id,
+        "referent_table": column_test_table.id,
+    }
+    response = client.post(
+        "/api/db/v0/links/",
+        data=data,
+    )
+    assert response.status_code == 201
+
+
+def test_one_to_many_link_create(column_test_table, client, create_table):
+    cache.clear()
+    table_2 = create_table('Table 2')
+    data = {
+        "link_type": "one-to-many",
+        "referent_column_name": "col_1",
+        "reference_table": table_2.id,
+        "referent_table": column_test_table.id,
+    }
+    response = client.post(
+        "/api/db/v0/links/",
+        data=data,
+    )
+    assert response.status_code == 201
+
+
+def test_one_to_many_self_referential_link_create(column_test_table, client):
+    cache.clear()
+    data = {
+        "link_type": "one-to-many",
+        "referent_column_name": "col_1",
+        "reference_table": column_test_table.id,
+        "referent_table": column_test_table.id,
+    }
+    response = client.post(
+        "/api/db/v0/links/",
+        data=data,
+    )
+    assert response.status_code == 201
+
+
+def test_many_to_many_self_referential_link_create(column_test_table, client):
+    cache.clear()
+    data = {
+        "link_type": "many-to-many",
+        "mapping_table_name": "map_table",
+        "referents": [
+            {'referent_table': column_test_table.id, 'column_name': "link_1"},
+            {'referent_table': column_test_table.id, 'column_name': "link_2"}
+        ],
+    }
+    response = client.post(
+        "/api/db/v0/links/",
+        data=data,
+    )
+    assert response.status_code == 201
+
+
+def test_many_to_many_link_create(column_test_table, client, create_table):
+    cache.clear()
+    table_2 = create_table('Table 2')
+    data = {
+        "link_type": "many-to-many",
+        "mapping_table_name": "map_table",
+        "referents": [
+            {'referent_table': column_test_table.id, 'column_name': "link_1"},
+            {'referent_table': table_2.id, 'column_name': "link_2"}
+        ],
+    }
+    response = client.post(
+        "/api/db/v0/links/",
+        data=data,
+    )
+    assert response.status_code == 201