Fixupsgit add .

Author: bosd

base_sparse_field_jsonb_search/models/base_model.py

@@ -45,12 +45,23 @@ class Base(models.AbstractModel):
 
  _inherit = "base"
 
- def _where_calc(self, domain, active_test=True):
+ def _search(
+ self,
+ domain,
+ offset=0,
+ limit=None,
+ order=None,
+ *,
+ active_test=True,
+ bypass_access=False,
+ ):
  """Override to translate sparse field domains to JSONB operators.
 
  This method intercepts the domain before it's processed by the ORM
  and translates any sparse field references to native PostgreSQL
  JSONB operators for efficient querying.
+
+ Note: In Odoo 19, _where_calc was replaced by _search.
  """
  # Get mapping of sparse fields to their containers
  sparse_fields = self._get_sparse_field_mapping()
@@ -59,10 +70,15 @@ def _where_calc(self, domain, active_test=True):
  # Transform domain to use JSONB operators for sparse fields
  domain = self._transform_jsonb_domain(domain, sparse_fields)
 
- # Call the original _where_calc from models.BaseModel
- from odoo.models import BaseModel
-
- return BaseModel._where_calc(self, domain, active_test=active_test)
+ # Call parent _search
+ return super()._search(
+ domain,
+ offset=offset,
+ limit=limit,
+ order=order,
+ active_test=active_test,
+ bypass_access=bypass_access,
+ )
 
  @api.model
  def _get_sparse_field_mapping(self):

base_sparse_field_jsonb_search/tests/test_jsonb_search.py

@@ -134,27 +134,27 @@ def test_transform_jsonb_domain_list_leaf(self):
  result = self.Base._transform_jsonb_domain(domain, {})
  self.assertEqual(result, domain)
 
- def test_where_calc_no_sparse_fields(self):
- """Test _where_calc works normally without sparse fields."""
+ def test_search_no_sparse_fields(self):
+ """Test _search works normally without sparse fields."""
  # This should not raise any errors
- query = self.Partner._where_calc([("name", "=", "test")])
+ query = self.Partner._search([("name", "=", "test")])
  self.assertIsNotNone(query)
 
- def test_where_calc_empty_domain(self):
- """Test _where_calc with empty domain."""
- query = self.Partner._where_calc([])
+ def test_search_empty_domain(self):
+ """Test _search with empty domain."""
+ query = self.Partner._search([])
  self.assertIsNotNone(query)
 
- def test_where_calc_complex_domain(self):
- """Test _where_calc with complex domain."""
+ def test_search_complex_domain(self):
+ """Test _search with complex domain."""
  domain = [
  "&",
  ("name", "ilike", "test"),
  "|",
  ("active", "=", True),
  ("comment", "!=", False),
  ]
- query = self.Partner._where_calc(domain)
+ query = self.Partner._search(domain)
  self.assertIsNotNone(query)