pyobvector 0.2.22__py3-none-any.whl → 0.2.24__py3-none-any.whl

pyobvector/client/ob_vec_json_table_client.py

@@ -3,7 +3,17 @@ import logging
 import re
 from typing import Optional, Union
 
-from sqlalchemy import Column, Integer, String, JSON, Engine, select, text, func, CursorResult
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    JSON,
+    Engine,
+    select,
+    text,
+    func,
+    CursorResult,
+)
 from sqlalchemy.dialects.mysql import TINYINT
 from sqlalchemy.orm import declarative_base, sessionmaker, Session
 from sqlglot import parse_one, exp, Expression, to_identifier
@@ -18,7 +28,7 @@ from ..json_table import (
     JsonTableDecimalFactory,
     JsonTableInt,
     val2json,
-    json_value
+    json_value,
 )
 
 logger = logging.getLogger(__name__)
@@ -27,6 +37,7 @@ logger.setLevel(logging.DEBUG)
 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."""
 
@@ -34,7 +45,7 @@ class ObVecJsonTableClient(ObVecClient):
 
     class JsonTableMetaTBL(Base):
         __tablename__ = JSON_TABLE_META_TABLE_NAME
-        
+
         user_id = Column(String(128), primary_key=True, autoincrement=False)
         jtable_name = Column(String(512), primary_key=True)
         jcol_id = Column(Integer, primary_key=True)
@@ -53,33 +64,33 @@ 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] = {}
 
         @classmethod
         def _parse_col_type(cls, col_type: str):
-            if col_type.startswith('TINYINT'):
+            if col_type.startswith("TINYINT"):
                 return JsonTableBool
-            elif col_type.startswith('TIMESTAMP'):
+            elif col_type.startswith("TIMESTAMP"):
                 return JsonTableTimestamp
-            elif col_type.startswith('INT'):
+            elif col_type.startswith("INT"):
                 return JsonTableInt
-            elif col_type.startswith('VARCHAR'):
-                if col_type == 'VARCHAR':
+            elif col_type.startswith("VARCHAR"):
+                if col_type == "VARCHAR":
                     factory = JsonTableVarcharFactory(255)
                 else:
-                    varchar_pattern = r'VARCHAR\s*\((\d+)\)'
+                    varchar_pattern = r"VARCHAR\s*\((\d+)\)"
                     varchar_matches = re.findall(varchar_pattern, col_type)
                     factory = JsonTableVarcharFactory(int(varchar_matches[0]))
                 model = factory.get_json_table_varchar_type()
                 return model
-            elif col_type.startswith('DECIMAL'):
-                if col_type == 'DECIMAL':
+            elif col_type.startswith("DECIMAL"):
+                if col_type == "DECIMAL":
                     factory = JsonTableDecimalFactory(10, 0)
                 else:
-                    decimal_pattern = r'DECIMAL\s*\((\d+),\s*(\d+)\)'
+                    decimal_pattern = r"DECIMAL\s*\((\d+),\s*(\d+)\)"
                     decimal_matches = re.findall(decimal_pattern, col_type)
                     x, y = decimal_matches[0]
                     factory = JsonTableDecimalFactory(int(x), int(y))
@@ -98,26 +109,29 @@ class ObVecJsonTableClient(ObVecClient):
                     for r in res:
                         if r[1] not in self.meta_cache:
                             self.meta_cache[r[1]] = []
-                        self.meta_cache[r[1]].append({
-                            'jcol_id': r[2],
-                            'jcol_name': r[3],
-                            'jcol_type': r[4],
-                            'jcol_nullable': bool(r[5]),
-                            'jcol_has_default': bool(r[6]),
-                            'jcol_default': (
-                                r[7]['default']
-                                if isinstance(r[7], dict) else
-                                json.loads(r[7])['default']
-                            ),
-                            'jcol_model': ObVecJsonTableClient.JsonTableMetadata._parse_col_type(r[4])
-                        })
+                        self.meta_cache[r[1]].append(
+                            {
+                                "jcol_id": r[2],
+                                "jcol_name": r[3],
+                                "jcol_type": r[4],
+                                "jcol_nullable": bool(r[5]),
+                                "jcol_has_default": bool(r[6]),
+                                "jcol_default": (
+                                    r[7]["default"]
+                                    if isinstance(r[7], dict)
+                                    else json.loads(r[7])["default"]
+                                ),
+                                "jcol_model": ObVecJsonTableClient.JsonTableMetadata._parse_col_type(
+                                    r[4]
+                                ),
+                            }
+                        )
                     for k, _ in self.meta_cache.items():
-                        self.meta_cache[k].sort(key=lambda x: x['jcol_id'])
+                        self.meta_cache[k].sort(key=lambda x: x["jcol_id"])
 
                     for k, v in self.meta_cache.items():
                         logger.debug(f"LOAD TABLE --- {k}: {v}")
 
-
     def __init__(
         self,
         user_id: Optional[str],
@@ -137,28 +151,30 @@ class ObVecJsonTableClient(ObVecClient):
             raise ValueError(f"Invalid admin_id: {admin_id}")
         self.jmetadata = ObVecJsonTableClient.JsonTableMetadata(self.admin_id)
         self.jmetadata.reflect(self.engine)
-    
+
     def check_admin_id_ok(self):
         if self.user_id is None:
             return True
-        
+
         with self.session() as session:
             with session.begin():
                 distinct_admin_ids = (
                     session.query(ObVecJsonTableClient.JsonTableDataTBL.admin_id)
-                    .filter_by(user_id = self.user_id)
+                    .filter_by(user_id=self.user_id)
                     .distinct()
                     .all()
                 )
                 admin_ids = [admin_id[0] for admin_id in distinct_admin_ids]
-                return (len(admin_ids) == 0) or (len(admin_ids) == 1 and admin_ids[0] == self.admin_id)
+                return (len(admin_ids) == 0) or (
+                    len(admin_ids) == 1 and admin_ids[0] == self.admin_id
+                )
 
     def _reset(self):
         # Only for test
         self.perform_raw_text_sql(f"TRUNCATE TABLE {JSON_TABLE_DATA_TABLE_NAME}")
         self.perform_raw_text_sql(f"TRUNCATE TABLE {JSON_TABLE_META_TABLE_NAME}")
         self.jmetadata = ObVecJsonTableClient.JsonTableMetadata(self.admin_id)
-    
+
     def refresh_metadata(self) -> None:
         self.jmetadata.reflect(self.engine)
 
@@ -171,7 +187,7 @@ class ObVecJsonTableClient(ObVecClient):
         """Perform common SQL that operates on JSON Table."""
         ast = parse_one(sql, dialect="oceanbase")
         if isinstance(ast, exp.Create):
-            if ast.kind and ast.kind == 'TABLE':
+            if ast.kind and ast.kind == "TABLE":
                 self._handle_create_json_table(ast)
             else:
                 raise ValueError(f"Create {ast.kind} is not supported")
@@ -192,7 +208,7 @@ class ObVecJsonTableClient(ObVecClient):
             return self._handle_jtable_dml_select(ast, select_with_data_id, opt_user_id)
         else:
             raise ValueError(f"{type(ast)} not supported")
-        
+
     def _parse_datatype_to_str(self, datatype):
         if datatype == exp.DataType.Type.INT:
             return "INT"
@@ -205,7 +221,7 @@ class ObVecJsonTableClient(ObVecClient):
         if datatype == exp.DataType.Type.DECIMAL:
             return "DECIMAL"
         raise ValueError(f"{datatype} not supported")
-    
+
     def _calc_default_value(self, default_val):
         if default_val is None:
             return None
@@ -214,7 +230,7 @@ class ObVecJsonTableClient(ObVecClient):
             for r in res:
                 logger.debug(f"============== Calculate default value: {r[0]}")
                 return r[0]
-    
+
     def _handle_create_json_table(self, ast: Expression):
         logger.debug("HANDLE CREATE JSON TABLE")
 
@@ -228,11 +244,14 @@ class ObVecJsonTableClient(ObVecClient):
             raise ValueError("Invalid create table statement")
         jtable_name = jtable.this.this
 
-        if jtable_name == JSON_TABLE_META_TABLE_NAME or jtable_name == JSON_TABLE_DATA_TABLE_NAME:
+        if (
+            jtable_name == JSON_TABLE_META_TABLE_NAME
+            or jtable_name == JSON_TABLE_DATA_TABLE_NAME
+        ):
             raise ValueError(f"Invalid table name: {jtable_name}")
         if jtable_name in self.jmetadata.meta_cache:
             raise ValueError("Table name duplicated")
-        
+
         session = self.session()
         session.execute(text("SET @@session.autocommit=0"))
         new_meta_cache_items = []
@@ -251,13 +270,17 @@ class ObVecJsonTableClient(ObVecClient):
                 else:
                     col_type_params_list.append(f"{param.this}")
             if len(col_type_params_list) > 0:
-                col_type_str += '(' + ','.join(col_type_params_list) + ')'
-            col_type_model = ObVecJsonTableClient.JsonTableMetadata._parse_col_type(col_type_str)
-            
+                col_type_str += "(" + ",".join(col_type_params_list) + ")"
+            col_type_model = ObVecJsonTableClient.JsonTableMetadata._parse_col_type(
+                col_type_str
+            )
+
             for cons in col_def.constraints:
                 if isinstance(cons.kind, exp.DefaultColumnConstraint):
                     col_has_default = True
-                    logger.debug(f"############ create jtable ########### {str(cons.kind.this)}")
+                    logger.debug(
+                        f"############ create jtable ########### {str(cons.kind.this)}"
+                    )
                     col_default_val = str(cons.kind.this)
                     if col_default_val.upper() == "NULL":
                         col_default_val = None
@@ -267,7 +290,7 @@ class ObVecJsonTableClient(ObVecClient):
                     pass
                     # raise ValueError(f"{cons.kind} constriaint is not supported.")
                     # TODO support json index
-            
+
             if col_has_default and (col_default_val is not None):
                 # check default value is valid
                 col_type_model(val=self._calc_default_value(col_default_val))
@@ -280,34 +303,40 @@ class ObVecJsonTableClient(ObVecClient):
                 f"col_type_str={col_type_str}, col_nullable={col_nullable}, "
                 f"col_has_default={col_has_default}, col_default_val={col_default_val}"
             )
-            new_meta_cache_items.append({
-                'jcol_id': col_id,
-                'jcol_name': col_name,
-                'jcol_type': col_type_str,
-                'jcol_nullable': col_nullable,
-                'jcol_has_default': col_has_default,
-                'jcol_default': col_default_val,
-                'jcol_model': col_type_model,
-            })
-            session.add(ObVecJsonTableClient.JsonTableMetaTBL(
-                user_id = self.admin_id,
-                jtable_name = jtable_name,
-                jcol_id = col_id,
-                jcol_name = col_name,
-                jcol_type = col_type_str,
-                jcol_nullable = col_nullable,
-                jcol_has_default = col_has_default,
-                jcol_default = {
-                    'default': col_default_val,
+            new_meta_cache_items.append(
+                {
+                    "jcol_id": col_id,
+                    "jcol_name": col_name,
+                    "jcol_type": col_type_str,
+                    "jcol_nullable": col_nullable,
+                    "jcol_has_default": col_has_default,
+                    "jcol_default": col_default_val,
+                    "jcol_model": col_type_model,
                 }
-            ))
-            
+            )
+            session.add(
+                ObVecJsonTableClient.JsonTableMetaTBL(
+                    user_id=self.admin_id,
+                    jtable_name=jtable_name,
+                    jcol_id=col_id,
+                    jcol_name=col_name,
+                    jcol_type=col_type_str,
+                    jcol_nullable=col_nullable,
+                    jcol_has_default=col_has_default,
+                    jcol_default={
+                        "default": col_default_val,
+                    },
+                )
+            )
+
             col_id += 1
-        
+
         try:
             session.commit()
             self.jmetadata.meta_cache[jtable_name] = new_meta_cache_items
-            logger.debug(f"ADD METADATA CACHE ---- {jtable_name}: {new_meta_cache_items}")
+            logger.debug(
+                f"ADD METADATA CACHE ---- {jtable_name}: {new_meta_cache_items}"
+            )
         except Exception as e:
             session.rollback()
             logger.error(f"Error occurred: {e}")
@@ -316,15 +345,15 @@ class ObVecJsonTableClient(ObVecClient):
 
     def _check_table_exists(self, jtable_name: str) -> bool:
         return jtable_name in self.jmetadata.meta_cache
-    
+
     def _check_col_exists(self, jtable_name: str, col_name: str) -> Optional[dict]:
         if not self._check_table_exists(jtable_name):
             return None
         for col_meta in self.jmetadata.meta_cache[jtable_name]:
-            if col_meta['jcol_name'] == col_name:
+            if col_meta["jcol_name"] == col_name:
                 return col_meta
         return None
-    
+
     def _parse_col_datatype(self, expr: Expression) -> str:
         col_type_str = self._parse_datatype_to_str(expr.this)
         col_type_params_list = []
@@ -334,16 +363,18 @@ class ObVecJsonTableClient(ObVecClient):
             else:
                 col_type_params_list.append(f"{param.this}")
         if len(col_type_params_list) > 0:
-            col_type_str += '(' + ','.join(col_type_params_list) + ')'
+            col_type_str += "(" + ",".join(col_type_params_list) + ")"
         return col_type_str
-    
+
     def _parse_col_constraints(self, expr: Expression) -> dict:
         col_has_default = False
         col_nullable = True
         for cons in expr:
             if isinstance(cons.kind, exp.DefaultColumnConstraint):
                 col_has_default = True
-                logger.debug(f"############ column constraints ########### {str(cons.kind.this)}")
+                logger.debug(
+                    f"############ column constraints ########### {str(cons.kind.this)}"
+                )
                 col_default_val = str(cons.kind.this)
                 if col_default_val.upper() == "NULL":
                     col_default_val = None
@@ -352,9 +383,9 @@ class ObVecJsonTableClient(ObVecClient):
             else:
                 raise ValueError(f"{cons.kind} constriaint is not supported.")
         return {
-            'jcol_nullable': col_nullable,
-            'jcol_has_default': col_has_default,
-            'jcol_default': col_default_val,
+            "jcol_nullable": col_nullable,
+            "jcol_has_default": col_has_default,
+            "jcol_default": col_default_val,
         }
 
     def _handle_alter_jtable_change_column(
@@ -367,56 +398,60 @@ class ObVecJsonTableClient(ObVecClient):
         origin_col_name = change_col.origin_col_name.this
         if not self._check_col_exists(jtable_name, origin_col_name):
             raise ValueError(f"{origin_col_name} not exists in {jtable_name}")
-        
+
         new_col_name = change_col.this
         if self._check_col_exists(jtable_name, new_col_name):
             raise ValueError(f"Column {new_col_name} exists!")
-        
+
         col_type_str = self._parse_col_datatype(change_col.dtype)
 
         session.query(ObVecJsonTableClient.JsonTableMetaTBL).filter_by(
-            user_id=self.admin_id,
-            jtable_name=jtable_name,
-            jcol_name=origin_col_name
-        ).update({
-            ObVecJsonTableClient.JsonTableMetaTBL.jcol_name: new_col_name,
-            ObVecJsonTableClient.JsonTableMetaTBL.jcol_type: col_type_str,
-            ObVecJsonTableClient.JsonTableMetaTBL.jcol_nullable: True,
-            ObVecJsonTableClient.JsonTableMetaTBL.jcol_has_default: True,
-            ObVecJsonTableClient.JsonTableMetaTBL.jcol_default: {
-                'default': None
-            },
-        })
+            user_id=self.admin_id, jtable_name=jtable_name, jcol_name=origin_col_name
+        ).update(
+            {
+                ObVecJsonTableClient.JsonTableMetaTBL.jcol_name: new_col_name,
+                ObVecJsonTableClient.JsonTableMetaTBL.jcol_type: col_type_str,
+                ObVecJsonTableClient.JsonTableMetaTBL.jcol_nullable: True,
+                ObVecJsonTableClient.JsonTableMetaTBL.jcol_has_default: True,
+                ObVecJsonTableClient.JsonTableMetaTBL.jcol_default: {"default": None},
+            }
+        )
 
         session.query(ObVecJsonTableClient.JsonTableDataTBL).filter_by(
             admin_id=self.admin_id,
             jtable_name=jtable_name,
-        ).update({
-            ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_insert(
-                func.json_remove(
-                    ObVecJsonTableClient.JsonTableDataTBL.jdata, f'$.{origin_col_name}'
-                ),
-                f'$.{new_col_name}',
-                func.json_value(
-                    ObVecJsonTableClient.JsonTableDataTBL.jdata, f'$.{origin_col_name}',
-                ),
-            )
-        })
+        ).update(
+            {
+                ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_insert(
+                    func.json_remove(
+                        ObVecJsonTableClient.JsonTableDataTBL.jdata,
+                        f"$.{origin_col_name}",
+                    ),
+                    f"$.{new_col_name}",
+                    func.json_value(
+                        ObVecJsonTableClient.JsonTableDataTBL.jdata,
+                        f"$.{origin_col_name}",
+                    ),
+                )
+            }
+        )
 
         session.query(ObVecJsonTableClient.JsonTableDataTBL).filter_by(
             admin_id=self.admin_id,
             jtable_name=jtable_name,
-        ).update({
-            ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_replace(
-                ObVecJsonTableClient.JsonTableDataTBL.jdata,
-                f'$.{new_col_name}',
-                json_value(
+        ).update(
+            {
+                ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_replace(
                     ObVecJsonTableClient.JsonTableDataTBL.jdata,
-                    f'$.{new_col_name}',
-                    col_type_str,
-                ),
-            )
-        })
+                    f"$.{new_col_name}",
+                    json_value(
+                        ObVecJsonTableClient.JsonTableDataTBL.jdata,
+                        f"$.{new_col_name}",
+                        col_type_str,
+                    ),
+                )
+            }
+        )
 
     def _handle_alter_jtable_drop_column(
         self,
@@ -432,19 +467,19 @@ class ObVecJsonTableClient(ObVecClient):
             raise ValueError(f"{col_name} not exists in {jtable_name}")
 
         session.query(ObVecJsonTableClient.JsonTableMetaTBL).filter_by(
-            user_id=self.admin_id,
-            jtable_name=jtable_name,
-            jcol_name=col_name
+            user_id=self.admin_id, jtable_name=jtable_name, jcol_name=col_name
         ).delete()
 
         session.query(ObVecJsonTableClient.JsonTableDataTBL).filter_by(
             admin_id=self.admin_id,
             jtable_name=jtable_name,
-        ).update({
-            ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_remove(
-                ObVecJsonTableClient.JsonTableDataTBL.jdata, f'$.{col_name}'
-            )
-        })
+        ).update(
+            {
+                ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_remove(
+                    ObVecJsonTableClient.JsonTableDataTBL.jdata, f"$.{col_name}"
+                )
+            }
+        )
 
     def _handle_alter_jtable_add_column(
         self,
@@ -456,54 +491,69 @@ class ObVecJsonTableClient(ObVecClient):
         new_col_name = add_col.this.this
         if self._check_col_exists(jtable_name, new_col_name):
             raise ValueError(f"{new_col_name} exists!")
-        
+
         col_type_str = self._parse_col_datatype(add_col.kind)
         model = ObVecJsonTableClient.JsonTableMetadata._parse_col_type(col_type_str)
         constraints = self._parse_col_constraints(add_col.constraints)
-        if (not constraints['jcol_nullable']) and constraints['jcol_has_default'] and (constraints['jcol_default'] is None):
+        if (
+            (not constraints["jcol_nullable"])
+            and constraints["jcol_has_default"]
+            and (constraints["jcol_default"] is None)
+        ):
             raise ValueError(f"Invalid default value for '{new_col_name}'")
-        if constraints['jcol_has_default'] and (constraints['jcol_default'] is not None):
-            model(val=self._calc_default_value(constraints['jcol_default']))
-        cur_col_id = max([meta['jcol_id'] for meta in self.jmetadata.meta_cache[jtable_name]]) + 1
-
-        session.add(ObVecJsonTableClient.JsonTableMetaTBL(
-            user_id = self.admin_id,
-            jtable_name = jtable_name,
-            jcol_id = cur_col_id,
-            jcol_name = new_col_name,
-            jcol_type = col_type_str,
-            jcol_nullable = constraints['jcol_nullable'],
-            jcol_has_default = constraints['jcol_has_default'],
-            jcol_default = {
-                'default': constraints['jcol_default'],
-            }
-        ))
+        if constraints["jcol_has_default"] and (
+            constraints["jcol_default"] is not None
+        ):
+            model(val=self._calc_default_value(constraints["jcol_default"]))
+        cur_col_id = (
+            max([meta["jcol_id"] for meta in self.jmetadata.meta_cache[jtable_name]])
+            + 1
+        )
+
+        session.add(
+            ObVecJsonTableClient.JsonTableMetaTBL(
+                user_id=self.admin_id,
+                jtable_name=jtable_name,
+                jcol_id=cur_col_id,
+                jcol_name=new_col_name,
+                jcol_type=col_type_str,
+                jcol_nullable=constraints["jcol_nullable"],
+                jcol_has_default=constraints["jcol_has_default"],
+                jcol_default={
+                    "default": constraints["jcol_default"],
+                },
+            )
+        )
 
-        if constraints['jcol_default'] is None:
+        if constraints["jcol_default"] is None:
             session.query(ObVecJsonTableClient.JsonTableDataTBL).filter_by(
                 admin_id=self.admin_id,
                 jtable_name=jtable_name,
-            ).update({
-                ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_insert(
-                    ObVecJsonTableClient.JsonTableDataTBL.jdata,
-                    f'$.{new_col_name}',
-                    None,
-                )
-            })
+            ).update(
+                {
+                    ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_insert(
+                        ObVecJsonTableClient.JsonTableDataTBL.jdata,
+                        f"$.{new_col_name}",
+                        None,
+                    )
+                }
+            )
         else:
             model = ObVecJsonTableClient.JsonTableMetadata._parse_col_type(col_type_str)
-            datum = model(val=self._calc_default_value(constraints['jcol_default']))
+            datum = model(val=self._calc_default_value(constraints["jcol_default"]))
             json_val = val2json(datum.val)
             session.query(ObVecJsonTableClient.JsonTableDataTBL).filter_by(
                 admin_id=self.admin_id,
                 jtable_name=jtable_name,
-            ).update({
-                ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_insert(
-                    ObVecJsonTableClient.JsonTableDataTBL.jdata,
-                    f'$.{new_col_name}',
-                    json_val,
-                )
-            })
+            ).update(
+                {
+                    ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_insert(
+                        ObVecJsonTableClient.JsonTableDataTBL.jdata,
+                        f"$.{new_col_name}",
+                        json_val,
+                    )
+                }
+            )
 
     def _handle_alter_jtable_modify_column(
         self,
@@ -516,65 +566,79 @@ class ObVecJsonTableClient(ObVecClient):
         col_name = col_def.this.this
         if not self._check_col_exists(jtable_name, col_name):
             raise ValueError(f"{col_name} not exists in {jtable_name}")
-        
+
         col_type_str = self._parse_col_datatype(col_def.kind)
         model = ObVecJsonTableClient.JsonTableMetadata._parse_col_type(col_type_str)
         constraints = self._parse_col_constraints(col_def.constraints)
-        if (not constraints['jcol_nullable']) and constraints['jcol_has_default'] and (constraints['jcol_default'] is None):
+        if (
+            (not constraints["jcol_nullable"])
+            and constraints["jcol_has_default"]
+            and (constraints["jcol_default"] is None)
+        ):
             raise ValueError(f"Invalid default value for '{col_name}'")
-        if constraints['jcol_has_default'] and (constraints['jcol_default'] is not None):
-            model(val=self._calc_default_value(constraints['jcol_default']))
+        if constraints["jcol_has_default"] and (
+            constraints["jcol_default"] is not None
+        ):
+            model(val=self._calc_default_value(constraints["jcol_default"]))
 
         session.query(ObVecJsonTableClient.JsonTableMetaTBL).filter_by(
-            user_id=self.admin_id,
-            jtable_name=jtable_name,
-            jcol_name=col_name
-        ).update({
-            ObVecJsonTableClient.JsonTableMetaTBL.jcol_name: col_name,
-            ObVecJsonTableClient.JsonTableMetaTBL.jcol_type: col_type_str,
-            ObVecJsonTableClient.JsonTableMetaTBL.jcol_nullable: constraints['jcol_nullable'],
-            ObVecJsonTableClient.JsonTableMetaTBL.jcol_has_default: constraints['jcol_has_default'],
-            ObVecJsonTableClient.JsonTableMetaTBL.jcol_default: {
-                'default': constraints['jcol_default']
-            },
-        })
-
-        if constraints['jcol_default'] is None:
+            user_id=self.admin_id, jtable_name=jtable_name, jcol_name=col_name
+        ).update(
+            {
+                ObVecJsonTableClient.JsonTableMetaTBL.jcol_name: col_name,
+                ObVecJsonTableClient.JsonTableMetaTBL.jcol_type: col_type_str,
+                ObVecJsonTableClient.JsonTableMetaTBL.jcol_nullable: constraints[
+                    "jcol_nullable"
+                ],
+                ObVecJsonTableClient.JsonTableMetaTBL.jcol_has_default: constraints[
+                    "jcol_has_default"
+                ],
+                ObVecJsonTableClient.JsonTableMetaTBL.jcol_default: {
+                    "default": constraints["jcol_default"]
+                },
+            }
+        )
+
+        if constraints["jcol_default"] is None:
             session.query(ObVecJsonTableClient.JsonTableDataTBL).filter_by(
                 admin_id=self.admin_id,
                 jtable_name=jtable_name,
-            ).update({
-                ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_replace(
-                    ObVecJsonTableClient.JsonTableDataTBL.jdata,
-                    f'$.{col_name}',
-                    json_value(
+            ).update(
+                {
+                    ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_replace(
                         ObVecJsonTableClient.JsonTableDataTBL.jdata,
-                        f'$.{col_name}',
-                        col_type_str,
-                    ),
-                )
-            })
+                        f"$.{col_name}",
+                        json_value(
+                            ObVecJsonTableClient.JsonTableDataTBL.jdata,
+                            f"$.{col_name}",
+                            col_type_str,
+                        ),
+                    )
+                }
+            )
         else:
             model = ObVecJsonTableClient.JsonTableMetadata._parse_col_type(col_type_str)
-            datum = model(val=self._calc_default_value(constraints['jcol_default']))
+            datum = model(val=self._calc_default_value(constraints["jcol_default"]))
             json_val = val2json(datum.val)
             session.query(ObVecJsonTableClient.JsonTableDataTBL).filter_by(
                 admin_id=self.admin_id,
                 jtable_name=jtable_name,
-            ).update({
-                ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_replace(
-                    ObVecJsonTableClient.JsonTableDataTBL.jdata,
-                    f'$.{col_name}',
-                    func.ifnull(
-                        json_value(
-                            ObVecJsonTableClient.JsonTableDataTBL.jdata,
-                            f'$.{col_name}',
-                            col_type_str,
+            ).update(
+                {
+                    ObVecJsonTableClient.JsonTableDataTBL.jdata: func.json_replace(
+                        ObVecJsonTableClient.JsonTableDataTBL.jdata,
+                        f"$.{col_name}",
+                        func.ifnull(
+                            json_value(
+                                ObVecJsonTableClient.JsonTableDataTBL.jdata,
+                                f"$.{col_name}",
+                                col_type_str,
+                            ),
+                            json_val,
                         ),
-                        json_val,
-                    ),
-                )
-            })
+                    )
+                }
+            )
 
     def _handle_alter_jtable_rename_table(
         self,
@@ -584,17 +648,19 @@ class ObVecJsonTableClient(ObVecClient):
     ):
         if not self._check_table_exists(jtable_name):
             raise ValueError(f"Table {jtable_name} does not exists")
-        
+
         new_table_name = rename.this.this.this
         if self.check_table_exists(new_table_name):
             raise ValueError(f"Table {new_table_name} exists!")
-        
+
         session.query(ObVecJsonTableClient.JsonTableMetaTBL).filter_by(
             user_id=self.admin_id,
             jtable_name=jtable_name,
-        ).update({
-            ObVecJsonTableClient.JsonTableMetaTBL.jtable_name: new_table_name,
-        })
+        ).update(
+            {
+                ObVecJsonTableClient.JsonTableMetaTBL.jtable_name: new_table_name,
+            }
+        )
 
     def _handle_alter_json_table(self, ast: Expression):
         if not isinstance(ast.this, exp.Table):
@@ -604,7 +670,7 @@ class ObVecJsonTableClient(ObVecClient):
         jtable_name = ast.this.this.this
         if not self._check_table_exists(jtable_name):
             raise ValueError(f"Table {jtable_name} does not exists")
-        
+
         session = self.session()
         session.execute(text("SET @@session.autocommit=0"))
         for action in ast.actions:
@@ -638,7 +704,7 @@ class ObVecJsonTableClient(ObVecClient):
                     jtable_name,
                     action,
                 )
-        
+
         try:
             session.commit()
             self.jmetadata.reflect(self.engine)
@@ -648,7 +714,9 @@ class ObVecJsonTableClient(ObVecClient):
         finally:
             session.close()
 
-    def _handle_jtable_dml_insert(self, ast: Expression, opt_user_id: Optional[str] = None):
+    def _handle_jtable_dml_insert(
+        self, ast: Expression, opt_user_id: Optional[str] = None
+    ):
         real_user_id = opt_user_id or self.user_id
 
         if real_user_id is None:
@@ -660,11 +728,12 @@ class ObVecJsonTableClient(ObVecClient):
             table_name = ast.this.this.this
         if not self._check_table_exists(table_name):
             raise ValueError(f"Table {table_name} does not exists")
-        
-        table_col_names = [meta['jcol_name'] for meta in self.jmetadata.meta_cache[table_name]]
+
+        table_col_names = [
+            meta["jcol_name"] for meta in self.jmetadata.meta_cache[table_name]
+        ]
         cols = {
-            meta['jcol_name']: meta
-            for meta in self.jmetadata.meta_cache[table_name]
+            meta["jcol_name"]: meta for meta in self.jmetadata.meta_cache[table_name]
         }
         if isinstance(ast.this, exp.Schema):
             insert_col_names = [expr.this for expr in ast.this.expressions]
@@ -672,9 +741,14 @@ class ObVecJsonTableClient(ObVecClient):
                 if col_name not in table_col_names:
                     raise ValueError(f"Unknown column {col_name} in field list")
             for meta in self.jmetadata.meta_cache[table_name]:
-                if ((meta['jcol_name'] not in insert_col_names) and
-                    (not meta['jcol_nullable']) and (not meta['jcol_has_default'])):
-                    raise ValueError(f"Field {meta['jcol_name']} does not have a default value")
+                if (
+                    (meta["jcol_name"] not in insert_col_names)
+                    and (not meta["jcol_nullable"])
+                    and (not meta["jcol_has_default"])
+                ):
+                    raise ValueError(
+                        f"Field {meta['jcol_name']} does not have a default value"
+                    )
         elif isinstance(ast.this, exp.Table):
             insert_col_names = table_col_names
         else:
@@ -686,28 +760,34 @@ class ObVecJsonTableClient(ObVecClient):
         for tuple in ast.expression.expressions:
             expr_list = tuple.expressions
             if len(expr_list) != len(insert_col_names):
-                raise ValueError(f"Values Tuple length does not match with the length of insert columns")
+                raise ValueError(
+                    f"Values Tuple length does not match with the length of insert columns"
+                )
             kv = {}
             for col_name, expr in zip(insert_col_names, expr_list):
-                model = cols[col_name]['jcol_model']
+                model = cols[col_name]["jcol_model"]
                 datum = model(val=self._calc_default_value(str(expr)))
                 kv[col_name] = val2json(datum.val)
             for col_name in table_col_names:
                 if col_name not in insert_col_names:
-                    model = cols[col_name]['jcol_model']
-                    datum = model(val=self._calc_default_value(cols[col_name]['jcol_default']))
+                    model = cols[col_name]["jcol_model"]
+                    datum = model(
+                        val=self._calc_default_value(cols[col_name]["jcol_default"])
+                    )
                     kv[col_name] = val2json(datum.val)
 
             logger.debug(f"================= [INSERT] =============== {kv}")
 
-            session.add(ObVecJsonTableClient.JsonTableDataTBL(
-                user_id = real_user_id,
-                admin_id = self.admin_id,
-                jtable_name = table_name,
-                jdata = kv,
-            ))
+            session.add(
+                ObVecJsonTableClient.JsonTableDataTBL(
+                    user_id=real_user_id,
+                    admin_id=self.admin_id,
+                    jtable_name=table_name,
+                    jdata=kv,
+                )
+            )
             n_new_records += 1
-        
+
         try:
             session.commit()
         except Exception as e:
@@ -718,20 +798,24 @@ class ObVecJsonTableClient(ObVecClient):
             session.close()
             return n_new_records
 
-    def _handle_jtable_dml_update(self, ast: Expression, opt_user_id: Optional[str] = None):
+    def _handle_jtable_dml_update(
+        self, ast: Expression, opt_user_id: Optional[str] = None
+    ):
         real_user_id = opt_user_id or self.user_id
 
         table_name = ast.this.this.this
         if not self._check_table_exists(table_name):
             raise ValueError(f"Table {table_name} does not exists")
-        
+
         path_settings = []
         for expr in ast.expressions:
             col_name = expr.this.this.this
             if not self._check_col_exists(table_name, col_name):
                 raise ValueError(f"Column {col_name} does not exists")
             col_expr = expr.expression
-            new_node = parse_one(f"JSON_VALUE({JSON_TABLE_DATA_TABLE_NAME}.jdata, '$.{col_name}')")
+            new_node = parse_one(
+                f"JSON_VALUE({JSON_TABLE_DATA_TABLE_NAME}.jdata, '$.{col_name}')"
+            )
             for column in col_expr.find_all(exp.Column):
                 parent_node = column.parent
                 if isinstance(parent_node.args[column.arg_key], list):
@@ -747,20 +831,20 @@ class ObVecJsonTableClient(ObVecClient):
             logger.info(str(col_expr))
             path_settings.append(f"'$.{col_name}', {str(col_expr)}")
 
-        where_clause = None        
-        if 'where' in ast.args.keys() and ast.args['where']:
-            for column in ast.args['where'].find_all(exp.Column):
+        where_clause = None
+        if "where" in ast.args.keys() and ast.args["where"]:
+            for column in ast.args["where"].find_all(exp.Column):
                 where_col_name = column.this.this
                 if not self._check_col_exists(table_name, where_col_name):
                     raise ValueError(f"Column {where_col_name} does not exists")
-                column.parent.args['this'] = parse_one(
+                column.parent.args["this"] = parse_one(
                     f"JSON_VALUE({JSON_TABLE_DATA_TABLE_NAME}.jdata, '$.{where_col_name}')"
                 )
             if real_user_id:
                 where_clause = f"{JSON_TABLE_DATA_TABLE_NAME}.user_id = '{real_user_id}' AND {JSON_TABLE_DATA_TABLE_NAME}.jtable_name = '{table_name}' AND ({str(ast.args['where'].this)})"
             else:
                 where_clause = f"{JSON_TABLE_DATA_TABLE_NAME}.jtable_name = '{table_name}' AND ({str(ast.args['where'].this)})"
-        
+
         if where_clause:
             update_sql = f"UPDATE {JSON_TABLE_DATA_TABLE_NAME} SET jdata = JSON_REPLACE({JSON_TABLE_DATA_TABLE_NAME}.jdata, {', '.join(path_settings)}) WHERE {where_clause}"
         else:
@@ -770,29 +854,33 @@ class ObVecJsonTableClient(ObVecClient):
         res = self.perform_raw_text_sql(update_sql)
         return res.rowcount
 
-    def _handle_jtable_dml_delete(self, ast: Expression, opt_user_id: Optional[str] = None):
+    def _handle_jtable_dml_delete(
+        self, ast: Expression, opt_user_id: Optional[str] = None
+    ):
         real_user_id = opt_user_id or self.user_id
 
         table_name = ast.this.this.this
         if not self._check_table_exists(table_name):
             raise ValueError(f"Table {table_name} does not exists")
-        
+
         where_clause = None
-        if 'where' in ast.args.keys() and ast.args['where']:
-            for column in ast.args['where'].find_all(exp.Column):
+        if "where" in ast.args.keys() and ast.args["where"]:
+            for column in ast.args["where"].find_all(exp.Column):
                 where_col_name = column.this.this
                 if not self._check_col_exists(table_name, where_col_name):
                     raise ValueError(f"Column {where_col_name} does not exists")
-                column.parent.args['this'] = parse_one(
+                column.parent.args["this"] = parse_one(
                     f"JSON_VALUE({JSON_TABLE_DATA_TABLE_NAME}.jdata, '$.{where_col_name}')"
                 )
             if real_user_id:
                 where_clause = f"{JSON_TABLE_DATA_TABLE_NAME}.user_id = '{real_user_id}' AND {JSON_TABLE_DATA_TABLE_NAME}.jtable_name = '{table_name}' AND ({str(ast.args['where'].this)})"
             else:
                 where_clause = f"{JSON_TABLE_DATA_TABLE_NAME}.jtable_name = '{table_name}' AND ({str(ast.args['where'].this)})"
-        
+
         if where_clause:
-            delete_sql = f"DELETE FROM {JSON_TABLE_DATA_TABLE_NAME} WHERE {where_clause}"
+            delete_sql = (
+                f"DELETE FROM {JSON_TABLE_DATA_TABLE_NAME} WHERE {where_clause}"
+            )
         else:
             delete_sql = f"DELETE FROM {JSON_TABLE_DATA_TABLE_NAME}"
 
@@ -811,16 +899,18 @@ class ObVecJsonTableClient(ObVecClient):
         self,
         ast: Expression,
         select_with_data_id: bool = False,
-        opt_user_id: Optional[str] = None
+        opt_user_id: Optional[str] = None,
     ):
         real_user_id = opt_user_id or self.user_id
 
-        from_key = 'from_' if 'from_' in ast.args else 'from'
+        from_key = "from_" if "from_" in ast.args else "from"
         table_name = ast.args[from_key].this.this.this
         if not self._check_table_exists(table_name):
             raise ValueError(f"Table {table_name} does not exists")
-        
-        ast.args[from_key].args['this'].args['this'] = to_identifier(name=JSON_TABLE_DATA_TABLE_NAME, quoted=False)
+
+        ast.args[from_key].args["this"].args["this"] = to_identifier(
+            name=JSON_TABLE_DATA_TABLE_NAME, quoted=False
+        )
 
         col_meta = self.jmetadata.meta_cache[table_name]
         json_table_meta_str = []
@@ -830,42 +920,42 @@ class ObVecJsonTableClient(ObVecClient):
                 f"{meta['jcol_name']} {self._get_full_datatype(meta['jcol_type'])} "
                 f"PATH '$.{meta['jcol_name']}'"
             )
-            all_jcol_names.append(meta['jcol_name'])
-        
+            all_jcol_names.append(meta["jcol_name"])
+
         need_replace_select_exprs = False
         new_select_exprs = []
 
         if select_with_data_id:
             data_id_col_expr = exp.Column()
             data_id_identifier = exp.Identifier()
-            data_id_identifier.args['this'] = 'jdata_id'
-            data_id_identifier.args['quoted'] = False
+            data_id_identifier.args["this"] = "jdata_id"
+            data_id_identifier.args["quoted"] = False
             data_json_table_identifier = exp.Identifier()
-            data_json_table_identifier.args['this'] = JSON_TABLE_DATA_TABLE_NAME
-            data_json_table_identifier.args['quoted'] = False
-            data_id_col_expr.args['this'] = data_id_identifier
-            data_id_col_expr.args['table'] = data_json_table_identifier
+            data_json_table_identifier.args["this"] = JSON_TABLE_DATA_TABLE_NAME
+            data_json_table_identifier.args["quoted"] = False
+            data_id_col_expr.args["this"] = data_id_identifier
+            data_id_col_expr.args["table"] = data_json_table_identifier
             new_select_exprs.append(data_id_col_expr)
             need_replace_select_exprs = True
 
         alias_names = set()
-        for select_expr in ast.args['expressions']:
+        for select_expr in ast.args["expressions"]:
             if isinstance(select_expr, exp.Star):
                 need_replace_select_exprs = True
                 for jcol_name in all_jcol_names:
                     col_expr = exp.Column()
                     identifier = exp.Identifier()
-                    identifier.args['this'] = jcol_name
-                    identifier.args['quoted'] = False
-                    col_expr.args['this'] = identifier
+                    identifier.args["this"] = jcol_name
+                    identifier.args["quoted"] = False
+                    col_expr.args["this"] = identifier
                     new_select_exprs.append(col_expr)
             else:
                 if isinstance(select_expr, exp.Alias):
-                    alias_names.add(select_expr.args['alias'].args['this'])
+                    alias_names.add(select_expr.args["alias"].args["this"])
                 new_select_exprs.append(select_expr)
         if need_replace_select_exprs:
-            ast.args['expressions'] = new_select_exprs
-        
+            ast.args["expressions"] = new_select_exprs
+
         tmp_table_name = "__tmp"
         json_table_str = f"json_table({JSON_TABLE_DATA_TABLE_NAME}.jdata, '$' COLUMNS ({', '.join(json_table_meta_str)})) {tmp_table_name}"
 
@@ -873,41 +963,43 @@ class ObVecJsonTableClient(ObVecClient):
             col_name = col.args["this"].args["this"]
             if col_name in alias_names:
                 continue
-            if 'table' in col.args.keys():
-                if col.args['table'].args['this'] != JSON_TABLE_DATA_TABLE_NAME:
-                    col.args['table'].args['this'] = tmp_table_name
+            if "table" in col.args.keys():
+                if col.args["table"].args["this"] != JSON_TABLE_DATA_TABLE_NAME:
+                    col.args["table"].args["this"] = tmp_table_name
             else:
                 identifier = exp.Identifier()
-                identifier.args['this'] = tmp_table_name
-                identifier.args['quoted'] = False
-                col.args['table'] = identifier
+                identifier.args["this"] = tmp_table_name
+                identifier.args["quoted"] = False
+                col.args["table"] = identifier
 
         # Manually create the JOIN node for json_table
         # In some versions of sqlglot, comma-separated tables may not be parsed as
         # explicit JOINS, so we directly parse the json_table expression and create a JOIN node
         # explicitly
         json_table_expr = parse_one(json_table_str, dialect="oceanbase")
-        
+
         join_node = exp.Join()
-        join_node.args['this'] = json_table_expr
-        join_node.args['kind'] = None  # CROSS JOIN (implicit join with comma)
-        
-        if 'joins' not in ast.args:
-            ast.args['joins'] = []
-        ast.args['joins'].append(join_node)
+        join_node.args["this"] = json_table_expr
+        join_node.args["kind"] = None  # CROSS JOIN (implicit join with comma)
+
+        if "joins" not in ast.args:
+            ast.args["joins"] = []
+        ast.args["joins"].append(join_node)
 
         if real_user_id:
             extra_filter_str = f"{JSON_TABLE_DATA_TABLE_NAME}.user_id = '{real_user_id}' AND {JSON_TABLE_DATA_TABLE_NAME}.jtable_name = '{table_name}'"
         else:
-            extra_filter_str = f"{JSON_TABLE_DATA_TABLE_NAME}.jtable_name = '{table_name}'"
-        if 'where' in ast.args.keys():
-            filter_str = str(ast.args['where'].args['this'])
+            extra_filter_str = (
+                f"{JSON_TABLE_DATA_TABLE_NAME}.jtable_name = '{table_name}'"
+            )
+        if "where" in ast.args.keys():
+            filter_str = str(ast.args["where"].args["this"])
             new_filter_str = f"{extra_filter_str} AND ({filter_str})"
-            ast.args['where'].args['this'] = parse_one(new_filter_str)
+            ast.args["where"].args["this"] = parse_one(new_filter_str)
         else:
             where_clause = exp.Where()
-            where_clause.args['this'] = parse_one(extra_filter_str)
-            ast.args['where'] = where_clause
+            where_clause.args["this"] = parse_one(extra_filter_str)
+            ast.args["where"] = where_clause
 
         select_sql = ast.sql(dialect="mysql", identify=True)
         logger.debug(f"===================== do select: {select_sql}")