WIP

Author: josephmancuso

orm.sqlite3

@@ -586,8 +586,15 @@ def __call__(self, *args):
         if not model:
             return self
 
-        related = self._items[0].__dict__['related']
-        return related.apply_query(self._items[0].builder)
+        if hasattr(self._items[0], 'related'):
+            related = self._items[0].__dict__['related']
+            return related.apply_query(self._items[0].builder)
+        else:
+            return self
+
+    def to_qmark(self):
+        print("to qmark", self._items)
+        return self
 
     def get_related(self):
         print("getting related", self._builder)

src/masoniteorm/collection/Collection.py

@@ -76,6 +76,10 @@ class SubSelectExpression:
 
     def __init__(self, builder):
         self.builder = builder
+        if hasattr(builder, 'to_qmark'):
+            self._bindings = builder._items
+        else:
+            self._bindings = []
 
 
 class SubGroupExpression:

src/masoniteorm/expressions/expressions.py

@@ -19,28 +19,18 @@ def apply_query(self, builder, foreign_key_value=None, eager=None):
     def get_related(self, foreign, result, eager=None):
         return self.apply_query(self.model_class, getattr(result, self.local_key)).first()
 
-
     def __call__(self, owner):
-        """Fetch the related record when invoked."""
+        """Return a query builder for the relationship."""
         related_model = self.model_class
-        related_model.owner = self
         self.owner = owner
+        
+        # Get the foreign key value
         foreign_key_value = owner.__attributes__.get(self.local_key)
         if not foreign_key_value:
-            print("No foreign key value")
-            return self
-
-        self.owner = owner
-        # print("relationships", owner, owner._relationships)
-        if self.method and self.method in owner._relationships:
-            return owner._relationships[self.method]
-        builder = self.apply_query(related_model.builder)
-        result = builder.first()
-        self.owner = owner
-        result.__dict__['related'] = self
-        return result
-
+            return related_model.builder.where_raw("1 = 0")  # Return empty query if no foreign key
+            
+        # Return the query builder directly
+        return self.apply_query(related_model.builder, foreign_key_value)
 
     def add_relation(self, model_instance, result, relation_key=None):
-        # if result is a collection, do a where
-       return model_instance.add_relation({relation_key: result or None})
+        return model_instance.add_relation({relation_key: result or None})

src/masoniteorm/models/relationships/new/BelongsTo.py

@@ -31,23 +31,17 @@ def get_related(self, foreign, result, eager=None):
         return self.apply_query(self.model_class, getattr(result, self.foreign_key)).get()
 
     def __call__(self, owner):
-        """Fetch the related record when invoked."""
+        """Return a query builder for the relationship."""
         related_model = self.model_class
-        # print("related model", related_model)
-        related_model.owner = self
         self.owner = owner
-        foreign_key_value = owner.__attributes__.get(self.foreign_key)
+        
+        # Get the foreign key value
+        foreign_key_value = owner.__attributes__.get(self.local_key)
         if not foreign_key_value:
-            return self
-
-        if self.method and self.method in owner._relationships:
-            return owner._relationships[self.method]
-        result = self.apply_query(related_model.builder).get()
-        result._builder = self.apply_query(self.model_class.builder, foreign_key_value)
-        result._related = self
-        for item in result:
-            item.__dict__['related'] = self
-        return result
+            return related_model.builder.where_raw("1 = 0")  # Return empty query if no foreign key
+            
+        # Return the query builder directly
+        return self.apply_query(related_model.builder, foreign_key_value)
 
     def add_relation(self, model_instance, result, relation_key=None):
         # if result is a collection, do a where

src/masoniteorm/models/relationships/new/HasMany.py

@@ -19,28 +19,18 @@ def apply_query(self, builder, foreign_key_value=None, eager=None):
     def get_related(self, foreign, result, eager=None):
         return self.apply_query(self.model_class, getattr(result, self.local_key)).first()
 
-
     def __call__(self, owner):
-        """Fetch the related record when invoked."""
+        """Return a query builder for the relationship."""
         related_model = self.model_class
-        related_model.owner = self
         self.owner = owner
+        
+        # Get the foreign key value
         foreign_key_value = owner.__attributes__.get(self.local_key)
         if not foreign_key_value:
-            print("No foreign key value")
-            return self
-
-        self.owner = owner
-        # print("relationships", owner, owner._relationships)
-        if self.method and self.method in owner._relationships:
-            return owner._relationships[self.method]
-        builder = self.apply_query(related_model.builder)
-        result = builder.first()
-        self.owner = owner
-        result.__dict__['related'] = self
-        return result
-
+            return related_model.builder.where_raw("1 = 0")  # Return empty query if no foreign key
+            
+        # Return the query builder directly
+        return self.apply_query(related_model.builder, foreign_key_value)
 
     def add_relation(self, model_instance, result, relation_key=None):
-        # if result is a collection, do a where
-       return model_instance.add_relation({relation_key: result or None})
+        return model_instance.add_relation({relation_key: result or None})

src/masoniteorm/models/relationships/new/HasOne.py

@@ -2345,3 +2345,20 @@ def oldest(self, *fields):
 
     def value(self, column: str):
         return self.get().first()[column]
+
+    def add_relation(self, model_instance, result, relation_key=None):
+        """Add a relationship to a model instance.
+        
+        Arguments:
+            model_instance {Model} -- The model instance to add the relationship to
+            result {Model|Collection} -- The related model or collection
+            relation_key {string} -- The name of the relationship
+            
+        Returns:
+            Model -- The model instance with the relationship added
+        """
+        if not hasattr(model_instance, '_relationships'):
+            model_instance._relationships = {}
+            
+        model_instance._relationships[relation_key] = result
+        return model_instance

src/masoniteorm/query/QueryBuilder.py

@@ -658,8 +658,11 @@ def process_wheres(self, qmark=False, strip_first_where=False):
                 sql_string = self.where_group_string()
             elif isinstance(value, SubSelectExpression):
                 if qmark:
+                    print(value)
                     query_from_builder = value.builder.to_qmark()
-                    if value.builder._bindings:
+                    if hasattr(value.builder, '_items'):
+                        self.add_binding(*value.builder._items)
+                    else:
                         self.add_binding(*value.builder._bindings)
                 else:
                     query_from_builder = value.builder.to_sql()

src/masoniteorm/query/grammars/BaseGrammar.py

@@ -124,7 +124,7 @@ def test_casting(self):
             user
 
     def test_setting(self):
-        users = User.with_("articles").where("is_admin", True).get()
+        users = User.where("is_admin", True).get()
         for user in users:
             user.name = "Joe"
             user.is_admin = 1