zodbc 0.9.1__tar.gz

zodbc-0.9.1/MANIFEST.in

@@ -0,0 +1,10 @@
+include _zodbc.zig
+include PyFuncs.zig
+include arrow.zig
+include fetch_arrow.zig
+include fetch_py.zig
+include put_arrow.zig
+include put_common.zig
+include put_py.zig
+include utils.zig
+include fmt.zig

zodbc-0.9.1/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: zodbc
+Version: 0.9.1
+Summary: DBAPI2-like ODBC client with Apache Arrow support
+Author: Felix Graßl
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ffelixg/zodbc_py
+Keywords: odbc,arrow,mssql,sql server
+Classifier: Programming Language :: Python
+Classifier: Topic :: Database
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: pyarrow
+Requires-Dist: pyarrow; extra == "pyarrow"
+
+# zodbc
+
+This odbc client tries to be compatible with the DB API 2 Specification, while also treating pyarrow compatibility as a first class citizen. At the moment it is tested with the msodbc driver. Compilation and installation is made easy by ziglang being a simple build dependency. The only system dependencies for compilation should be development headers for unixodbc (if on linux) and python.
+
+
+# Installation
+
+```bash
+pip install zodbc
+```
+
+
+# Features
+
+
+## DB API 2
+
+```py
+import zodbc
+import os
+
+con = zodbc.connect(os.environ["ODBC_CONSTR"])  # Connect with odbc connection string or DSN
+cur = con.cursor()  # Cursor, which translates to an odbc statement handle
+
+# python parameters & return values, data types like str, int, bool, UUID, decimal, date, time, datetime
+cur.execute("select ? a", [42])
+assert cur.fetchone()[0] == 42
+
+# Short hand alternative for getting column names from cur.description
+assert [c[0] for c in cur.description] == cur.column_names == ["a"]
+
+con.commit()  # Transactions, autocommit is disabled by default
+```
+
+
+## Additional fetch methods
+
+The DB API 2 fetch methods `fetchone`, `fetchmany` and `fetchall` return (lists of) tuples. Additionally, there is `fetch_named` which returns a list of named tuples, which allows accessing fields by attribute name like `row.a` as well as `fetch_dict` which returns a list of dicts. `fetch_dict` requires unique column names in the query. These methods are implemented directly in Zig and should therefore be more efficient than fetching tuples and converting them in python.
+
+
+## Apache Arrow
+
+A query can be executed for every row in an Arrow RecordBatch.
+
+```py
+import pyarrow as pa
+
+cur.execute("drop table if exists t1")
+cur.execute("create table t1(a int)")
+cur.executemany_arrow(
+    "insert into t1(a) values(?)",
+    pa.RecordBatch.from_arrays([pa.array([1, 2, 3])], ["a"])
+)
+cur.execute("select * from t1").fetchall()  # [(1,), (2,), (3,)]
+```
+
+Arrow RecordBatches can be fetched from a query result.
+
+```py
+cur.execute("select 1 a").fetch_arrow()
+```
+
+Arrow RecordBatches can be used as a table valued parameter for MS SQL.
+
+```py
+cur.execute("drop type if exists test_tabletype")
+cur.execute("create type test_tabletype as table(a int)")
+con.commit()
+
+assert cur.execute(
+    "select sum(a) from ? where a <= ?",
+    [
+        zodbc.ArrowTVP(
+            zodbc.ArrowTVPType.from_name("test_tabletype"),
+            pa.RecordBatch.from_arrays([pa.array([1, 2, 3])], ["a"]),
+        ),
+        2,
+    ]
+).fetchone()[0] == 3
+```
+
+
+# Differences with pyodbc
+
+- UUID is always returned as a python UUID object (no pyodbc.native_uuid global variable)
+- No output conversion (add_output_converter connection method)
+- More explicit:
+    - No `execute(query, param1, param2)` => params must be passed as sequence
+    - No Cursor.commit, instead use Cursor.connection.commit
+- Connection.getinfo takes a string instead of the odbc enum value

zodbc-0.9.1/PyFuncs.zig

@@ -0,0 +1,60 @@
+const c = @import("c");
+const Obj = *c.PyObject;
+
+cls_datetime: Obj,
+cls_date: Obj,
+cls_time: Obj,
+cls_timezone: Obj,
+cls_timedelta: Obj,
+cls_decimal: Obj,
+func_decimal_intratio: Obj,
+cls_uuid: Obj,
+
+pub fn init() !@This() {
+    const mod_datetime = c.PyImport_ImportModule("datetime") orelse return error.PyErr;
+    defer c.Py_DECREF(mod_datetime);
+    const cls_datetime = c.PyObject_GetAttrString(mod_datetime, "datetime") orelse return error.PyErr;
+    errdefer c.Py_DECREF(cls_datetime);
+    const cls_date = c.PyObject_GetAttrString(mod_datetime, "date") orelse return error.PyErr;
+    errdefer c.Py_DECREF(cls_date);
+    const cls_time = c.PyObject_GetAttrString(mod_datetime, "time") orelse return error.PyErr;
+    errdefer c.Py_DECREF(cls_time);
+    const cls_timezone = c.PyObject_GetAttrString(mod_datetime, "timezone") orelse return error.PyErr;
+    errdefer c.Py_DECREF(cls_timezone);
+    const cls_timedelta = c.PyObject_GetAttrString(mod_datetime, "timedelta") orelse return error.PyErr;
+    errdefer c.Py_DECREF(cls_timedelta);
+
+    const mod_decimal = c.PyImport_ImportModule("decimal") orelse return error.PyErr;
+    defer c.Py_DECREF(mod_decimal);
+    const cls_decimal = c.PyObject_GetAttrString(mod_decimal, "Decimal") orelse return error.PyErr;
+    errdefer c.Py_DECREF(cls_decimal);
+    const func_decimal_intratio = c.PyObject_GetAttrString(cls_decimal, "as_integer_ratio") orelse return error.PyErr;
+    errdefer c.Py_DECREF(func_decimal_intratio);
+
+    const mod_uuid = c.PyImport_ImportModule("uuid") orelse return error.PyErr;
+    defer c.Py_DECREF(mod_uuid);
+    const cls_uuid = c.PyObject_GetAttrString(mod_uuid, "UUID") orelse return error.PyErr;
+    errdefer c.Py_DECREF(cls_uuid);
+
+    return .{
+        .cls_datetime = cls_datetime,
+        .cls_date = cls_date,
+        .cls_time = cls_time,
+        .cls_timezone = cls_timezone,
+        .cls_timedelta = cls_timedelta,
+        .cls_decimal = cls_decimal,
+        .func_decimal_intratio = func_decimal_intratio,
+        .cls_uuid = cls_uuid,
+    };
+}
+
+pub fn deinit(self: @This()) void {
+    c.Py_DECREF(self.cls_datetime);
+    c.Py_DECREF(self.cls_date);
+    c.Py_DECREF(self.cls_time);
+    c.Py_DECREF(self.cls_timezone);
+    c.Py_DECREF(self.cls_timedelta);
+    c.Py_DECREF(self.cls_decimal);
+    c.Py_DECREF(self.func_decimal_intratio);
+    c.Py_DECREF(self.cls_uuid);
+}

zodbc-0.9.1/README.md

@@ -0,0 +1,90 @@
+# zodbc
+
+This odbc client tries to be compatible with the DB API 2 Specification, while also treating pyarrow compatibility as a first class citizen. At the moment it is tested with the msodbc driver. Compilation and installation is made easy by ziglang being a simple build dependency. The only system dependencies for compilation should be development headers for unixodbc (if on linux) and python.
+
+
+# Installation
+
+```bash
+pip install zodbc
+```
+
+
+# Features
+
+
+## DB API 2
+
+```py
+import zodbc
+import os
+
+con = zodbc.connect(os.environ["ODBC_CONSTR"])  # Connect with odbc connection string or DSN
+cur = con.cursor()  # Cursor, which translates to an odbc statement handle
+
+# python parameters & return values, data types like str, int, bool, UUID, decimal, date, time, datetime
+cur.execute("select ? a", [42])
+assert cur.fetchone()[0] == 42
+
+# Short hand alternative for getting column names from cur.description
+assert [c[0] for c in cur.description] == cur.column_names == ["a"]
+
+con.commit()  # Transactions, autocommit is disabled by default
+```
+
+
+## Additional fetch methods
+
+The DB API 2 fetch methods `fetchone`, `fetchmany` and `fetchall` return (lists of) tuples. Additionally, there is `fetch_named` which returns a list of named tuples, which allows accessing fields by attribute name like `row.a` as well as `fetch_dict` which returns a list of dicts. `fetch_dict` requires unique column names in the query. These methods are implemented directly in Zig and should therefore be more efficient than fetching tuples and converting them in python.
+
+
+## Apache Arrow
+
+A query can be executed for every row in an Arrow RecordBatch.
+
+```py
+import pyarrow as pa
+
+cur.execute("drop table if exists t1")
+cur.execute("create table t1(a int)")
+cur.executemany_arrow(
+    "insert into t1(a) values(?)",
+    pa.RecordBatch.from_arrays([pa.array([1, 2, 3])], ["a"])
+)
+cur.execute("select * from t1").fetchall()  # [(1,), (2,), (3,)]
+```
+
+Arrow RecordBatches can be fetched from a query result.
+
+```py
+cur.execute("select 1 a").fetch_arrow()
+```
+
+Arrow RecordBatches can be used as a table valued parameter for MS SQL.
+
+```py
+cur.execute("drop type if exists test_tabletype")
+cur.execute("create type test_tabletype as table(a int)")
+con.commit()
+
+assert cur.execute(
+    "select sum(a) from ? where a <= ?",
+    [
+        zodbc.ArrowTVP(
+            zodbc.ArrowTVPType.from_name("test_tabletype"),
+            pa.RecordBatch.from_arrays([pa.array([1, 2, 3])], ["a"]),
+        ),
+        2,
+    ]
+).fetchone()[0] == 3
+```
+
+
+# Differences with pyodbc
+
+- UUID is always returned as a python UUID object (no pyodbc.native_uuid global variable)
+- No output conversion (add_output_converter connection method)
+- More explicit:
+    - No `execute(query, param1, param2)` => params must be passed as sequence
+    - No Cursor.commit, instead use Cursor.connection.commit
+- Connection.getinfo takes a string instead of the odbc enum value