ronds-datastore-postgresql 0.0.1__py3-none-any.whl

datastore_postgresql/__init__.py

@@ -0,0 +1,11 @@
+"""PostgreSQL driver for DataStore SDK."""
+from .driver import PgDataStoreDriver
+from .connection import PgDataStoreConnection
+from .pg_read_request import PgReadRequest, PgReadRequestBuilder
+
+__all__ = [
+    "PgDataStoreDriver",
+    "PgDataStoreConnection",
+    "PgReadRequest",
+    "PgReadRequestBuilder",
+]

datastore_postgresql/connection.py

@@ -0,0 +1,226 @@
+# -*- coding: utf-8 -*-
+"""
+PostgreSQL 连接实现
+支持 read（点查/扫描/自定义 SQL）、write、delete
+URL 格式：pg://host:port/database 或 postgresql://host:port/database/schema/table
+"""
+from typing import Any, Dict, List, Optional
+
+from datastore_client.exceptions import DataStoreException
+from datastore_client.model.request import ReadRequest
+from datastore_client.model.response import WriteResponse
+from datastore_client.spi.connection import DataStoreConnection
+from datastore_client.spi.config import ConnectionConfig
+
+
+def _quote_identifier(name: str) -> str:
+    return '"' + name.replace('"', '""') + '"'
+
+
+def _camel_to_snake(camel: str) -> str:
+    if not camel:
+        return camel
+    result = []
+    for i, c in enumerate(camel):
+        if c.isupper():
+            if i > 0:
+                result.append("_")
+            result.append(c.lower())
+        else:
+            result.append(c)
+    return "".join(result)
+
+
+def _snake_to_camel(snake: str) -> str:
+    if not snake:
+        return snake
+    result = []
+    cap = False
+    for c in snake:
+        if c == "_":
+            cap = True
+        else:
+            result.append(c.upper() if cap else c)
+            cap = False
+    return "".join(result)
+
+
+class PgDataStoreConnection(DataStoreConnection):
+    """PostgreSQL 存储连接"""
+
+    DEFAULT_TABLE = "kv"
+    DEFAULT_SCHEMA = "public"
+    DEFAULT_PORT = 5432
+
+    def __init__(
+        self,
+        connection_config: ConnectionConfig,
+        data_schema: Optional[str],
+    ):
+        super().__init__(connection_config, data_schema)
+        config = connection_config
+        self._database = (
+            config.namespace.strip() if config.namespace and config.namespace.strip() else "postgres"
+        )
+        self._schema = config.get_parameter("schema") or self.DEFAULT_SCHEMA
+        self._table = (
+            config.entity.strip() if config.entity and config.entity.strip() else self.DEFAULT_TABLE
+        )
+        self._connection = None
+        self._conn_lock = __import__("threading").Lock()
+
+    def _get_connection(self):
+        import psycopg2
+
+        if self._connection is None or self._connection.closed:
+            with self._conn_lock:
+                if self._connection is None or self._connection.closed:
+                    config = self.get_connection_config()
+                    hosts = config.hosts
+                    ports = config.ports
+
+                    if hosts and len(hosts) > 0:
+                        host = hosts[0]
+                        port = (
+                            ports[0]
+                            if ports and len(ports) > 0 and ports[0] > 0
+                            else self.DEFAULT_PORT
+                        )
+                    elif config.endpoints and config.endpoints.strip():
+                        part = config.endpoints.split(",")[0].strip()
+                        if ":" in part:
+                            host, port_str = part.rsplit(":", 1)
+                            host = host.strip()
+                            port = int(port_str.strip())
+                        else:
+                            host = part
+                            port = self.DEFAULT_PORT
+                    else:
+                        raise ValueError(
+                            "PostgreSQL URL must specify host (e.g. pg://host:port/database)"
+                        )
+
+                    conn_params = {
+                        "host": host,
+                        "port": port,
+                        "dbname": self._database,
+                    }
+                    auth = config.auth_info
+                    if auth and auth.username:
+                        conn_params["user"] = auth.username
+                    if auth and auth.password:
+                        conn_params["password"] = auth.password
+                    sslmode = config.get_parameter("sslmode")
+                    if sslmode:
+                        conn_params["sslmode"] = sslmode
+
+                    self._connection = psycopg2.connect(**conn_params)
+        return self._connection
+
+    def read(self, request: ReadRequest) -> List[Any]:
+        where_clause = request.get_option(ReadRequest.OPT_WHERE_CLAUSE)
+        limit = request.get_limit() or 1000
+
+        try:
+            conn = self._get_connection()
+
+            custom_sql = request.get_option(ReadRequest.OPT_SQL)
+            if custom_sql and custom_sql.strip():
+                return self._read_by_sql(conn, custom_sql)
+
+            full_table = f"{_quote_identifier(self._schema)}.{_quote_identifier(self._table)}"
+
+            if where_clause and where_clause.strip():
+                sql = f"SELECT * FROM {full_table} WHERE {where_clause} LIMIT {limit}"
+            else:
+                sql = f"SELECT * FROM {full_table} LIMIT {limit}"
+
+            with conn.cursor() as cur:
+                cur.execute(sql)
+                columns = [desc[0] for desc in cur.description]
+                rows = cur.fetchall()
+                result = []
+                for row in rows:
+                    obj = {}
+                    for i, col in enumerate(columns):
+                        camel = _snake_to_camel(col) if "_" in col else col
+                        obj[camel] = row[i]
+                    result.append(obj)
+                return result
+        except DataStoreException:
+            raise
+        except Exception as e:
+            raise DataStoreException("PostgreSQL read failed", cause=e)
+
+    def _read_by_sql(self, conn, custom_sql: str) -> List[Any]:
+        with conn.cursor() as cur:
+            cur.execute(custom_sql)
+            columns = [desc[0] for desc in cur.description]
+            rows = cur.fetchall()
+            result = []
+            for row in rows:
+                obj = {}
+                for i, col in enumerate(columns):
+                    camel = _snake_to_camel(col) if "_" in col else col
+                    obj[camel] = row[i]
+                result.append(obj)
+            return result
+
+    def write(self, data: Any, options: Optional[Dict[str, Any]] = None) -> WriteResponse:
+        if data is None:
+            return WriteResponse.failure("write data is null")
+        try:
+            if isinstance(data, dict):
+                cols = list(data.keys())
+                vals = list(data.values())
+            else:
+                import json
+                data_str = json.dumps(data, default=str)
+                data_dict = json.loads(data_str)
+                cols = list(data_dict.keys())
+                vals = list(data_dict.values())
+
+            if not cols:
+                return WriteResponse.failure("write data has no fields")
+
+            snake_cols = [_camel_to_snake(c) for c in cols]
+            col_list = ", ".join(_quote_identifier(c) for c in snake_cols)
+            placeholders = ", ".join(["%s"] * len(cols))
+            full_table = f"{_quote_identifier(self._schema)}.{_quote_identifier(self._table)}"
+            sql = f"INSERT INTO {full_table} ({col_list}) VALUES ({placeholders})"
+
+            conn = self._get_connection()
+            with conn.cursor() as cur:
+                cur.execute(sql, vals)
+            conn.commit()
+            return WriteResponse.ok()
+        except DataStoreException:
+            raise
+        except Exception as e:
+            return WriteResponse.failure(str(e))
+
+    def delete(self, options: Optional[Dict[str, Any]] = None) -> WriteResponse:
+        where_clause = (options or {}).get(ReadRequest.OPT_WHERE_CLAUSE)
+        if not where_clause or not str(where_clause).strip():
+            raise DataStoreException("PostgreSQL delete requires whereClause in options")
+        try:
+            full_table = f"{_quote_identifier(self._schema)}.{_quote_identifier(self._table)}"
+            sql = f"DELETE FROM {full_table} WHERE {where_clause}"
+            conn = self._get_connection()
+            with conn.cursor() as cur:
+                cur.execute(sql)
+            conn.commit()
+            return WriteResponse.ok()
+        except DataStoreException:
+            raise
+        except Exception as e:
+            return WriteResponse.failure(str(e))
+
+    def close(self) -> None:
+        with self._conn_lock:
+            if self._connection and not self._connection.closed:
+                try:
+                    self._connection.close()
+                except Exception:
+                    pass
+                self._connection = None

datastore_postgresql/driver.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+"""PostgreSQL 存储驱动"""
+from typing import Optional
+
+from datastore_client.model.resource import ResourceCategory
+from datastore_client.spi.config import ConnectionConfig
+from datastore_client.spi.connection import DataStoreConnection
+from datastore_client.spi.driver import DataStoreDriver
+
+from .connection import PgDataStoreConnection
+
+
+class PgDataStoreDriver(DataStoreDriver):
+    """PostgreSQL 存储驱动
+    URL 格式: pg://host:port/database 或 postgresql://host:port/database 或 pg://host:port/database/schema/table
+    """
+
+    def accepts(self, scheme: str) -> bool:
+        s = (scheme or "").lower()
+        return s in ("pg", "postgresql", "pgsql")
+
+    def connect(
+        self,
+        config: ConnectionConfig,
+        data_schema: Optional[str],
+    ) -> DataStoreConnection:
+        return PgDataStoreConnection(config, data_schema)
+
+    def get_category(self) -> ResourceCategory:
+        return ResourceCategory.DATABASE

datastore_postgresql/pg_read_request.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+"""PostgreSQL 读取请求的强类型封装（对齐 Java PgReadRequest）。"""
+from typing import Optional
+
+from datastore_client.model.request import ReadRequest, ReadRequestBuilder
+
+
+class PgReadRequest(ReadRequest):
+    def get_where_clause(self) -> Optional[str]:
+        return self.get_option(ReadRequest.OPT_WHERE_CLAUSE)
+
+    def get_sql(self) -> Optional[str]:
+        return self.get_option(ReadRequest.OPT_SQL)
+
+    @classmethod
+    def builder(cls) -> "PgReadRequestBuilder":
+        return PgReadRequestBuilder()
+
+
+class PgReadRequestBuilder(ReadRequestBuilder):
+    def _self(self) -> "PgReadRequestBuilder":
+        return self
+
+    def where_clause(self, where_clause: str) -> "PgReadRequestBuilder":
+        return self.option(ReadRequest.OPT_WHERE_CLAUSE, where_clause)
+
+    def sql(self, sql: str) -> "PgReadRequestBuilder":
+        return self.option(ReadRequest.OPT_SQL, sql)
+
+    def build(self) -> PgReadRequest:
+        return PgReadRequest(self._timeout_ms, dict(self._options))

ronds_datastore_postgresql-0.0.1.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: ronds-datastore-postgresql
+Version: 0.0.1
+Summary: PostgreSQL driver for DataStore SDK
+Requires-Python: >=3.8
+Requires-Dist: ronds-datastore-client
+Requires-Dist: psycopg2-binary
+

ronds_datastore_postgresql-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+datastore_postgresql/__init__.py,sha256=vhHPFxter_zDjwSe3yVCNYYtaLaK__WX18TUcOkTyXo,321
+datastore_postgresql/connection.py,sha256=X-BtLTYDiYr2mKGLJ8eQbxue8tfkObzeiJKiB_NifME,8685
+datastore_postgresql/driver.py,sha256=yDCjW2Y4UwNhe_j3K8AV5HLc-Ko1VNVvmtRL3JhvNgk,1008
+datastore_postgresql/pg_read_request.py,sha256=nMnfhCwTE4omNnCoSLb9qB7R1TA6ptWSEKZCzL_1CCo,1062
+ronds_datastore_postgresql-0.0.1.dist-info/METADATA,sha256=_1Y8mgDkjLH9D7HfjfT7Z3uAXVWfUuqIfqDE5_BCHG0,216
+ronds_datastore_postgresql-0.0.1.dist-info/WHEEL,sha256=BNRMDyzLkkcmlv0J8ppDQkk2VED33SesJDynr9ED1gc,91
+ronds_datastore_postgresql-0.0.1.dist-info/entry_points.txt,sha256=S57eyvXNiboW9ocE5G5q1XCAWnSo98PIcDgLAVL0RIQ,184
+ronds_datastore_postgresql-0.0.1.dist-info/top_level.txt,sha256=LdSbSYi9J95RU07dFhShT8OMJWzLu_ZJP_kJJJhkukE,21
+ronds_datastore_postgresql-0.0.1.dist-info/RECORD,,

ronds_datastore_postgresql-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.4)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ronds_datastore_postgresql-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[datastore.drivers]
+pg = datastore_postgresql.driver:PgDataStoreDriver
+pgsql = datastore_postgresql.driver:PgDataStoreDriver
+postgresql = datastore_postgresql.driver:PgDataStoreDriver

ronds_datastore_postgresql-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+datastore_postgresql