diff --git a/Database/SQLite3.hs b/Database/SQLite3.hs --- a/Database/SQLite3.hs +++ b/Database/SQLite3.hs @@ -45,6 +45,9 @@ columnText, columnBlob, + -- * Interrupting a long-running query + interrupt, + -- * Types Database, Statement, @@ -76,6 +79,7 @@ -- Re-exported from Database.SQLite3.Direct without modification. -- Note that if this module were in another package, source links would not -- be generated for these functions. + , interrupt , clearBindings , bindParameterCount , columnCount diff --git a/Database/SQLite3/Bindings.hs b/Database/SQLite3/Bindings.hs --- a/Database/SQLite3/Bindings.hs +++ b/Database/SQLite3/Bindings.hs @@ -6,6 +6,7 @@ c_sqlite3_open, c_sqlite3_close, c_sqlite3_errmsg, + c_sqlite3_interrupt, -- * Simple query execution -- | @@ -67,7 +68,11 @@ foreign import ccall "sqlite3_errmsg" c_sqlite3_errmsg :: Ptr CDatabase -> IO CString +-- | +foreign import ccall "sqlite3_interrupt" + c_sqlite3_interrupt :: Ptr CDatabase -> IO () + foreign import ccall "sqlite3_exec" c_sqlite3_exec :: Ptr CDatabase @@ -79,7 +84,7 @@ type CExecCallback a = Ptr a - -> ColumnCount -- ^ Number of columns, which is the number of elements in + -> CColumnCount -- ^ Number of columns, which is the number of elements in -- the following arrays. -> Ptr CString -- ^ Array of column names -> Ptr CString -- ^ Array of column values, as returned by @@ -150,21 +155,21 @@ -- necessarily the number of parameters. If numbered parameters like @?5@ -- are used, there may be gaps in the list. foreign import ccall unsafe "sqlite3_bind_parameter_count" - c_sqlite3_bind_parameter_count :: Ptr CStatement -> IO ParamIndex + c_sqlite3_bind_parameter_count :: Ptr CStatement -> IO CParamIndex -- | foreign import ccall unsafe "sqlite3_bind_parameter_name" - c_sqlite3_bind_parameter_name :: Ptr CStatement -> ParamIndex -> IO CString + c_sqlite3_bind_parameter_name :: Ptr CStatement -> CParamIndex -> IO CString -- | foreign import ccall unsafe "sqlite3_column_count" - c_sqlite3_column_count :: Ptr CStatement -> IO ColumnCount + c_sqlite3_column_count :: Ptr CStatement -> IO CColumnCount foreign import ccall unsafe "sqlite3_bind_blob" c_sqlite3_bind_blob :: Ptr CStatement - -> ParamIndex -- ^ Index of the SQL parameter to be set + -> CParamIndex -- ^ Index of the SQL parameter to be set -> Ptr a -- ^ Value to bind to the parameter. -- -- /Warning:/ If this pointer is @NULL@, this @@ -176,7 +181,7 @@ foreign import ccall unsafe "sqlite3_bind_text" c_sqlite3_bind_text :: Ptr CStatement - -> ParamIndex + -> CParamIndex -> CString -- ^ /Warning:/ If this pointer is @NULL@, this -- will bind a null value, rather than an empty text. -> CNumBytes -- ^ Length, in bytes. If this is negative, @@ -185,32 +190,32 @@ -> IO CError foreign import ccall unsafe "sqlite3_bind_double" - c_sqlite3_bind_double :: Ptr CStatement -> ParamIndex -> Double -> IO CError + c_sqlite3_bind_double :: Ptr CStatement -> CParamIndex -> Double -> IO CError foreign import ccall unsafe "sqlite3_bind_int64" - c_sqlite3_bind_int64 :: Ptr CStatement -> ParamIndex -> Int64 -> IO CError + c_sqlite3_bind_int64 :: Ptr CStatement -> CParamIndex -> Int64 -> IO CError foreign import ccall unsafe "sqlite3_bind_null" - c_sqlite3_bind_null :: Ptr CStatement -> ParamIndex -> IO CError + c_sqlite3_bind_null :: Ptr CStatement -> CParamIndex -> IO CError foreign import ccall unsafe "sqlite3_column_type" - c_sqlite3_column_type :: Ptr CStatement -> ColumnIndex -> IO CColumnType + c_sqlite3_column_type :: Ptr CStatement -> CColumnIndex -> IO CColumnType foreign import ccall unsafe "sqlite3_column_bytes" - c_sqlite3_column_bytes :: Ptr CStatement -> ColumnIndex -> IO CNumBytes + c_sqlite3_column_bytes :: Ptr CStatement -> CColumnIndex -> IO CNumBytes foreign import ccall unsafe "sqlite3_column_blob" - c_sqlite3_column_blob :: Ptr CStatement -> ColumnIndex -> IO (Ptr a) + c_sqlite3_column_blob :: Ptr CStatement -> CColumnIndex -> IO (Ptr a) foreign import ccall unsafe "sqlite3_column_text" - c_sqlite3_column_text :: Ptr CStatement -> ColumnIndex -> IO CString + c_sqlite3_column_text :: Ptr CStatement -> CColumnIndex -> IO CString foreign import ccall unsafe "sqlite3_column_int64" - c_sqlite3_column_int64 :: Ptr CStatement -> ColumnIndex -> IO Int64 + c_sqlite3_column_int64 :: Ptr CStatement -> CColumnIndex -> IO Int64 foreign import ccall unsafe "sqlite3_column_double" - c_sqlite3_column_double :: Ptr CStatement -> ColumnIndex -> IO Double + c_sqlite3_column_double :: Ptr CStatement -> CColumnIndex -> IO Double -- | diff --git a/Database/SQLite3/Bindings/Types.hsc b/Database/SQLite3/Bindings/Types.hsc --- a/Database/SQLite3/Bindings/Types.hsc +++ b/Database/SQLite3/Bindings/Types.hsc @@ -1,4 +1,6 @@ {-# LANGUAGE EmptyDataDecls #-} +{-# LANGUAGE FunctionalDependencies #-} +{-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} module Database.SQLite3.Bindings.Types ( -- * Objects @@ -11,11 +13,13 @@ -- ** Error CError(..), decodeError, + encodeError, Error(..), -- ** ColumnType CColumnType(..), decodeColumnType, + encodeColumnType, ColumnType(..), -- * Indices @@ -23,10 +27,18 @@ ColumnIndex(..), ColumnCount, + -- ** Indices (FFI) + CParamIndex(..), + CColumnIndex(..), + CColumnCount, + -- * Miscellaneous CNumBytes(..), CDestructor, c_SQLITE_TRANSIENT, + + -- * Conversion to and from FFI types + FFIType(..), ) where #ifdef direct_sqlite_systemlib @@ -105,7 +117,7 @@ -- -- See for the syntax of -- parameter placeholders, and how parameter indices are assigned. -newtype ParamIndex = ParamIndex CInt +newtype ParamIndex = ParamIndex Int deriving (Eq, Ord, Enum, Num, Real, Integral) -- | This just shows the underlying integer, without the data constructor. @@ -113,7 +125,7 @@ show (ParamIndex n) = show n -- | Index of a column in a result set. Column indices start from 0. -newtype ColumnIndex = ColumnIndex CInt +newtype ColumnIndex = ColumnIndex Int deriving (Eq, Ord, Enum, Num, Real, Integral) -- | This just shows the underlying integer, without the data constructor. @@ -123,6 +135,22 @@ -- | Number of columns in a result set. type ColumnCount = ColumnIndex +newtype CParamIndex = CParamIndex CInt + deriving (Eq, Ord, Enum, Num, Real, Integral) + +-- | This just shows the underlying integer, without the data constructor. +instance Show CParamIndex where + show (CParamIndex n) = show n + +newtype CColumnIndex = CColumnIndex CInt + deriving (Eq, Ord, Enum, Num, Real, Integral) + +-- | This just shows the underlying integer, without the data constructor. +instance Show CColumnIndex where + show (CColumnIndex n) = show n + +type CColumnCount = CColumnIndex + newtype CNumBytes = CNumBytes CInt deriving (Eq, Ord, Show, Enum, Num, Real, Integral) @@ -131,13 +159,14 @@ -- @Ptr CDestructor@ = @sqlite3_destructor_type@ data CDestructor +-- | Tells SQLite3 to make its own private copy of the data c_SQLITE_TRANSIENT :: Ptr CDestructor c_SQLITE_TRANSIENT = intPtrToPtr (-1) -- | newtype CError = CError CInt - deriving Show + deriving (Eq, Show) -- | Note that this is a partial function. If the error code is invalid, or -- perhaps introduced in a newer version of SQLite but this library has not @@ -182,10 +211,42 @@ #{const SQLITE_DONE} -> ErrorDone _ -> error $ "decodeError " ++ show n +encodeError :: Error -> CError +encodeError err = CError $ case err of + ErrorOK -> #const SQLITE_OK + ErrorError -> #const SQLITE_ERROR + ErrorInternal -> #const SQLITE_INTERNAL + ErrorPermission -> #const SQLITE_PERM + ErrorAbort -> #const SQLITE_ABORT + ErrorBusy -> #const SQLITE_BUSY + ErrorLocked -> #const SQLITE_LOCKED + ErrorNoMemory -> #const SQLITE_NOMEM + ErrorReadOnly -> #const SQLITE_READONLY + ErrorInterrupt -> #const SQLITE_INTERRUPT + ErrorIO -> #const SQLITE_IOERR + ErrorCorrupt -> #const SQLITE_CORRUPT + ErrorNotFound -> #const SQLITE_NOTFOUND + ErrorFull -> #const SQLITE_FULL + ErrorCan'tOpen -> #const SQLITE_CANTOPEN + ErrorProtocol -> #const SQLITE_PROTOCOL + ErrorEmpty -> #const SQLITE_EMPTY + ErrorSchema -> #const SQLITE_SCHEMA + ErrorTooBig -> #const SQLITE_TOOBIG + ErrorConstraint -> #const SQLITE_CONSTRAINT + ErrorMismatch -> #const SQLITE_MISMATCH + ErrorMisuse -> #const SQLITE_MISUSE + ErrorNoLargeFileSupport -> #const SQLITE_NOLFS + ErrorAuthorization -> #const SQLITE_AUTH + ErrorFormat -> #const SQLITE_FORMAT + ErrorRange -> #const SQLITE_RANGE + ErrorNotADatabase -> #const SQLITE_NOTADB + ErrorRow -> #const SQLITE_ROW + ErrorDone -> #const SQLITE_DONE + -- | newtype CColumnType = CColumnType CInt - deriving Show + deriving (Eq, Show) -- | Note that this is a partial function. -- See 'decodeError' for more information. @@ -197,3 +258,38 @@ #{const SQLITE_BLOB} -> BlobColumn #{const SQLITE_NULL} -> NullColumn _ -> error $ "decodeColumnType " ++ show n + +encodeColumnType :: ColumnType -> CColumnType +encodeColumnType t = CColumnType $ case t of + IntegerColumn -> #const SQLITE_INTEGER + FloatColumn -> #const SQLITE_FLOAT + TextColumn -> #const SQLITE_TEXT + BlobColumn -> #const SQLITE_BLOB + NullColumn -> #const SQLITE_NULL + +------------------------------------------------------------------------ +-- Conversion to and from FFI types + +-- | The "Database.SQLite3" and "Database.SQLite3.Direct" modules use +-- higher-level representations of some types than those used in the +-- FFI signatures ("Database.SQLite3.Bindings"). This typeclass +-- helps with the conversions. +class FFIType public ffi | public -> ffi, ffi -> public where + toFFI :: public -> ffi + fromFFI :: ffi -> public + +instance FFIType ParamIndex CParamIndex where + toFFI (ParamIndex n) = CParamIndex (fromIntegral n) + fromFFI (CParamIndex n) = ParamIndex (fromIntegral n) + +instance FFIType ColumnIndex CColumnIndex where + toFFI (ColumnIndex n) = CColumnIndex (fromIntegral n) + fromFFI (CColumnIndex n) = ColumnIndex (fromIntegral n) + +instance FFIType Error CError where + toFFI = encodeError + fromFFI = decodeError + +instance FFIType ColumnType CColumnType where + toFFI = encodeColumnType + fromFFI = decodeColumnType diff --git a/Database/SQLite3/Direct.hs b/Database/SQLite3/Direct.hs --- a/Database/SQLite3/Direct.hs +++ b/Database/SQLite3/Direct.hs @@ -11,6 +11,7 @@ open, close, errmsg, + interrupt, -- * Simple query execution -- | @@ -160,6 +161,19 @@ close (Database db) = toResult () <$> c_sqlite3_close db +-- | +-- +-- Cause any pending operation on the 'Database' handle to stop at its earliest +-- opportunity. This simply sets a flag and returns immediately. It does not +-- wait for the pending operation to finish. +-- +-- You'll need to compile with @-threaded@ for this to do any good. +-- Without @-threaded@, FFI calls block the whole RTS, meaning 'interrupt' +-- would never run at the same time as 'step'. +interrupt :: Database -> IO () +interrupt (Database db) = + c_sqlite3_interrupt db + -- | errmsg :: Database -> IO Utf8 errmsg (Database db) = @@ -240,63 +254,63 @@ -- See 'ParamIndex' for more information. bindParameterCount :: Statement -> IO ParamIndex bindParameterCount (Statement stmt) = - c_sqlite3_bind_parameter_count stmt + fromFFI <$> c_sqlite3_bind_parameter_count stmt -- | bindParameterName :: Statement -> ParamIndex -> IO (Maybe Utf8) bindParameterName (Statement stmt) idx = - c_sqlite3_bind_parameter_name stmt idx >>= + c_sqlite3_bind_parameter_name stmt (toFFI idx) >>= packUtf8 Nothing Just -- | columnCount :: Statement -> IO ColumnCount columnCount (Statement stmt) = - c_sqlite3_column_count stmt + fromFFI <$> c_sqlite3_column_count stmt bindInt64 :: Statement -> ParamIndex -> Int64 -> IO (Either Error ()) bindInt64 (Statement stmt) idx value = - toResult () <$> c_sqlite3_bind_int64 stmt idx value + toResult () <$> c_sqlite3_bind_int64 stmt (toFFI idx) value bindDouble :: Statement -> ParamIndex -> Double -> IO (Either Error ()) bindDouble (Statement stmt) idx value = - toResult () <$> c_sqlite3_bind_double stmt idx value + toResult () <$> c_sqlite3_bind_double stmt (toFFI idx) value bindText :: Statement -> ParamIndex -> Utf8 -> IO (Either Error ()) bindText (Statement stmt) idx (Utf8 value) = unsafeUseAsCStringLenNoNull value $ \ptr len -> toResult () <$> - c_sqlite3_bind_text stmt idx ptr len c_SQLITE_TRANSIENT + c_sqlite3_bind_text stmt (toFFI idx) ptr len c_SQLITE_TRANSIENT bindBlob :: Statement -> ParamIndex -> ByteString -> IO (Either Error ()) bindBlob (Statement stmt) idx value = unsafeUseAsCStringLenNoNull value $ \ptr len -> toResult () <$> - c_sqlite3_bind_blob stmt idx ptr len c_SQLITE_TRANSIENT + c_sqlite3_bind_blob stmt (toFFI idx) ptr len c_SQLITE_TRANSIENT bindNull :: Statement -> ParamIndex -> IO (Either Error ()) bindNull (Statement stmt) idx = - toResult () <$> c_sqlite3_bind_null stmt idx + toResult () <$> c_sqlite3_bind_null stmt (toFFI idx) columnType :: Statement -> ColumnIndex -> IO ColumnType columnType (Statement stmt) idx = - decodeColumnType <$> c_sqlite3_column_type stmt idx + decodeColumnType <$> c_sqlite3_column_type stmt (toFFI idx) columnInt64 :: Statement -> ColumnIndex -> IO Int64 columnInt64 (Statement stmt) idx = - c_sqlite3_column_int64 stmt idx + c_sqlite3_column_int64 stmt (toFFI idx) columnDouble :: Statement -> ColumnIndex -> IO Double columnDouble (Statement stmt) idx = - c_sqlite3_column_double stmt idx + c_sqlite3_column_double stmt (toFFI idx) columnText :: Statement -> ColumnIndex -> IO Utf8 columnText (Statement stmt) idx = do - ptr <- c_sqlite3_column_text stmt idx - len <- c_sqlite3_column_bytes stmt idx + ptr <- c_sqlite3_column_text stmt (toFFI idx) + len <- c_sqlite3_column_bytes stmt (toFFI idx) Utf8 <$> packCStringLen ptr len columnBlob :: Statement -> ColumnIndex -> IO ByteString columnBlob (Statement stmt) idx = do - ptr <- c_sqlite3_column_blob stmt idx - len <- c_sqlite3_column_bytes stmt idx + ptr <- c_sqlite3_column_blob stmt (toFFI idx) + len <- c_sqlite3_column_bytes stmt (toFFI idx) packCStringLen ptr len diff --git a/cbits/sqlite3.c b/cbits/sqlite3.c # file too large to diff: cbits/sqlite3.c diff --git a/cbits/sqlite3.h b/cbits/sqlite3.h --- a/cbits/sqlite3.h +++ b/cbits/sqlite3.h @@ -107,9 +107,9 @@ ** [sqlite3_libversion_number()], [sqlite3_sourceid()], ** [sqlite_version()] and [sqlite_source_id()]. */ -#define SQLITE_VERSION "3.7.13" -#define SQLITE_VERSION_NUMBER 3007013 -#define SQLITE_SOURCE_ID "2012-06-11 02:05:22 f5b5a13f7394dc143aa136f1d4faba6839eaa6dc" +#define SQLITE_VERSION "3.7.15" +#define SQLITE_VERSION_NUMBER 3007015 +#define SQLITE_SOURCE_ID "2012-12-12 13:36:53 cd0b37c52658bfdf992b1e3dc467bae1835a94ae" /* ** CAPI3REF: Run-Time Library Version Numbers @@ -219,7 +219,8 @@ ** the opaque structure named "sqlite3". It is useful to think of an sqlite3 ** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and ** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] -** is its destructor. There are many other interfaces (such as +** and [sqlite3_close_v2()] are its destructors. There are many other +** interfaces (such as ** [sqlite3_prepare_v2()], [sqlite3_create_function()], and ** [sqlite3_busy_timeout()] to name but three) that are methods on an ** sqlite3 object. @@ -266,28 +267,46 @@ /* ** CAPI3REF: Closing A Database Connection ** -** ^The sqlite3_close() routine is the destructor for the [sqlite3] object. -** ^Calls to sqlite3_close() return SQLITE_OK if the [sqlite3] object is -** successfully destroyed and all associated resources are deallocated. +** ^The sqlite3_close() and sqlite3_close_v2() routines are destructors +** for the [sqlite3] object. +** ^Calls to sqlite3_close() and sqlite3_close_v2() return SQLITE_OK if +** the [sqlite3] object is successfully destroyed and all associated +** resources are deallocated. ** -** Applications must [sqlite3_finalize | finalize] all [prepared statements] -** and [sqlite3_blob_close | close] all [BLOB handles] associated with -** the [sqlite3] object prior to attempting to close the object. ^If +** ^If the database connection is associated with unfinalized prepared +** statements or unfinished sqlite3_backup objects then sqlite3_close() +** will leave the database connection open and return [SQLITE_BUSY]. +** ^If sqlite3_close_v2() is called with unfinalized prepared statements +** and unfinished sqlite3_backups, then the database connection becomes +** an unusable "zombie" which will automatically be deallocated when the +** last prepared statement is finalized or the last sqlite3_backup is +** finished. The sqlite3_close_v2() interface is intended for use with +** host languages that are garbage collected, and where the order in which +** destructors are called is arbitrary. +** +** Applications should [sqlite3_finalize | finalize] all [prepared statements], +** [sqlite3_blob_close | close] all [BLOB handles], and +** [sqlite3_backup_finish | finish] all [sqlite3_backup] objects associated +** with the [sqlite3] object prior to attempting to close the object. ^If ** sqlite3_close() is called on a [database connection] that still has -** outstanding [prepared statements] or [BLOB handles], then it returns -** SQLITE_BUSY. +** outstanding [prepared statements], [BLOB handles], and/or +** [sqlite3_backup] objects then it returns SQLITE_OK but the deallocation +** of resources is deferred until all [prepared statements], [BLOB handles], +** and [sqlite3_backup] objects are also destroyed. ** -** ^If [sqlite3_close()] is invoked while a transaction is open, +** ^If an [sqlite3] object is destroyed while a transaction is open, ** the transaction is automatically rolled back. ** -** The C parameter to [sqlite3_close(C)] must be either a NULL +** The C parameter to [sqlite3_close(C)] and [sqlite3_close_v2(C)] +** must be either a NULL ** pointer or an [sqlite3] object pointer obtained ** from [sqlite3_open()], [sqlite3_open16()], or ** [sqlite3_open_v2()], and not previously closed. -** ^Calling sqlite3_close() with a NULL pointer argument is a -** harmless no-op. +** ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer +** argument is a harmless no-op. */ -SQLITE_API int sqlite3_close(sqlite3 *); +SQLITE_API int sqlite3_close(sqlite3*); +SQLITE_API int sqlite3_close_v2(sqlite3*); /* ** The type for a callback function. @@ -455,10 +474,12 @@ #define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8)) #define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8)) #define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8)) +#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR | (23<<8)) #define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8)) #define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8)) #define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8)) #define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8)) +#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8)) #define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8)) #define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8)) #define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8)) @@ -498,7 +519,7 @@ ** CAPI3REF: Device Characteristics ** ** The xDeviceCharacteristics method of the [sqlite3_io_methods] -** object returns an integer which is a vector of the these +** object returns an integer which is a vector of these ** bit values expressing I/O characteristics of the mass storage ** device that holds the file that the [sqlite3_io_methods] ** refers to. @@ -836,6 +857,26 @@ ** compilation of the PRAGMA fails with an error. ^The [SQLITE_FCNTL_PRAGMA] ** file control occurs at the beginning of pragma statement analysis and so ** it is able to override built-in [PRAGMA] statements. +** +**
  • [[SQLITE_FCNTL_BUSYHANDLER]] +** ^This file-control may be invoked by SQLite on the database file handle +** shortly after it is opened in order to provide a custom VFS with access +** to the connections busy-handler callback. The argument is of type (void **) +** - an array of two (void *) values. The first (void *) actually points +** to a function of type (int (*)(void *)). In order to invoke the connections +** busy-handler, this function should be invoked with the second (void *) in +** the array as the only argument. If it returns non-zero, then the operation +** should be retried. If it returns zero, the custom VFS should abandon the +** current operation. +** +**
  • [[SQLITE_FCNTL_TEMPFILENAME]] +** ^Application can invoke this file-control to have SQLite generate a +** temporary filename using the same algorithm that is followed to generate +** temporary filenames for TEMP tables and other internal uses. The +** argument should be a char** which will be filled with the filename +** written into memory obtained from [sqlite3_malloc()]. The caller should +** invoke [sqlite3_free()] on the result to avoid a memory leak. +** ** */ #define SQLITE_FCNTL_LOCKSTATE 1 @@ -852,6 +893,8 @@ #define SQLITE_FCNTL_VFSNAME 12 #define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13 #define SQLITE_FCNTL_PRAGMA 14 +#define SQLITE_FCNTL_BUSYHANDLER 15 +#define SQLITE_FCNTL_TEMPFILENAME 16 /* ** CAPI3REF: Mutex Handle @@ -1548,11 +1591,39 @@ ** disabled. The default value may be changed by compiling with the ** [SQLITE_USE_URI] symbol defined. ** +** [[SQLITE_CONFIG_COVERING_INDEX_SCAN]]
    SQLITE_CONFIG_COVERING_INDEX_SCAN +**
    This option takes a single integer argument which is interpreted as +** a boolean in order to enable or disable the use of covering indices for +** full table scans in the query optimizer. The default setting is determined +** by the [SQLITE_ALLOW_COVERING_INDEX_SCAN] compile-time option, or is "on" +** if that compile-time option is omitted. +** The ability to disable the use of covering indices for full table scans +** is because some incorrectly coded legacy applications might malfunction +** malfunction when the optimization is enabled. Providing the ability to +** disable the optimization allows the older, buggy application code to work +** without change even with newer versions of SQLite. +** ** [[SQLITE_CONFIG_PCACHE]] [[SQLITE_CONFIG_GETPCACHE]] **
    SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE **
    These options are obsolete and should not be used by new code. ** They are retained for backwards compatibility but are now no-ops. ** +** +** [[SQLITE_CONFIG_SQLLOG]] +**
    SQLITE_CONFIG_SQLLOG +**
    This option is only available if sqlite is compiled with the +** SQLITE_ENABLE_SQLLOG pre-processor macro defined. The first argument should +** be a pointer to a function of type void(*)(void*,sqlite3*,const char*, int). +** The second should be of type (void*). The callback is invoked by the library +** in three separate circumstances, identified by the value passed as the +** fourth parameter. If the fourth parameter is 0, then the database connection +** passed as the second argument has just been opened. The third argument +** points to a buffer containing the name of the main database file. If the +** fourth parameter is 1, then the SQL statement that the third parameter +** points to has just been executed. Or, if the fourth parameter is 2, then +** the connection being passed as the second parameter is being closed. The +** third parameter is passed NULL In this case. +** */ #define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ #define SQLITE_CONFIG_MULTITHREAD 2 /* nil */ @@ -1573,6 +1644,8 @@ #define SQLITE_CONFIG_URI 17 /* int */ #define SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */ #define SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */ +#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */ +#define SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */ /* ** CAPI3REF: Database Connection Configuration Options @@ -2581,7 +2654,7 @@ ** an error)^. ** ^If "ro" is specified, then the database is opened for read-only ** access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the -** third argument to sqlite3_prepare_v2(). ^If the mode option is set to +** third argument to sqlite3_open_v2(). ^If the mode option is set to ** "rw", then the database is opened for read-write (but not create) ** access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had ** been set. ^Value "rwc" is equivalent to setting both @@ -2648,6 +2721,12 @@ ** codepage is currently defined. Filenames containing international ** characters must be converted to UTF-8 prior to passing them into ** sqlite3_open() or sqlite3_open_v2(). +** +** Note to Windows Runtime users: The temporary directory must be set +** prior to calling sqlite3_open() or sqlite3_open_v2(). Otherwise, various +** features that require the use of temporary files may fail. +** +** See also: [sqlite3_temp_directory] */ SQLITE_API int sqlite3_open( const char *filename, /* Database filename (UTF-8) */ @@ -2727,6 +2806,11 @@ ** However, the error string might be overwritten or deallocated by ** subsequent calls to other SQLite interface functions.)^ ** +** ^The sqlite3_errstr() interface returns the English-language text +** that describes the [result code], as UTF-8. +** ^(Memory to hold the error message string is managed internally +** and must not be freed by the application)^. +** ** When the serialized [threading mode] is in use, it might be the ** case that a second error occurs on a separate thread in between ** the time of the first error and the call to these interfaces. @@ -2745,6 +2829,7 @@ SQLITE_API int sqlite3_extended_errcode(sqlite3 *db); SQLITE_API const char *sqlite3_errmsg(sqlite3*); SQLITE_API const void *sqlite3_errmsg16(sqlite3*); +SQLITE_API const char *sqlite3_errstr(int); /* ** CAPI3REF: SQL Statement Object @@ -3140,8 +3225,11 @@ ** ^(In those routines that have a fourth argument, its value is the ** number of bytes in the parameter. To be clear: the value is the ** number of bytes in the value, not the number of characters.)^ -** ^If the fourth parameter is negative, the length of the string is +** ^If the fourth parameter to sqlite3_bind_text() or sqlite3_bind_text16() +** is negative, then the length of the string is ** the number of bytes up to the first zero terminator. +** If the fourth parameter to sqlite3_bind_blob() is negative, then +** the behavior is undefined. ** If a non-negative fourth parameter is provided to sqlite3_bind_text() ** or sqlite3_bind_text16() then that parameter must be the byte offset ** where the NUL terminator would occur assuming the string were NUL @@ -4138,11 +4226,11 @@ ** the error code is SQLITE_ERROR. ^A subsequent call to sqlite3_result_error() ** or sqlite3_result_error16() resets the error code to SQLITE_ERROR. ** -** ^The sqlite3_result_toobig() interface causes SQLite to throw an error -** indicating that a string or BLOB is too long to represent. +** ^The sqlite3_result_error_toobig() interface causes SQLite to throw an +** error indicating that a string or BLOB is too long to represent. ** -** ^The sqlite3_result_nomem() interface causes SQLite to throw an error -** indicating that a memory allocation failed. +** ^The sqlite3_result_error_nomem() interface causes SQLite to throw an +** error indicating that a memory allocation failed. ** ** ^The sqlite3_result_int() interface sets the return value ** of the application-defined function to be the 32-bit signed integer @@ -4449,6 +4537,21 @@ ** Hence, if this variable is modified directly, either it should be ** made NULL or made to point to memory obtained from [sqlite3_malloc] ** or else the use of the [temp_store_directory pragma] should be avoided. +** +** Note to Windows Runtime users: The temporary directory must be set +** prior to calling [sqlite3_open] or [sqlite3_open_v2]. Otherwise, various +** features that require the use of temporary files may fail. Here is an +** example of how to do this using C++ with the Windows Runtime: +** +** 
    +** LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
+**       TemporaryFolder->Path->Data();
+** char zPathBuf[MAX_PATH + 1];
+** memset(zPathBuf, 0, sizeof(zPathBuf));
+** WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
+**       NULL, NULL);
+** sqlite3_temp_directory = sqlite3_mprintf("%s", zPathBuf);
+**
    */ SQLITE_API SQLITE_EXTERN char *sqlite3_temp_directory; @@ -4689,6 +4792,9 @@ ** future releases of SQLite. Applications that care about shared ** cache setting should set it explicitly. ** +** This interface is threadsafe on processors where writing a +** 32-bit integer is atomic. +** ** See Also: [SQLite Shared-Cache Mode] */ SQLITE_API int sqlite3_enable_shared_cache(int); @@ -5494,7 +5600,6 @@ ** implementations are available in the SQLite core: ** **
      -**
    • SQLITE_MUTEX_OS2 **
    • SQLITE_MUTEX_PTHREADS **
    • SQLITE_MUTEX_W32 **
    • SQLITE_MUTEX_NOOP @@ -5502,9 +5607,9 @@ ** ** ^The SQLITE_MUTEX_NOOP implementation is a set of routines ** that does no real locking and is appropriate for use in -** a single-threaded application. ^The SQLITE_MUTEX_OS2, -** SQLITE_MUTEX_PTHREADS, and SQLITE_MUTEX_W32 implementations -** are appropriate for use on OS/2, Unix, and Windows. +** a single-threaded application. ^The SQLITE_MUTEX_PTHREADS and +** SQLITE_MUTEX_W32 implementations are appropriate for use on Unix +** and Windows. ** ** ^(If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor ** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex diff --git a/direct-sqlite.cabal b/direct-sqlite.cabal --- a/direct-sqlite.cabal +++ b/direct-sqlite.cabal @@ -1,5 +1,5 @@ name: direct-sqlite -version: 2.3 +version: 2.3.1 build-type: Simple license: BSD3 license-file: LICENSE @@ -22,6 +22,9 @@ . Release history: . + [Version 2.3.1] Upgrade the bundled SQLite3 to 3.7.15. Add bindings for + sqlite3_interrupt. Export Int rather than CInt. + . [Version 2.3] Mark some FFI calls "unsafe", for a substantial performance benefit. . @@ -85,12 +88,14 @@ other-modules: StrictEq - ghc-options: -Wall -fno-warn-name-shadowing -fno-warn-unused-do-bind + ghc-options: -Wall -threaded -fno-warn-name-shadowing -fno-warn-unused-do-bind - extensions: NamedFieldPuns - , OverloadedStrings - , Rank2Types - , RecordWildCards + default-language: Haskell2010 + + default-extensions: NamedFieldPuns + , OverloadedStrings + , Rank2Types + , RecordWildCards build-depends: base , base16-bytestring diff --git a/test/Main.hs b/test/Main.hs --- a/test/Main.hs +++ b/test/Main.hs @@ -1,13 +1,10 @@ -{-# LANGUAGE ScopedTypeVariables #-} - import StrictEq import Database.SQLite3 import qualified Database.SQLite3.Direct as Direct -import Prelude hiding (catch) -- Remove this import when GHC 7.6 is released, - -- as Prelude no longer exports catch. -import Control.Exception (bracket, handleJust, try) +import Control.Concurrent +import Control.Exception import Control.Monad (forM_, when) import Data.Text (Text) import Data.Text.Encoding.Error (UnicodeException(..)) @@ -47,7 +44,10 @@ , TestLabel "Errors" . testErrors , TestLabel "Integrity" . testIntegrity , TestLabel "DecodeError" . testDecodeError - ] + ] ++ + (if rtsSupportsBoundThreads then + [ TestLabel "Interrupt" . testInterrupt + ] else []) featureTests :: [TestEnv -> Test] featureTests = @@ -458,6 +458,29 @@ where invalidUtf8 = Direct.Utf8 $ B.pack [0x80] +testInterrupt :: TestEnv -> Test +testInterrupt TestEnv{..} = TestCase $ + withConn $ \conn -> do + exec conn "CREATE TABLE tbl (n INT)" + + withStmt conn "INSERT INTO tbl VALUES (?)" $ \stmt -> do + exec conn "BEGIN" + forM_ [1..200] $ \i -> do + reset stmt + bind stmt [SQLInteger i] + Done <- step stmt + return () + exec conn "COMMIT" + + stmt <- prepare conn tripleSum + _ <- forkIO $ threadDelay 100000 >> interrupt conn + Left ErrorInterrupt <- Direct.step stmt + Left ErrorInterrupt <- Direct.finalize stmt + return () + + where + tripleSum = "SELECT sum(a.n + b.n + c.n) FROM tbl as a, tbl as b, tbl as c" + testMultiRowInsert :: TestEnv -> Test testMultiRowInsert TestEnv{..} = TestCase $ do withConn $ \conn -> do @@ -491,8 +514,16 @@ , withConnShared = withConnPath sharedDBPath } where - withConn = withConnPath ":memory:" - withConnPath path = bracket (open path) close + withConn = withConnPath ":memory:" + withConnPath path cb = do + conn <- open path + r <- cb conn `onException` Direct.close conn + -- If the callback throws an exception, try to close the DB. + -- If closing fails (usually due to open 'Statement's), + -- throw the original error, not the error produced by 'close'. + -- Direct.close returns the error rather than throwing it. + close conn + return r runTestGroup :: [TestEnv -> Test] -> IO Bool runTestGroup tests = do