ns-pydm 0.0.1__tar.gz

ns_pydm-0.0.1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

ns_pydm-0.0.1/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: ns-pydm
+Version: 0.0.1
+Summary: Dameng (DM) DB-API 2.0 driver implemented on top of JDBC via JPype
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: JPype1<2,>=1.5.2
+Dynamic: license-file
+
+# ns-pydm
+
+基于 JDBC + JPype 的达梦（DM）Python 驱动，提供 DB-API 2.0 风格接口，跨平台使用。
+
+## 特性
+
+- DB-API 2.0 风格：`connect()` / `Connection` / `Cursor` / `commit()` / `rollback()`
+- 参数绑定：支持 `?` 占位符；兼容把 SQL 中的 `%s`（非引号区域）自动转换为 `?`
+- 内置达梦 JDBC 驱动 Jar：安装 Python 包即可使用（仍需本机存在 Java 运行时）
+- 自动选择 Jar：根据 `java -version` 探测的 Java 主版本选择对应驱动
+
+## 依赖
+
+- Python 3.7+
+- 运行环境需要安装 Java（JRE/JDK），并确保 `java` 在 PATH 中或已配置 `JAVA_HOME`
+
+## 安装
+
+```bash
+pip install ns-pydm
+```
+
+## 快速开始
+
+```python
+import nspydm
+
+conn = nspydm.connect(
+    user="SYSDBA",
+    password="SYSDBA",
+    server="127.0.0.1",
+    port=5236,
+)
+
+cur = conn.cursor()
+cur.execute("select ? as x", [1])
+print(cur.fetchone())
+conn.close()
+```
+
+## 参数绑定
+
+推荐写法（JDBC 原生）：使用 `?`
+
+```python
+cur.execute("select ? as x, ? as y", [1, "hello"])
+```
+
+兼容写法：使用 `%s`（会转换为 `?`）
+
+```python
+cur.execute("select %s as x, %s as y", [1, "hello"])
+```
+
+## 事务与自动提交
+
+```python
+conn = nspydm.connect(..., autocommit=False)
+cur = conn.cursor()
+cur.execute("insert into t(a) values(?)", [1])
+conn.commit()
+```
+
+也可以通过属性开关：
+
+```python
+conn.autocommit = True
+```
+
+## Schema 切换示例
+
+```python
+cur.execute("set schema your_schema")
+```
+
+## 连接参数
+
+- `connect(user, password, server, port, dsn, url, autocommit, properties, jars, driver_class)`
+- `url` 优先级最高，支持直接传入 `jdbc:dm://host:port` 形式
+- `dsn` 传入 `host:port` 时会自动拼接为 `jdbc:dm://{dsn}`
+
+## Jar 选择与 Java 版本识别
+
+- 默认会通过 `java -version` 探测 Java 主版本，并自动选择内置的驱动 Jar：
+  - Java 6 -> `DmJdbcDriver6.jar`
+  - Java 7 -> `DmJdbcDriver7.jar`
+  - Java 8/9/10 -> `DmJdbcDriver8.jar`
+  - Java 11+ -> `DmJdbcDriver11.jar`
+- 如需自定义或覆盖默认选择：
+  - 环境变量：`DM_JDBC_JAR=/abs/path/to/DmJdbcDriver8.jar`
+  - 代码传参：`connect(..., jars=["/abs/path/to/DmJdbcDriver8.jar"])`
+
+## 常见问题
+
+1. 提示找不到 `java`
+   - 确认已安装 JRE/JDK，并保证 `java -version` 能在命令行执行
+2. 连接时报错但信息不全
+   - 驱动底层异常会被映射为 DB-API 异常（例如 `OperationalError`），可直接打印异常信息排查

ns_pydm-0.0.1/README.md

@@ -0,0 +1,98 @@
+# ns-pydm
+
+基于 JDBC + JPype 的达梦（DM）Python 驱动，提供 DB-API 2.0 风格接口，跨平台使用。
+
+## 特性
+
+- DB-API 2.0 风格：`connect()` / `Connection` / `Cursor` / `commit()` / `rollback()`
+- 参数绑定：支持 `?` 占位符；兼容把 SQL 中的 `%s`（非引号区域）自动转换为 `?`
+- 内置达梦 JDBC 驱动 Jar：安装 Python 包即可使用（仍需本机存在 Java 运行时）
+- 自动选择 Jar：根据 `java -version` 探测的 Java 主版本选择对应驱动
+
+## 依赖
+
+- Python 3.7+
+- 运行环境需要安装 Java（JRE/JDK），并确保 `java` 在 PATH 中或已配置 `JAVA_HOME`
+
+## 安装
+
+```bash
+pip install ns-pydm
+```
+
+## 快速开始
+
+```python
+import nspydm
+
+conn = nspydm.connect(
+    user="SYSDBA",
+    password="SYSDBA",
+    server="127.0.0.1",
+    port=5236,
+)
+
+cur = conn.cursor()
+cur.execute("select ? as x", [1])
+print(cur.fetchone())
+conn.close()
+```
+
+## 参数绑定
+
+推荐写法（JDBC 原生）：使用 `?`
+
+```python
+cur.execute("select ? as x, ? as y", [1, "hello"])
+```
+
+兼容写法：使用 `%s`（会转换为 `?`）
+
+```python
+cur.execute("select %s as x, %s as y", [1, "hello"])
+```
+
+## 事务与自动提交
+
+```python
+conn = nspydm.connect(..., autocommit=False)
+cur = conn.cursor()
+cur.execute("insert into t(a) values(?)", [1])
+conn.commit()
+```
+
+也可以通过属性开关：
+
+```python
+conn.autocommit = True
+```
+
+## Schema 切换示例
+
+```python
+cur.execute("set schema your_schema")
+```
+
+## 连接参数
+
+- `connect(user, password, server, port, dsn, url, autocommit, properties, jars, driver_class)`
+- `url` 优先级最高，支持直接传入 `jdbc:dm://host:port` 形式
+- `dsn` 传入 `host:port` 时会自动拼接为 `jdbc:dm://{dsn}`
+
+## Jar 选择与 Java 版本识别
+
+- 默认会通过 `java -version` 探测 Java 主版本，并自动选择内置的驱动 Jar：
+  - Java 6 -> `DmJdbcDriver6.jar`
+  - Java 7 -> `DmJdbcDriver7.jar`
+  - Java 8/9/10 -> `DmJdbcDriver8.jar`
+  - Java 11+ -> `DmJdbcDriver11.jar`
+- 如需自定义或覆盖默认选择：
+  - 环境变量：`DM_JDBC_JAR=/abs/path/to/DmJdbcDriver8.jar`
+  - 代码传参：`connect(..., jars=["/abs/path/to/DmJdbcDriver8.jar"])`
+
+## 常见问题
+
+1. 提示找不到 `java`
+   - 确认已安装 JRE/JDK，并保证 `java -version` 能在命令行执行
+2. 连接时报错但信息不全
+   - 驱动底层异常会被映射为 DB-API 异常（例如 `OperationalError`），可直接打印异常信息排查

ns_pydm-0.0.1/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ns-pydm"
+version = "0.0.1"
+description = "Dameng (DM) DB-API 2.0 driver implemented on top of JDBC via JPype"
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.7"
+dependencies = ["JPype1>=1.5.2,<2"]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.package-data]
+nspydm = ["jdbc/*.jar"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

ns_pydm-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ns_pydm-0.0.1/src/ns_pydm.egg-info/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: ns-pydm
+Version: 0.0.1
+Summary: Dameng (DM) DB-API 2.0 driver implemented on top of JDBC via JPype
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: JPype1<2,>=1.5.2
+Dynamic: license-file
+
+# ns-pydm
+
+基于 JDBC + JPype 的达梦（DM）Python 驱动，提供 DB-API 2.0 风格接口，跨平台使用。
+
+## 特性
+
+- DB-API 2.0 风格：`connect()` / `Connection` / `Cursor` / `commit()` / `rollback()`
+- 参数绑定：支持 `?` 占位符；兼容把 SQL 中的 `%s`（非引号区域）自动转换为 `?`
+- 内置达梦 JDBC 驱动 Jar：安装 Python 包即可使用（仍需本机存在 Java 运行时）
+- 自动选择 Jar：根据 `java -version` 探测的 Java 主版本选择对应驱动
+
+## 依赖
+
+- Python 3.7+
+- 运行环境需要安装 Java（JRE/JDK），并确保 `java` 在 PATH 中或已配置 `JAVA_HOME`
+
+## 安装
+
+```bash
+pip install ns-pydm
+```
+
+## 快速开始
+
+```python
+import nspydm
+
+conn = nspydm.connect(
+    user="SYSDBA",
+    password="SYSDBA",
+    server="127.0.0.1",
+    port=5236,
+)
+
+cur = conn.cursor()
+cur.execute("select ? as x", [1])
+print(cur.fetchone())
+conn.close()
+```
+
+## 参数绑定
+
+推荐写法（JDBC 原生）：使用 `?`
+
+```python
+cur.execute("select ? as x, ? as y", [1, "hello"])
+```
+
+兼容写法：使用 `%s`（会转换为 `?`）
+
+```python
+cur.execute("select %s as x, %s as y", [1, "hello"])
+```
+
+## 事务与自动提交
+
+```python
+conn = nspydm.connect(..., autocommit=False)
+cur = conn.cursor()
+cur.execute("insert into t(a) values(?)", [1])
+conn.commit()
+```
+
+也可以通过属性开关：
+
+```python
+conn.autocommit = True
+```
+
+## Schema 切换示例
+
+```python
+cur.execute("set schema your_schema")
+```
+
+## 连接参数
+
+- `connect(user, password, server, port, dsn, url, autocommit, properties, jars, driver_class)`
+- `url` 优先级最高，支持直接传入 `jdbc:dm://host:port` 形式
+- `dsn` 传入 `host:port` 时会自动拼接为 `jdbc:dm://{dsn}`
+
+## Jar 选择与 Java 版本识别
+
+- 默认会通过 `java -version` 探测 Java 主版本，并自动选择内置的驱动 Jar：
+  - Java 6 -> `DmJdbcDriver6.jar`
+  - Java 7 -> `DmJdbcDriver7.jar`
+  - Java 8/9/10 -> `DmJdbcDriver8.jar`
+  - Java 11+ -> `DmJdbcDriver11.jar`
+- 如需自定义或覆盖默认选择：
+  - 环境变量：`DM_JDBC_JAR=/abs/path/to/DmJdbcDriver8.jar`
+  - 代码传参：`connect(..., jars=["/abs/path/to/DmJdbcDriver8.jar"])`
+
+## 常见问题
+
+1. 提示找不到 `java`
+   - 确认已安装 JRE/JDK，并保证 `java -version` 能在命令行执行
+2. 连接时报错但信息不全
+   - 驱动底层异常会被映射为 DB-API 异常（例如 `OperationalError`），可直接打印异常信息排查

ns_pydm-0.0.1/src/ns_pydm.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/ns_pydm.egg-info/PKG-INFO
+src/ns_pydm.egg-info/SOURCES.txt
+src/ns_pydm.egg-info/dependency_links.txt
+src/ns_pydm.egg-info/requires.txt
+src/ns_pydm.egg-info/top_level.txt
+src/nspydm/__init__.py
+src/nspydm/dbapi.py
+src/nspydm/jdbc/DmJdbcDriver11.jar
+src/nspydm/jdbc/DmJdbcDriver6.jar
+src/nspydm/jdbc/DmJdbcDriver7.jar
+src/nspydm/jdbc/DmJdbcDriver8.jar
+tests/test_smoke.py

ns_pydm-0.0.1/src/ns_pydm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ns_pydm-0.0.1/src/ns_pydm.egg-info/requires.txt

@@ -0,0 +1 @@
+JPype1<2,>=1.5.2

ns_pydm-0.0.1/src/ns_pydm.egg-info/top_level.txt

@@ -0,0 +1 @@
+nspydm

ns_pydm-0.0.1/src/nspydm/__init__.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from .dbapi import (
+    BINARY,
+    DATETIME,
+    NUMBER,
+    ROWID,
+    STRING,
+    Binary,
+    Connection,
+    Cursor,
+    DataError,
+    DatabaseError,
+    Date,
+    DateFromTicks,
+    Error,
+    IntegrityError,
+    InterfaceError,
+    InternalError,
+    NotSupportedError,
+    OperationalError,
+    ProgrammingError,
+    Time,
+    TimeFromTicks,
+    Timestamp,
+    TimestampFromTicks,
+    Warning,
+    connect,
+    paramstyle,
+    threadsafety,
+)
+
+apilevel = "2.0"
+
+__all__ = [
+    "BINARY",
+    "DATETIME",
+    "NUMBER",
+    "ROWID",
+    "STRING",
+    "Binary",
+    "Connection",
+    "Cursor",
+    "DataError",
+    "DatabaseError",
+    "Date",
+    "DateFromTicks",
+    "Error",
+    "IntegrityError",
+    "InterfaceError",
+    "InternalError",
+    "NotSupportedError",
+    "OperationalError",
+    "ProgrammingError",
+    "Time",
+    "TimeFromTicks",
+    "Timestamp",
+    "TimestampFromTicks",
+    "Warning",
+    "apilevel",
+    "connect",
+    "paramstyle",
+    "threadsafety",
+]

ns_pydm-0.0.1/src/nspydm/dbapi.py

@@ -0,0 +1,603 @@
+from __future__ import annotations
+
+import datetime as _dt
+import decimal as _decimal
+import os
+import re
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Iterable, Iterator, List, Mapping, Optional, Sequence, Tuple, Union
+
+import jpype
+
+threadsafety = 1
+paramstyle = "qmark"
+
+
+class Warning(Exception):
+    pass
+
+
+class Error(Exception):
+    pass
+
+
+class InterfaceError(Error):
+    pass
+
+
+class DatabaseError(Error):
+    pass
+
+
+class DataError(DatabaseError):
+    pass
+
+
+class OperationalError(DatabaseError):
+    pass
+
+
+class IntegrityError(DatabaseError):
+    pass
+
+
+class InternalError(DatabaseError):
+    pass
+
+
+class ProgrammingError(DatabaseError):
+    pass
+
+
+class NotSupportedError(DatabaseError):
+    pass
+
+
+@dataclass(frozen=True)
+class _TypeObject:
+    name: str
+
+    def __repr__(self) -> str:
+        return self.name
+
+
+STRING = _TypeObject("STRING")
+BINARY = _TypeObject("BINARY")
+NUMBER = _TypeObject("NUMBER")
+DATETIME = _TypeObject("DATETIME")
+ROWID = _TypeObject("ROWID")
+
+
+def _detect_java_major() -> Optional[int]:
+    try:
+        proc = subprocess.run(
+            ["java", "-version"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
+            check=False,
+        )
+    except Exception:
+        return None
+
+    text = (proc.stderr or "") + "\n" + (proc.stdout or "")
+    m = re.search(r'version\s+"([^"]+)"', text)
+    if not m:
+        m = re.search(r'openjdk\s+version\s+"([^"]+)"', text)
+    if not m:
+        return None
+
+    ver = m.group(1).strip()
+    if ver.startswith("1."):
+        parts = ver.split(".")
+        if len(parts) >= 2 and parts[1].isdigit():
+            return int(parts[1])
+        return None
+
+    major_text = re.split(r"[+._-]", ver, maxsplit=1)[0]
+    if major_text.isdigit():
+        return int(major_text)
+    return None
+
+
+def _pick_driver_filename(java_major: Optional[int]) -> str:
+    if java_major is None:
+        return "DmJdbcDriver8.jar"
+    if java_major <= 6:
+        return "DmJdbcDriver6.jar"
+    if java_major == 7:
+        return "DmJdbcDriver7.jar"
+    if java_major >= 11:
+        return "DmJdbcDriver11.jar"
+    return "DmJdbcDriver8.jar"
+
+
+def _default_jars() -> List[str]:
+    env = os.environ.get("DM_JDBC_JAR")
+    if env:
+        jars = [p for p in env.split(os.pathsep) if p]
+        return [str(Path(p).expanduser().resolve()) for p in jars]
+
+    java_major = _detect_java_major()
+    preferred = _pick_driver_filename(java_major)
+    fallbacks = ["DmJdbcDriver11.jar", "DmJdbcDriver8.jar", "DmJdbcDriver7.jar", "DmJdbcDriver6.jar"]
+
+    here = Path(__file__).resolve()
+
+    package_jdbc = here.parent / "jdbc"
+    if package_jdbc.exists():
+        cand = package_jdbc / preferred
+        if cand.exists():
+            return [str(cand)]
+        for name in fallbacks:
+            cand = package_jdbc / name
+            if cand.exists():
+                return [str(cand)]
+
+    for parent in [here.parent, here.parent.parent, *here.parents]:
+        candidate_dir = parent / "jdbc"
+        if not candidate_dir.exists():
+            continue
+        cand = candidate_dir / preferred
+        if cand.exists():
+            return [str(cand)]
+        for name in fallbacks:
+            cand = candidate_dir / name
+            if cand.exists():
+                return [str(cand)]
+
+    return []
+
+
+def _ensure_jvm(jars: Optional[Sequence[str]]) -> None:
+    jars = [p for p in (_default_jars() if jars is None else list(jars)) if p]
+    jars = [str(Path(p).expanduser().resolve()) for p in jars]
+
+    if not jars:
+        raise InterfaceError(
+            "找不到达梦 JDBC 驱动 Jar。请通过 connect(..., jars=[...]) 或环境变量 DM_JDBC_JAR 指定。"
+        )
+
+    if jpype.isJVMStarted():
+        for jar in jars:
+            jpype.addClassPath(jar)
+        return
+
+    jpype.startJVM(classpath=jars, convertStrings=True)
+
+
+def _java() -> Dict[str, Any]:
+    DriverManager = jpype.JClass("java.sql.DriverManager")
+    Class = jpype.JClass("java.lang.Class")
+    Properties = jpype.JClass("java.util.Properties")
+    Types = jpype.JClass("java.sql.Types")
+    SQLException = jpype.JClass("java.sql.SQLException")
+    Timestamp = jpype.JClass("java.sql.Timestamp")
+    Date = jpype.JClass("java.sql.Date")
+    Time = jpype.JClass("java.sql.Time")
+    BigDecimal = jpype.JClass("java.math.BigDecimal")
+    JByte = jpype.JByte
+    JArray = jpype.JArray
+    return {
+        "BigDecimal": BigDecimal,
+        "Class": Class,
+        "Date": Date,
+        "DriverManager": DriverManager,
+        "JArray": JArray,
+        "JByte": JByte,
+        "Properties": Properties,
+        "SQLException": SQLException,
+        "Time": Time,
+        "Timestamp": Timestamp,
+        "Types": Types,
+    }
+
+
+def _wrap_sql_exception(exc: BaseException) -> DatabaseError:
+    try:
+        j = _java()
+    except Exception:
+        return DatabaseError(str(exc))
+
+    if isinstance(exc, j["SQLException"]):
+        message = str(exc.getMessage())
+        sqlstate = str(exc.getSQLState()) if exc.getSQLState() is not None else None
+        errorcode = int(exc.getErrorCode())
+        return OperationalError("%s (sqlstate=%s, code=%s)" % (message, sqlstate, errorcode))
+
+    return DatabaseError(str(exc))
+
+
+def _adapt_paramstyle(sql: str) -> str:
+    if "?" in sql or "%s" not in sql:
+        return sql
+
+    out = []
+    i = 0
+    in_single = False
+    in_double = False
+
+    while i < len(sql):
+        ch = sql[i]
+
+        if ch == "'" and not in_double:
+            if in_single and i + 1 < len(sql) and sql[i + 1] == "'":
+                out.append("''")
+                i += 2
+                continue
+            in_single = not in_single
+            out.append(ch)
+            i += 1
+            continue
+
+        if ch == '"' and not in_single:
+            in_double = not in_double
+            out.append(ch)
+            i += 1
+            continue
+
+        if not in_single and not in_double and sql.startswith("%s", i):
+            out.append("?")
+            i += 2
+            continue
+
+        out.append(ch)
+        i += 1
+
+    return "".join(out)
+
+
+def _to_java_param(value: Any) -> Any:
+    j = _java()
+
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return bool(value)
+    if isinstance(value, int):
+        return int(value)
+    if isinstance(value, float):
+        return float(value)
+    if isinstance(value, _decimal.Decimal):
+        return j["BigDecimal"](str(value))
+    if isinstance(value, _dt.datetime):
+        if value.tzinfo is not None:
+            value = value.astimezone(_dt.timezone.utc).replace(tzinfo=None)
+        text = value.isoformat(sep=" ")
+        return j["Timestamp"].valueOf(text)
+    if isinstance(value, _dt.date) and not isinstance(value, _dt.datetime):
+        return j["Date"].valueOf(value.isoformat())
+    if isinstance(value, _dt.time):
+        millis = (
+            (value.hour * 3600 + value.minute * 60 + value.second) * 1000
+            + value.microsecond // 1000
+        )
+        return j["Time"](millis)
+    if isinstance(value, (bytes, bytearray, memoryview)):
+        data = bytes(value)
+        return j["JArray"](j["JByte"])(data)
+
+    return value
+
+
+def _from_java_value(value: Any) -> Any:
+    if value is None:
+        return None
+
+    j = _java()
+
+    if isinstance(value, j["Timestamp"]):
+        text = str(value.toString())
+        return _dt.datetime.fromisoformat(text.replace(" ", "T"))
+    if isinstance(value, j["Date"]):
+        return _dt.date.fromisoformat(str(value.toString()))
+    if isinstance(value, j["Time"]):
+        return _dt.time.fromisoformat(str(value.toString()))
+    if isinstance(value, j["BigDecimal"]):
+        return _decimal.Decimal(value.toPlainString())
+
+    if isinstance(value, jpype.JBoolean):
+        return bool(value)
+    if isinstance(value, (jpype.JByte, jpype.JShort, jpype.JInt, jpype.JLong)):
+        return int(value)
+    if isinstance(value, (jpype.JFloat, jpype.JDouble)):
+        return float(value)
+
+    if isinstance(value, jpype.JArray(jpype.JByte)):
+        return bytes(value)
+
+    return value
+
+
+def Binary(x: Union[bytes, bytearray, memoryview]) -> bytes:
+    return bytes(x)
+
+
+def Date(year: int, month: int, day: int) -> _dt.date:
+    return _dt.date(year, month, day)
+
+
+def DateFromTicks(ticks: float) -> _dt.date:
+    return _dt.date.fromtimestamp(ticks)
+
+
+def Time(hour: int, minute: int, second: int) -> _dt.time:
+    return _dt.time(hour, minute, second)
+
+
+def TimeFromTicks(ticks: float) -> _dt.time:
+    return _dt.datetime.fromtimestamp(ticks).time()
+
+
+def Timestamp(year: int, month: int, day: int, hour: int, minute: int, second: int) -> _dt.datetime:
+    return _dt.datetime(year, month, day, hour, minute, second)
+
+
+def TimestampFromTicks(ticks: float) -> _dt.datetime:
+    return _dt.datetime.fromtimestamp(ticks)
+
+
+class Connection:
+    def __init__(self, jconn: Any):
+        self._jconn = jconn
+        self._closed = False
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        try:
+            self._jconn.close()
+        finally:
+            self._closed = True
+
+    def commit(self) -> None:
+        try:
+            self._jconn.commit()
+        except BaseException as exc:
+            raise _wrap_sql_exception(exc) from exc
+
+    def rollback(self) -> None:
+        try:
+            self._jconn.rollback()
+        except BaseException as exc:
+            raise _wrap_sql_exception(exc) from exc
+
+    def cursor(self) -> "Cursor":
+        if self._closed:
+            raise InterfaceError("connection already closed")
+        return Cursor(self)
+
+    def __enter__(self) -> "Connection":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        if exc is None:
+            self.commit()
+        else:
+            self.rollback()
+        self.close()
+
+    @property
+    def autocommit(self) -> bool:
+        return bool(self._jconn.getAutoCommit())
+
+    @autocommit.setter
+    def autocommit(self, value: bool) -> None:
+        self._jconn.setAutoCommit(bool(value))
+
+
+class Cursor:
+    arraysize = 1
+
+    def __init__(self, connection: Connection):
+        self.connection = connection
+        self._closed = False
+        self._rs = None
+        self._stmt = None
+        self.description = None
+        self.rowcount = -1
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        for obj in (self._rs, self._stmt):
+            try:
+                if obj is not None:
+                    obj.close()
+            except Exception:
+                pass
+        self._rs = None
+        self._stmt = None
+
+    def _check_open(self) -> None:
+        if self._closed:
+            raise InterfaceError("cursor already closed")
+
+    def _clear_result(self) -> None:
+        for obj in (self._rs, self._stmt):
+            try:
+                if obj is not None:
+                    obj.close()
+            except Exception:
+                pass
+        self._rs = None
+        self._stmt = None
+
+    def execute(
+        self,
+        operation: str,
+        parameters: Optional[Union[Sequence[Any], Mapping[str, Any]]] = None,
+    ) -> "Cursor":
+        self._check_open()
+        if parameters is not None and isinstance(parameters, Mapping):
+            raise NotSupportedError("仅支持序列参数（qmark/format），不支持命名参数")
+
+        sql = _adapt_paramstyle(operation)
+
+        try:
+            self._clear_result()
+            if parameters is None:
+                self._stmt = self.connection._jconn.createStatement()
+                has_rs = bool(self._stmt.execute(sql))
+            else:
+                self._stmt = self.connection._jconn.prepareStatement(sql)
+                for idx, value in enumerate(parameters, start=1):
+                    self._stmt.setObject(idx, _to_java_param(value))
+                has_rs = bool(self._stmt.execute())
+
+            if has_rs:
+                self._rs = self._stmt.getResultSet()
+                self.description = self._build_description(self._rs)
+                self.rowcount = -1
+            else:
+                self._rs = None
+                self.description = None
+                self.rowcount = int(self._stmt.getUpdateCount())
+            return self
+        except BaseException as exc:
+            raise _wrap_sql_exception(exc) from exc
+
+    def executemany(self, operation: str, seq_of_parameters: Iterable[Sequence[Any]]) -> "Cursor":
+        self._check_open()
+        sql = _adapt_paramstyle(operation)
+
+        try:
+            self._clear_result()
+            self._stmt = self.connection._jconn.prepareStatement(sql)
+            total = 0
+            for parameters in seq_of_parameters:
+                for idx, value in enumerate(parameters, start=1):
+                    self._stmt.setObject(idx, _to_java_param(value))
+                self._stmt.addBatch()
+            results = list(self._stmt.executeBatch())
+            if results:
+                for r in results:
+                    if int(r) > 0:
+                        total += int(r)
+            self.rowcount = total if total else -1
+            self._rs = None
+            self.description = None
+            return self
+        except BaseException as exc:
+            raise _wrap_sql_exception(exc) from exc
+
+    def _build_description(self, rs: Any) -> Tuple[Tuple[Any, ...], ...]:
+        meta = rs.getMetaData()
+        col_count = int(meta.getColumnCount())
+        desc = []
+        for i in range(1, col_count + 1):
+            name = str(meta.getColumnLabel(i))
+            type_code = int(meta.getColumnType(i))
+            display_size = int(meta.getColumnDisplaySize(i))
+            precision = int(meta.getPrecision(i))
+            scale = int(meta.getScale(i))
+            nullable = int(meta.isNullable(i))
+            null_ok = nullable != 0
+            desc.append((name, type_code, display_size, display_size, precision, scale, null_ok))
+        return tuple(desc)
+
+    def fetchone(self):
+        self._check_open()
+        if self._rs is None:
+            return None
+        try:
+            if not self._rs.next():
+                return None
+            return self._read_row(self._rs)
+        except BaseException as exc:
+            raise _wrap_sql_exception(exc) from exc
+
+    def fetchmany(self, size: Optional[int] = None):
+        self._check_open()
+        if self._rs is None:
+            return []
+        size = self.arraysize if size is None else int(size)
+        rows = []
+        for _ in range(size):
+            row = self.fetchone()
+            if row is None:
+                break
+            rows.append(row)
+        return rows
+
+    def fetchall(self):
+        self._check_open()
+        if self._rs is None:
+            return []
+        rows = []
+        while True:
+            row = self.fetchone()
+            if row is None:
+                break
+            rows.append(row)
+        return rows
+
+    def _read_row(self, rs: Any):
+        meta = rs.getMetaData()
+        col_count = int(meta.getColumnCount())
+        row = []
+        for i in range(1, col_count + 1):
+            value = rs.getObject(i)
+            row.append(_from_java_value(value))
+        return tuple(row)
+
+    def __iter__(self) -> Iterator[Tuple[Any, ...]]:
+        while True:
+            row = self.fetchone()
+            if row is None:
+                return
+            yield row
+
+    def setinputsizes(self, sizes: Sequence[Any]) -> None:
+        self._check_open()
+
+    def setoutputsize(self, size: int, column: Optional[int] = None) -> None:
+        self._check_open()
+
+
+def connect(
+    user: Optional[str] = None,
+    password: Optional[str] = None,
+    server: str = "127.0.0.1",
+    port: int = 5236,
+    dsn: Optional[str] = None,
+    url: Optional[str] = None,
+    autocommit: bool = False,
+    jars: Optional[Sequence[str]] = None,
+    driver_class: str = "dm.jdbc.driver.DmDriver",
+    properties: Optional[Mapping[str, str]] = None,
+) -> Connection:
+    _ensure_jvm(jars)
+    j = _java()
+
+    try:
+        j["Class"].forName(driver_class)
+    except BaseException as exc:
+        raise InterfaceError("无法加载 JDBC Driver: %s" % driver_class) from exc
+
+    if url is None:
+        if dsn is not None and dsn.startswith("jdbc:"):
+            url = dsn
+        elif dsn is not None:
+            url = "jdbc:dm://%s" % dsn
+        else:
+            url = "jdbc:dm://%s:%s" % (server, int(port))
+
+    props = j["Properties"]()
+    if user is not None:
+        props.setProperty("user", str(user))
+    if password is not None:
+        props.setProperty("password", str(password))
+    if properties:
+        for k, v in properties.items():
+            props.setProperty(str(k), str(v))
+
+    try:
+        jconn = j["DriverManager"].getConnection(url, props)
+        jconn.setAutoCommit(bool(autocommit))
+        return Connection(jconn)
+    except BaseException as exc:
+        raise _wrap_sql_exception(exc) from exc

ns_pydm-0.0.1/tests/test_smoke.py

@@ -0,0 +1,61 @@
+import unittest
+
+
+class TestSmoke(unittest.TestCase):
+    def test_paramstyle_adapt(self):
+        from nspydm.dbapi import _adapt_paramstyle
+
+        self.assertEqual(
+            _adapt_paramstyle("select * from t where a=%s and b=%s"),
+            "select * from t where a=? and b=?",
+        )
+        self.assertEqual(
+            _adapt_paramstyle("select '%s' as x, col from t where a=%s"),
+            "select '%s' as x, col from t where a=?",
+        )
+
+    def test_can_load_driver_class(self):
+        try:
+            import jpype
+        except Exception as exc:
+            self.skipTest(str(exc))
+
+        from nspydm.dbapi import _default_jars, _ensure_jvm
+
+        jars = _default_jars()
+        if not jars:
+            self.skipTest("no dm jdbc jar found")
+
+        try:
+            _ensure_jvm(jars)
+        except Exception as exc:
+            self.skipTest(str(exc))
+
+        try:
+            jpype.JClass("dm.jdbc.driver.DmDriver")
+        except Exception as exc:
+            self.fail(str(exc))
+
+    def test_usage_example(self):
+        import os
+
+        url = os.environ.get("DM_TEST_URL")
+        if not url:
+            self.skipTest("set DM_TEST_URL=jdbc:dm://host:port for integration test")
+
+        user = os.environ.get("DM_TEST_USER")
+        password = os.environ.get("DM_TEST_PASSWORD")
+
+        import nspydm
+
+        conn = nspydm.connect(url=url, user=user, password=password)
+        cur = conn.cursor()
+        cur.execute("select ? as x", [1])
+        row = cur.fetchone()
+        conn.close()
+
+        self.assertTrue(row is None or row[0] == 1)
+
+
+if __name__ == "__main__":
+    unittest.main()