Some more progress.

Author: ankitml

paradedb/sqlalchemy/search.py

@@ -172,6 +172,37 @@ def more_like_this(
 ) -> ColumnElement[bool]:
     if (document_id is None) == (document is None):
         raise InvalidArgumentError("exactly one of document_id or document must be provided")
+    if document is not None and fields is not None:
+        raise InvalidArgumentError("fields can only be used with document_id")
+
+    if min_term_frequency is not None and min_term_frequency < 0:
+        raise InvalidArgumentError("min_term_frequency must be >= 0")
+    if max_query_terms is not None and max_query_terms <= 0:
+        raise InvalidArgumentError("max_query_terms must be > 0")
+    if min_doc_frequency is not None and min_doc_frequency < 0:
+        raise InvalidArgumentError("min_doc_frequency must be >= 0")
+    if max_doc_frequency is not None and max_doc_frequency < 0:
+        raise InvalidArgumentError("max_doc_frequency must be >= 0")
+    if (
+        min_doc_frequency is not None
+        and max_doc_frequency is not None
+        and min_doc_frequency > max_doc_frequency
+    ):
+        raise InvalidArgumentError("min_doc_frequency cannot be greater than max_doc_frequency")
+    if min_word_length is not None and min_word_length < 0:
+        raise InvalidArgumentError("min_word_length must be >= 0")
+    if max_word_length is not None and max_word_length < 0:
+        raise InvalidArgumentError("max_word_length must be >= 0")
+    if (
+        min_word_length is not None
+        and max_word_length is not None
+        and min_word_length > max_word_length
+    ):
+        raise InvalidArgumentError("min_word_length cannot be greater than max_word_length")
+    if boost_factor is not None and boost_factor < 0:
+        raise InvalidArgumentError("boost_factor must be >= 0")
+    if stopwords is not None and any((not isinstance(word, str)) or (not word.strip()) for word in stopwords):
+        raise InvalidArgumentError("stopwords entries must be non-empty strings")
 
     options_provided = any(
         option is not None

tests/integration/test_advanced_search_integration.py

@@ -5,6 +5,7 @@
 
 from conftest import Product, assert_uses_paradedb_scan
 from paradedb.sqlalchemy import search
+from paradedb.sqlalchemy.errors import InvalidArgumentError
 
 
 pytestmark = pytest.mark.integration
@@ -60,3 +61,30 @@ def test_more_like_this_by_document_payload(session):
     assert_uses_paradedb_scan(session, stmt)
     ids = list(session.scalars(stmt))
     assert 3 in ids
+
+
+def test_more_like_this_rejects_fields_with_document():
+    with pytest.raises(InvalidArgumentError, match="fields can only be used with document_id"):
+        search.more_like_this(Product.id, document={"description": "x"}, fields=["description"])
+
+
+def test_more_like_this_rejects_invalid_numeric_options():
+    with pytest.raises(InvalidArgumentError, match="min_term_frequency must be >= 0"):
+        search.more_like_this(Product.id, document_id=1, min_term_frequency=-1)
+
+    with pytest.raises(InvalidArgumentError, match="max_query_terms must be > 0"):
+        search.more_like_this(Product.id, document_id=1, max_query_terms=0)
+
+    with pytest.raises(InvalidArgumentError, match="min_doc_frequency cannot be greater than max_doc_frequency"):
+        search.more_like_this(Product.id, document_id=1, min_doc_frequency=10, max_doc_frequency=2)
+
+    with pytest.raises(InvalidArgumentError, match="min_word_length cannot be greater than max_word_length"):
+        search.more_like_this(Product.id, document_id=1, min_word_length=10, max_word_length=2)
+
+    with pytest.raises(InvalidArgumentError, match="boost_factor must be >= 0"):
+        search.more_like_this(Product.id, document_id=1, boost_factor=-1.0)
+
+
+def test_more_like_this_rejects_invalid_stopwords():
+    with pytest.raises(InvalidArgumentError, match="stopwords entries must be non-empty strings"):
+        search.more_like_this(Product.id, document_id=1, stopwords=["ok", ""])

tests/integration/test_range_query_integration.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import pytest
+from sqlalchemy import Column, Integer, MetaData, Table, Text, select, text
+from sqlalchemy.dialects.postgresql import INT4RANGE
+from sqlalchemy.orm import Session
+
+from conftest import assert_uses_paradedb_scan
+from paradedb.sqlalchemy import search
+
+
+pytestmark = pytest.mark.integration
+
+
+def test_range_query_with_op_and_all_predicate(engine):
+    metadata = MetaData()
+    items = Table(
+        "range_items",
+        metadata,
+        Column("id", Integer, primary_key=True),
+        Column("description", Text, nullable=False),
+        Column("weight_range", INT4RANGE, nullable=False),
+    )
+
+    with engine.begin() as conn:
+        conn.execute(text("DROP INDEX IF EXISTS range_items_bm25_idx"))
+        conn.execute(text("DROP TABLE IF EXISTS range_items"))
+    metadata.create_all(engine)
+
+    with engine.begin() as conn:
+        conn.execute(
+            text(
+                "CREATE INDEX range_items_bm25_idx ON range_items USING bm25 (id, description, weight_range) WITH (key_field='id')"
+            )
+        )
+        conn.execute(
+            text(
+                """
+                INSERT INTO range_items (id, description, weight_range)
+                VALUES
+                  (1, 'Ergonomic camera strap', int4range(1, 8)),
+                  (2, 'Mechanical keyboard', int4range(8, 15)),
+                  (3, 'Running shoes', int4range(3, 10))
+                """
+            )
+        )
+
+    try:
+        with Session(engine) as session:
+            stmt = (
+                select(items.c.id)
+                .where(items.c.weight_range.op("@>")(5))
+                .where(search.all(items.c.id))
+                .order_by(items.c.id)
+            )
+            assert_uses_paradedb_scan(session, stmt, index_name="range_items_bm25_idx")
+            ids = list(session.scalars(stmt))
+            assert ids == [1, 3]
+
+            stmt_with_text = (
+                select(items.c.id)
+                .where(items.c.weight_range.op("@>")(5))
+                .where(search.match_any(items.c.description, "running", "camera"))
+                .order_by(items.c.id)
+            )
+            assert_uses_paradedb_scan(session, stmt_with_text, index_name="range_items_bm25_idx")
+            ids_with_text = list(session.scalars(stmt_with_text))
+            assert ids_with_text == [1, 3]
+    finally:
+        with engine.begin() as conn:
+            conn.execute(text("DROP INDEX IF EXISTS range_items_bm25_idx"))
+            conn.execute(text("DROP TABLE IF EXISTS range_items"))