You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by cu...@apache.org on 2024/05/01 16:04:09 UTC
(arrow-adbc) branch main updated: feat(csharp): imported objects should have call "release" when no longer in use (#1802)
This is an automated email from the ASF dual-hosted git repository.
curth pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-adbc.git
The following commit(s) were added to refs/heads/main by this push:
new a48c3b050 feat(csharp): imported objects should have call "release" when no longer in use (#1802)
a48c3b050 is described below
commit a48c3b0500e6d80c383f57fbf6a9c907ca584a80
Author: Curt Hagenlocher <cu...@hagenlocher.org>
AuthorDate: Wed May 1 09:04:03 2024 -0700
feat(csharp): imported objects should have call "release" when no longer in use (#1802)
Closes #1780
---
.../src/Apache.Arrow.Adbc/C/CAdbcDriverExporter.cs | 105 ++-----
.../src/Apache.Arrow.Adbc/C/CAdbcDriverImporter.cs | 345 ++++++++++++++++-----
csharp/src/Apache.Arrow.Adbc/C/Delegates.cs | 47 +++
csharp/src/Apache.Arrow.Adbc/C/NativeDelegate.cs | 14 +-
4 files changed, 361 insertions(+), 150 deletions(-)
diff --git a/csharp/src/Apache.Arrow.Adbc/C/CAdbcDriverExporter.cs b/csharp/src/Apache.Arrow.Adbc/C/CAdbcDriverExporter.cs
index 9034c37e3..7352e3480 100644
--- a/csharp/src/Apache.Arrow.Adbc/C/CAdbcDriverExporter.cs
+++ b/csharp/src/Apache.Arrow.Adbc/C/CAdbcDriverExporter.cs
@@ -27,10 +27,7 @@ namespace Apache.Arrow.Adbc.C
{
public class CAdbcDriverExporter
{
- internal unsafe delegate void ErrorRelease(CAdbcError* error);
private static unsafe readonly NativeDelegate<ErrorRelease> s_releaseError = new NativeDelegate<ErrorRelease>(ReleaseError);
- internal unsafe delegate AdbcStatusCode DatabaseFn(CAdbcDatabase* database, CAdbcError* error);
- internal unsafe delegate AdbcStatusCode ConnectionFn(CAdbcConnection* connection, CAdbcError* error);
#if NET5_0_OR_GREATER
private static unsafe delegate* unmanaged<CAdbcError*, void> ReleaseErrorPtr => (delegate* unmanaged<CAdbcError*, void>)s_releaseError.Pointer;
@@ -63,79 +60,35 @@ namespace Apache.Arrow.Adbc.C
private static unsafe delegate* unmanaged<CAdbcStatement*, byte*, int, CAdbcError*, AdbcStatusCode> StatementSetSubstraitPlanPtr => &SetStatementSubstraitPlan;
private static unsafe delegate* unmanaged<CAdbcStatement*, CArrowSchema*, CAdbcError*, AdbcStatusCode> StatementGetParameterSchemaPtr => &GetStatementParameterSchema;
#else
- private static IntPtr ReleaseErrorPtr => s_releaseError.Pointer;
- internal unsafe delegate AdbcStatusCode DriverRelease(CAdbcDriver* driver, CAdbcError* error);
- private static unsafe readonly NativeDelegate<DriverRelease> s_releaseDriver = new NativeDelegate<DriverRelease>(ReleaseDriver);
- private static IntPtr ReleaseDriverPtr => s_releaseDriver.Pointer;
- internal unsafe delegate void PartitionsRelease(CAdbcPartitions* partitions);
- private static unsafe readonly NativeDelegate<PartitionsRelease> s_releasePartitions = new NativeDelegate<PartitionsRelease>(ReleasePartitions);
- private static IntPtr ReleasePartitionsPtr => s_releasePartitions.Pointer;
-
- private static unsafe readonly NativeDelegate<DatabaseFn> s_databaseInit = new NativeDelegate<DatabaseFn>(InitDatabase);
- private static IntPtr DatabaseInitPtr => s_databaseInit.Pointer;
- private static unsafe readonly NativeDelegate<DatabaseFn> s_databaseRelease = new NativeDelegate<DatabaseFn>(ReleaseDatabase);
- private static IntPtr DatabaseReleasePtr => s_databaseRelease.Pointer;
- internal unsafe delegate AdbcStatusCode DatabaseSetOption(CAdbcDatabase* database, byte* name, byte* value, CAdbcError* error);
- private static unsafe readonly NativeDelegate<DatabaseSetOption> s_databaseSetOption = new NativeDelegate<DatabaseSetOption>(SetDatabaseOption);
- private static IntPtr DatabaseSetOptionPtr => s_databaseSetOption.Pointer;
-
- internal unsafe delegate AdbcStatusCode ConnectionGetObjects(CAdbcConnection* connection, int depth, byte* catalog, byte* db_schema, byte* table_name, byte** table_type, byte* column_name, CArrowArrayStream* stream, CAdbcError* error);
- private static unsafe readonly NativeDelegate<ConnectionGetObjects> s_connectionGetObjects = new NativeDelegate<ConnectionGetObjects>(GetConnectionObjects);
- private static IntPtr ConnectionGetObjectsPtr => s_connectionGetObjects.Pointer;
- internal unsafe delegate AdbcStatusCode ConnectionGetTableSchema(CAdbcConnection* connection, byte* catalog, byte* db_schema, byte* table_name, CArrowSchema* schema, CAdbcError* error);
- private static unsafe readonly NativeDelegate<ConnectionGetTableSchema> s_connectionGetTableSchema = new NativeDelegate<ConnectionGetTableSchema>(GetConnectionTableSchema);
- private static IntPtr ConnectionGetTableSchemaPtr => s_connectionGetTableSchema.Pointer;
- internal unsafe delegate AdbcStatusCode ConnectionGetTableTypes(CAdbcConnection* connection, CArrowArrayStream* stream, CAdbcError* error);
- private static unsafe readonly NativeDelegate<ConnectionGetTableTypes> s_connectionGetTableTypes = new NativeDelegate<ConnectionGetTableTypes>(GetConnectionTableTypes);
- private static IntPtr ConnectionGetTableTypesPtr => s_connectionGetTableTypes.Pointer;
- internal unsafe delegate AdbcStatusCode ConnectionInit(CAdbcConnection* connection, CAdbcDatabase* database, CAdbcError* error);
- private static unsafe readonly NativeDelegate<ConnectionInit> s_connectionInit = new NativeDelegate<ConnectionInit>(InitConnection);
- private static IntPtr ConnectionInitPtr => s_connectionInit.Pointer;
- private static unsafe readonly NativeDelegate<ConnectionFn> s_connectionRollback = new NativeDelegate<ConnectionFn>(RollbackConnection);
- private static IntPtr ConnectionRollbackPtr => s_connectionRollback.Pointer;
- private static unsafe readonly NativeDelegate<ConnectionFn> s_connectionCommit = new NativeDelegate<ConnectionFn>(CommitConnection);
- private static IntPtr ConnectionCommitPtr => s_connectionCommit.Pointer;
- private static unsafe readonly NativeDelegate<ConnectionFn> s_connectionRelease = new NativeDelegate<ConnectionFn>(ReleaseConnection);
- private static IntPtr ConnectionReleasePtr => s_connectionRelease.Pointer;
- internal unsafe delegate AdbcStatusCode ConnectionGetInfo(CAdbcConnection* connection, int* info_codes, int info_codes_length, CArrowArrayStream* stream, CAdbcError* error);
- private static unsafe readonly NativeDelegate<ConnectionGetInfo> s_connectionGetInfo = new NativeDelegate<ConnectionGetInfo>(GetConnectionInfo);
- private static IntPtr ConnectionGetInfoPtr => s_connectionGetInfo.Pointer;
- private unsafe delegate AdbcStatusCode ConnectionReadPartition(CAdbcConnection* connection, byte* serialized_partition, int serialized_length, CArrowArrayStream* stream, CAdbcError* error);
- private static unsafe readonly NativeDelegate<ConnectionReadPartition> s_connectionReadPartition = new NativeDelegate<ConnectionReadPartition>(ReadConnectionPartition);
- private static IntPtr ConnectionReadPartitionPtr => s_connectionReadPartition.Pointer;
- internal unsafe delegate AdbcStatusCode ConnectionSetOption(CAdbcConnection* connection, byte* name, byte* value, CAdbcError* error);
- private static unsafe readonly NativeDelegate<ConnectionSetOption> s_connectionSetOption = new NativeDelegate<ConnectionSetOption>(SetConnectionOption);
- private static IntPtr ConnectionSetOptionPtr => s_connectionSetOption.Pointer;
-
- internal unsafe delegate AdbcStatusCode StatementBind(CAdbcStatement* statement, CArrowArray* array, CArrowSchema* schema, CAdbcError* error);
- private static unsafe readonly NativeDelegate<StatementBind> s_statementBind = new NativeDelegate<StatementBind>(BindStatement);
- private static IntPtr StatementBindPtr => s_statementBind.Pointer;
- internal unsafe delegate AdbcStatusCode StatementBindStream(CAdbcStatement* statement, CArrowArrayStream* stream, CAdbcError* error);
- private static unsafe readonly NativeDelegate<StatementBindStream> s_statementBindStream = new NativeDelegate<StatementBindStream>(BindStreamStatement);
- private static IntPtr StatementBindStreamPtr => s_statementBindStream.Pointer;
- internal unsafe delegate AdbcStatusCode StatementExecuteQuery(CAdbcStatement* statement, CArrowArrayStream* stream, long* rows, CAdbcError* error);
- private static unsafe readonly NativeDelegate<StatementExecuteQuery> s_statementExecuteQuery = new NativeDelegate<StatementExecuteQuery>(ExecuteStatementQuery);
- private static IntPtr StatementExecuteQueryPtr = s_statementExecuteQuery.Pointer;
- internal unsafe delegate AdbcStatusCode StatementExecutePartitions(CAdbcStatement* statement, CArrowSchema* schema, CAdbcPartitions* partitions, long* rows, CAdbcError* error);
- private static unsafe readonly NativeDelegate<StatementExecutePartitions> s_statementExecutePartitions = new NativeDelegate<StatementExecutePartitions>(ExecuteStatementPartitions);
- private static IntPtr StatementExecutePartitionsPtr = s_statementExecutePartitions.Pointer;
- internal unsafe delegate AdbcStatusCode StatementNew(CAdbcConnection* connection, CAdbcStatement* statement, CAdbcError* error);
- private static unsafe readonly NativeDelegate<StatementNew> s_statementNew = new NativeDelegate<StatementNew>(NewStatement);
- private static IntPtr StatementNewPtr => s_statementNew.Pointer;
- internal unsafe delegate AdbcStatusCode StatementFn(CAdbcStatement* statement, CAdbcError* error);
- private static unsafe readonly NativeDelegate<StatementFn> s_statementRelease = new NativeDelegate<StatementFn>(ReleaseStatement);
- private static IntPtr StatementReleasePtr => s_statementRelease.Pointer;
- private static unsafe readonly NativeDelegate<StatementFn> s_statementPrepare = new NativeDelegate<StatementFn>(PrepareStatement);
- private static IntPtr StatementPreparePtr => s_statementPrepare.Pointer;
- internal unsafe delegate AdbcStatusCode StatementSetSqlQuery(CAdbcStatement* statement, byte* text, CAdbcError* error);
- private static unsafe readonly NativeDelegate<StatementSetSqlQuery> s_statementSetSqlQuery = new NativeDelegate<StatementSetSqlQuery>(SetStatementSqlQuery);
- private static IntPtr StatementSetSqlQueryPtr = s_statementSetSqlQuery.Pointer;
- internal unsafe delegate AdbcStatusCode StatementSetSubstraitPlan(CAdbcStatement* statement, byte* plan, int length, CAdbcError* error);
- private static unsafe readonly NativeDelegate<StatementSetSubstraitPlan> s_statementSetSubstraitPlan = new NativeDelegate<StatementSetSubstraitPlan>(SetStatementSubstraitPlan);
- private static IntPtr StatementSetSubstraitPlanPtr = s_statementSetSubstraitPlan.Pointer;
- internal unsafe delegate AdbcStatusCode StatementGetParameterSchema(CAdbcStatement* statement, CArrowSchema* schema, CAdbcError* error);
- private static unsafe readonly NativeDelegate<StatementGetParameterSchema> s_statementGetParameterSchema = new NativeDelegate<StatementGetParameterSchema>(GetStatementParameterSchema);
- private static IntPtr StatementGetParameterSchemaPtr = s_statementGetParameterSchema.Pointer;
+ private static unsafe IntPtr ReleaseErrorPtr => s_releaseError.Pointer;
+ private static unsafe IntPtr ReleaseDriverPtr = NativeDelegate<DriverRelease>.AsNativePointer(ReleaseDriver);
+ private static unsafe IntPtr ReleasePartitionsPtr = NativeDelegate<PartitionsRelease>.AsNativePointer(ReleasePartitions);
+
+ private static unsafe IntPtr DatabaseInitPtr = NativeDelegate<DatabaseFn>.AsNativePointer(InitDatabase);
+ private static unsafe IntPtr DatabaseReleasePtr = NativeDelegate<DatabaseFn>.AsNativePointer(ReleaseDatabase);
+ private static unsafe IntPtr DatabaseSetOptionPtr = NativeDelegate<DatabaseSetOption>.AsNativePointer(SetDatabaseOption);
+
+ private static unsafe IntPtr ConnectionGetObjectsPtr = NativeDelegate<ConnectionGetObjects>.AsNativePointer(GetConnectionObjects);
+ private static unsafe IntPtr ConnectionGetTableSchemaPtr = NativeDelegate<ConnectionGetTableSchema>.AsNativePointer(GetConnectionTableSchema);
+ private static unsafe IntPtr ConnectionGetTableTypesPtr = NativeDelegate<ConnectionGetTableTypes>.AsNativePointer(GetConnectionTableTypes);
+ private static unsafe IntPtr ConnectionInitPtr = NativeDelegate<ConnectionInit>.AsNativePointer(InitConnection);
+ private static unsafe IntPtr ConnectionRollbackPtr = NativeDelegate<ConnectionFn>.AsNativePointer(RollbackConnection);
+ private static unsafe IntPtr ConnectionCommitPtr = NativeDelegate<ConnectionFn>.AsNativePointer(CommitConnection);
+ private static unsafe IntPtr ConnectionReleasePtr = NativeDelegate<ConnectionFn>.AsNativePointer(ReleaseConnection);
+ private static unsafe IntPtr ConnectionGetInfoPtr = NativeDelegate<ConnectionGetInfo>.AsNativePointer(GetConnectionInfo);
+ private static unsafe IntPtr ConnectionReadPartitionPtr = NativeDelegate<ConnectionReadPartition>.AsNativePointer(ReadConnectionPartition);
+ private static unsafe IntPtr ConnectionSetOptionPtr = NativeDelegate<ConnectionSetOption>.AsNativePointer(SetConnectionOption);
+
+ private static unsafe IntPtr StatementBindPtr = NativeDelegate<StatementBind>.AsNativePointer(BindStatement);
+ private static unsafe IntPtr StatementBindStreamPtr = NativeDelegate<StatementBindStream>.AsNativePointer(BindStreamStatement);
+ private static unsafe IntPtr StatementExecuteQueryPtr = NativeDelegate<StatementExecuteQuery>.AsNativePointer(ExecuteStatementQuery);
+ private static unsafe IntPtr StatementExecutePartitionsPtr = NativeDelegate<StatementExecutePartitions>.AsNativePointer(ExecuteStatementPartitions);
+ private static unsafe IntPtr StatementNewPtr = NativeDelegate<StatementNew>.AsNativePointer(NewStatement);
+ private static unsafe IntPtr StatementReleasePtr = NativeDelegate<StatementFn>.AsNativePointer(ReleaseStatement);
+ private static unsafe IntPtr StatementPreparePtr = NativeDelegate<StatementFn>.AsNativePointer(PrepareStatement);
+ private static unsafe IntPtr StatementSetSqlQueryPtr = NativeDelegate<StatementSetSqlQuery>.AsNativePointer(SetStatementSqlQuery);
+ private static unsafe IntPtr StatementSetSubstraitPlanPtr = NativeDelegate<StatementSetSubstraitPlan>.AsNativePointer(SetStatementSubstraitPlan);
+ private static unsafe IntPtr StatementGetParameterSchemaPtr = NativeDelegate<StatementGetParameterSchema>.AsNativePointer(GetStatementParameterSchema);
#endif
public unsafe static AdbcStatusCode AdbcDriverInit(int version, CAdbcDriver* nativeDriver, CAdbcError* error, AdbcDriver driver)
diff --git a/csharp/src/Apache.Arrow.Adbc/C/CAdbcDriverImporter.cs b/csharp/src/Apache.Arrow.Adbc/C/CAdbcDriverImporter.cs
index a76d150ec..c8a61cf44 100644
--- a/csharp/src/Apache.Arrow.Adbc/C/CAdbcDriverImporter.cs
+++ b/csharp/src/Apache.Arrow.Adbc/C/CAdbcDriverImporter.cs
@@ -20,6 +20,7 @@ using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
+using System.Threading;
using Apache.Arrow.Adbc.Extensions;
using Apache.Arrow.C;
using Apache.Arrow.Ipc;
@@ -88,15 +89,55 @@ namespace Apache.Arrow.Adbc.C
/// <summary>
/// Native implementation of <see cref="AdbcDriver"/>
/// </summary>
- sealed class ImportedAdbcDriver : AdbcDriver
+ internal sealed class ImportedAdbcDriver : AdbcDriver
{
private IntPtr _library;
private CAdbcDriver _nativeDriver;
+ private int _references;
+ private bool _disposed;
public ImportedAdbcDriver(IntPtr library, CAdbcDriver nativeDriver)
{
_library = library;
_nativeDriver = nativeDriver;
+ _references = 1;
+ }
+
+ ~ImportedAdbcDriver()
+ {
+ Dispose(false);
+ }
+
+ internal unsafe ref CAdbcDriver Driver
+ {
+ get
+ {
+ if (_disposed) { throw new ObjectDisposedException(nameof(ImportedAdbcDriver)); }
+ return ref _nativeDriver;
+ }
+ }
+
+ internal ImportedAdbcDriver AddReference()
+ {
+ Interlocked.Increment(ref _references);
+ return this;
+ }
+
+ internal unsafe void RemoveReference()
+ {
+ if (Interlocked.Decrement(ref _references) == 0)
+ {
+ if (_nativeDriver.release != default)
+ {
+ using (CallHelper caller = new CallHelper())
+ {
+ caller.Call(_nativeDriver.release, ref _nativeDriver);
+ }
+
+ NativeLibrary.Free(_library);
+ _library = IntPtr.Zero;
+ }
+ }
}
/// <summary>
@@ -113,39 +154,35 @@ namespace Apache.Arrow.Adbc.C
using (CallHelper caller = new CallHelper())
{
- caller.Call(_nativeDriver.DatabaseNew, ref nativeDatabase);
+ caller.Call(Driver.DatabaseNew, ref nativeDatabase);
foreach (KeyValuePair<string, string> pair in parameters)
{
- caller.Call(_nativeDriver.DatabaseSetOption, ref nativeDatabase, pair.Key, pair.Value);
+ caller.Call(Driver.DatabaseSetOption, ref nativeDatabase, pair.Key, pair.Value);
}
- caller.Call(_nativeDriver.DatabaseInit, ref nativeDatabase);
+ caller.Call(Driver.DatabaseInit, ref nativeDatabase);
}
- return new AdbcDatabaseNative(_nativeDriver, nativeDatabase);
+ return new ImportedAdbcDatabase(this, nativeDatabase);
}
public unsafe override void Dispose()
{
- if (_nativeDriver.release != default)
+ Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ private void Dispose(bool disposing)
+ {
+ if (!_disposed)
{
- using (CallHelper caller = new CallHelper())
+ _disposed = true;
+ RemoveReference();
+ if (disposing)
{
- try
- {
- caller.Call(_nativeDriver.release, ref _nativeDriver);
- }
- finally
- {
- _nativeDriver.release = default;
- }
+ base.Dispose();
}
-
- NativeLibrary.Free(_library);
- _library = IntPtr.Zero;
-
- base.Dispose();
}
}
}
@@ -153,62 +190,121 @@ namespace Apache.Arrow.Adbc.C
/// <summary>
/// A native implementation of <see cref="AdbcDatabase"/>
/// </summary>
- internal sealed class AdbcDatabaseNative : AdbcDatabase
+ internal sealed class ImportedAdbcDatabase : AdbcDatabase
{
- private CAdbcDriver _nativeDriver;
+ private readonly ImportedAdbcDriver _driver;
private CAdbcDatabase _nativeDatabase;
+ private bool _disposed;
- public AdbcDatabaseNative(CAdbcDriver nativeDriver, CAdbcDatabase nativeDatabase)
+ internal ImportedAdbcDatabase(ImportedAdbcDriver driver, CAdbcDatabase nativeDatabase)
{
- _nativeDriver = nativeDriver;
+ _driver = driver.AddReference();
_nativeDatabase = nativeDatabase;
}
+ ~ImportedAdbcDatabase()
+ {
+ Dispose(false);
+ }
+
+ private unsafe ref CAdbcDriver Driver
+ {
+ get
+ {
+ if (_disposed) { throw new ObjectDisposedException(nameof(ImportedAdbcDatabase)); }
+ return ref _driver.Driver;
+ }
+ }
+
public unsafe override AdbcConnection Connect(IReadOnlyDictionary<string, string>? options)
{
CAdbcConnection nativeConnection = new CAdbcConnection();
using (CallHelper caller = new CallHelper())
{
- caller.Call(_nativeDriver.ConnectionNew, ref nativeConnection);
+ caller.Call(Driver.ConnectionNew, ref nativeConnection);
if (options != null)
{
foreach (KeyValuePair<string, string> pair in options)
{
- caller.Call(_nativeDriver.ConnectionSetOption, ref nativeConnection, pair.Key, pair.Value);
+ caller.Call(Driver.ConnectionSetOption, ref nativeConnection, pair.Key, pair.Value);
}
}
- caller.Call(_nativeDriver.ConnectionInit, ref nativeConnection, ref _nativeDatabase);
+ caller.Call(Driver.ConnectionInit, ref nativeConnection, ref _nativeDatabase);
}
- return new AdbcConnectionNative(_nativeDriver, nativeConnection);
+ return new ImportedAdbcConnection(_driver, nativeConnection);
}
public override void Dispose()
{
- base.Dispose();
+ Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ private unsafe void Dispose(bool disposing)
+ {
+ if (!_disposed)
+ {
+ _disposed = true;
+
+ try
+ {
+ if (_nativeDatabase.private_data != default)
+ {
+ using (CallHelper caller = new CallHelper())
+ {
+ caller.Call(_driver.Driver.DatabaseRelease, ref _nativeDatabase);
+ }
+ }
+ }
+ finally
+ {
+ _nativeDatabase.private_data = default;
+ _driver.RemoveReference();
+ }
+ if (disposing)
+ {
+ base.Dispose();
+ }
+ }
}
}
/// <summary>
/// A native implementation of <see cref="AdbcConnection"/>
/// </summary>
- internal sealed class AdbcConnectionNative : AdbcConnection
+ internal sealed class ImportedAdbcConnection : AdbcConnection
{
- private CAdbcDriver _nativeDriver;
+ private readonly ImportedAdbcDriver _driver;
private CAdbcConnection _nativeConnection;
+ private bool _disposed;
private bool? _autoCommit;
private IsolationLevel? _isolationLevel;
private bool? _readOnly;
- public AdbcConnectionNative(CAdbcDriver nativeDriver, CAdbcConnection nativeConnection)
+ internal ImportedAdbcConnection(ImportedAdbcDriver driver, CAdbcConnection nativeConnection)
{
- _nativeDriver = nativeDriver;
+ _driver = driver.AddReference();
_nativeConnection = nativeConnection;
}
+ ~ImportedAdbcConnection()
+ {
+ Dispose(false);
+ }
+
+ private unsafe ref CAdbcDriver Driver
+ {
+ get
+ {
+ if (_disposed) { throw new ObjectDisposedException(nameof(ImportedAdbcConnection)); }
+ return ref _driver.Driver;
+ }
+ }
+
public override bool AutoCommit
{
get => _autoCommit ?? throw AdbcException.NotImplemented("no value has been set for AutoCommit");
@@ -249,15 +345,15 @@ namespace Apache.Arrow.Adbc.C
{
caller.TranslateCode(
#if NET5_0_OR_GREATER
- _nativeDriver.StatementNew
+ Driver.StatementNew
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.StatementNew>(_nativeDriver.StatementNew)
+ Marshal.GetDelegateForFunctionPointer<StatementNew>(Driver.StatementNew)
#endif
(connection, &nativeStatement, &caller._error));
}
}
- return new AdbcStatementNative(_nativeDriver, nativeStatement);
+ return new ImportedAdbcStatement(_driver, nativeStatement);
}
public unsafe override IArrowArrayStream GetInfo(IReadOnlyList<AdbcInfoCode> codes)
@@ -270,9 +366,9 @@ namespace Apache.Arrow.Adbc.C
{
caller.TranslateCode(
#if NET5_0_OR_GREATER
- _nativeDriver.ConnectionGetInfo
+ Driver.ConnectionGetInfo
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.ConnectionGetInfo>(_nativeDriver.ConnectionGetInfo)
+ Marshal.GetDelegateForFunctionPointer<ConnectionGetInfo>(Driver.ConnectionGetInfo)
#endif
(connection, (int*)spanPtr, codes.Count, caller.CreateStream(), &caller._error));
return caller.ImportStream();
@@ -306,9 +402,9 @@ namespace Apache.Arrow.Adbc.C
{
caller.TranslateCode(
#if NET5_0_OR_GREATER
- _nativeDriver.ConnectionGetObjects
+ Driver.ConnectionGetObjects
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.ConnectionGetObjects>(_nativeDriver.ConnectionGetObjects)
+ Marshal.GetDelegateForFunctionPointer<ConnectionGetObjects>(Driver.ConnectionGetObjects)
#endif
(connection, (int)depth, utf8Catalog, utf8Schema, utf8Table, utf8TableTypes, utf8Column, caller.CreateStream(), &caller._error));
return caller.ImportStream();
@@ -333,9 +429,9 @@ namespace Apache.Arrow.Adbc.C
{
caller.TranslateCode(
#if NET5_0_OR_GREATER
- _nativeDriver.ConnectionGetTableTypes
+ Driver.ConnectionGetTableTypes
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.ConnectionGetTableTypes>(_nativeDriver.ConnectionGetTableTypes)
+ Marshal.GetDelegateForFunctionPointer<ConnectionGetTableTypes>(Driver.ConnectionGetTableTypes)
#endif
(connection, caller.CreateStream(), &caller._error));
return caller.ImportStream();
@@ -354,9 +450,9 @@ namespace Apache.Arrow.Adbc.C
{
caller.TranslateCode(
#if NET5_0_OR_GREATER
- _nativeDriver.ConnectionGetTableSchema
+ Driver.ConnectionGetTableSchema
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.ConnectionGetTableSchema>(_nativeDriver.ConnectionGetTableSchema)
+ Marshal.GetDelegateForFunctionPointer<ConnectionGetTableSchema>(Driver.ConnectionGetTableSchema)
#endif
(connection, utf8Catalog, utf8Schema, utf8Table, caller.CreateSchema(), &caller._error));
return caller.ImportSchema();
@@ -368,7 +464,7 @@ namespace Apache.Arrow.Adbc.C
{
using (CallHelper caller = new CallHelper())
{
- caller.Call(_nativeDriver.ConnectionCommit, ref _nativeConnection);
+ caller.Call(Driver.ConnectionCommit, ref _nativeConnection);
}
}
@@ -376,7 +472,7 @@ namespace Apache.Arrow.Adbc.C
{
using (CallHelper caller = new CallHelper())
{
- caller.Call(_nativeDriver.ConnectionRollback, ref _nativeConnection);
+ caller.Call(Driver.ConnectionRollback, ref _nativeConnection);
}
}
@@ -384,7 +480,41 @@ namespace Apache.Arrow.Adbc.C
{
using (CallHelper caller = new CallHelper())
{
- caller.Call(_nativeDriver.ConnectionSetOption, ref _nativeConnection, key, value);
+ caller.Call(Driver.ConnectionSetOption, ref _nativeConnection, key, value);
+ }
+ }
+
+ public override void Dispose()
+ {
+ Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ private unsafe void Dispose(bool disposing)
+ {
+ if (!_disposed)
+ {
+ _disposed = true;
+
+ try
+ {
+ if (_nativeConnection.private_data != default)
+ {
+ using (CallHelper caller = new CallHelper())
+ {
+ caller.Call(_driver.Driver.ConnectionRelease, ref _nativeConnection);
+ }
+ }
+ }
+ finally
+ {
+ _nativeConnection.private_data = default;
+ _driver.RemoveReference();
+ }
+ if (disposing)
+ {
+ base.Dispose();
+ }
}
}
}
@@ -392,18 +522,33 @@ namespace Apache.Arrow.Adbc.C
/// <summary>
/// A native implementation of <see cref="AdbcStatement"/>
/// </summary>
- sealed class AdbcStatementNative : AdbcStatement
+ internal sealed class ImportedAdbcStatement : AdbcStatement
{
- private CAdbcDriver _nativeDriver;
+ private ImportedAdbcDriver _driver;
private CAdbcStatement _nativeStatement;
private byte[]? _substraitPlan;
+ private bool _disposed;
- public AdbcStatementNative(CAdbcDriver nativeDriver, CAdbcStatement nativeStatement)
+ internal ImportedAdbcStatement(ImportedAdbcDriver driver, CAdbcStatement nativeStatement)
{
- _nativeDriver = nativeDriver;
+ _driver = driver.AddReference();
_nativeStatement = nativeStatement;
}
+ ~ImportedAdbcStatement()
+ {
+ Dispose(false);
+ }
+
+ private unsafe ref CAdbcDriver Driver
+ {
+ get
+ {
+ if (_disposed) { throw new ObjectDisposedException(nameof(ImportedAdbcStatement)); }
+ return ref _driver.Driver;
+ }
+ }
+
public unsafe override byte[]? SubstraitPlan
{
get => _substraitPlan;
@@ -416,9 +561,9 @@ namespace Apache.Arrow.Adbc.C
{
caller.TranslateCode(
#if NET5_0_OR_GREATER
- _nativeDriver.StatementSetSubstraitPlan
+ Driver.StatementSetSubstraitPlan
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.StatementSetSubstraitPlan>(_nativeDriver.StatementSetSubstraitPlan)
+ Marshal.GetDelegateForFunctionPointer<StatementSetSubstraitPlan>(Driver.StatementSetSubstraitPlan)
#endif
(statement, substraitPlan, value?.Length ?? 0, &caller._error));
}
@@ -438,9 +583,9 @@ namespace Apache.Arrow.Adbc.C
caller.TranslateCode(
#if NET5_0_OR_GREATER
- _nativeDriver.StatementBind
+ Driver.StatementBind
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.StatementBind>(_nativeDriver.StatementBind)
+ Marshal.GetDelegateForFunctionPointer<StatementBind>(Driver.StatementBind)
#endif
(statement, caller.Array, caller.Schema, &caller._error));
@@ -460,9 +605,9 @@ namespace Apache.Arrow.Adbc.C
CArrowArrayStreamExporter.ExportArrayStream(stream, caller.CreateStream());
caller.TranslateCode(
#if NET5_0_OR_GREATER
- _nativeDriver.StatementBindStream
+ Driver.StatementBindStream
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.StatementBindStream>(_nativeDriver.StatementBindStream)
+ Marshal.GetDelegateForFunctionPointer<StatementBindStream>(Driver.StatementBindStream)
#endif
(statement, caller.ArrayStream, &caller._error));
@@ -487,9 +632,9 @@ namespace Apache.Arrow.Adbc.C
long rows = 0;
caller.TranslateCode(
#if NET5_0_OR_GREATER
- _nativeDriver.StatementExecuteQuery
+ Driver.StatementExecuteQuery
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.StatementExecuteQuery>(_nativeDriver.StatementExecuteQuery)
+ Marshal.GetDelegateForFunctionPointer<StatementExecuteQuery>(Driver.StatementExecuteQuery)
#endif
(statement, caller.CreateStream(), &rows, &caller._error));
@@ -513,9 +658,9 @@ namespace Apache.Arrow.Adbc.C
long rows = 0;
caller.TranslateCode(
#if NET5_0_OR_GREATER
- _nativeDriver.StatementExecuteQuery
+ Driver.StatementExecuteQuery
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.StatementExecuteQuery>(_nativeDriver.StatementExecuteQuery)
+ Marshal.GetDelegateForFunctionPointer<StatementExecuteQuery>(Driver.StatementExecuteQuery)
#endif
(statement, caller.CreateStream(), &rows, &caller._error));
@@ -543,9 +688,9 @@ namespace Apache.Arrow.Adbc.C
nativePartitions = (CAdbcPartitions*)Marshal.AllocHGlobal(sizeof(CAdbcPartitions));
caller.TranslateCode(
#if NET5_0_OR_GREATER
- _nativeDriver.StatementExecutePartitions
+ Driver.StatementExecutePartitions
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.StatementExecutePartitions>(_nativeDriver.StatementExecutePartitions)
+ Marshal.GetDelegateForFunctionPointer<StatementExecutePartitions>(Driver.StatementExecutePartitions)
#endif
(statement, caller.CreateSchema(), nativePartitions, &rowsAffected, &caller._error));
@@ -564,7 +709,7 @@ namespace Apache.Arrow.Adbc.C
#if NET5_0_OR_GREATER
nativePartitions->release(nativePartitions);
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.PartitionsRelease>(nativePartitions->release)(nativePartitions);
+ Marshal.GetDelegateForFunctionPointer<PartitionsRelease>(nativePartitions->release)(nativePartitions);
#endif
}
@@ -577,6 +722,40 @@ namespace Apache.Arrow.Adbc.C
}
}
+ public override void Dispose()
+ {
+ Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ private unsafe void Dispose(bool disposing)
+ {
+ if (!_disposed)
+ {
+ _disposed = true;
+
+ try
+ {
+ if (_nativeStatement.private_data != default)
+ {
+ using (CallHelper caller = new CallHelper())
+ {
+ caller.Call(_driver.Driver.StatementRelease, ref _nativeStatement);
+ }
+ }
+ }
+ finally
+ {
+ _nativeStatement.private_data = default;
+ _driver.RemoveReference();
+ }
+ if (disposing)
+ {
+ base.Dispose();
+ }
+ }
+ }
+
private unsafe void SetSqlQuery(string sqlQuery)
{
fixed (CAdbcStatement* statement = &_nativeStatement)
@@ -586,9 +765,9 @@ namespace Apache.Arrow.Adbc.C
{
caller.TranslateCode(
#if NET5_0_OR_GREATER
- _nativeDriver.StatementSetSqlQuery
+ _driver.Driver.StatementSetSqlQuery
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.StatementSetSqlQuery>(_nativeDriver.StatementSetSqlQuery)
+ Marshal.GetDelegateForFunctionPointer<StatementSetSqlQuery>(_driver.Driver.StatementSetSqlQuery)
#endif
(statement, query, &caller._error));
}
@@ -710,7 +889,7 @@ namespace Apache.Arrow.Adbc.C
fixed (CAdbcDriver* driver = &nativeDriver)
fixed (CAdbcError* e = &_error)
{
- TranslateCode(Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.DriverRelease>(fn)(driver, e));
+ TranslateCode(Marshal.GetDelegateForFunctionPointer<DriverRelease>(fn)(driver, e));
}
}
#endif
@@ -730,7 +909,7 @@ namespace Apache.Arrow.Adbc.C
fixed (CAdbcDatabase* db = &nativeDatabase)
fixed (CAdbcError* e = &_error)
{
- TranslateCode(Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.DatabaseFn>(fn)(db, e));
+ TranslateCode(Marshal.GetDelegateForFunctionPointer<DatabaseFn>(fn)(db, e));
}
}
#endif
@@ -757,7 +936,7 @@ namespace Apache.Arrow.Adbc.C
using (Utf8Helper utf8Key = new Utf8Helper(key))
using (Utf8Helper utf8Value = new Utf8Helper(value))
{
- TranslateCode(Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.DatabaseSetOption>(fn)(db, utf8Key, utf8Value, e));
+ TranslateCode(Marshal.GetDelegateForFunctionPointer<DatabaseSetOption>(fn)(db, utf8Key, utf8Value, e));
}
}
}
@@ -778,7 +957,27 @@ namespace Apache.Arrow.Adbc.C
fixed (CAdbcConnection* cn = &nativeConnection)
fixed (CAdbcError* e = &_error)
{
- TranslateCode(Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.ConnectionFn>(fn)(cn, e));
+ TranslateCode(Marshal.GetDelegateForFunctionPointer<ConnectionFn>(fn)(cn, e));
+ }
+ }
+#endif
+
+#if NET5_0_OR_GREATER
+ public unsafe void Call(delegate* unmanaged<CAdbcStatement*, CAdbcError*, AdbcStatusCode> fn, ref CAdbcStatement nativeStatement)
+ {
+ fixed (CAdbcStatement* stmt = &nativeStatement)
+ fixed (CAdbcError* e = &_error)
+ {
+ TranslateCode(fn(stmt, e));
+ }
+ }
+#else
+ public unsafe void Call(IntPtr fn, ref CAdbcStatement nativeStatement)
+ {
+ fixed (CAdbcStatement* stmt = &nativeStatement)
+ fixed (CAdbcError* e = &_error)
+ {
+ TranslateCode(Marshal.GetDelegateForFunctionPointer<StatementFn>(fn)(stmt, e));
}
}
#endif
@@ -805,7 +1004,7 @@ namespace Apache.Arrow.Adbc.C
using (Utf8Helper utf8Key = new Utf8Helper(key))
using (Utf8Helper utf8Value = new Utf8Helper(value))
{
- TranslateCode(Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.ConnectionSetOption>(fn)(cn, utf8Key, utf8Value, e));
+ TranslateCode(Marshal.GetDelegateForFunctionPointer<ConnectionSetOption>(fn)(cn, utf8Key, utf8Value, e));
}
}
}
@@ -828,7 +1027,7 @@ namespace Apache.Arrow.Adbc.C
fixed (CAdbcDatabase* db = &database)
fixed (CAdbcError* e = &_error)
{
- TranslateCode(Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.ConnectionInit>(fn)(cn, db, e));
+ TranslateCode(Marshal.GetDelegateForFunctionPointer<ConnectionInit>(fn)(cn, db, e));
}
}
#endif
@@ -842,7 +1041,7 @@ namespace Apache.Arrow.Adbc.C
#if NET5_0_OR_GREATER
_error.release(err);
#else
- Marshal.GetDelegateForFunctionPointer<CAdbcDriverExporter.ErrorRelease>(err->release)(err);
+ Marshal.GetDelegateForFunctionPointer<ErrorRelease>(err->release)(err);
#endif
_error.release = default;
}
diff --git a/csharp/src/Apache.Arrow.Adbc/C/Delegates.cs b/csharp/src/Apache.Arrow.Adbc/C/Delegates.cs
new file mode 100644
index 000000000..482580159
--- /dev/null
+++ b/csharp/src/Apache.Arrow.Adbc/C/Delegates.cs
@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+
+using Apache.Arrow.C;
+
+namespace Apache.Arrow.Adbc.C
+{
+ internal unsafe delegate void ErrorRelease(CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode DatabaseFn(CAdbcDatabase* database, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode ConnectionFn(CAdbcConnection* connection, CAdbcError* error);
+
+#if !NET5_0_OR_GREATER
+ internal unsafe delegate AdbcStatusCode DriverRelease(CAdbcDriver* driver, CAdbcError* error);
+ internal unsafe delegate void PartitionsRelease(CAdbcPartitions* partitions);
+ internal unsafe delegate AdbcStatusCode DatabaseSetOption(CAdbcDatabase* database, byte* name, byte* value, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode ConnectionGetObjects(CAdbcConnection* connection, int depth, byte* catalog, byte* db_schema, byte* table_name, byte** table_type, byte* column_name, CArrowArrayStream* stream, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode ConnectionGetTableSchema(CAdbcConnection* connection, byte* catalog, byte* db_schema, byte* table_name, CArrowSchema* schema, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode ConnectionGetTableTypes(CAdbcConnection* connection, CArrowArrayStream* stream, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode ConnectionInit(CAdbcConnection* connection, CAdbcDatabase* database, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode ConnectionGetInfo(CAdbcConnection* connection, int* info_codes, int info_codes_length, CArrowArrayStream* stream, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode ConnectionReadPartition(CAdbcConnection* connection, byte* serialized_partition, int serialized_length, CArrowArrayStream* stream, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode ConnectionSetOption(CAdbcConnection* connection, byte* name, byte* value, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode StatementBind(CAdbcStatement* statement, CArrowArray* array, CArrowSchema* schema, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode StatementBindStream(CAdbcStatement* statement, CArrowArrayStream* stream, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode StatementExecuteQuery(CAdbcStatement* statement, CArrowArrayStream* stream, long* rows, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode StatementExecutePartitions(CAdbcStatement* statement, CArrowSchema* schema, CAdbcPartitions* partitions, long* rows, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode StatementNew(CAdbcConnection* connection, CAdbcStatement* statement, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode StatementFn(CAdbcStatement* statement, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode StatementSetSqlQuery(CAdbcStatement* statement, byte* text, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode StatementSetSubstraitPlan(CAdbcStatement* statement, byte* plan, int length, CAdbcError* error);
+ internal unsafe delegate AdbcStatusCode StatementGetParameterSchema(CAdbcStatement* statement, CArrowSchema* schema, CAdbcError* error);
+#endif
+}
diff --git a/csharp/src/Apache.Arrow.Adbc/C/NativeDelegate.cs b/csharp/src/Apache.Arrow.Adbc/C/NativeDelegate.cs
index 4dcb063d6..5453c21ee 100644
--- a/csharp/src/Apache.Arrow.Adbc/C/NativeDelegate.cs
+++ b/csharp/src/Apache.Arrow.Adbc/C/NativeDelegate.cs
@@ -16,13 +16,16 @@
*/
using System;
+using System.Collections.Generic;
using System.Runtime.InteropServices;
namespace Apache.Arrow.Adbc.C
{
internal readonly struct NativeDelegate<T> where T : Delegate
{
- private readonly T _managedDelegate; // For lifetime management
+ // Lifetime management
+ private static readonly List<Delegate> _managedDelegates = new List<Delegate>();
+ private readonly T _managedDelegate;
public NativeDelegate(T managedDelegate)
{
@@ -30,6 +33,15 @@ namespace Apache.Arrow.Adbc.C
Pointer = Marshal.GetFunctionPointerForDelegate(managedDelegate);
}
+ public static IntPtr AsNativePointer(T managedDelegate)
+ {
+ lock (_managedDelegates)
+ {
+ _managedDelegates.Add(managedDelegate);
+ }
+ return Marshal.GetFunctionPointerForDelegate(managedDelegate);
+ }
+
public IntPtr Pointer { get; }
}
}