sqlalchemy-cubrid 1.1.0__tar.gz → 1.2.0__tar.gz

{sqlalchemy_cubrid-1.1.0/sqlalchemy_cubrid.egg-info → sqlalchemy_cubrid-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-cubrid
-Version: 1.1.0
+Version: 1.2.0
 Summary: CUBRID dialect for SQLAlchemy
 Author-email: Yeongseon Choe <yeongseon.choe@gmail.com>, Gyeongjun Paik <paikend@gmail.com>
 License-Expression: MIT
@@ -180,7 +180,7 @@ async with AsyncSession(engine) as session:
 
 ## Features
 
-- Complete type system -- numeric, string, date/time, bit, LOB, and collection types
+- Complete type system -- numeric, string, date/time, bit, LOB, collection, and JSON types
 - SQL compilation -- SELECT, JOIN, CAST, LIMIT/OFFSET, subqueries, CTEs, window functions
 - DML extensions -- `ON DUPLICATE KEY UPDATE`, `MERGE`, `REPLACE INTO`, `FOR UPDATE`, `TRUNCATE`
 - DDL support -- `COMMENT`, `IF NOT EXISTS` / `IF EXISTS`, `AUTO_INCREMENT`

{sqlalchemy_cubrid-1.1.0 → sqlalchemy_cubrid-1.2.0}/README.md

@@ -131,7 +131,7 @@ async with AsyncSession(engine) as session:
 
 ## Features
 
-- Complete type system -- numeric, string, date/time, bit, LOB, and collection types
+- Complete type system -- numeric, string, date/time, bit, LOB, collection, and JSON types
 - SQL compilation -- SELECT, JOIN, CAST, LIMIT/OFFSET, subqueries, CTEs, window functions
 - DML extensions -- `ON DUPLICATE KEY UPDATE`, `MERGE`, `REPLACE INTO`, `FOR UPDATE`, `TRUNCATE`
 - DDL support -- `COMMENT`, `IF NOT EXISTS` / `IF EXISTS`, `AUTO_INCREMENT`

{sqlalchemy_cubrid-1.1.0 → sqlalchemy_cubrid-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sqlalchemy-cubrid"
-version = "1.1.0"
+version = "1.2.0"
 description = "CUBRID dialect for SQLAlchemy"
 readme = "README.md"
 license = "MIT"

{sqlalchemy_cubrid-1.1.0 → sqlalchemy_cubrid-1.2.0}/sqlalchemy_cubrid/__init__.py

@@ -25,6 +25,9 @@ from .types import (
     DOUBLE,
     DOUBLE_PRECISION,
     FLOAT,
+    JSON,
+    JSONIndexType,
+    JSONPathType,
     MONETARY,
     MULTISET,
     NCHAR,
@@ -49,7 +52,7 @@ from sqlalchemy.sql.sqltypes import (
     TIMESTAMP,
 )
 
-__version__ = "1.0.0"
+__version__ = "1.2.0"
 
 __all__ = (
     "insert",
@@ -82,4 +85,7 @@ __all__ = (
     "MULTISET",
     "SEQUENCE",
     "OBJECT",
+    "JSON",
+    "JSONIndexType",
+    "JSONPathType",
 )

{sqlalchemy_cubrid-1.1.0 → sqlalchemy_cubrid-1.2.0}/sqlalchemy_cubrid/aio_pycubrid_dialect.py

@@ -7,8 +7,7 @@
 
 from __future__ import annotations
 
-import collections
-from typing import Any, Callable, Optional, cast
+from typing import Any, Callable, cast
 
 from sqlalchemy.connectors.asyncio import (
     AsyncAdapt_dbapi_connection,

{sqlalchemy_cubrid-1.1.0 → sqlalchemy_cubrid-1.2.0}/sqlalchemy_cubrid/compiler.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from sqlalchemy.sql import compiler
+from sqlalchemy.sql import compiler, elements
 from sqlalchemy.sql import sqltypes
 
 
@@ -320,6 +320,56 @@ class CubridCompiler(compiler.SQLCompiler):
             return "REPLACE" + text[len("INSERT") :]
         return text
 
+    def _render_json_extract_from_binary(
+        self, binary: elements.BinaryExpression[Any], operator: Any, **kw: Any
+    ) -> str:
+        if binary.type._type_affinity is sqltypes.JSON:
+            return "JSON_EXTRACT(%s, %s)" % (
+                self.process(binary.left, **kw),
+                self.process(binary.right, **kw),
+            )
+
+        # When the target type is not JSON, convert JSON 'null' to SQL NULL
+        case_expression = "CASE JSON_EXTRACT(%s, %s) WHEN 'null' THEN NULL" % (
+            self.process(binary.left, **kw),
+            self.process(binary.right, **kw),
+        )
+
+        if binary.type._type_affinity is sqltypes.Boolean:
+            type_expression = (
+                "WHEN 'true' THEN 1 WHEN 'false' THEN 0 ELSE CAST(JSON_EXTRACT(%s, %s) AS INTEGER)"
+            ) % (
+                self.process(binary.left, **kw),
+                self.process(binary.right, **kw),
+            )
+        elif binary.type._type_affinity is sqltypes.Integer:
+            type_expression = "ELSE CAST(JSON_EXTRACT(%s, %s) AS INTEGER)" % (
+                self.process(binary.left, **kw),
+                self.process(binary.right, **kw),
+            )
+        elif binary.type._type_affinity is sqltypes.Numeric:
+            type_expression = "ELSE CAST(JSON_EXTRACT(%s, %s) AS DOUBLE)" % (
+                self.process(binary.left, **kw),
+                self.process(binary.right, **kw),
+            )
+        else:
+            type_expression = "ELSE JSON_UNQUOTE(JSON_EXTRACT(%s, %s))" % (
+                self.process(binary.left, **kw),
+                self.process(binary.right, **kw),
+            )
+
+        return case_expression + " " + type_expression + " END"
+
+    def visit_json_getitem_op_binary(
+        self, binary: elements.BinaryExpression[Any], operator: Any, **kw: Any
+    ) -> str:
+        return self._render_json_extract_from_binary(binary, operator, **kw)
+
+    def visit_json_path_getitem_op_binary(
+        self, binary: elements.BinaryExpression[Any], operator: Any, **kw: Any
+    ) -> str:
+        return self._render_json_extract_from_binary(binary, operator, **kw)
+
 
 class CubridDDLCompiler(compiler.DDLCompiler):
     """DDLCompiler subclass for CUBRID.
@@ -534,3 +584,6 @@ class CubridTypeCompiler(compiler.GenericTypeCompiler):
             else:
                 parts.append(value.__visit_name__)
         return f"{collection_type}({','.join(parts)})"
+
+    def visit_JSON(self, type_: Any, **kw: Any) -> str:
+        return "JSON"

{sqlalchemy_cubrid-1.1.0 → sqlalchemy_cubrid-1.2.0}/sqlalchemy_cubrid/dialect.py

@@ -48,6 +48,9 @@ from sqlalchemy_cubrid.types import (
     DOUBLE,
     DOUBLE_PRECISION,
     FLOAT,
+    JSON,
+    JSONIndexType,
+    JSONPathType,
     MULTISET,
     NCHAR,
     NUMERIC,
@@ -84,6 +87,9 @@ colspecs = {
     sqltypes.Numeric: NUMERIC,
     sqltypes.Float: FLOAT,
     sqltypes.Time: TIME,
+    sqltypes.JSON: JSON,
+    sqltypes.JSON.JSONIndexType: JSONIndexType,
+    sqltypes.JSON.JSONPathType: JSONPathType,
 }
 
 # ischema_names maps CUBRID type names from SHOW COLUMNS to SA types.
@@ -120,6 +126,8 @@ ischema_names = {
     "SET": SET,
     "MULTISET": MULTISET,
     "SEQUENCE": SEQUENCE,
+    # JSON (CUBRID 10.2+)
+    "JSON": JSON,
 }
 
 

{sqlalchemy_cubrid-1.1.0 → sqlalchemy_cubrid-1.2.0}/sqlalchemy_cubrid/types.py

@@ -354,3 +354,92 @@ class OBJECT(sqltypes.TypeEngine[Any]):
     """
 
     __visit_name__ = "OBJECT"
+
+
+# ---------------------------------------------------------------------------
+# JSON Type (CUBRID 10.2+)
+# ---------------------------------------------------------------------------
+
+
+class _FormatTypeMixin:
+    """Mixin for formatting JSON path index/path values for bind parameters."""
+
+    def _format_value(self, value: Any) -> str:
+        raise NotImplementedError()
+
+    def bind_processor(self, dialect: Any) -> Any:
+        super_proc = self.string_bind_processor(dialect)  # type: ignore[attr-defined]  # noqa: E501
+
+        def process(value: Any) -> Any:
+            value = self._format_value(value)
+            if super_proc:
+                value = super_proc(value)
+            return value
+
+        return process
+
+    def literal_processor(self, dialect: Any) -> Any:
+        super_proc = self.string_literal_processor(dialect)  # type: ignore[attr-defined]  # noqa: E501
+
+        def process(value: Any) -> str:
+            value = self._format_value(value)
+            if super_proc:
+                value = super_proc(value)
+            return value
+
+        return process
+
+
+class JSONIndexType(_FormatTypeMixin, sqltypes.JSON.JSONIndexType):
+    """CUBRID JSON index type for single-key access.
+
+    Converts Python index values to CUBRID JSON path syntax:
+    - Integer index: ``$[0]``
+    - String key: ``$."key"``
+    """
+
+    def _format_value(self, value: Any) -> str:
+        if isinstance(value, int):
+            return "$[%s]" % value
+        else:
+            return '$."%s"' % str(value).replace('"', '""')
+
+
+class JSONPathType(_FormatTypeMixin, sqltypes.JSON.JSONPathType):
+    """CUBRID JSON path type for multi-level access.
+
+    Converts Python tuple paths to CUBRID JSON path syntax:
+    - ``("a", 1, "b")`` → ``$."a"[1]."b"``
+    """
+
+    def _format_value(self, value: Any) -> str:
+        return "$%s" % (
+            "".join(
+                "[%s]" % elem if isinstance(elem, int) else '."%s"' % str(elem).replace('"', '""')
+                for elem in value
+            )
+        )
+
+
+class JSON(sqltypes.JSON):  # type: ignore[type-arg]
+    """CUBRID JSON type.
+
+    CUBRID supports JSON as of version 10.2 (RFC 7159 compliant).
+
+    :class:`_cubrid.JSON` is used automatically whenever the base
+    :class:`_types.JSON` datatype is used against a CUBRID backend.
+
+    The :class:`.cubrid.JSON` type supports persistence of JSON values
+    as well as the core index operations provided by :class:`_types.JSON`
+    datatype, by adapting the operations to render the ``JSON_EXTRACT``
+    function at the database level.
+
+    .. seealso::
+
+        :class:`_types.JSON` - main documentation for the generic
+        cross-platform JSON datatype.
+
+    .. versionadded:: 1.2.0
+    """
+
+    __visit_name__ = "JSON"

{sqlalchemy_cubrid-1.1.0 → sqlalchemy_cubrid-1.2.0/sqlalchemy_cubrid.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-cubrid
-Version: 1.1.0
+Version: 1.2.0
 Summary: CUBRID dialect for SQLAlchemy
 Author-email: Yeongseon Choe <yeongseon.choe@gmail.com>, Gyeongjun Paik <paikend@gmail.com>
 License-Expression: MIT
@@ -180,7 +180,7 @@ async with AsyncSession(engine) as session:
 
 ## Features
 
-- Complete type system -- numeric, string, date/time, bit, LOB, and collection types
+- Complete type system -- numeric, string, date/time, bit, LOB, collection, and JSON types
 - SQL compilation -- SELECT, JOIN, CAST, LIMIT/OFFSET, subqueries, CTEs, window functions
 - DML extensions -- `ON DUPLICATE KEY UPDATE`, `MERGE`, `REPLACE INTO`, `FOR UPDATE`, `TRUNCATE`
 - DDL support -- `COMMENT`, `IF NOT EXISTS` / `IF EXISTS`, `AUTO_INCREMENT`

{sqlalchemy_cubrid-1.1.0 → sqlalchemy_cubrid-1.2.0}/sqlalchemy_cubrid.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ test/test_compiler.py
 test/test_dialect_offline.py
 test/test_dialects.py
 test/test_integration.py
+test/test_json.py
 test/test_pycubrid_dialect.py
 test/test_requirements.py
 test/test_suite.py

{sqlalchemy_cubrid-1.1.0 → sqlalchemy_cubrid-1.2.0}/test/test_aio_pycubrid_dialect.py

@@ -2,10 +2,8 @@ from __future__ import annotations
 
 import sys
 import types
-from typing import Any
 from unittest.mock import AsyncMock, MagicMock, patch
 
-import pytest
 from sqlalchemy.engine import url
 
 from sqlalchemy_cubrid.aio_pycubrid_dialect import (

{sqlalchemy_cubrid-1.1.0 → sqlalchemy_cubrid-1.2.0}/test/test_integration.py

@@ -36,7 +36,7 @@ from sqlalchemy import (
     select,
     text,
 )
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import DeclarativeBase, Mapped, Session, mapped_column
 
 # ---------------------------------------------------------------------------
 # Fixtures
@@ -587,7 +587,6 @@ class TestFetchShapeCompatibility:
         execute successfully against a live CUBRID instance, confirming
         the dialect's use_insertmanyvalues=True is honored end-to-end.
         """
-        from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
         class _Base(DeclarativeBase):
             pass
@@ -595,22 +594,20 @@ class TestFetchShapeCompatibility:
         class BulkUser(_Base):
             __tablename__ = "imv_bulk_test"
             id: Mapped[int] = mapped_column(
-                Integer, primary_key=True, autoincrement=True,
+                Integer,
+                primary_key=True,
+                autoincrement=True,
             )
             name: Mapped[str] = mapped_column(String(100))
 
         _Base.metadata.create_all(engine)
         try:
             with Session(engine) as session:
-                session.add_all(
-                    [BulkUser(name=f"user_{i}") for i in range(10)]
-                )
+                session.add_all([BulkUser(name=f"user_{i}") for i in range(10)])
                 session.commit()
 
             with engine.connect() as conn:
-                count = conn.execute(
-                    text("SELECT COUNT(*) FROM imv_bulk_test")
-                ).scalar()
+                count = conn.execute(text("SELECT COUNT(*) FROM imv_bulk_test")).scalar()
                 assert count == 10
         finally:
             _Base.metadata.drop_all(engine)

sqlalchemy_cubrid-1.2.0/test/test_json.py

@@ -0,0 +1,312 @@
+# test/test_json.py
+from __future__ import annotations
+
+
+import pytest
+import sqlalchemy as sa
+from sqlalchemy import Column, Integer, MetaData, String, Table, func, select
+
+from sqlalchemy_cubrid.dialect import CubridDialect
+from sqlalchemy_cubrid.types import JSON, JSONIndexType, JSONPathType
+
+
+def _compile(stmt, dialect=None):
+    if dialect is None:
+        dialect = CubridDialect()
+    return stmt.compile(dialect=dialect, compile_kwargs={"literal_binds": True}).string
+
+
+metadata = MetaData()
+json_table = Table(
+    "json_test",
+    metadata,
+    Column("id", Integer, primary_key=True),
+    Column("data", JSON),
+    Column("name", String(100)),
+)
+
+
+class TestJSONType:
+    def test_visit_name(self):
+        assert JSON.__visit_name__ == "JSON"
+
+    def test_is_subclass_of_sa_json(self):
+        from sqlalchemy.sql import sqltypes
+
+        assert issubclass(JSON, sqltypes.JSON)
+
+    def test_instantiation(self):
+        t = JSON()
+        assert t is not None
+
+    def test_none_as_null_parameter(self):
+        t = JSON(none_as_null=True)
+        assert t.none_as_null is True
+
+
+class TestJSONDDLCompilation:
+    def test_json_column_ddl(self):
+        dialect = CubridDialect()
+        compiled = dialect.type_compiler_instance.process(JSON())
+        assert compiled == "JSON"
+
+    def test_generic_sa_json_compiles_to_json(self):
+        tbl = Table(
+            "ddl_test",
+            MetaData(),
+            Column("id", Integer, primary_key=True),
+            Column("payload", sa.JSON),
+        )
+        dialect = CubridDialect()
+        create_ddl = sa.schema.CreateTable(tbl).compile(dialect=dialect).string
+        assert "JSON" in create_ddl
+
+    def test_cubrid_json_compiles_to_json(self):
+        tbl = Table(
+            "ddl_test2",
+            MetaData(),
+            Column("id", Integer, primary_key=True),
+            Column("payload", JSON),
+        )
+        dialect = CubridDialect()
+        create_ddl = sa.schema.CreateTable(tbl).compile(dialect=dialect).string
+        assert "JSON" in create_ddl
+
+
+class TestJSONIndexType:
+    def test_format_integer_index(self):
+        idx = JSONIndexType()
+        assert idx._format_value(0) == "$[0]"
+        assert idx._format_value(3) == "$[3]"
+
+    def test_format_string_key(self):
+        idx = JSONIndexType()
+        assert idx._format_value("name") == '$."name"'
+        assert idx._format_value("address") == '$."address"'
+
+
+class TestJSONPathType:
+    def test_format_simple_path(self):
+        pth = JSONPathType()
+        assert pth._format_value(("a",)) == '$."a"'
+
+    def test_format_nested_path(self):
+        pth = JSONPathType()
+        assert pth._format_value(("a", "b", "c")) == '$."a"."b"."c"'
+
+    def test_format_mixed_path(self):
+        pth = JSONPathType()
+        assert pth._format_value(("a", 1, "b")) == '$."a"[1]."b"'
+
+    def test_format_array_only_path(self):
+        pth = JSONPathType()
+        assert pth._format_value((0, 1, 2)) == "$[0][1][2]"
+
+
+class TestJSONPathExpressionCompilation:
+    def test_json_getitem_string_key(self):
+        stmt = select(json_table.c.data["name"])
+        sql = _compile(stmt)
+        assert "JSON_EXTRACT" in sql
+
+    def test_json_getitem_integer_index(self):
+        stmt = select(json_table.c.data[0])
+        sql = _compile(stmt)
+        assert "JSON_EXTRACT" in sql
+
+    def test_json_path_getitem(self):
+        stmt = select(json_table.c.data[("a", "b")])
+        sql = _compile(stmt)
+        assert "JSON_EXTRACT" in sql
+
+    def test_json_getitem_in_where(self):
+        stmt = select(json_table).where(json_table.c.data["status"].as_string() == "active")
+        sql = _compile(stmt)
+        assert "JSON_EXTRACT" in sql
+        assert "JSON_UNQUOTE" in sql
+
+    def test_json_getitem_as_integer(self):
+        stmt = select(json_table).where(json_table.c.data["count"].as_integer() > 5)
+        sql = _compile(stmt)
+        assert "JSON_EXTRACT" in sql
+        assert "CAST" in sql
+        assert "INTEGER" in sql
+
+    def test_json_getitem_as_float(self):
+        stmt = select(json_table).where(json_table.c.data["score"].as_float() > 3.5)
+        sql = _compile(stmt)
+        assert "JSON_EXTRACT" in sql
+        assert "CAST" in sql
+        assert "DOUBLE" in sql
+
+    def test_json_null_handling_for_string(self):
+        stmt = select(json_table.c.data["name"].as_string())
+        sql = _compile(stmt)
+        assert "WHEN 'null' THEN NULL" in sql
+
+    def test_json_getitem_as_boolean(self):
+        stmt = select(json_table).where(
+            json_table.c.data["active"].as_boolean() == True  # noqa: E712
+        )
+        sql = _compile(stmt)
+        assert "WHEN 'true' THEN 1" in sql
+        assert "WHEN 'false' THEN 0" in sql
+
+
+class TestJSONKeyEscaping:
+    def test_key_with_embedded_quote(self):
+        idx = JSONIndexType()
+        assert idx._format_value('a"b') == '$."a""b"'
+
+    def test_key_with_dot(self):
+        idx = JSONIndexType()
+        assert idx._format_value("a.b") == '$."a.b"'
+
+    def test_key_with_space(self):
+        idx = JSONIndexType()
+        assert idx._format_value("a b") == '$."a b"'
+
+    def test_empty_string_key(self):
+        idx = JSONIndexType()
+        assert idx._format_value("") == '$.""'
+
+    def test_path_with_embedded_quote(self):
+        pth = JSONPathType()
+        assert pth._format_value(('a"b', "c")) == '$."a""b"."c"'
+
+
+class TestFuncJSONExtract:
+    def test_func_json_extract(self):
+        stmt = select(func.JSON_EXTRACT(json_table.c.data, "$.name"))
+        sql = _compile(stmt)
+        assert "JSON_EXTRACT" in sql
+        assert "$.name" in sql
+
+    def test_func_json_contains(self):
+        stmt = select(json_table).where(
+            func.JSON_CONTAINS(json_table.c.data, '"value"', "$.key") == 1
+        )
+        sql = _compile(stmt)
+        assert "JSON_CONTAINS" in sql
+
+    def test_func_json_object(self):
+        stmt = select(func.JSON_OBJECT("key", "value"))
+        sql = _compile(stmt)
+        assert "JSON_OBJECT" in sql
+
+    def test_func_json_array(self):
+        stmt = select(func.JSON_ARRAY(1, 2, 3))
+        sql = _compile(stmt)
+        assert "JSON_ARRAY" in sql
+
+
+class TestColspecs:
+    def test_generic_json_maps_to_cubrid_json(self):
+        from sqlalchemy_cubrid.dialect import colspecs
+        from sqlalchemy.sql import sqltypes
+
+        assert sqltypes.JSON in colspecs
+        assert colspecs[sqltypes.JSON] is JSON
+
+    def test_json_index_type_mapped(self):
+        from sqlalchemy_cubrid.dialect import colspecs
+        from sqlalchemy.sql import sqltypes
+
+        assert sqltypes.JSON.JSONIndexType in colspecs
+        assert colspecs[sqltypes.JSON.JSONIndexType] is JSONIndexType
+
+    def test_json_path_type_mapped(self):
+        from sqlalchemy_cubrid.dialect import colspecs
+        from sqlalchemy.sql import sqltypes
+
+        assert sqltypes.JSON.JSONPathType in colspecs
+        assert colspecs[sqltypes.JSON.JSONPathType] is JSONPathType
+
+
+class TestIschemaNames:
+    def test_json_in_ischema_names(self):
+        from sqlalchemy_cubrid.dialect import ischema_names
+
+        assert "JSON" in ischema_names
+        assert ischema_names["JSON"] is JSON
+
+
+class TestJSONExport:
+    def test_json_in_init_all(self):
+        import sqlalchemy_cubrid
+
+        assert "JSON" in sqlalchemy_cubrid.__all__
+        assert "JSONIndexType" in sqlalchemy_cubrid.__all__
+        assert "JSONPathType" in sqlalchemy_cubrid.__all__
+
+    def test_json_importable(self):
+        from sqlalchemy_cubrid import JSON as ImportedJSON
+
+        assert ImportedJSON is JSON
+
+    def test_json_index_type_importable(self):
+        from sqlalchemy_cubrid import JSONIndexType as ImportedJIT
+
+        assert ImportedJIT is JSONIndexType
+
+    def test_json_path_type_importable(self):
+        from sqlalchemy_cubrid import JSONPathType as ImportedJPT
+
+        assert ImportedJPT is JSONPathType
+
+
+class TestFormatTypeMixinProcessors:
+    def _dialect(self):
+        from sqlalchemy_cubrid.dialect import CubridDialect
+
+        return CubridDialect()
+
+    def test_format_value_not_implemented(self):
+        from sqlalchemy_cubrid.types import _FormatTypeMixin
+
+        with pytest.raises(NotImplementedError):
+            _FormatTypeMixin()._format_value("anything")
+
+    def test_index_bind_processor_int(self):
+        proc = JSONIndexType().bind_processor(self._dialect())
+        assert proc is not None
+        assert proc(0) == "$[0]"
+
+    def test_index_bind_processor_string_escapes(self):
+        proc = JSONIndexType().bind_processor(self._dialect())
+        assert proc('a"b') == '$."a""b"'
+
+    def test_index_literal_processor_int(self):
+        proc = JSONIndexType().literal_processor(self._dialect())
+        assert proc is not None
+        result = proc(2)
+        assert "$[2]" in result
+
+    def test_index_literal_processor_string(self):
+        proc = JSONIndexType().literal_processor(self._dialect())
+        result = proc("name")
+        assert '$."name"' in result
+
+    def test_path_bind_processor(self):
+        proc = JSONPathType().bind_processor(self._dialect())
+        assert proc is not None
+        assert proc(("a", 1, "b")) == '$."a"[1]."b"'
+
+    def test_path_literal_processor(self):
+        proc = JSONPathType().literal_processor(self._dialect())
+        result = proc(("x", 0))
+        assert '$."x"[0]' in result
+
+    def test_index_bind_processor_no_super(self, monkeypatch):
+        """Cover the branch where string_bind_processor returns None."""
+        idx = JSONIndexType()
+        monkeypatch.setattr(idx, "string_bind_processor", lambda dialect: None)
+        proc = idx.bind_processor(self._dialect())
+        assert proc("k") == '$."k"'
+
+    def test_index_literal_processor_no_super(self, monkeypatch):
+        """Cover the branch where string_literal_processor returns None."""
+        idx = JSONIndexType()
+        monkeypatch.setattr(idx, "string_literal_processor", lambda dialect: None)
+        proc = idx.literal_processor(self._dialect())
+        assert proc("k") == '$."k"'