test and fixing bugs

Author: CrispenGari

Changelog.md

@@ -4,14 +4,15 @@ Dataloom **`2.4.0`**
 
 ### Release Notes - `dataloom`
 
-We have release the new `dataloom` Version `2.6.0` (`2024-02-27`)
+We have release the new `dataloom` Version `2.4.0` (`2024-02-27`)
 
 ##### Features
 
 - `sync` and `connect_and_sync` function can now take in a collection of `Model` or a single `Model` instance.
 - Updated documentation.
 - Fixing `ForeignKeyColumn` bugs.
 - Adding the `alias` as an argument to `Include` class so that developers can flexibly use their own alias for eager model inclusion rather than letting `dataloom` decide for them.
+- Adding the `junction_table` as an argument to the `Include` so that we can use this table as a reference for `N-N` associations.
 - Introducing self relations
 
   - now you can define self relations in `dataloom`
@@ -65,6 +66,17 @@ We have release the new `dataloom` Version `2.6.0` (`2024-02-27`)
       courseId = ForeignKeyColumn(table=Course, type="int")
   ```
 
+  - you can do `eager` data fetching in this type of relationship, however you need to specify the `junction_table`. Here is an example:
+
+  ```py
+  english = mysql_loom.find_by_pk(
+    Course,
+    pk=engId,
+    select=["id", "name"],
+    include=Include(model=Student, junction_table=StudentCourses, has="many"),
+  )
+  ```
+
 ===
 Dataloom **`2.3.0`**
 ===

README.md

@@ -113,7 +113,6 @@
     - [Retrieving Records](#retrieving-records-4)
 - [Query Builder.](#query-builder)
   - [Why Use Query Builder?](#why-use-query-builder)
-- [What is coming next?](#what-is-coming-next)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -623,16 +622,17 @@ posts = pg_loom.find_all(
 
 The `Include` class facilitates eager loading for models with relationships. Below is a table detailing the parameters available for the `Include` class:
 
-| Argument  | Description                                                                        | Type                | Default  | Required |
-| --------- | ---------------------------------------------------------------------------------- | ------------------- | -------- | -------- |
-| `model`   | The model to be included when eagerly fetching records.                            | `Model`             | -        | Yes      |
-| `order`   | The list of order specifications for sorting the included data.                    | `list[Order]`       | `[]`     | No       |
-| `limit`   | The maximum number of records to include.                                          | `int \| None`       | `0`      | No       |
-| `offset`  | The number of records to skip before including.                                    | `int \| None`       | `0`      | No       |
-| `select`  | The list of columns to include.                                                    | `list[str] \| None` | `None`   | No       |
-| `has`     | The relationship type between the current model and the included model.            | `INCLUDE_LITERAL`   | `"many"` | No       |
-| `include` | The extra included models.                                                         | `list[Include]`     | `[]`     | No       |
-| `alias`   | The alias name for the included model. Very important when mapping self relations. | `str`               | `None`   | No       |
+| Argument         | Description                                                                                 | Type                | Default  | Required |
+| ---------------- | ------------------------------------------------------------------------------------------- | ------------------- | -------- | -------- |
+| `model`          | The model to be included when eagerly fetching records.                                     | `Model`             | -        | Yes      |
+| `junction_table` | The `junction_table` model that is used as a reference table in a many to many association. | `Model`             | `None`   | No       |
+| `order`          | The list of order specifications for sorting the included data.                             | `list[Order]`       | `[]`     | No       |
+| `limit`          | The maximum number of records to include.                                                   | `int \| None`       | `0`      | No       |
+| `offset`         | The number of records to skip before including.                                             | `int \| None`       | `0`      | No       |
+| `select`         | The list of columns to include.                                                             | `list[str] \| None` | `None`   | No       |
+| `has`            | The relationship type between the current model and the included model.                     | `INCLUDE_LITERAL`   | `"many"` | No       |
+| `include`        | The extra included models.                                                                  | `list[Include]`     | `[]`     | No       |
+| `alias`          | The alias name for the included model. Very important when mapping self relations.          | `str`               | `None`   | No       |
 
 #### `Group` Class
 
@@ -2339,53 +2339,74 @@ mysql_loom.insert_bulk(
 
 ##### Retrieving Records
 
-Now let's query employee `Michael` with his supervisor.
+Now let's query a student called `Alice` with her courses. We can do it as follows:
 
 ```py
-emp = mysql_loom.find_by_pk(
-    instance=Employee, pk=2, select=["id", "name", "supervisorId"]
+s = mysql_loom.find_by_pk(
+    Student,
+    pk=stud1,
+    select=["id", "name"],
 )
-sup = mysql_loom.find_by_pk(
-    instance=Employee, select=["id", "name"], pk=emp["supervisorId"]
+c = mysql_loom.find_many(
+    StudentCourses,
+    filters=Filter(column="studentId", value=stud1),
+    select=["courseId"],
+)
+courses = mysql_loom.find_many(
+    Course,
+    filters=Filter(column="id", operator="in", value=[list(i.values())[0] for i in c]),
+    select=["id", "name"],
 )
-emp_and_sup = {**emp, "supervisor": sup}
-print(emp_and_sup) # ? = {'id': 2, 'name': 'Michael Johnson', 'supervisorId': 1, 'supervisor': {'id': 1, 'name': 'John Doe'}}
-```
 
-We're querying the database to retrieve information about a `employee` and their associated `supervisor`.
+alice = {**s, "courses": courses}
+print(courses) # ? = {'id': 1, 'name': 'Alice', 'courses': [{'id': 1, 'name': 'Mathematics'}, {'id': 2, 'name': 'English'}, {'id': 3, 'name': 'Physics'}]}
+```
 
-1. **Querying an Employee**:
+We're querying the database to retrieve information about a `student` and their associated `courses`. Here are the steps in achieving that:
 
-   - We use `mysql_loom.find_by_pk()` to fetch a single employee record from the database.
-   - The employee's ID is specified as `2`.
+1. **Querying Student**:
 
-2. **Querying Supervisor**:
+   - We use `mysql_loom.find_by_pk()` to fetch a single `student` record from the database in the table `students`.
 
-   - We use `mysql_loom.find_by_pk()` to retrieve a supervisor that is associated with this employee.
-   - We create a dictionary `emp_and_sup` containing the `employee` information and their `supervisor`.
+2. **Querying Course Id's**:
+   - Next we are going to query all the course ids of that student and store them in `c` in the joint table `students_courses`.
+   - We use `mysql_loom.find_many()` to retrieve the course `ids` of `alice`.
+3. **Querying Course**:
+   - Next we will query all the courses using the operator `in` in the `courses` table based on the id's we obtained previously.
 
-With eager loading this can be done in one query as follows the above can be done as follows:
+As you can see we are doing a lot of work to get the information about `Alice`. With eager loading this can be done in one query as follows the above can be done as follows:
 
 ```py
-emp_and_sup = mysql_loom.find_by_pk(
-    instance=Employee,
-    pk=2,
-    select=["id", "name", "supervisorId"],
+alice = mysql_loom.find_by_pk(
+    Student,
+    pk=stud1,
+    select=["id", "name"],
     include=Include(
-        model=Employee,
-        has="one",
-        select=["id", "name"],
-        alias="supervisor",
+        model=Course, junction_table=StudentCourses, alias="courses", has="many"
     ),
 )
 
-print(emp_and_sup) # ? = {'id': 2, 'name': 'Michael Johnson', 'supervisorId': 1, 'supervisor': {'id': 1, 'name': 'John Doe'}}
+print(alice) # ? = {'id': 1, 'name': 'Alice', 'courses': [{'id': 1, 'name': 'Mathematics'}, {'id': 2, 'name': 'English'}, {'id': 3, 'name': 'Physics'}]}
 ```
 
-- We use `mysql_loom.find_by_pk()` to fetch a single an employee record from the database.
-- Additionally, we include associated `employee` record using `eager` loading with an `alias` of `supervisor`.
+- We use `mysql_loom.find_by_pk()` to retrieve a single student record from the database.
+- Furthermore, we include the associated `course` records using `eager` loading with an `alias` of `courses`.
+- We specify a `junction_table` in our `Include` statement. This allows dataloom to recognize the relationship between the `students` and `courses` tables through this `junction_table`.
 
-> 👍 **Pro Tip:** Note that the `alias` is very important in this situation because it allows you to get the included relationships with objects that are named well, if you don't give an alias dataloom will just use the model class name as the alias of your included models, in this case you will get an object that looks like `{'id': 2, 'name': 'Michael Johnson', 'supervisorId': 1, 'employee': {'id': 1, 'name': 'John Doe'}}`, which practically and theoretically doesn't make sense.
+> 👍 **Pro Tip:** It is crucial to specify the `junction_table` when querying in a many-to-many (`N-N`) relationship. This is because, by default, the models will not establish a direct many-to-many relationship without referencing the `junction_table`. They lack foreign key columns within them to facilitate this relationship.
+
+As for our last example let's query all the students that are enrolled in the `English` class. We can easily do it as follows:
+
+```py
+english = mysql_loom.find_by_pk(
+    Course,
+    pk=engId,
+    select=["id", "name"],
+    include=Include(model=Student, junction_table=StudentCourses, has="many"),
+)
+
+print(english) # ? = {'id': 2, 'name': 'English', 'students': [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}, {'id': 3, 'name': 'Lisa'}]}
+```
 
 ### Query Builder.
 
@@ -2458,10 +2479,6 @@ The `run` method takes the following as arguments:
   print(result)
   ```
 
-### What is coming next?
-
-1. N-N associations
-
 ### Contributing
 
 Contributions to `dataloom` are welcome! Feel free to submit bug reports, feature requests, or pull requests on [GitHub](https://github.com/CrispenGari/dataloom).

dataloom/keys.py

@@ -1,7 +1,7 @@
 # Configuration file for unit testing.
 
 
-push = False
+push = True
 
 
 class PgConfig:

dataloom/statements/__init__.py

@@ -160,7 +160,7 @@ def _get_create_table_command(self) -> str:
             dialect=self.dialect,
             model=self.model,
         )
-        if len(fks) > 2:
+        if len(fks) > 2 and len(pks) == 0:
             raise TooManyFkException(
                 f"Reference table '{self.table_name}' can not have more than 2 foreign keys."
             )
@@ -176,7 +176,7 @@ def _get_create_table_command(self) -> str:
         fields = [*user_fields, *predefined_fields]
         fields_name = ", ".join(f for f in [" ".join(field) for field in fields])
         if self.dialect == "postgres":
-            if len(fks) == 2 and len(pks) == 0:
+            if len(fks) == 2 or len(pks) == 0:
                 pks, user_fields, fks = get_create_reference_table_params(
                     dialect=self.dialect,
                     model=self.model,
@@ -205,7 +205,7 @@ def _get_create_table_command(self) -> str:
                 )
 
         elif self.dialect == "mysql":
-            if len(fks) == 2 and len(pks) == 0:
+            if len(fks) == 2 or len(pks) == 0:
                 pks, user_fields, fks = get_create_reference_table_params(
                     dialect=self.dialect,
                     model=self.model,
@@ -234,7 +234,7 @@ def _get_create_table_command(self) -> str:
                 )
 
         elif self.dialect == "sqlite":
-            if len(fks) == 2 and len(pks) == 0:
+            if len(fks) == 2 or len(pks) == 0:
                 pks, user_fields, fks = get_create_reference_table_params(
                     dialect=self.dialect,
                     model=self.model,
@@ -986,7 +986,10 @@ def _get_alter_table_command(self, old_columns: list[str]) -> str:
         ).get_alter_table_params
 
         alterations = " ".join(alterations) if self.dialect != "sqlite" else ""
-
+        if len(fks) > 2 and len(pks) == 0:
+            raise TooManyFkException(
+                f"Reference table '{self.table_name}' can not have more than 2 foreign keys."
+            )
         # do we have a single primary key or not?
         if len(pks) == 0 and len(fks) != 2:
             raise PkNotDefinedException(
@@ -997,11 +1000,6 @@ def _get_alter_table_command(self, old_columns: list[str]) -> str:
                 f"You have defined many field as primary keys which is not allowed. Fields ({', '.join(pks)}) are primary keys."
             )
 
-        if len(fks) > 2:
-            raise TooManyFkException(
-                f"Reference table '{self.table_name}' can not have more than 2 foreign keys."
-            )
-
         if self.dialect == "postgres":
             sql = PgStatements.ALTER_TABLE_COMMAND.format(alterations=alterations)
         elif self.dialect == "mysql":
@@ -1017,7 +1015,10 @@ def _get_alter_table_command(self, old_columns: list[str]) -> str:
                 dialect=self.dialect,
                 model=self.model,
             )
-
+            if len(fks) > 2 and len(pks) == 0:
+                raise TooManyFkException(
+                    f"Reference table '{self.table_name}' can not have more than 2 foreign keys."
+                )
             if len(pks) == 0 and len(fks) != 2:
                 raise PkNotDefinedException(
                     f"Your table '{self.table_name}' does not have a primary key column and it is not a reference table."
@@ -1026,10 +1027,7 @@ def _get_alter_table_command(self, old_columns: list[str]) -> str:
                 raise TooManyPkException(
                     f"You have defined many field as primary keys which is not allowed. Fields ({', '.join(pks)}) are primary keys."
                 )
-            if len(fks) > 2:
-                raise TooManyFkException(
-                    f"Reference table '{self.table_name}' can not have more than 2 foreign keys."
-                )
+
             fields = [*user_fields, *predefined_fields]
 
             fields_name = ", ".join(f for f in [" ".join(field) for field in fields])