Disabling SQL compilation cache for Solr releases earlier than 9.0

README.md

@@ -28,6 +28,8 @@ To connect to Solr with SQLAlchemy, the following URL pattern can be used:
 solr://<username>:<password>@<host>:<port>/solr/<collection>[?parameter=value]
 ```
 
+_Note_: port 8983 is used when `port` in the URL is omitted
+
 ### Authentication
 
 #### Basic Authentication
@@ -162,6 +164,7 @@ translates to `[2024-01-01T00:00:00Z TO *]`
 | Aliases | ✗ | ✗ | ✓ | ✓ | ✓ | ✓ |
 | Built-in date range compilation | ✗ | ✗ | ✗ | ✗ | ✗ | ✓ |
 | `SELECT` _expression_ statements | ✗ | ✓ | ✓ | ✓ | ✓ | ✓ |
+| SQL compilation caching | ✗ | ✗ | ✗ | ✗ | ✗ | ✓ |
 
 ## Use Cases
 

src/sqlalchemy_solr/admin/solr_spec.py

@@ -1,15 +1,51 @@
 from requests import Session
+from sqlalchemy_solr import defaults
 
 
 class SolrSpec:
 
  _spec = None
 
- def __init__(self, solr_base_url):
+ def __init__(self, url):
+ """
+ Initializes a SolrSpec object
+
+ :param url: Solr base url which can be a string HTTP(S) URL or a sqlalchemy.engine.url.URL.
+ """
+
  session = Session()
+
+ if isinstance(url, str):
+ base_url = url
+ else:
+ if "verify_ssl" in url.query and url.query["verify_ssl"] in [
+ "False",
+ "false",
+ ]:
+ session.verify = False
+
+ token = None
+ if "token" in url.query:
+ token = url.query["token"]
+
+ if token is not None:
+ session.headers.update({"Authorization": f"Bearer {token}"})
+ else:
+ session.auth = (url.username, url.password)
+
+ proto = "http"
+ if "use_ssl" in url.query and url.query["use_ssl"] in ["True", "true"]:
+ proto = "https"
+
+ server_path = url.database.split("/")[0]
+
+ port = url.port or defaults.PORT
+ base_url = f"{proto}://{url.host}:{port}/{server_path}"
+
  sys_info_response = session.get(
- solr_base_url + "/admin/info/system", params={"wt": "json"}
+ base_url + "/admin/info/system", params={"wt": "json"}
  )
+
  spec_version = sys_info_response.json()["lucene"]["solr-spec-version"]
  self._spec = list(map(int, spec_version.split(".")))
 

src/sqlalchemy_solr/base.py

@@ -30,10 +30,10 @@
 from sqlalchemy.sql import expression
 from sqlalchemy.sql import operators
 from sqlalchemy.sql.expression import BindParameter
+from sqlalchemy_solr import release_flags
 
 from . import solrdbapi as module
 from .solr_type_compiler import SolrTypeCompiler
-from .solrdbapi import Connection
 from .type_map import metadata_type_map
 
 logging.basicConfig(format="%(asctime)s - %(message)s", level=logging.ERROR)
@@ -42,8 +42,6 @@
 class SolrCompiler(compiler.SQLCompiler):
  # pylint: disable=abstract-method
 
- SOLR_DATE_RANGE_TRANS_RELEASE = 9
-
  merge_ops = (operators.ge, operators.gt, operators.le, operators.lt)
  bounds = {
  operators.ge: "[",
@@ -70,7 +68,10 @@ def visit_binary(
  ):
 
  # Handled in Solr 9
- if Connection.solr_spec.spec()[0] >= self.SOLR_DATE_RANGE_TRANS_RELEASE:
+ if (
+ SolrDialect.solr_spec.spec()[0]
+ >= release_flags.SOLR_DATE_RANGE_TRANS_RELEASE
+ ):
  return super().visit_binary(binary, override_operator, eager_grouping, **kw)
 
  if binary.operator not in self.merge_ops:
@@ -157,7 +158,10 @@ def visit_binary(
 
  def visit_clauselist(self, clauselist, **kw):
  # Handled in Solr 9
- if Connection.solr_spec.spec()[0] >= self.SOLR_DATE_RANGE_TRANS_RELEASE:
+ if (
+ SolrDialect.solr_spec.spec()[0]
+ >= release_flags.SOLR_DATE_RANGE_TRANS_RELEASE
+ ):
  return super().visit_clauselist(clauselist, **kw)
 
  if clauselist.operator == operators.and_:
@@ -537,6 +541,8 @@ class SolrDialect(default.DefaultDialect):
  supports_native_boolean = True
  supports_statement_cache = True
 
+ solr_spec = None
+
  def __init__(self, **kw):
  default.DefaultDialect.__init__(self, **kw)
  self.supported_extensions = []

src/sqlalchemy_solr/defaults.py

@@ -0,0 +1 @@
+PORT = 8983

src/sqlalchemy_solr/http.py

@@ -23,6 +23,9 @@
 
 from requests import RequestException
 from requests import Session
+from sqlalchemy_solr import defaults
+from sqlalchemy_solr import release_flags
+from sqlalchemy_solr.admin.solr_spec import SolrSpec
 from sqlalchemy_solr.solrdbapi.api_exceptions import DatabaseError
 
 from .api_globals import _HEADER
@@ -86,7 +89,7 @@ def create_connect_args(self, url):
 
  # Save this for later use.
  self.host = url.host
- self.port = url_port
+ self.port = url.port or defaults.PORT
  self.username = url.username
  self.password = url.password
  self.db = db
@@ -96,11 +99,7 @@ def create_connect_args(self, url):
  # Prepare a session with proper authorization handling.
  session = Session()
  # session.verify property which is bydefault true so Handled here
- if "verify_ssl" in url.query and url.query["verify_ssl"] in [
- False,
- "False",
- "false",
- ]:
+ if "verify_ssl" in url.query and url.query["verify_ssl"] in ["False", "false"]:
  session.verify = False
 
  if self.token is not None:
@@ -209,3 +208,22 @@ def get_unique_columns(self, columns):
  columns_set.remove(c["name"])
 
  return unique_columns
+
+ def on_connect_url(self, url):
+ SolrDialect.solr_spec = SolrSpec(url)
+
+ def do_on_connect(connection): # pylint: disable=unused-argument
+ SolrDialect.solr_spec = SolrSpec(url)
+
+ if (
+ SolrDialect.solr_spec.spec()[0]
+ < release_flags.SOLR_DATE_RANGE_TRANS_RELEASE
+ ):
+ logging.warning(
+ "Solr version %s less than 9, SQL compilation cache disabled",
+ SolrDialect.solr_spec.spec()[0],
+ )
+ SolrDialect_http.supports_statement_cache = False
+ SolrDialect.supports_statement_cache = False
+
+ return do_on_connect

src/sqlalchemy_solr/release_flags.py

@@ -0,0 +1 @@
+SOLR_DATE_RANGE_TRANS_RELEASE = 9

src/sqlalchemy_solr/solrdbapi/_solrdbapi.py

@@ -1,9 +1,9 @@
 import logging
 
 from requests import Session
+from sqlalchemy_solr import defaults
 
 from .. import type_map
-from ..admin.solr_spec import SolrSpec
 from ..api_globals import _HEADER
 from ..api_globals import _PAYLOAD
 from ..message_formatter import MessageFormatter
@@ -286,7 +286,6 @@ def __iter__(self):
 class Connection:
  # pylint: disable=too-many-instance-attributes
 
- solr_spec = None
  mf = MessageFormatter()
 
  # pylint: disable=too-many-arguments
@@ -314,8 +313,6 @@ def __init__(
  self._session = session
  self._connected = True
 
- Connection.solr_spec = SolrSpec(f"{proto}{host}:{port}/{server_path}")
-
  SolrTableReflection.connection = self
 
  @property
@@ -374,23 +371,23 @@ def cursor(self):
 # pylint: disable=too-many-arguments
 def connect(
  host,
- port=8047,
- db=None,
+ db,
+ server_path,
+ collection,
+ port=defaults.PORT,
  username=None,
  password=None,
- server_path="solr",
- collection=None,
- use_ssl=False,
+ use_ssl=None,
  verify_ssl=None,
  token=None,
 ):
 
  session = Session()
  # bydefault session.verify is set to True
- if verify_ssl is not None and verify_ssl in [False, "False", "false"]:
+ if verify_ssl is not None and verify_ssl in ["False", "false"]:
  session.verify = False
 
- if use_ssl in [True, "True", "true"]:
+ if use_ssl in ["True", "true"]:
  proto = "https://"
  else:
  proto = "http://"

tests/assertions.py

@@ -0,0 +1,10 @@
+import pytest
+from sqlalchemy_solr.admin.solr_spec import SolrSpec
+
+
+def assert_solr_release(settings, releases):
+ solr_spec = SolrSpec(settings["SOLR_BASE_URL"])
+ if solr_spec.spec()[0] not in releases:
+ pytest.skip(
+ reason=f"Solr spec version {solr_spec} not compatible with the current test"
+ )

tests/test_sql_compilation_caching_6.py

@@ -0,0 +1,54 @@
+from sqlalchemy import select
+from sqlalchemy.sql.expression import bindparam
+from sqlalchemy.util.langhelpers import _symbol
+from tests import assertions
+from tests.setup import prepare_orm
+
+releases = [6, 7, 8]
+
+
+class TestSQLCompilationCaching:
+
+ def test_sql_compilation_caching_1(self, settings):
+ assertions.assert_solr_release(settings, releases)
+
+ engine, t = prepare_orm(settings)
+
+ qry_1 = (select(t.c.COUNTRY_s).select_from(t)).limit(1)
+ qry_2 = (select(t.c.COUNTRY_s).select_from(t)).limit(10)
+
+ with engine.connect() as connection:
+ result_1 = connection.execute(qry_1)
+ result_2 = connection.execute(qry_2)
+
+ assert result_1.context.cache_hit == _symbol("NO_DIALECT_SUPPORT")
+ assert result_2.context.cache_hit == _symbol("NO_DIALECT_SUPPORT")
+
+ def test_sql_compilation_caching_2(self, settings):
+ assertions.assert_solr_release(settings, releases)
+
+ engine, t = prepare_orm(settings)
+
+ qry_1 = (select(t.c.COUNTRY_s).select_from(t)).limit(1).offset(1)
+ qry_2 = (select(t.c.COUNTRY_s).select_from(t)).limit(1).offset(2)
+
+ with engine.connect() as connection:
+ result_1 = connection.execute(qry_1)
+ result_2 = connection.execute(qry_2)
+
+ assert result_1.context.cache_hit == _symbol("NO_DIALECT_SUPPORT")
+ assert result_2.context.cache_hit == _symbol("NO_DIALECT_SUPPORT")
+
+ def test_sql_compilation_caching_3(self, settings):
+ assertions.assert_solr_release(settings, releases)
+
+ engine, t = prepare_orm(settings)
+
+ qry = select(t).where(t.c.COUNTRY_s == bindparam("COUNTRY_s")).limit(10)
+
+ with engine.connect() as connection:
+ result_1 = connection.execute(qry, {"COUNTRY_s": "Sweden"})
+ result_2 = connection.execute(qry, {"COUNTRY_s": "France"})
+
+ assert result_1.context.cache_hit == _symbol("NO_DIALECT_SUPPORT")
+ assert result_2.context.cache_hit == _symbol("NO_DIALECT_SUPPORT")