pyobvector 0.2.10__tar.gz → 0.2.12__tar.gz

{pyobvector-0.2.10 → pyobvector-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyobvector
-Version: 0.2.10
+Version: 0.2.12
 Summary: A python SDK for OceanBase Vector Store, based on SQLAlchemy, compatible with Milvus API.
 Author: shanhaikang.shk
 Author-email: shanhaikang.shk@oceanbase.com
@@ -36,7 +36,7 @@ poetry install
 - install with pip:
 
 ```shell
-pip install pyobvector==0.2.10
+pip install pyobvector==0.2.12
 ```
 
 ## Build Doc

{pyobvector-0.2.10 → pyobvector-0.2.12}/README.md

@@ -15,7 +15,7 @@ poetry install
 - install with pip:
 
 ```shell
-pip install pyobvector==0.2.10
+pip install pyobvector==0.2.12
 ```
 
 ## Build Doc

{pyobvector-0.2.10 → pyobvector-0.2.12}/pyobvector/__init__.py

@@ -41,6 +41,7 @@ In this mode, you can regard `pyobvector` as an extension of SQLAlchemy.
 """
 from .client import *
 from .schema import (
+    ARRAY,
     VECTOR,
     POINT,
     VectorIndex,
@@ -67,6 +68,7 @@ __all__ = [
     "IndexParam",
     "IndexParams",
     "DataType",
+    "ARRAY",
     "VECTOR",
     "POINT",
     "VectorIndex",

{pyobvector-0.2.10 → pyobvector-0.2.12}/pyobvector/client/ob_vec_json_table_client.py

@@ -26,8 +26,8 @@ from ..json_table import (
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
 
-JSON_TABLE_META_TABLE_NAME = "_meta_json_t"
-JSON_TABLE_DATA_TABLE_NAME = "_data_json_t"
+JSON_TABLE_META_TABLE_NAME = "meta_json_t"
+JSON_TABLE_DATA_TABLE_NAME = "data_json_t"
 
 class ObVecJsonTableClient(ObVecClient):
     """OceanBase Vector Store Client with JSON Table."""
@@ -55,7 +55,7 @@ class ObVecJsonTableClient(ObVecClient):
         jdata_id = Column(Integer, primary_key=True, autoincrement=True, nullable=False)
         jdata = Column(JSON)
 
-    class JsonTableMetadata:
+    class JsonTableMetadata: 
         def __init__(self, user_id: str):
             self.user_id = user_id
             self.meta_cache: Dict[str, List] = {}
@@ -200,7 +200,7 @@ class ObVecJsonTableClient(ObVecClient):
             return "INT"
         if datatype == exp.DataType.Type.TINYINT:
             return "TINYINT"
-        if datatype == exp.DataType.Type.TIMESTAMP:
+        if datatype in (exp.DataType.Type.TIMESTAMP, exp.DataType.Type.TIMESTAMPTZ):
             return "TIMESTAMP"
         if datatype == exp.DataType.Type.VARCHAR:
             return "VARCHAR"

{pyobvector-0.2.10 → pyobvector-0.2.12}/pyobvector/client/schema_type.py

@@ -11,7 +11,7 @@ from sqlalchemy import (
 )
 from sqlalchemy.dialects.mysql import LONGTEXT
 from .enum import IntEnum
-from ..schema import VECTOR
+from ..schema import ARRAY, VECTOR
 
 
 class DataType(IntEnum):
@@ -60,8 +60,8 @@ def convert_datatype_to_sqltype(datatype: DataType):
         return LONGTEXT
     if datatype == DataType.VARCHAR:
         return String
-    # if datatype == DataType.ARRAY:
-    #     return ARRAY
+    if datatype == DataType.ARRAY:
+        return ARRAY
     if datatype == DataType.JSON:
         return JSON
     if datatype == DataType.FLOAT_VECTOR:

{pyobvector-0.2.10 → pyobvector-0.2.12}/pyobvector/schema/__init__.py

@@ -1,5 +1,6 @@
 """A extension for SQLAlchemy for vector storage related schema definition.
 
+* ARRAY             An extended data type in SQLAlchemy for ObVecClient
 * VECTOR            An extended data type in SQLAlchemy for ObVecClient
 * VectorIndex       An extended index type in SQLAlchemy for ObVecClient
 * CreateVectorIndex Vector Index Creation statement clause
@@ -18,6 +19,7 @@
 * CreateFtsIndex    Full Text Search Index Creation statement clause
 * MatchAgainst      Full Text Search clause
 """
+from .array import ARRAY
 from .vector import VECTOR
 from .geo_srid_point import POINT
 from .vector_index import VectorIndex, CreateVectorIndex
@@ -30,6 +32,7 @@ from .full_text_index import FtsIndex, CreateFtsIndex
 from .match_against_func import MatchAgainst
 
 __all__ = [
+    "ARRAY",
     "VECTOR",
     "POINT",
     "VectorIndex",

pyobvector-0.2.12/pyobvector/schema/array.py

@@ -0,0 +1,142 @@
+"""ARRAY: An extended data type for SQLAlchemy"""
+import json
+from typing import Any, List, Optional, Sequence, Union, Type
+
+from sqlalchemy.sql.type_api import TypeEngine
+from sqlalchemy.types import UserDefinedType, String
+
+
+class ARRAY(UserDefinedType):
+    """ARRAY data type definition with support for up to 6 levels of nesting."""
+    cache_ok = True
+    _string = String()
+    _max_nesting_level = 6
+
+    def __init__(self, item_type: Union[TypeEngine, type]):
+        """Construct an ARRAY.
+
+        Args:
+            item_type: The data type of items in this array. For nested arrays,
+                      pass another ARRAY type.
+
+        Raises:
+            ValueError: If nesting level exceeds the maximum allowed level (6).
+        """
+        super(UserDefinedType, self).__init__()
+        if isinstance(item_type, type):
+            item_type = item_type()
+        self.item_type = item_type
+        self._validate_nesting_level()
+
+    def _validate_nesting_level(self):
+        """Validate that the nesting level does not exceed the maximum allowed level."""
+        level = 1
+        current_type = self.item_type
+        while isinstance(current_type, ARRAY):
+            level += 1
+            if level > self._max_nesting_level:
+                raise ValueError(f"Maximum nesting level of {self._max_nesting_level} exceeded")
+            current_type = current_type.item_type
+
+    def get_col_spec(self, **kw):  # pylint: disable=unused-argument
+        """Parse to array data type definition in text SQL."""
+        if hasattr(self.item_type, 'get_col_spec'):
+            base_type = self.item_type.get_col_spec(**kw)
+        else:
+            base_type = str(self.item_type)
+        return f"ARRAY({base_type})"
+
+    def bind_processor(self, dialect):
+        item_proc = self.item_type.dialect_impl(dialect).bind_processor(dialect)
+
+        def process(value: Optional[Sequence[Any]]) -> Optional[str]:
+            if value is None:
+                return None
+
+            def convert(val):
+                if isinstance(val, (list, tuple)):
+                    return [convert(v) for v in val]
+                if item_proc:
+                    return item_proc(val)
+                return val
+
+            processed = convert(value)
+            return json.dumps(processed)
+
+        return process
+
+    def result_processor(self, dialect, coltype):
+        item_proc = self.item_type.dialect_impl(dialect).result_processor(dialect, coltype)
+
+        def process(value: Optional[str]) -> Optional[List[Any]]:
+            if value is None:
+                return None
+
+            def convert(val):
+                if isinstance(val, (list, tuple)):
+                    return [convert(v) for v in val]
+                if item_proc:
+                    return item_proc(val)
+                return val
+
+            value = json.loads(value) if isinstance(value, str) else value
+            return convert(value)
+
+        return process
+
+    def literal_processor(self, dialect):
+        item_proc = self.item_type.dialect_impl(dialect).literal_processor(dialect)
+
+        def process(value: Sequence[Any]) -> str:
+            def convert(val):
+                if isinstance(val, (list, tuple)):
+                    return [convert(v) for v in val]
+                if item_proc:
+                    return item_proc(val)
+                return val
+
+            processed = convert(value)
+            return json.dumps(processed)
+
+        return process
+
+    def __repr__(self):
+        """Return a string representation of the array type."""
+        current_type = self.item_type
+        nesting_level = 1
+        base_type = current_type
+
+        # Find the innermost type and count nesting level
+        while isinstance(current_type, ARRAY):
+            nesting_level += 1
+            current_type = current_type.item_type
+            if not isinstance(current_type, ARRAY):
+                base_type = current_type
+
+        return f"{nesting_level}D_Array({base_type})"
+
+
+def nested_array(dim: int) -> Type[ARRAY]:
+    """Create a nested array type class with specified dimensions.
+    
+    Args:
+        dim: The number of dimensions for the array type (1-6)
+        
+    Returns:
+        A class type that can be instantiated with an item_type to create a nested array
+        
+    Raises:
+        ValueError: If dim is not between 1 and 6
+    """
+    if not 1 <= dim <= 6:
+        raise ValueError("Dimension must be between 1 and 6")
+
+    class ArrayType(ARRAY):
+        def __init__(self, item_type: Union[TypeEngine, type]):
+            nested_type = item_type
+            for _ in range(dim - 1):
+                nested_type = ARRAY(nested_type)
+            super().__init__(nested_type)
+
+    ArrayType.__name__ = f"{dim}D_Array"
+    return ArrayType

{pyobvector-0.2.10 → pyobvector-0.2.12}/pyobvector/schema/reflection.py

@@ -1,7 +1,9 @@
 """OceanBase table definition reflection."""
 import re
 import logging
-from sqlalchemy.dialects.mysql.reflection import MySQLTableDefinitionParser, _re_compile
+from sqlalchemy.dialects.mysql.reflection import MySQLTableDefinitionParser, _re_compile, cleanup_text
+
+from pyobvector.schema.array import nested_array
 
 logger = logging.getLogger(__name__)
 
@@ -31,6 +33,16 @@ class OceanBaseTableDefinitionParser(MySQLTableDefinitionParser):
         )
         ### end of block
 
+        self._re_array_column = _re_compile(
+            r"\s*"
+            r"%(iq)s(?P<name>(?:%(esc_fq)s|[^%(fq)s])+)%(fq)s\s+"
+            r"(?P<coltype_with_args>(?i:(?<!\w)array(?!\w))\s*\([^()]*(?:\([^()]*\)[^()]*)*\))"
+            r"(?:\s+(?P<notnull>(?:NOT\s+)?NULL))?"
+            r"(?:\s+DEFAULT\s+(?P<default>(?:NULL|'(?:''|[^'])*'|\(.+?\)|[\-\w\.\(\)]+)))?"
+            r"(?:\s+COMMENT\s+'(?P<comment>(?:''|[^'])*)')?"
+            r"\s*,?\s*$" % quotes
+        )
+
         self._re_key = _re_compile(
             r"  "
             r"(?:(FULLTEXT|SPATIAL|VECTOR|(?P<type>\S+)) )?KEY"
@@ -64,6 +76,59 @@ class OceanBaseTableDefinitionParser(MySQLTableDefinitionParser):
             )
         )
 
+    def _parse_column(self, line, state):
+        m = self._re_array_column.match(line)
+        if m:
+            spec = m.groupdict()
+            name, coltype_with_args = spec["name"].strip(), spec["coltype_with_args"].strip()
+
+            item_pattern = re.compile(
+                r"^(?:array\s*\()*([\w]+)(?:\(([\d,]+)\))?\)*$",
+                re.IGNORECASE
+            )
+            item_m = item_pattern.match(coltype_with_args)
+            if not item_m:
+                raise ValueError(f"Failed to find inner type from array column definition: {line}")
+
+            item_type = self.dialect.ischema_names[item_m.group(1).lower()]
+            item_type_arg = item_m.group(2)
+            if item_type_arg is None or item_type_arg == "":
+                item_type_args = []
+            elif item_type_arg[0] == "'" and item_type_arg[-1] == "'":
+                item_type_args = self._re_csv_str.findall(item_type_arg)
+            else:
+                item_type_args = [int(v) for v in self._re_csv_int.findall(item_type_arg)]
+
+            nested_level = coltype_with_args.lower().count('array')
+            type_instance = nested_array(nested_level)(item_type(*item_type_args))
+
+            col_kw = {}
+
+            # NOT NULL
+            col_kw["nullable"] = True
+            if spec.get("notnull", False) == "NOT NULL":
+                col_kw["nullable"] = False
+
+            # DEFAULT
+            default = spec.get("default", None)
+
+            if default == "NULL":
+                # eliminates the need to deal with this later.
+                default = None
+
+            comment = spec.get("comment", None)
+
+            if comment is not None:
+                comment = cleanup_text(comment)
+
+            col_d = dict(
+                name=name, type=type_instance, default=default, comment=comment
+            )
+            col_d.update(col_kw)
+            state.columns.append(col_d)
+        else:
+            super()._parse_column(line, state)
+
     def _parse_constraints(self, line):
         """Parse a CONSTRAINT line."""
         ret = super()._parse_constraints(line)

{pyobvector-0.2.10 → pyobvector-0.2.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyobvector"
-version = "0.2.10"
+version = "0.2.12"
 description = "A python SDK for OceanBase Vector Store, based on SQLAlchemy, compatible with Milvus API."
 authors = ["shanhaikang.shk <shanhaikang.shk@oceanbase.com>"]
 readme = "README.md"