diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,4 +1,7 @@ # Changelog +## 0.1.4.2 +- Move deprecated FFI functions to the Deprecated module. + ## 0.1.4.1 - Initial release diff --git a/duckdb-ffi.cabal b/duckdb-ffi.cabal --- a/duckdb-ffi.cabal +++ b/duckdb-ffi.cabal @@ -1,6 +1,6 @@ cabal-version: 3.4 name: duckdb-ffi -version: 1.4.1.1 +version: 1.4.1.2 author: Matthias Pall Gissurarson maintainer: mpg@mpg.is category: Database @@ -49,6 +49,7 @@ src exposed-modules: Database.DuckDB.FFI + Database.DuckDB.FFI.Deprecated other-modules: Database.DuckDB.FFI.AggregateFunctions Database.DuckDB.FFI.Appender @@ -57,6 +58,14 @@ Database.DuckDB.FFI.CastFunctions Database.DuckDB.FFI.Configuration Database.DuckDB.FFI.DataChunk + Database.DuckDB.FFI.Deprecated.Appender + Database.DuckDB.FFI.Deprecated.Arrow + Database.DuckDB.FFI.Deprecated.ExecutePrepared + Database.DuckDB.FFI.Deprecated.PendingResult + Database.DuckDB.FFI.Deprecated.QueryExecution + Database.DuckDB.FFI.Deprecated.ResultFunctions + Database.DuckDB.FFI.Deprecated.SafeFetch + Database.DuckDB.FFI.Deprecated.StreamingResult Database.DuckDB.FFI.ErrorData Database.DuckDB.FFI.ExecutePrepared Database.DuckDB.FFI.Expression @@ -70,7 +79,6 @@ Database.DuckDB.FFI.QueryExecution Database.DuckDB.FFI.ReplacementScans Database.DuckDB.FFI.ResultFunctions - Database.DuckDB.FFI.SafeFetch Database.DuckDB.FFI.ScalarFunctions Database.DuckDB.FFI.SelectionVector Database.DuckDB.FFI.StreamingResult diff --git a/src/Database/DuckDB/FFI.hs b/src/Database/DuckDB/FFI.hs --- a/src/Database/DuckDB/FFI.hs +++ b/src/Database/DuckDB/FFI.hs @@ -13,7 +13,6 @@ module Database.DuckDB.FFI.ErrorData, module Database.DuckDB.FFI.QueryExecution, module Database.DuckDB.FFI.ResultFunctions, - module Database.DuckDB.FFI.SafeFetch, module Database.DuckDB.FFI.Helpers, module Database.DuckDB.FFI.PreparedStatements, module Database.DuckDB.FFI.BindValues, @@ -60,7 +59,6 @@ import Database.DuckDB.FFI.QueryExecution import Database.DuckDB.FFI.ReplacementScans import Database.DuckDB.FFI.ResultFunctions -import Database.DuckDB.FFI.SafeFetch import Database.DuckDB.FFI.ScalarFunctions import Database.DuckDB.FFI.SelectionVector import Database.DuckDB.FFI.StreamingResult diff --git a/src/Database/DuckDB/FFI/Appender.hs b/src/Database/DuckDB/FFI/Appender.hs --- a/src/Database/DuckDB/FFI/Appender.hs +++ b/src/Database/DuckDB/FFI/Appender.hs @@ -4,7 +4,6 @@ c_duckdb_appender_create_query, c_duckdb_appender_column_count, c_duckdb_appender_column_type, - c_duckdb_appender_error, c_duckdb_appender_error_data, c_duckdb_appender_flush, c_duckdb_appender_close, @@ -128,23 +127,6 @@ -} foreign import ccall "duckdb_appender_column_type" c_duckdb_appender_column_type :: DuckDBAppender -> DuckDBIdx -> IO DuckDBLogicalType - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. Use duckdb_appender_error_data instead. - -Returns the error message associated with the appender. If the appender has no -error message, this returns @nullptr@ instead. - -The error message should not be freed. It will be de-allocated when -@duckdb_appender_destroy@ is called. - -Parameters: -* @appender@: The appender to get the error from. - -Returns The error message, or @nullptr@ if there is none. --} -foreign import ccall "duckdb_appender_error" - c_duckdb_appender_error :: DuckDBAppender -> IO CString {- | Returns the error data associated with the appender. Must be destroyed with duckdb_destroy_error_data. diff --git a/src/Database/DuckDB/FFI/Arrow.hs b/src/Database/DuckDB/FFI/Arrow.hs --- a/src/Database/DuckDB/FFI/Arrow.hs +++ b/src/Database/DuckDB/FFI/Arrow.hs @@ -4,32 +4,11 @@ c_duckdb_schema_from_arrow, c_duckdb_data_chunk_from_arrow, c_duckdb_destroy_arrow_converted_schema, - c_duckdb_query_arrow, - c_duckdb_query_arrow_schema, - c_duckdb_prepared_arrow_schema, - c_duckdb_result_arrow_array, - c_duckdb_query_arrow_array, - c_duckdb_arrow_column_count, - c_duckdb_arrow_row_count, - c_duckdb_arrow_rows_changed, - c_duckdb_query_arrow_error, - c_duckdb_destroy_arrow, - c_duckdb_destroy_arrow_stream, - c_duckdb_execute_prepared_arrow, - c_duckdb_arrow_scan, - c_duckdb_arrow_array_scan, - duckdbArrowSchemaInternal, - duckdbArrowSchemaClear, - duckdbArrowArrayInternal, - duckdbArrowArrayClear, - duckdbArrowStreamInternal, - duckdbArrowStreamClear, ) where import Database.DuckDB.FFI.Types import Foreign.C.String (CString) -import Foreign.C.Types (CInt (..)) -import Foreign.Ptr (Ptr, castPtr, nullPtr) +import Foreign.Ptr (Ptr) {- | Transforms a DuckDB Schema into an Arrow Schema @@ -99,297 +78,3 @@ -} foreign import ccall safe "duckdb_destroy_arrow_converted_schema" c_duckdb_destroy_arrow_converted_schema :: Ptr DuckDBArrowConvertedSchema -> IO () - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Executes a SQL query within a connection and stores the full (materialized) -result in an arrow structure. If the query fails to execute, DuckDBError is -returned and the error message can be retrieved by calling -@duckdb_query_arrow_error@. - -Note that after running @duckdb_query_arrow@, @duckdb_destroy_arrow@ must be -called on the result object even if the query fails, otherwise the error -stored within the result will not be freed correctly. - -Parameters: -* @connection@: The connection to perform the query in. -* @query@: The SQL query to run. -* @out_result@: The query result. - -Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. --} -foreign import ccall "duckdb_query_arrow" - c_duckdb_query_arrow :: DuckDBConnection -> CString -> Ptr DuckDBArrow -> IO DuckDBState - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Fetch the internal arrow schema from the arrow result. Remember to call -release on the respective ArrowSchema object. - -Parameters: -* @result@: The result to fetch the schema from. -* @out_schema@: The output schema. - -Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. --} -foreign import ccall safe "duckdb_query_arrow_schema" - c_duckdb_query_arrow_schema :: DuckDBArrow -> Ptr DuckDBArrowSchema -> IO DuckDBState - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Fetch the internal arrow schema from the prepared statement. Remember to call -release on the respective ArrowSchema object. - -Parameters: -* @prepared@: The prepared statement to fetch the schema from. -* @out_schema@: The output schema. - -Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. --} -foreign import ccall safe "duckdb_prepared_arrow_schema" - c_duckdb_prepared_arrow_schema :: DuckDBPreparedStatement -> Ptr DuckDBArrowSchema -> IO DuckDBState - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Convert a data chunk into an arrow struct array. Remember to call release on -the respective ArrowArray object. - -Parameters: -* @result@: The result object the data chunk have been fetched from. -* @chunk@: The data chunk to convert. -* @out_array@: The output array. - -These bindings call the wrapper symbol -@wrapped_duckdb_result_arrow_array@ but mirror the DuckDB C API semantics of -@duckdb_result_arrow_array@. --} -foreign import ccall safe "wrapped_duckdb_result_arrow_array" - c_duckdb_result_arrow_array :: Ptr DuckDBResult -> DuckDBDataChunk -> Ptr DuckDBArrowArray -> IO () - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Fetch an internal arrow struct array from the arrow result. Remember to call -release on the respective ArrowArray object. - -This function can be called multiple time to get next chunks, which will free -the previous out_array. So consume the out_array before calling this function -again. - -Parameters: -* @result@: The result to fetch the array from. -* @out_array@: The output array. - -Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. --} -foreign import ccall "duckdb_query_arrow_array" - c_duckdb_query_arrow_array :: DuckDBArrow -> Ptr DuckDBArrowArray -> IO DuckDBState - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns the number of columns present in the arrow result object. - -Parameters: -* @result@: The result object. - -Returns The number of columns present in the result object. --} -foreign import ccall safe "duckdb_arrow_column_count" - c_duckdb_arrow_column_count :: DuckDBArrow -> IO DuckDBIdx - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns the number of rows present in the arrow result object. - -Parameters: -* @result@: The result object. - -Returns The number of rows present in the result object. --} -foreign import ccall safe "duckdb_arrow_row_count" - c_duckdb_arrow_row_count :: DuckDBArrow -> IO DuckDBIdx - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns the number of rows changed by the query stored in the arrow result. -This is relevant only for INSERT/UPDATE/DELETE queries. For other queries the -rows_changed will be 0. - -Parameters: -* @result@: The result object. - -Returns The number of rows changed. --} -foreign import ccall safe "duckdb_arrow_rows_changed" - c_duckdb_arrow_rows_changed :: DuckDBArrow -> IO DuckDBIdx - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns the error message contained within the result. The error is only set -if @duckdb_query_arrow@ returns @DuckDBError@. - -The error message should not be freed. It will be de-allocated when -@duckdb_destroy_arrow@ is called. - -Parameters: -* @result@: The result object to fetch the error from. - -Returns The error of the result. --} -foreign import ccall safe "duckdb_query_arrow_error" - c_duckdb_query_arrow_error :: DuckDBArrow -> IO CString - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Closes the result and de-allocates all memory allocated for the arrow result. - -Parameters: -* @result@: The result to destroy. --} -foreign import ccall safe "duckdb_destroy_arrow" - c_duckdb_destroy_arrow :: Ptr DuckDBArrow -> IO () - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Releases the arrow array stream and de-allocates its memory. - -Parameters: -* @stream_p@: The arrow array stream to destroy. --} -foreign import ccall safe "duckdb_destroy_arrow_stream" - c_duckdb_destroy_arrow_stream :: Ptr DuckDBArrowStream -> IO () - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Executes the prepared statement with the given bound parameters, and returns -an arrow query result. Note that after running -@duckdb_execute_prepared_arrow@, @duckdb_destroy_arrow@ must be called on the -result object. - -Parameters: -* @prepared_statement@: The prepared statement to execute. -* @out_result@: The query result. - -Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. --} -foreign import ccall "duckdb_execute_prepared_arrow" - c_duckdb_execute_prepared_arrow :: DuckDBPreparedStatement -> Ptr DuckDBArrow -> IO DuckDBState - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Scans the Arrow stream and creates a view with the given name. - -Parameters: -* @connection@: The connection on which to execute the scan. -* @table_name@: Name of the temporary view to create. -* @arrow@: Arrow stream wrapper. - -Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. --} -foreign import ccall "duckdb_arrow_scan" - c_duckdb_arrow_scan :: DuckDBConnection -> CString -> DuckDBArrowStream -> IO DuckDBState - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Scans the Arrow array and creates a view with the given name. Note that after -running @duckdb_arrow_array_scan@, @duckdb_destroy_arrow_stream@ must be -called on the out stream. - -Parameters: -* @connection@: The connection on which to execute the scan. -* @table_name@: Name of the temporary view to create. -* @arrow_schema@: Arrow schema wrapper. -* @arrow_array@: Arrow array wrapper. -* @out_stream@: Output array stream that wraps around the passed schema, for - releasing/deleting once done. - -Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. --} -foreign import ccall "duckdb_arrow_array_scan" - c_duckdb_arrow_array_scan :: DuckDBConnection -> CString -> DuckDBArrowSchema -> DuckDBArrowArray -> Ptr DuckDBArrowStream -> IO DuckDBState - -foreign import ccall safe "wrapped_duckdb_arrow_schema_internal_ptr" - c_duckdb_arrow_schema_internal_ptr :: DuckDBArrowSchema -> IO (Ptr ()) - -foreign import ccall safe "wrapped_duckdb_arrow_schema_clear_internal_ptr" - c_duckdb_arrow_schema_clear_internal_ptr :: DuckDBArrowSchema -> IO () - -foreign import ccall safe "wrapped_duckdb_arrow_array_internal_ptr" - c_duckdb_arrow_array_internal_ptr :: DuckDBArrowArray -> IO (Ptr ()) - -foreign import ccall safe "wrapped_duckdb_arrow_array_clear_internal_ptr" - c_duckdb_arrow_array_clear_internal_ptr :: DuckDBArrowArray -> IO () - -foreign import ccall safe "wrapped_duckdb_arrow_stream_internal_ptr" - c_duckdb_arrow_stream_internal_ptr :: DuckDBArrowStream -> IO (Ptr ()) - -foreign import ccall safe "wrapped_duckdb_arrow_stream_clear_internal_ptr" - c_duckdb_arrow_stream_clear_internal_ptr :: DuckDBArrowStream -> IO () - -{- | Read the @internal_ptr@ field of a deprecated Arrow schema wrapper. -Returns 'Nothing' when the wrapper is null or DuckDB has already cleared the -pointer. --} -duckdbArrowSchemaInternal :: DuckDBArrowSchema -> IO (Maybe ArrowSchemaPtr) -duckdbArrowSchemaInternal schema = do - raw <- c_duckdb_arrow_schema_internal_ptr schema - pure $ - if raw == nullPtr - then Nothing - else Just (ArrowSchemaPtr (castPtr raw)) - -{- | Clear the @internal_ptr@ field on a deprecated Arrow schema wrapper. -Useful after copying the schema to application-managed storage. --} -duckdbArrowSchemaClear :: DuckDBArrowSchema -> IO () -duckdbArrowSchemaClear = c_duckdb_arrow_schema_clear_internal_ptr - -{- | Read the @internal_ptr@ field of a deprecated Arrow array wrapper. -Returns 'Nothing' when the wrapper is null or the internal pointer has been -cleared by DuckDB. --} -duckdbArrowArrayInternal :: DuckDBArrowArray -> IO (Maybe ArrowArrayPtr) -duckdbArrowArrayInternal array = do - raw <- c_duckdb_arrow_array_internal_ptr array - pure $ - if raw == nullPtr - then Nothing - else Just (ArrowArrayPtr (castPtr raw)) - -{- | Clear the @internal_ptr@ field on a deprecated Arrow array wrapper. -After this call DuckDB treats the wrapper as null. --} -duckdbArrowArrayClear :: DuckDBArrowArray -> IO () -duckdbArrowArrayClear = c_duckdb_arrow_array_clear_internal_ptr - -{- | Read the @internal_ptr@ field of a deprecated Arrow stream wrapper. -Returns 'Nothing' when the wrapper is null or the stream has already been -released. --} -duckdbArrowStreamInternal :: DuckDBArrowStream -> IO (Maybe ArrowStreamPtr) -duckdbArrowStreamInternal stream = do - raw <- c_duckdb_arrow_stream_internal_ptr stream - pure $ - if raw == nullPtr - then Nothing - else Just (ArrowStreamPtr raw) - -{- | Clear the @internal_ptr@ field on a deprecated Arrow stream wrapper. -Use this after consuming the stream via @duckdb_arrow_scan@ to avoid stale -pointers on the DuckDB side. --} -duckdbArrowStreamClear :: DuckDBArrowStream -> IO () -duckdbArrowStreamClear = c_duckdb_arrow_stream_clear_internal_ptr diff --git a/src/Database/DuckDB/FFI/Deprecated.hs b/src/Database/DuckDB/FFI/Deprecated.hs new file mode 100644 --- /dev/null +++ b/src/Database/DuckDB/FFI/Deprecated.hs @@ -0,0 +1,27 @@ +{- | +Module : Database.DuckDB.FFI.Deprecated +Description : Re-exports of deprecated DuckDB C API bindings. + +This module gathers bindings that DuckDB has marked with a deprecation notice +so downstream code can opt-in to the legacy surface separately from the main +@Database.DuckDB.FFI@ module. +-} +module Database.DuckDB.FFI.Deprecated ( + module Database.DuckDB.FFI.Deprecated.Appender, + module Database.DuckDB.FFI.Deprecated.Arrow, + module Database.DuckDB.FFI.Deprecated.ExecutePrepared, + module Database.DuckDB.FFI.Deprecated.PendingResult, + module Database.DuckDB.FFI.Deprecated.QueryExecution, + module Database.DuckDB.FFI.Deprecated.ResultFunctions, + module Database.DuckDB.FFI.Deprecated.SafeFetch, + module Database.DuckDB.FFI.Deprecated.StreamingResult, +) where + +import Database.DuckDB.FFI.Deprecated.Appender +import Database.DuckDB.FFI.Deprecated.Arrow +import Database.DuckDB.FFI.Deprecated.ExecutePrepared +import Database.DuckDB.FFI.Deprecated.PendingResult +import Database.DuckDB.FFI.Deprecated.QueryExecution +import Database.DuckDB.FFI.Deprecated.ResultFunctions +import Database.DuckDB.FFI.Deprecated.SafeFetch +import Database.DuckDB.FFI.Deprecated.StreamingResult diff --git a/src/Database/DuckDB/FFI/Deprecated/Appender.hs b/src/Database/DuckDB/FFI/Deprecated/Appender.hs new file mode 100644 --- /dev/null +++ b/src/Database/DuckDB/FFI/Deprecated/Appender.hs @@ -0,0 +1,23 @@ +module Database.DuckDB.FFI.Deprecated.Appender ( + c_duckdb_appender_error, +) where + +import Database.DuckDB.FFI.Types +import Foreign.C.String (CString) + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. Use duckdb_appender_error_data instead. + +Returns the error message associated with the appender. If the appender has no +error message, this returns @nullptr@ instead. + +The error message should not be freed. It will be de-allocated when +@duckdb_appender_destroy@ is called. + +Parameters: +* @appender@: The appender to get the error from. + +Returns The error message, or @nullptr@ if there is none. +-} +foreign import ccall "duckdb_appender_error" + c_duckdb_appender_error :: DuckDBAppender -> IO CString diff --git a/src/Database/DuckDB/FFI/Deprecated/Arrow.hs b/src/Database/DuckDB/FFI/Deprecated/Arrow.hs new file mode 100644 --- /dev/null +++ b/src/Database/DuckDB/FFI/Deprecated/Arrow.hs @@ -0,0 +1,321 @@ +module Database.DuckDB.FFI.Deprecated.Arrow ( + c_duckdb_query_arrow, + c_duckdb_query_arrow_schema, + c_duckdb_prepared_arrow_schema, + c_duckdb_result_arrow_array, + c_duckdb_query_arrow_array, + c_duckdb_arrow_column_count, + c_duckdb_arrow_row_count, + c_duckdb_arrow_rows_changed, + c_duckdb_query_arrow_error, + c_duckdb_destroy_arrow, + c_duckdb_destroy_arrow_stream, + c_duckdb_execute_prepared_arrow, + c_duckdb_arrow_scan, + c_duckdb_arrow_array_scan, + duckdbArrowSchemaInternal, + duckdbArrowSchemaClear, + duckdbArrowArrayInternal, + duckdbArrowArrayClear, + duckdbArrowStreamInternal, + duckdbArrowStreamClear, +) where + +import Database.DuckDB.FFI.Types +import Foreign.C.String (CString) +import Foreign.C.Types (CInt (..)) +import Foreign.Ptr (Ptr, castPtr, nullPtr) + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Executes a SQL query within a connection and stores the full (materialized) +result in an arrow structure. If the query fails to execute, DuckDBError is +returned and the error message can be retrieved by calling +@duckdb_query_arrow_error@. + +Note that after running @duckdb_query_arrow@, @duckdb_destroy_arrow@ must be +called on the result object even if the query fails, otherwise the error +stored within the result will not be freed correctly. + +Parameters: +* @connection@: The connection to perform the query in. +* @query@: The SQL query to run. +* @out_result@: The query result. + +Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. +-} +foreign import ccall "duckdb_query_arrow" + c_duckdb_query_arrow :: DuckDBConnection -> CString -> Ptr DuckDBArrow -> IO DuckDBState + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Fetch the internal arrow schema from the arrow result. Remember to call +release on the respective ArrowSchema object. + +Parameters: +* @result@: The result to fetch the schema from. +* @out_schema@: The output schema. + +Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. +-} +foreign import ccall safe "duckdb_query_arrow_schema" + c_duckdb_query_arrow_schema :: DuckDBArrow -> Ptr DuckDBArrowSchema -> IO DuckDBState + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Fetch the internal arrow schema from the prepared statement. Remember to call +release on the respective ArrowSchema object. + +Parameters: +* @prepared@: The prepared statement to fetch the schema from. +* @out_schema@: The output schema. + +Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. +-} +foreign import ccall safe "duckdb_prepared_arrow_schema" + c_duckdb_prepared_arrow_schema :: DuckDBPreparedStatement -> Ptr DuckDBArrowSchema -> IO DuckDBState + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Convert a data chunk into an arrow struct array. Remember to call release on +the respective ArrowArray object. + +Parameters: +* @result@: The result object the data chunk have been fetched from. +* @chunk@: The data chunk to convert. +* @out_array@: The output array. + +These bindings call the wrapper symbol +@wrapped_duckdb_result_arrow_array@ but mirror the DuckDB C API semantics of +@duckdb_result_arrow_array@. +-} +foreign import ccall safe "wrapped_duckdb_result_arrow_array" + c_duckdb_result_arrow_array :: Ptr DuckDBResult -> DuckDBDataChunk -> Ptr DuckDBArrowArray -> IO () + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Fetch an internal arrow struct array from the arrow result. Remember to call +release on the respective ArrowArray object. + +This function can be called multiple time to get next chunks, which will free +the previous out_array. So consume the out_array before calling this function +again. + +Parameters: +* @result@: The result to fetch the array from. +* @out_array@: The output array. + +Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. +-} +foreign import ccall "duckdb_query_arrow_array" + c_duckdb_query_arrow_array :: DuckDBArrow -> Ptr DuckDBArrowArray -> IO DuckDBState + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns the number of columns present in the arrow result object. + +Parameters: +* @result@: The result object. + +Returns The number of columns present in the result object. +-} +foreign import ccall safe "duckdb_arrow_column_count" + c_duckdb_arrow_column_count :: DuckDBArrow -> IO DuckDBIdx + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns the number of rows present in the arrow result object. + +Parameters: +* @result@: The result object. + +Returns The number of rows present in the result object. +-} +foreign import ccall safe "duckdb_arrow_row_count" + c_duckdb_arrow_row_count :: DuckDBArrow -> IO DuckDBIdx + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns the number of rows changed by the query stored in the arrow result. +This is relevant only for INSERT/UPDATE/DELETE queries. For other queries the +rows_changed will be 0. + +Parameters: +* @result@: The result object. + +Returns The number of rows changed. +-} +foreign import ccall safe "duckdb_arrow_rows_changed" + c_duckdb_arrow_rows_changed :: DuckDBArrow -> IO DuckDBIdx + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns the error message contained within the result. The error is only set +if @duckdb_query_arrow@ returns @DuckDBError@. + +The error message should not be freed. It will be de-allocated when +@duckdb_destroy_arrow@ is called. + +Parameters: +* @result@: The result object to fetch the error from. + +Returns The error of the result. +-} +foreign import ccall safe "duckdb_query_arrow_error" + c_duckdb_query_arrow_error :: DuckDBArrow -> IO CString + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Closes the result and de-allocates all memory allocated for the arrow result. + +Parameters: +* @result@: The result to destroy. +-} +foreign import ccall safe "duckdb_destroy_arrow" + c_duckdb_destroy_arrow :: Ptr DuckDBArrow -> IO () + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Releases the arrow array stream and de-allocates its memory. + +Parameters: +* @stream_p@: The arrow array stream to destroy. +-} +foreign import ccall safe "duckdb_destroy_arrow_stream" + c_duckdb_destroy_arrow_stream :: Ptr DuckDBArrowStream -> IO () + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Executes the prepared statement with the given bound parameters, and returns +an arrow query result. Note that after running +@duckdb_execute_prepared_arrow@, @duckdb_destroy_arrow@ must be called on the +result object. + +Parameters: +* @prepared_statement@: The prepared statement to execute. +* @out_result@: The query result. + +Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. +-} +foreign import ccall "duckdb_execute_prepared_arrow" + c_duckdb_execute_prepared_arrow :: DuckDBPreparedStatement -> Ptr DuckDBArrow -> IO DuckDBState + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Scans the Arrow stream and creates a view with the given name. + +Parameters: +* @connection@: The connection on which to execute the scan. +* @table_name@: Name of the temporary view to create. +* @arrow@: Arrow stream wrapper. + +Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. +-} +foreign import ccall "duckdb_arrow_scan" + c_duckdb_arrow_scan :: DuckDBConnection -> CString -> DuckDBArrowStream -> IO DuckDBState + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Scans the Arrow array and creates a view with the given name. Note that after +running @duckdb_arrow_array_scan@, @duckdb_destroy_arrow_stream@ must be +called on the out stream. + +Parameters: +* @connection@: The connection on which to execute the scan. +* @table_name@: Name of the temporary view to create. +* @arrow_schema@: Arrow schema wrapper. +* @arrow_array@: Arrow array wrapper. +* @out_stream@: Output array stream that wraps around the passed schema, for + releasing/deleting once done. + +Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. +-} +foreign import ccall "duckdb_arrow_array_scan" + c_duckdb_arrow_array_scan :: DuckDBConnection -> CString -> DuckDBArrowSchema -> DuckDBArrowArray -> Ptr DuckDBArrowStream -> IO DuckDBState + +foreign import ccall safe "wrapped_duckdb_arrow_schema_internal_ptr" + c_duckdb_arrow_schema_internal_ptr :: DuckDBArrowSchema -> IO (Ptr ()) + +foreign import ccall safe "wrapped_duckdb_arrow_schema_clear_internal_ptr" + c_duckdb_arrow_schema_clear_internal_ptr :: DuckDBArrowSchema -> IO () + +foreign import ccall safe "wrapped_duckdb_arrow_array_internal_ptr" + c_duckdb_arrow_array_internal_ptr :: DuckDBArrowArray -> IO (Ptr ()) + +foreign import ccall safe "wrapped_duckdb_arrow_array_clear_internal_ptr" + c_duckdb_arrow_array_clear_internal_ptr :: DuckDBArrowArray -> IO () + +foreign import ccall safe "wrapped_duckdb_arrow_stream_internal_ptr" + c_duckdb_arrow_stream_internal_ptr :: DuckDBArrowStream -> IO (Ptr ()) + +foreign import ccall safe "wrapped_duckdb_arrow_stream_clear_internal_ptr" + c_duckdb_arrow_stream_clear_internal_ptr :: DuckDBArrowStream -> IO () + +{- | Read the @internal_ptr@ field of a deprecated Arrow schema wrapper. +Returns 'Nothing' when the wrapper is null or DuckDB has already cleared the +pointer. +-} +duckdbArrowSchemaInternal :: DuckDBArrowSchema -> IO (Maybe ArrowSchemaPtr) +duckdbArrowSchemaInternal schema = do + raw <- c_duckdb_arrow_schema_internal_ptr schema + pure $ + if raw == nullPtr + then Nothing + else Just (ArrowSchemaPtr (castPtr raw)) + +{- | Clear the @internal_ptr@ field on a deprecated Arrow schema wrapper. +Useful after copying the schema to application-managed storage. +-} +duckdbArrowSchemaClear :: DuckDBArrowSchema -> IO () +duckdbArrowSchemaClear = c_duckdb_arrow_schema_clear_internal_ptr + +{- | Read the @internal_ptr@ field of a deprecated Arrow array wrapper. +Returns 'Nothing' when the wrapper is null or the internal pointer has been +cleared by DuckDB. +-} +duckdbArrowArrayInternal :: DuckDBArrowArray -> IO (Maybe ArrowArrayPtr) +duckdbArrowArrayInternal array = do + raw <- c_duckdb_arrow_array_internal_ptr array + pure $ + if raw == nullPtr + then Nothing + else Just (ArrowArrayPtr (castPtr raw)) + +{- | Clear the @internal_ptr@ field on a deprecated Arrow array wrapper. +After this call DuckDB treats the wrapper as null. +-} +duckdbArrowArrayClear :: DuckDBArrowArray -> IO () +duckdbArrowArrayClear = c_duckdb_arrow_array_clear_internal_ptr + +{- | Read the @internal_ptr@ field of a deprecated Arrow stream wrapper. +Returns 'Nothing' when the wrapper is null or the stream has already been +released. +-} +duckdbArrowStreamInternal :: DuckDBArrowStream -> IO (Maybe ArrowStreamPtr) +duckdbArrowStreamInternal stream = do + raw <- c_duckdb_arrow_stream_internal_ptr stream + pure $ + if raw == nullPtr + then Nothing + else Just (ArrowStreamPtr raw) + +{- | Clear the @internal_ptr@ field on a deprecated Arrow stream wrapper. +Use this after consuming the stream via @duckdb_arrow_scan@ to avoid stale +pointers on the DuckDB side. +-} +duckdbArrowStreamClear :: DuckDBArrowStream -> IO () +duckdbArrowStreamClear = c_duckdb_arrow_stream_clear_internal_ptr diff --git a/src/Database/DuckDB/FFI/Deprecated/ExecutePrepared.hs b/src/Database/DuckDB/FFI/Deprecated/ExecutePrepared.hs new file mode 100644 --- /dev/null +++ b/src/Database/DuckDB/FFI/Deprecated/ExecutePrepared.hs @@ -0,0 +1,28 @@ +module Database.DuckDB.FFI.Deprecated.ExecutePrepared ( + c_duckdb_execute_prepared_streaming, +) where + +import Database.DuckDB.FFI.Types +import Foreign.C.Types (CInt (..)) +import Foreign.Ptr (Ptr) + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Executes the prepared statement with the given bound parameters, and returns +an optionally-streaming query result. To determine if the resulting query was +in fact streamed, use @duckdb_result_is_streaming@ + +This method can be called multiple times for each prepared statement, and the +parameters can be modified between calls to this function. + +Note that the result must be freed with @duckdb_destroy_result@. + +Parameters: +* @prepared_statement@: The prepared statement to execute. +* @out_result@: The query result. + +Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. +-} +foreign import ccall "duckdb_execute_prepared_streaming" + c_duckdb_execute_prepared_streaming :: DuckDBPreparedStatement -> Ptr DuckDBResult -> IO DuckDBState diff --git a/src/Database/DuckDB/FFI/Deprecated/PendingResult.hs b/src/Database/DuckDB/FFI/Deprecated/PendingResult.hs new file mode 100644 --- /dev/null +++ b/src/Database/DuckDB/FFI/Deprecated/PendingResult.hs @@ -0,0 +1,28 @@ +module Database.DuckDB.FFI.Deprecated.PendingResult ( + c_duckdb_pending_prepared_streaming, +) where + +import Database.DuckDB.FFI.Types +import Foreign.C.Types (CInt (..)) +import Foreign.Ptr (Ptr) + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Executes the prepared statement with the given bound parameters, and returns a +pending result. This pending result will create a streaming duckdb_result when +executed. The pending result represents an intermediate structure for a query +that is not yet fully executed. + +Note that after calling @duckdb_pending_prepared_streaming@, the pending +result should always be destroyed using @duckdb_destroy_pending@, even if this +function returns DuckDBError. + +Parameters: +* @prepared_statement@: The prepared statement to execute. +* @out_result@: The pending query result. + +Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. +-} +foreign import ccall "duckdb_pending_prepared_streaming" + c_duckdb_pending_prepared_streaming :: DuckDBPreparedStatement -> Ptr DuckDBPendingResult -> IO DuckDBState diff --git a/src/Database/DuckDB/FFI/Deprecated/QueryExecution.hs b/src/Database/DuckDB/FFI/Deprecated/QueryExecution.hs new file mode 100644 --- /dev/null +++ b/src/Database/DuckDB/FFI/Deprecated/QueryExecution.hs @@ -0,0 +1,69 @@ +module Database.DuckDB.FFI.Deprecated.QueryExecution ( + c_duckdb_column_data, + c_duckdb_nullmask_data, + c_duckdb_row_count, +) where + +import Database.DuckDB.FFI.Types +import Foreign.C.Types (CBool (..)) +import Foreign.Ptr (Ptr) + +{- | > Deprecated This method has been deprecated. Prefer using +@duckdb_result_get_chunk@ instead. + +Returns the data of a specific column of a result in columnar format. + +The function returns a dense array which contains the result data. The exact +type stored in the array depends on the corresponding duckdb_type (as provided +by @duckdb_column_type@). For the exact type by which the data should be +accessed, see the comments in [the types section](types) or the @DUCKDB_TYPE@ +enum. + +For example, for a column of type @DUCKDB_TYPE_INTEGER@, rows can be accessed +in the following manner: ``@c int32_t *data = (int32_t *) +duckdb_column_data(&result, 0); printf("Data for row %d: %d\n", row, +data[row]); @`` + +Parameters: +* @result@: The result object to fetch the column data from. +* @col@: The column index. + +Returns The column data of the specified column. +-} +foreign import ccall safe "duckdb_column_data" + c_duckdb_column_data :: Ptr DuckDBResult -> DuckDBIdx -> IO (Ptr ()) + +{- | > Deprecated This method has been deprecated. Prefer using +@duckdb_result_get_chunk@ instead. + +Returns the nullmask of a specific column of a result in columnar format. The +nullmask indicates for every row whether or not the corresponding row is +@NULL@. If a row is @NULL@, the values present in the array provided by +@duckdb_column_data@ are undefined. + +``@c int32_t *data = (int32_t *) duckdb_column_data(&result, 0); bool +*nullmask = duckdb_nullmask_data(&result, 0); if (nullmask[row]) { +printf("Data for row %d: NULL\n", row); } else { printf("Data for row %d: +%d\n", row, data[row]); } @`` + +Parameters: +* @result@: The result object to fetch the nullmask from. +* @col@: The column index. + +Returns The nullmask of the specified column. +-} +foreign import ccall safe "duckdb_nullmask_data" + c_duckdb_nullmask_data :: Ptr DuckDBResult -> DuckDBIdx -> IO (Ptr CBool) + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns the number of rows present in the result object. + +Parameters: +* @result@: The result object. + +Returns The number of rows present in the result object. +-} +foreign import ccall safe "duckdb_row_count" + c_duckdb_row_count :: Ptr DuckDBResult -> IO DuckDBIdx diff --git a/src/Database/DuckDB/FFI/Deprecated/ResultFunctions.hs b/src/Database/DuckDB/FFI/Deprecated/ResultFunctions.hs new file mode 100644 --- /dev/null +++ b/src/Database/DuckDB/FFI/Deprecated/ResultFunctions.hs @@ -0,0 +1,76 @@ +module Database.DuckDB.FFI.Deprecated.ResultFunctions ( + c_duckdb_result_get_chunk, + c_duckdb_result_is_streaming, + c_duckdb_result_chunk_count, +) where + +import Database.DuckDB.FFI.Types +import Foreign.C.Types (CBool (..)) +import Foreign.Ptr (Ptr) + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Fetches a data chunk from the duckdb_result. This function should be called +repeatedly until the result is exhausted. + +The result must be destroyed with @duckdb_destroy_data_chunk@. + +This function supersedes all @duckdb_value@ functions, as well as the +@duckdb_column_data@ and @duckdb_nullmask_data@ functions. It results in +significantly better performance, and should be preferred in newer code-bases. + +If this function is used, none of the other result functions can be used and +vice versa (i.e., this function cannot be mixed with the legacy result +functions). + +Use @duckdb_result_chunk_count@ to figure out how many chunks there are in the +result. + +Parameters: +* @result@: The result object to fetch the data chunk from. +* @chunk_index@: The chunk index to fetch from. + +Returns The resulting data chunk. Returns @NULL@ if the chunk index is out of +bounds. + +These bindings call the wrapper symbol +@wrapped_duckdb_result_get_chunk@ but mirror the DuckDB C API semantics of +@duckdb_result_get_chunk@. +-} +foreign import ccall safe "wrapped_duckdb_result_get_chunk" + c_duckdb_result_get_chunk :: Ptr DuckDBResult -> DuckDBIdx -> IO DuckDBDataChunk + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Checks if the type of the internal result is StreamQueryResult. + +Parameters: +* @result@: The result object to check. + +Returns Whether or not the result object is of the type StreamQueryResult + +These bindings call the wrapper symbol +@wrapped_duckdb_result_is_streaming@ but mirror the DuckDB C API semantics of +@duckdb_result_is_streaming@. +-} +foreign import ccall safe "wrapped_duckdb_result_is_streaming" + c_duckdb_result_is_streaming :: Ptr DuckDBResult -> IO CBool + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns the number of data chunks present in the result. + +Parameters: +* @result@: The result object + +Returns Number of data chunks present in the result. + +These bindings call the wrapper symbol +@wrapped_duckdb_result_chunk_count@ but mirror the DuckDB C API semantics of +@duckdb_result_chunk_count@. +-} +foreign import ccall safe "wrapped_duckdb_result_chunk_count" + c_duckdb_result_chunk_count :: Ptr DuckDBResult -> IO DuckDBIdx diff --git a/src/Database/DuckDB/FFI/Deprecated/SafeFetch.hs b/src/Database/DuckDB/FFI/Deprecated/SafeFetch.hs new file mode 100644 --- /dev/null +++ b/src/Database/DuckDB/FFI/Deprecated/SafeFetch.hs @@ -0,0 +1,280 @@ +module Database.DuckDB.FFI.Deprecated.SafeFetch ( + c_duckdb_value_boolean, + c_duckdb_value_int8, + c_duckdb_value_int16, + c_duckdb_value_int32, + c_duckdb_value_int64, + c_duckdb_value_hugeint, + c_duckdb_value_uhugeint, + c_duckdb_value_decimal, + c_duckdb_value_uint8, + c_duckdb_value_uint16, + c_duckdb_value_uint32, + c_duckdb_value_uint64, + c_duckdb_value_float, + c_duckdb_value_double, + c_duckdb_value_date, + c_duckdb_value_time, + c_duckdb_value_timestamp, + c_duckdb_value_interval, + c_duckdb_value_string, + c_duckdb_value_blob, + c_duckdb_value_is_null, + c_duckdb_value_varchar, + c_duckdb_value_varchar_internal, + c_duckdb_value_string_internal, +) where + +import Data.Int (Int16, Int32, Int64, Int8) +import Data.Word (Word16, Word32, Word64, Word8) +import Database.DuckDB.FFI.Types +import Foreign.C.String (CString) +import Foreign.C.Types (CBool (..), CDouble (..), CFloat (..)) +import Foreign.Ptr (Ptr) + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The boolean value at the specified location, or false if the value +cannot be converted. +-} +foreign import ccall safe "duckdb_value_boolean" + c_duckdb_value_boolean :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO CBool + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The int8_t value at the specified location, or 0 if the value cannot +be converted. +-} +foreign import ccall safe "duckdb_value_int8" + c_duckdb_value_int8 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Int8 + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The int16_t value at the specified location, or 0 if the value cannot +be converted. +-} +foreign import ccall safe "duckdb_value_int16" + c_duckdb_value_int16 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Int16 + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The int32_t value at the specified location, or 0 if the value cannot +be converted. +-} +foreign import ccall safe "duckdb_value_int32" + c_duckdb_value_int32 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Int32 + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The int64_t value at the specified location, or 0 if the value cannot +be converted. +-} +foreign import ccall safe "duckdb_value_int64" + c_duckdb_value_int64 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Int64 + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The duckdb_hugeint value at the specified location, or 0 if the value +cannot be converted. + +These bindings call the wrapper symbol @wrapped_duckdb_value_hugeint@ +but mirror the DuckDB C API semantics of @duckdb_value_hugeint@. +-} +foreign import ccall safe "wrapped_duckdb_value_hugeint" + c_duckdb_value_hugeint :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBHugeInt -> IO () + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The duckdb_uhugeint value at the specified location, or 0 if the value +cannot be converted. + +These bindings call the wrapper symbol @wrapped_duckdb_value_uhugeint@ +but mirror the DuckDB C API semantics of @duckdb_value_uhugeint@. +-} +foreign import ccall safe "wrapped_duckdb_value_uhugeint" + c_duckdb_value_uhugeint :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBUHugeInt -> IO () + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The duckdb_decimal value at the specified location, or 0 if the value +cannot be converted. + +These bindings call the wrapper symbol @wrapped_duckdb_value_decimal@ +but mirror the DuckDB C API semantics of @duckdb_value_decimal@. +-} +foreign import ccall safe "wrapped_duckdb_value_decimal" + c_duckdb_value_decimal :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBDecimal -> IO () + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The uint8_t value at the specified location, or 0 if the value cannot +be converted. +-} +foreign import ccall safe "duckdb_value_uint8" + c_duckdb_value_uint8 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Word8 + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The uint16_t value at the specified location, or 0 if the value cannot +be converted. +-} +foreign import ccall safe "duckdb_value_uint16" + c_duckdb_value_uint16 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Word16 + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The uint32_t value at the specified location, or 0 if the value cannot +be converted. +-} +foreign import ccall safe "duckdb_value_uint32" + c_duckdb_value_uint32 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Word32 + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The uint64_t value at the specified location, or 0 if the value cannot +be converted. +-} +foreign import ccall safe "duckdb_value_uint64" + c_duckdb_value_uint64 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Word64 + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The float value at the specified location, or 0 if the value cannot be +converted. +-} +foreign import ccall safe "duckdb_value_float" + c_duckdb_value_float :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO CFloat + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The double value at the specified location, or 0 if the value cannot +be converted. +-} +foreign import ccall safe "duckdb_value_double" + c_duckdb_value_double :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO CDouble + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The duckdb_date value at the specified location, or 0 if the value +cannot be converted. +-} +foreign import ccall safe "duckdb_value_date" + c_duckdb_value_date :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO DuckDBDate + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The duckdb_time value at the specified location, or 0 if the value +cannot be converted. +-} +foreign import ccall safe "duckdb_value_time" + c_duckdb_value_time :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO DuckDBTime + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The duckdb_timestamp value at the specified location, or 0 if the +value cannot be converted. +-} +foreign import ccall safe "duckdb_value_timestamp" + c_duckdb_value_timestamp :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO DuckDBTimestamp + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The duckdb_interval value at the specified location, or 0 if the value +cannot be converted. + +These bindings call the wrapper symbol @wrapped_duckdb_value_interval@ +but mirror the DuckDB C API semantics of @duckdb_value_interval@. +-} +foreign import ccall safe "wrapped_duckdb_value_interval" + c_duckdb_value_interval :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBInterval -> IO () + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +No support for nested types, and for other complex types. The resulting field +"string.data" must be freed with @duckdb_free.@ + +Returns The string value at the specified location. Attempts to cast the +result value to string. + +These bindings call the wrapper symbol @wrapped_duckdb_value_string@ +but mirror the DuckDB C API semantics of @duckdb_value_string@. +-} +foreign import ccall safe "wrapped_duckdb_value_string" + c_duckdb_value_string :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBString -> IO () + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns The duckdb_blob value at the specified location. Returns a blob with +blob.data set to nullptr if the value cannot be converted. The resulting field +"blob.data" must be freed with @duckdb_free.@ + +These bindings call the wrapper symbol @wrapped_duckdb_value_blob@ but +mirror the DuckDB C API semantics of @duckdb_value_blob@. +-} +foreign import ccall safe "wrapped_duckdb_value_blob" + c_duckdb_value_blob :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBBlob -> IO () + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Returns Returns true if the value at the specified index is NULL, and false +otherwise. +-} +foreign import ccall safe "duckdb_value_is_null" + c_duckdb_value_is_null :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO CBool + +{- | > Deprecated This method has been deprecated. Use duckdb_value_string instead. +This function does not work correctly if the string contains null bytes. + +Returns The text value at the specified location as a null-terminated string, +or nullptr if the value cannot be converted. The result must be freed with +@duckdb_free@. +-} +foreign import ccall safe "duckdb_value_varchar" + c_duckdb_value_varchar :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO CString + +{- | > Deprecated This method has been deprecated. Use duckdb_value_string_internal +instead. This function does not work correctly if the string contains null +bytes. + +Returns The char* value at the specified location. ONLY works on VARCHAR +columns and does not auto-cast. If the column is NOT a VARCHAR column this +function will return NULL. The result must NOT be freed. +-} +foreign import ccall safe "duckdb_value_varchar_internal" + c_duckdb_value_varchar_internal :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO CString + +{- | > Deprecated This method has been deprecated. Use duckdb_value_string_internal +instead. This function does not work correctly if the string contains null +bytes. + +Returns The char* value at the specified location. ONLY works on VARCHAR +columns and does not auto-cast. If the column is NOT a VARCHAR column this +function will return NULL. The result must NOT be freed. + +These bindings call the wrapper symbol +@wrapped_duckdb_value_string_internal@ but mirror the DuckDB C API semantics of +@duckdb_value_string_internal@. +-} +foreign import ccall safe "wrapped_duckdb_value_string_internal" + c_duckdb_value_string_internal :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBString -> IO () diff --git a/src/Database/DuckDB/FFI/Deprecated/StreamingResult.hs b/src/Database/DuckDB/FFI/Deprecated/StreamingResult.hs new file mode 100644 --- /dev/null +++ b/src/Database/DuckDB/FFI/Deprecated/StreamingResult.hs @@ -0,0 +1,35 @@ +module Database.DuckDB.FFI.Deprecated.StreamingResult ( + c_duckdb_stream_fetch_chunk, +) where + +import Database.DuckDB.FFI.Types +import Foreign.Ptr (Ptr) + +{- | > Warning Deprecation notice. This method is scheduled for removal in a future +release. + +Fetches a data chunk from the (streaming) duckdb_result. This function should +be called repeatedly until the result is exhausted. + +The result must be destroyed with @duckdb_destroy_data_chunk@. + +This function can only be used on duckdb_results created with +@duckdb_pending_prepared_streaming@ + +If this function is used, none of the other result functions can be used and +vice versa (i.e., this function cannot be mixed with the legacy result +functions or the materialized result functions). + +It is not known beforehand how many chunks will be returned by this result. + +Parameters: +* @result@: The result object to fetch the data chunk from. + +Returns The resulting data chunk. Returns @NULL@ if the result has an error. + +These bindings call the wrapper symbol +@wrapped_duckdb_stream_fetch_chunk@ but mirror the DuckDB C API semantics of +@duckdb_stream_fetch_chunk@. +-} +foreign import ccall safe "wrapped_duckdb_stream_fetch_chunk" + c_duckdb_stream_fetch_chunk :: Ptr DuckDBResult -> IO DuckDBDataChunk diff --git a/src/Database/DuckDB/FFI/ExecutePrepared.hs b/src/Database/DuckDB/FFI/ExecutePrepared.hs --- a/src/Database/DuckDB/FFI/ExecutePrepared.hs +++ b/src/Database/DuckDB/FFI/ExecutePrepared.hs @@ -1,6 +1,5 @@ module Database.DuckDB.FFI.ExecutePrepared ( c_duckdb_execute_prepared, - c_duckdb_execute_prepared_streaming, ) where import Database.DuckDB.FFI.Types @@ -23,24 +22,3 @@ -} foreign import ccall "duckdb_execute_prepared" c_duckdb_execute_prepared :: DuckDBPreparedStatement -> Ptr DuckDBResult -> IO DuckDBState - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Executes the prepared statement with the given bound parameters, and returns -an optionally-streaming query result. To determine if the resulting query was -in fact streamed, use @duckdb_result_is_streaming@ - -This method can be called multiple times for each prepared statement, and the -parameters can be modified between calls to this function. - -Note that the result must be freed with @duckdb_destroy_result@. - -Parameters: -* @prepared_statement@: The prepared statement to execute. -* @out_result@: The query result. - -Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. --} -foreign import ccall "duckdb_execute_prepared_streaming" - c_duckdb_execute_prepared_streaming :: DuckDBPreparedStatement -> Ptr DuckDBResult -> IO DuckDBState diff --git a/src/Database/DuckDB/FFI/PendingResult.hs b/src/Database/DuckDB/FFI/PendingResult.hs --- a/src/Database/DuckDB/FFI/PendingResult.hs +++ b/src/Database/DuckDB/FFI/PendingResult.hs @@ -1,6 +1,5 @@ module Database.DuckDB.FFI.PendingResult ( c_duckdb_pending_prepared, - c_duckdb_pending_prepared_streaming, c_duckdb_destroy_pending, c_duckdb_pending_error, c_duckdb_pending_execute_task, @@ -31,27 +30,6 @@ -} foreign import ccall "duckdb_pending_prepared" c_duckdb_pending_prepared :: DuckDBPreparedStatement -> Ptr DuckDBPendingResult -> IO DuckDBState - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Executes the prepared statement with the given bound parameters, and returns a -pending result. This pending result will create a streaming duckdb_result when -executed. The pending result represents an intermediate structure for a query -that is not yet fully executed. - -Note that after calling @duckdb_pending_prepared_streaming@, the pending -result should always be destroyed using @duckdb_destroy_pending@, even if this -function returns DuckDBError. - -Parameters: -* @prepared_statement@: The prepared statement to execute. -* @out_result@: The pending query result. - -Returns @DuckDBSuccess@ on success or @DuckDBError@ on failure. --} -foreign import ccall "duckdb_pending_prepared_streaming" - c_duckdb_pending_prepared_streaming :: DuckDBPreparedStatement -> Ptr DuckDBPendingResult -> IO DuckDBState {- | Closes the pending result and de-allocates all memory allocated for the result. diff --git a/src/Database/DuckDB/FFI/QueryExecution.hs b/src/Database/DuckDB/FFI/QueryExecution.hs --- a/src/Database/DuckDB/FFI/QueryExecution.hs +++ b/src/Database/DuckDB/FFI/QueryExecution.hs @@ -7,17 +7,14 @@ c_duckdb_column_logical_type, c_duckdb_result_get_arrow_options, c_duckdb_column_count, - c_duckdb_row_count, c_duckdb_rows_changed, - c_duckdb_column_data, - c_duckdb_nullmask_data, c_duckdb_result_error, c_duckdb_result_error_type, ) where import Database.DuckDB.FFI.Types import Foreign.C.String (CString) -import Foreign.C.Types (CBool (..), CInt (..)) +import Foreign.C.Types (CInt (..)) import Foreign.Ptr (Ptr) {- | Executes a SQL query within a connection and stores the full (materialized) @@ -131,19 +128,6 @@ foreign import ccall safe "duckdb_column_count" c_duckdb_column_count :: Ptr DuckDBResult -> IO DuckDBIdx -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns the number of rows present in the result object. - -Parameters: -* @result@: The result object. - -Returns The number of rows present in the result object. --} -foreign import ccall safe "duckdb_row_count" - c_duckdb_row_count :: Ptr DuckDBResult -> IO DuckDBIdx - {- | Returns the number of rows changed by the query stored in the result. This is relevant only for INSERT/UPDATE/DELETE queries. For other queries the rows_changed will be 0. @@ -155,53 +139,6 @@ -} foreign import ccall safe "duckdb_rows_changed" c_duckdb_rows_changed :: Ptr DuckDBResult -> IO DuckDBIdx - -{- | > Deprecated This method has been deprecated. Prefer using -@duckdb_result_get_chunk@ instead. - -Returns the data of a specific column of a result in columnar format. - -The function returns a dense array which contains the result data. The exact -type stored in the array depends on the corresponding duckdb_type (as provided -by @duckdb_column_type@). For the exact type by which the data should be -accessed, see the comments in [the types section](types) or the @DUCKDB_TYPE@ -enum. - -For example, for a column of type @DUCKDB_TYPE_INTEGER@, rows can be accessed -in the following manner: ``@c int32_t *data = (int32_t *) -duckdb_column_data(&result, 0); printf("Data for row %d: %d\n", row, -data[row]); @`` - -Parameters: -* @result@: The result object to fetch the column data from. -* @col@: The column index. - -Returns The column data of the specified column. --} -foreign import ccall safe "duckdb_column_data" - c_duckdb_column_data :: Ptr DuckDBResult -> DuckDBIdx -> IO (Ptr ()) - -{- | > Deprecated This method has been deprecated. Prefer using -@duckdb_result_get_chunk@ instead. - -Returns the nullmask of a specific column of a result in columnar format. The -nullmask indicates for every row whether or not the corresponding row is -@NULL@. If a row is @NULL@, the values present in the array provided by -@duckdb_column_data@ are undefined. - -``@c int32_t *data = (int32_t *) duckdb_column_data(&result, 0); bool -*nullmask = duckdb_nullmask_data(&result, 0); if (nullmask[row]) { -printf("Data for row %d: NULL\n", row); } else { printf("Data for row %d: -%d\n", row, data[row]); } @`` - -Parameters: -* @result@: The result object to fetch the nullmask from. -* @col@: The column index. - -Returns The nullmask of the specified column. --} -foreign import ccall safe "duckdb_nullmask_data" - c_duckdb_nullmask_data :: Ptr DuckDBResult -> DuckDBIdx -> IO (Ptr CBool) {- | Returns the error message contained within the result. The error is only set if @duckdb_query@ returns @DuckDBError@. diff --git a/src/Database/DuckDB/FFI/ResultFunctions.hs b/src/Database/DuckDB/FFI/ResultFunctions.hs --- a/src/Database/DuckDB/FFI/ResultFunctions.hs +++ b/src/Database/DuckDB/FFI/ResultFunctions.hs @@ -1,80 +1,10 @@ module Database.DuckDB.FFI.ResultFunctions ( - c_duckdb_result_get_chunk, - c_duckdb_result_is_streaming, - c_duckdb_result_chunk_count, c_duckdb_result_return_type, ) where import Database.DuckDB.FFI.Types -import Foreign.C.Types (CBool (..), CInt (..)) +import Foreign.C.Types (CInt (..)) import Foreign.Ptr (Ptr) - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Fetches a data chunk from the duckdb_result. This function should be called -repeatedly until the result is exhausted. - -The result must be destroyed with @duckdb_destroy_data_chunk@. - -This function supersedes all @duckdb_value@ functions, as well as the -@duckdb_column_data@ and @duckdb_nullmask_data@ functions. It results in -significantly better performance, and should be preferred in newer code-bases. - -If this function is used, none of the other result functions can be used and -vice versa (i.e., this function cannot be mixed with the legacy result -functions). - -Use @duckdb_result_chunk_count@ to figure out how many chunks there are in the -result. - -Parameters: -* @result@: The result object to fetch the data chunk from. -* @chunk_index@: The chunk index to fetch from. - -Returns The resulting data chunk. Returns @NULL@ if the chunk index is out of -bounds. - -These bindings call the wrapper symbol -@wrapped_duckdb_result_get_chunk@ but mirror the DuckDB C API semantics of -@duckdb_result_get_chunk@. --} -foreign import ccall safe "wrapped_duckdb_result_get_chunk" - c_duckdb_result_get_chunk :: Ptr DuckDBResult -> DuckDBIdx -> IO DuckDBDataChunk - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Checks if the type of the internal result is StreamQueryResult. - -Parameters: -* @result@: The result object to check. - -Returns Whether or not the result object is of the type StreamQueryResult - -These bindings call the wrapper symbol -@wrapped_duckdb_result_is_streaming@ but mirror the DuckDB C API semantics of -@duckdb_result_is_streaming@. --} -foreign import ccall safe "wrapped_duckdb_result_is_streaming" - c_duckdb_result_is_streaming :: Ptr DuckDBResult -> IO CBool - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns the number of data chunks present in the result. - -Parameters: -* @result@: The result object - -Returns Number of data chunks present in the result. - -These bindings call the wrapper symbol -@wrapped_duckdb_result_chunk_count@ but mirror the DuckDB C API semantics of -@duckdb_result_chunk_count@. --} -foreign import ccall safe "wrapped_duckdb_result_chunk_count" - c_duckdb_result_chunk_count :: Ptr DuckDBResult -> IO DuckDBIdx {- | Returns the return_type of the given result, or DUCKDB_RETURN_TYPE_INVALID on error diff --git a/src/Database/DuckDB/FFI/SafeFetch.hs b/src/Database/DuckDB/FFI/SafeFetch.hs deleted file mode 100644 --- a/src/Database/DuckDB/FFI/SafeFetch.hs +++ /dev/null @@ -1,280 +0,0 @@ -module Database.DuckDB.FFI.SafeFetch ( - c_duckdb_value_boolean, - c_duckdb_value_int8, - c_duckdb_value_int16, - c_duckdb_value_int32, - c_duckdb_value_int64, - c_duckdb_value_hugeint, - c_duckdb_value_uhugeint, - c_duckdb_value_decimal, - c_duckdb_value_uint8, - c_duckdb_value_uint16, - c_duckdb_value_uint32, - c_duckdb_value_uint64, - c_duckdb_value_float, - c_duckdb_value_double, - c_duckdb_value_date, - c_duckdb_value_time, - c_duckdb_value_timestamp, - c_duckdb_value_interval, - c_duckdb_value_varchar, - c_duckdb_value_string, - c_duckdb_value_varchar_internal, - c_duckdb_value_string_internal, - c_duckdb_value_blob, - c_duckdb_value_is_null, -) where - -import Data.Int (Int16, Int32, Int64, Int8) -import Data.Word (Word16, Word32, Word64, Word8) -import Database.DuckDB.FFI.Types -import Foreign.C.String (CString) -import Foreign.C.Types (CBool (..), CDouble (..), CFloat (..)) -import Foreign.Ptr (Ptr) - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The boolean value at the specified location, or false if the value -cannot be converted. --} -foreign import ccall safe "duckdb_value_boolean" - c_duckdb_value_boolean :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO CBool - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The int8_t value at the specified location, or 0 if the value cannot -be converted. --} -foreign import ccall safe "duckdb_value_int8" - c_duckdb_value_int8 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Int8 - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The int16_t value at the specified location, or 0 if the value cannot -be converted. --} -foreign import ccall safe "duckdb_value_int16" - c_duckdb_value_int16 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Int16 - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The int32_t value at the specified location, or 0 if the value cannot -be converted. --} -foreign import ccall safe "duckdb_value_int32" - c_duckdb_value_int32 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Int32 - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The int64_t value at the specified location, or 0 if the value cannot -be converted. --} -foreign import ccall safe "duckdb_value_int64" - c_duckdb_value_int64 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Int64 - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The duckdb_hugeint value at the specified location, or 0 if the value -cannot be converted. - -These bindings call the wrapper symbol @wrapped_duckdb_value_hugeint@ -but mirror the DuckDB C API semantics of @duckdb_value_hugeint@. --} -foreign import ccall safe "wrapped_duckdb_value_hugeint" - c_duckdb_value_hugeint :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBHugeInt -> IO () - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The duckdb_uhugeint value at the specified location, or 0 if the value -cannot be converted. - -These bindings call the wrapper symbol @wrapped_duckdb_value_uhugeint@ -but mirror the DuckDB C API semantics of @duckdb_value_uhugeint@. --} -foreign import ccall safe "wrapped_duckdb_value_uhugeint" - c_duckdb_value_uhugeint :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBUHugeInt -> IO () - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The duckdb_decimal value at the specified location, or 0 if the value -cannot be converted. - -These bindings call the wrapper symbol @wrapped_duckdb_value_decimal@ -but mirror the DuckDB C API semantics of @duckdb_value_decimal@. --} -foreign import ccall safe "wrapped_duckdb_value_decimal" - c_duckdb_value_decimal :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBDecimal -> IO () - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The uint8_t value at the specified location, or 0 if the value cannot -be converted. --} -foreign import ccall safe "duckdb_value_uint8" - c_duckdb_value_uint8 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Word8 - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The uint16_t value at the specified location, or 0 if the value cannot -be converted. --} -foreign import ccall safe "duckdb_value_uint16" - c_duckdb_value_uint16 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Word16 - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The uint32_t value at the specified location, or 0 if the value cannot -be converted. --} -foreign import ccall safe "duckdb_value_uint32" - c_duckdb_value_uint32 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Word32 - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The uint64_t value at the specified location, or 0 if the value cannot -be converted. --} -foreign import ccall safe "duckdb_value_uint64" - c_duckdb_value_uint64 :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO Word64 - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The float value at the specified location, or 0 if the value cannot be -converted. --} -foreign import ccall safe "duckdb_value_float" - c_duckdb_value_float :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO CFloat - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The double value at the specified location, or 0 if the value cannot -be converted. --} -foreign import ccall safe "duckdb_value_double" - c_duckdb_value_double :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO CDouble - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The duckdb_date value at the specified location, or 0 if the value -cannot be converted. --} -foreign import ccall safe "duckdb_value_date" - c_duckdb_value_date :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO DuckDBDate - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The duckdb_time value at the specified location, or 0 if the value -cannot be converted. --} -foreign import ccall safe "duckdb_value_time" - c_duckdb_value_time :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO DuckDBTime - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The duckdb_timestamp value at the specified location, or 0 if the -value cannot be converted. --} -foreign import ccall safe "duckdb_value_timestamp" - c_duckdb_value_timestamp :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO DuckDBTimestamp - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The duckdb_interval value at the specified location, or 0 if the value -cannot be converted. - -These bindings call the wrapper symbol @wrapped_duckdb_value_interval@ -but mirror the DuckDB C API semantics of @duckdb_value_interval@. --} -foreign import ccall safe "wrapped_duckdb_value_interval" - c_duckdb_value_interval :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBInterval -> IO () - -{- | > Deprecated This method has been deprecated. Use duckdb_value_string instead. -This function does not work correctly if the string contains null bytes. - -Returns The text value at the specified location as a null-terminated string, -or nullptr if the value cannot be converted. The result must be freed with -@duckdb_free@. --} -foreign import ccall safe "duckdb_value_varchar" - c_duckdb_value_varchar :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO CString - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -No support for nested types, and for other complex types. The resulting field -"string.data" must be freed with @duckdb_free.@ - -Returns The string value at the specified location. Attempts to cast the -result value to string. - -These bindings call the wrapper symbol @wrapped_duckdb_value_string@ -but mirror the DuckDB C API semantics of @duckdb_value_string@. --} -foreign import ccall safe "wrapped_duckdb_value_string" - c_duckdb_value_string :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBString -> IO () - -{- | > Deprecated This method has been deprecated. Use duckdb_value_string_internal -instead. This function does not work correctly if the string contains null -bytes. - -Returns The char* value at the specified location. ONLY works on VARCHAR -columns and does not auto-cast. If the column is NOT a VARCHAR column this -function will return NULL. The result must NOT be freed. --} -foreign import ccall safe "duckdb_value_varchar_internal" - c_duckdb_value_varchar_internal :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO CString - -{- | > Deprecated This method has been deprecated. Use duckdb_value_string_internal -instead. This function does not work correctly if the string contains null -bytes. - -Returns The char* value at the specified location. ONLY works on VARCHAR -columns and does not auto-cast. If the column is NOT a VARCHAR column this -function will return NULL. The result must NOT be freed. - -These bindings call the wrapper symbol -@wrapped_duckdb_value_string_internal@ but mirror the DuckDB C API semantics of -@duckdb_value_string_internal@. --} -foreign import ccall safe "wrapped_duckdb_value_string_internal" - c_duckdb_value_string_internal :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBString -> IO () - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns The duckdb_blob value at the specified location. Returns a blob with -blob.data set to nullptr if the value cannot be converted. The resulting field -"blob.data" must be freed with @duckdb_free.@ - -These bindings call the wrapper symbol @wrapped_duckdb_value_blob@ but -mirror the DuckDB C API semantics of @duckdb_value_blob@. --} -foreign import ccall safe "wrapped_duckdb_value_blob" - c_duckdb_value_blob :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> Ptr DuckDBBlob -> IO () - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Returns Returns true if the value at the specified index is NULL, and false -otherwise. --} -foreign import ccall safe "duckdb_value_is_null" - c_duckdb_value_is_null :: Ptr DuckDBResult -> DuckDBIdx -> DuckDBIdx -> IO CBool diff --git a/src/Database/DuckDB/FFI/StreamingResult.hs b/src/Database/DuckDB/FFI/StreamingResult.hs --- a/src/Database/DuckDB/FFI/StreamingResult.hs +++ b/src/Database/DuckDB/FFI/StreamingResult.hs @@ -1,39 +1,9 @@ module Database.DuckDB.FFI.StreamingResult ( - c_duckdb_stream_fetch_chunk, c_duckdb_fetch_chunk, ) where import Database.DuckDB.FFI.Types import Foreign.Ptr (Ptr) - -{- | > Warning Deprecation notice. This method is scheduled for removal in a future -release. - -Fetches a data chunk from the (streaming) duckdb_result. This function should -be called repeatedly until the result is exhausted. - -The result must be destroyed with @duckdb_destroy_data_chunk@. - -This function can only be used on duckdb_results created with -@duckdb_pending_prepared_streaming@ - -If this function is used, none of the other result functions can be used and -vice versa (i.e., this function cannot be mixed with the legacy result -functions or the materialized result functions). - -It is not known beforehand how many chunks will be returned by this result. - -Parameters: -* @result@: The result object to fetch the data chunk from. - -Returns The resulting data chunk. Returns @NULL@ if the result has an error. - -These bindings call the wrapper symbol -@wrapped_duckdb_stream_fetch_chunk@ but mirror the DuckDB C API semantics of -@duckdb_stream_fetch_chunk@. --} -foreign import ccall safe "wrapped_duckdb_stream_fetch_chunk" - c_duckdb_stream_fetch_chunk :: Ptr DuckDBResult -> IO DuckDBDataChunk {- | Fetches a data chunk from a duckdb_result. This function should be called repeatedly until the result is exhausted. diff --git a/test/AggregateFunctionsTest.hs b/test/AggregateFunctionsTest.hs --- a/test/AggregateFunctionsTest.hs +++ b/test/AggregateFunctionsTest.hs @@ -10,6 +10,7 @@ import Data.List (isInfixOf) import Data.Word (Word64) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (CString, peekCString, withCString) import Foreign.C.Types (CBool (..)) import Foreign.Marshal.Alloc (alloca, free, mallocBytes) diff --git a/test/AppenderTest.hs b/test/AppenderTest.hs --- a/test/AppenderTest.hs +++ b/test/AppenderTest.hs @@ -9,6 +9,7 @@ import Data.List (isInfixOf) import Data.Word (Word16, Word32, Word64, Word8) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (peekCString, withCString, withCStringLen) import Foreign.C.Types (CBool (..)) import Foreign.Marshal.Alloc (alloca) diff --git a/test/ArrowInterfaceDeprecatedTests.hs b/test/ArrowInterfaceDeprecatedTests.hs --- a/test/ArrowInterfaceDeprecatedTests.hs +++ b/test/ArrowInterfaceDeprecatedTests.hs @@ -9,6 +9,7 @@ import Data.List (isInfixOf) import Data.Maybe (isNothing) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (peekCString, peekCStringLen, withCString) import Foreign.C.Types (CChar) import Foreign.Marshal.Alloc (alloca) diff --git a/test/BindValuesTest.hs b/test/BindValuesTest.hs --- a/test/BindValuesTest.hs +++ b/test/BindValuesTest.hs @@ -8,6 +8,7 @@ import Data.Time.Calendar (diffDays, fromGregorian) import Data.Word (Word16, Word32, Word64, Word8) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (peekCString, peekCStringLen, withCString) import Foreign.C.Types (CBool (..), CDouble (..), CFloat (..)) import Foreign.Marshal.Alloc (alloca) diff --git a/test/CastFunctionsTest.hs b/test/CastFunctionsTest.hs --- a/test/CastFunctionsTest.hs +++ b/test/CastFunctionsTest.hs @@ -10,6 +10,7 @@ import Data.Int (Int32) import Data.List (isInfixOf) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (peekCString, withCString, withCStringLen) import Foreign.C.Types (CBool (..)) import Foreign.Marshal.Alloc (alloca) diff --git a/test/ExecutePreparedStatementsTest.hs b/test/ExecutePreparedStatementsTest.hs --- a/test/ExecutePreparedStatementsTest.hs +++ b/test/ExecutePreparedStatementsTest.hs @@ -4,6 +4,7 @@ import Control.Monad (forM_) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (peekCString, withCString) import Foreign.C.Types (CBool (..)) import Foreign.Marshal.Alloc (alloca) diff --git a/test/ExtractStatementsTest.hs b/test/ExtractStatementsTest.hs --- a/test/ExtractStatementsTest.hs +++ b/test/ExtractStatementsTest.hs @@ -5,6 +5,7 @@ import Control.Monad (forM_, when) import Data.Int (Int64) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (peekCString, withCString) import Foreign.Marshal.Alloc (alloca) import Foreign.Ptr (nullPtr) diff --git a/test/LogicalTypesTest.hs b/test/LogicalTypesTest.hs --- a/test/LogicalTypesTest.hs +++ b/test/LogicalTypesTest.hs @@ -5,6 +5,7 @@ import Control.Monad (forM_, when, (>=>)) import Data.Word (Word32, Word8) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (peekCString, withCString) import Foreign.Marshal.Array (withArray) import Foreign.Marshal.Utils (withMany) diff --git a/test/PendingResultTest.hs b/test/PendingResultTest.hs --- a/test/PendingResultTest.hs +++ b/test/PendingResultTest.hs @@ -6,6 +6,7 @@ import Data.Int (Int32, Int64) import Data.Maybe (isNothing) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (peekCString, withCString) import Foreign.C.Types (CBool (..)) import Foreign.Marshal.Alloc (alloca) diff --git a/test/QueryExecutionTest.hs b/test/QueryExecutionTest.hs --- a/test/QueryExecutionTest.hs +++ b/test/QueryExecutionTest.hs @@ -4,6 +4,7 @@ import Control.Monad (forM_, when) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (peekCString, withCString) import Foreign.Marshal.Alloc (alloca) import Foreign.Ptr (nullPtr) diff --git a/test/ReplacementScansTest.hs b/test/ReplacementScansTest.hs --- a/test/ReplacementScansTest.hs +++ b/test/ReplacementScansTest.hs @@ -9,6 +9,7 @@ import Data.Int (Int64) import Data.List (isInfixOf) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (CString, peekCString, withCString) import Foreign.Marshal.Alloc (alloca) import Foreign.Ptr (Ptr, freeHaskellFunPtr, nullFunPtr, nullPtr) diff --git a/test/ResultFunctionsTest.hs b/test/ResultFunctionsTest.hs --- a/test/ResultFunctionsTest.hs +++ b/test/ResultFunctionsTest.hs @@ -4,6 +4,7 @@ import Control.Monad (forM_, when) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (withCString) import Foreign.C.Types (CBool (..)) import Foreign.Marshal.Alloc (alloca) diff --git a/test/SafeFetchTest.hs b/test/SafeFetchTest.hs --- a/test/SafeFetchTest.hs +++ b/test/SafeFetchTest.hs @@ -7,6 +7,7 @@ import Data.Time.Calendar (diffDays, fromGregorian) import Data.Word (Word16, Word32, Word64, Word8) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (peekCString, peekCStringLen, withCString) import Foreign.C.Types (CBool (..)) import Foreign.Marshal.Alloc (alloca) diff --git a/test/ScalarFunctionsTest.hs b/test/ScalarFunctionsTest.hs --- a/test/ScalarFunctionsTest.hs +++ b/test/ScalarFunctionsTest.hs @@ -9,6 +9,7 @@ import Data.Int (Int32) import Data.List (isInfixOf) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (peekCString, withCString) import Foreign.Marshal.Alloc (alloca, free, mallocBytes) import Foreign.Ptr (Ptr, castPtr, nullPtr) diff --git a/test/StreamingResultTest.hs b/test/StreamingResultTest.hs --- a/test/StreamingResultTest.hs +++ b/test/StreamingResultTest.hs @@ -6,6 +6,7 @@ import Data.Int (Int64) import Data.List (intercalate) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (CString, withCString) import Foreign.C.Types (CBool (..)) import Foreign.Marshal.Alloc (alloca) diff --git a/test/TableFunctionsTest.hs b/test/TableFunctionsTest.hs --- a/test/TableFunctionsTest.hs +++ b/test/TableFunctionsTest.hs @@ -13,6 +13,7 @@ import Data.List (isInfixOf) import Data.Maybe (fromMaybe) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (CString, peekCString, withCString) import Foreign.C.Types (CBool (..)) import Foreign.Marshal.Alloc (alloca, free, mallocBytes) diff --git a/test/ThreadingTest.hs b/test/ThreadingTest.hs --- a/test/ThreadingTest.hs +++ b/test/ThreadingTest.hs @@ -5,6 +5,7 @@ import Control.Concurrent (forkFinally, newEmptyMVar, putMVar, takeMVar) import Data.Int (Int64) import Database.DuckDB.FFI +import Database.DuckDB.FFI.Deprecated import Foreign.C.String (CString, withCString) import Foreign.C.Types (CBool (..)) import Foreign.Marshal.Alloc (alloca)