!Ąy      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxNone2Wpersistent-sqlite2Run-time status parameter that can be returned by O function.persistent-sqliteThis parameter is the current amount of memory checked out using sqlite3_malloc(), either directly or indirectly. The figure includes calls made to sqlite3_malloc() by the application and internal memory usage by the SQLite library. Scratch memory controlled by SQLITE_CONFIG_SCRATCH and auxiliary page-cache memory controlled by SQLITE_CONFIG_PAGECACHE is not included in this parameter. The amount returned is the sum of the allocation sizes as reported by the xSize method in sqlite3_mem_methods.persistent-sqliteThis parameter returns the number of pages used out of the pagecache memory allocator that was configured using SQLITE_CONFIG_PAGECACHE. The value returned is in pages, not in bytes.persistent-sqliteThis parameter returns the number of bytes of page cache allocation which could not be satisfied by the SQLITE_CONFIG_PAGECACHE buffer and where forced to overflow to sqlite3_malloc(). The returned value includes allocations that overflowed because they where too large (they were larger than the "sz" parameter to SQLITE_CONFIG_PAGECACHE) and allocations that overflowed because no space was left in the page cache.persistent-sqlitebThis parameter returns the number of allocations used out of the scratch memory allocator configured using SQLITE_CONFIG_SCRATCH. The value returned is in allocations, not in bytes. Since a single thread may only have one scratch allocation outstanding at time, this parameter also reports the number of threads using scratch memory at the same time.persistent-sqliteThis parameter returns the number of bytes of scratch memory allocation which could not be satisfied by the SQLITE_CONFIG_SCRATCH buffer and where forced to overflow to sqlite3_malloc(). The values returned include overflows because the requested allocation was too larger (that is, because the requested allocation was larger than the "sz" parameter to SQLITE_CONFIG_SCRATCH) and because no scratch buffer slots were available.persistent-sqliteThis parameter records the largest memory allocation request handed to sqlite3_malloc() or sqlite3_realloc() (or their internal equivalents). Only the value returned in   field of  4 record is of interest. The value written into the   field is Nothing.persistent-sqliteThis parameter records the largest memory allocation request handed to pagecache memory allocator. Only the value returned in the   field of  4 record is of interest. The value written into the   field is Nothing.persistent-sqliteThis parameter records the largest memory allocation request handed to scratch memory allocator. Only the value returned in the   field of  4 record is of interest. The value written into the   field is Nothing. persistent-sqliteXThis parameter records the number of separate memory allocations currently checked out. persistent-sqliteReturn type of the O function persistent-sqlitePThe current value of the parameter. Some parameters do not record current value. persistent-sqliteLThe highest recorded value. Some parameters do not record the highest value.persistent-sqlite=Configuration option for SQLite to be used together with the N function.persistent-sqlite!A function to be used for loggingpersistent-sqliteypersistent-sqlite@Log function callback. Arguments are error code and log message.2persistent-sqlite>A custom exception type to make it easier to catch exceptions.>persistent-sqlite6Execute a database statement. It's recommended to use ?1 instead, because it gives better error messages.?persistent-sqlite5Execute a database statement. This function uses the 81 passed to it to give better error messages than >.zpersistent-sqliteLike unsafeUseAsCStringLenF, but if the string is empty, never pass the callback a null pointer.Lpersistent-sqliteWraps a given function to a  to be further used with x. First argument of given function will take error code, second - log message. Returned value should be released with M when no longer required.Mpersistent-sqlite!Releases a native FunPtr for the .Npersistent-sqliteMSets SQLite global configuration parameter. See SQLite documentation for the  (https://www.sqlite.org/c3ref/config.htmlsqlite3_configm function. In short, this must be called prior to any other SQLite function if you want the call to succeed.Opersistent-sqlite/Retrieves runtime status information about the performance of SQLite, and optionally resets various highwater marks. The first argument is a status parameter to measure, the second is reset flag. If reset flag is True then the highest recorded value is reset after being returned from this function.Ppersistent-sqlitebSets and/or queries the soft limit on the amount of heap memory that may be allocated by SQLite. If the argument is zero then the soft heap limit is disabled. If the argument is negative then no change is made to the soft heap limit. Hence, the current size of the soft heap limit can be determined by invoking this function with a negative argument.Q  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ87 !"#$%&'()*+,-./0123456  9:=>?@ABCDEFGHIJKLMNOP;<None >HPVXx[persistent-sqliteInformation required to connect to a sqlite database. We export lenses instead of fields to avoid being limited to the current implementation.{persistent-sqlite(connection string for the database. Use :memory: for an in-memory database.|persistent-sqlite(if the write-ahead log is enabled - see  1https://github.com/yesodweb/persistent/issues/363.}persistent-sqlite'if foreign-key constraints are enabled.~persistent-sqlite.additional pragmas to be set on initialization\persistent-sqlite0Information required to setup a connection pool.bpersistent-sqlite$Create a pool of SQLite connections.+Note that this should not be used with the :memory:l connection string, as the pool will regularly remove connections, destroying your database. Instead, use f.cpersistent-sqlite$Create a pool of SQLite connections.+Note that this should not be used with the :memory:l connection string, as the pool will regularly remove connections, destroying your database. Instead, use f.dpersistent-sqlite,Run the given action with a connection pool.Like b, this should not be used with :memory:.epersistent-sqlite,Run the given action with a connection pool.Like b, this should not be used with :memory:.gpersistent-sqlitehpersistent-sqliteWrap up a raw 8 as a Persistent SQL  Connection. Example usage {-# LANGUAGE GADTs #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE QuasiQuotes #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} import Control.Monad.IO.Class (liftIO) import Database.Persist import Database.Sqlite import Database.Persist.Sqlite import Database.Persist.TH share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase| Person name String age Int Maybe deriving Show |] main :: IO () main = do conn <- open "/home/sibi/test.db" (backend :: SqlBackend) <- wrapConnection conn (\_ _ _ _ -> return ()) flip runSqlPersistM backend $ do runMigration migrateAll insert_ $ Person "John doe" $ Just 35 insert_ $ Person "Hema" $ Just 36 (pers :: [Entity Person]) <- selectList [] [] liftIO $ print pers close' backend%On executing it, you get this output: Migrating: CREATE TABLE "person"("id" INTEGER PRIMARY KEY,"name" VARCHAR NOT NULL,"age" INTEGER NULL) [Entity {entityKey = PersonKey {unPersonKey = SqlBackendKey {unSqlBackendKey = 1}}, entityVal = Person {personName = "John doe", personAge = Just 35}},Entity {entityKey = PersonKey {unPersonKey = SqlBackendKey {unSqlBackendKey = 2}}, entityVal = Person {personName = "Hema", personAge = Just 36}}]i persistent-sqliteERetry if a Busy is thrown, following an exponential backoff strategy.j persistent-sqlite?Wait until some noop action on the database does not return an . See i.kpersistent-sqliteWrap up a raw 8 as a Persistent SQL  Connection4, allowing full control over WAL and FK constraints.lpersistent-sqliteaA convenience helper which creates a new database connection and runs the given block, handling  MonadResource and  MonadLogger9 requirements. Note that all log messages are discarded.mpersistent-sqliteaA convenience helper which creates a new database connection and runs the given block, handling  MonadResource and  MonadLogger9 requirements. Note that all log messages are discarded.npersistent-sqlitejMock a migration even when the database is not present. This function performs the same functionality of B with the difference that an actual database isn't needed for it.persistent-sqliteMCheck if a column name is listed as the "safe to remove" in the entity list.opersistent-sqliteTCreates a SqliteConnectionInfo from a connection string, with the default settings.persistent-sqliteXParses connection options from a connection string. Used only to provide deprecated API.dpersistent-sqlitenumber of connections to openepersistent-sqlitenumber of connections to openlpersistent-sqliteconnection stringpersistent-sqlitedatabase actionmpersistent-sqlitedatabase actionpersistent-sqlitecomputation to run firstpersistent-sqlite>computation to run afterward (even if an exception was raised)      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-[\]^_`abcdefghijklmnotuvwdefgbc\]^_`a[ovwutlmhknij.       !"#$%&'()*+,-./01234456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]]^_`abcdefghijklmnopqrstuvwxyz{|}~88       !"#$%&'()*+*,*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>?@?A?B?C?D?E?F?G?H?I?J?K?L?M?N?O?P?QRSTUVW?X?Y?Z?[?\?]?^?_?`?a?b?c?d?e?f?g?h?ijkjljmjnjojpjqjrjsjtjujvjwjxjyjzj{j|j}j~jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj      !"#$#%#&#'#(#)#*+/persistent-sqlite-2.10.1-IgTFvcxMvpP6MORl7LBTOiDatabase.SqliteDatabase.Persist.SqliteSqliteStatusVerbSqliteStatusMemoryUsedSqliteStatusPagecacheUsedSqliteStatusPagecacheOverflowSqliteStatusScratchUsedSqliteStatusScratchOverflowSqliteStatusMallocSizeSqliteStatusPagecacheSizeSqliteStatusScratchSizeSqliteStatusMallocCount SqliteStatussqliteStatusCurrentsqliteStatusHighwaterConfig ConfigLogFn LogFunction StepResultRowDoneErrorErrorOK ErrorError ErrorInternalErrorPermission ErrorAbort ErrorBusy ErrorLocked ErrorNoMemory ErrorReadOnlyErrorInterruptErrorIO ErrorNotFound ErrorCorrupt ErrorFullErrorCan'tOpen ErrorProtocol ErrorEmpty ErrorSchema ErrorTooBigErrorConstraint ErrorMismatch ErrorMisuseErrorNoLargeFileSupportErrorAuthorization ErrorFormat ErrorRangeErrorNotAConnectionErrorRow ErrorDoneSqliteExceptionseErrorseFunctionName seDetails Statement ConnectionopencloseenableExtendedResultCodesdisableExtendedResultCodespreparestepstepConnresetfinalizebindBlob bindDoublebindInt bindInt64bindNullbindTextbindcolumncolumnschanges mkLogFunctionfreeLogFunctionconfigstatus softHeapLimit$fExceptionSqliteException$fShowSqliteException $fEqError $fShowError$fEqStepResult$fShowStepResult$fEqColumnType$fShowColumnType$fEqSqliteStatus$fShowSqliteStatusSqliteConnectionInfo SqliteConfSqliteConfInfo sqlDatabase sqlPoolSize sqlConnInfocreateSqlitePoolcreateSqlitePoolFromInfowithSqlitePoolwithSqlitePoolInfowithSqliteConnwithSqliteConnInfowrapConnection retryOnBusywaitForDatabasewrapConnectionInfo runSqlite runSqliteInfo mockMigrationmkSqliteConnectionInfo$fPersistConfigSqliteConf$fFromJSONSqliteConf$fShowSqliteConnectionInfo$fShowSqliteConf extraPragmas fkEnabledsqlConnectionStr walEnabled$fFromJSONSqliteConnectionInfoRawLogFunctionunsafeUseAsCStringLenNoNull_sqlConnectionStr _walEnabled _fkEnabled _extraPragmas(persistent-2.10.0-DqXk87WG2T8FMjcxU1xTqMDatabase.Persist.Sql.MigrationprintMigration safeToRemoveconStringToInfofinallyDatabase.Persist.SqltransactionUndoWithIsolationtransactionUndotransactionSaveWithIsolationtransactionSave addMigrations addMigration reportErrors reportErrormigraterunMigrationUnsaferunMigrationSilent runMigration getMigration showMigrationparseMigration'parseMigration(Database.Persist.Sql.Orphan.PersistQuerydecorateSQLWithLimitOffsetupdateWhereCountdeleteWhereCount(Database.Persist.Sql.Orphan.PersistStore fieldDBName getFieldName tableDBName getTableName fromSqlKeytoSqlKey withRawQueryDatabase.Persist.Sql.Runclose' withSqlConn askLogFunc createSqlPool withSqlPoolliftSqlPersistMPoolrunSqlPersistMPoolrunSqlPersistMrunSqlConnWithIsolation runSqlConnrunSqlPoolWithIsolation runSqlPoolDatabase.Persist.Sql.RawrawSql getStmtConnrawExecuteCount rawExecute rawQueryResrawQueryDatabase.Persist.Sql.ClassRawSql rawSqlColsrawSqlColCountReasonrawSqlProcessRowPersistFieldSqlsqlTypeDatabase.PersistlimitOffsetOrder toJsonText mapToJSON listToJSON||./<-.<-.>=.>.<=.<.!=.==./=.*=.-=.+=.=.Database.Persist.Sql.Internal mkColumnsdefaultAttributeDatabase.Persist.Sql.TypesColumncNamecNullcSqlTypecDefaultcDefaultConstraintNamecMaxLen cReferencePersistentSqlExceptionStatementAlreadyFinalizedCouldn'tGetSQLConnection SqlPersistT SqlPersistMSqlCautiousMigration MigrationConnectionPoolSingleunSingle#Database.Persist.Sql.Types.Internal readToUnknown readToWritewriteToUnknownLogFuncInsertSqlResult ISRSingle ISRInsertGet ISRManyKeys stmtFinalize stmtReset stmtExecute stmtQueryIsolationLevelReadUncommitted ReadCommittedRepeatableRead Serializable SqlBackend connPrepare connInsertSqlconnInsertManySql connUpsertSqlconnPutManySql connStmtMap connCloseconnMigrateSql connBegin connCommit connRollbackconnEscapeName connNoLimit connRDBMSconnLimitOffset connLogFunc connMaxParamsconnRepsertManySqlSqlReadBackendunSqlReadBackendSqlWriteBackendunSqlWriteBackendSqlBackendCanReadSqlBackendCanWriteSqlReadT SqlWriteT IsSqlBackendDatabase.Persist.Class PersistUnique PersistQuery PersistStore$Database.Persist.Class.DeleteCascadedeleteCascadeWhere DeleteCascade deleteCascade#Database.Persist.Class.PersistQueryselectKeysList selectList selectKeys selectSourcePersistQueryReadcountselectSourceRes selectFirst selectKeysResPersistQueryWrite updateWhere deleteWhere$Database.Persist.Class.PersistUnique checkUnique replaceUnique getByValue onlyUniqueinsertUniqueEntityinsertByPersistUniqueReadgetByPersistUniqueWritedeleteBy insertUniqueupsertupsertByputManyOnlyOneUniqueKey onlyUniquePNoUniqueKeysErrorMultipleUniqueKeysErrorAtLeastOneUniqueKeyrequireUniquesP#Database.Persist.Class.PersistStore insertRecord getEntity insertEntity belongsToJust belongsTo getJustEntitygetJust liftPersistHasPersistBackend BaseBackendpersistBackendIsPersistBackendBackendCompatibleprojectBackendPersistRecordBackend ToBackendKey toBackendKeyfromBackendKeySqlWriteBackendKeySqlReadBackendKey SqlBackendKeyunSqlWriteBackendKeyunSqlReadBackendKeyunSqlBackendKey PersistCore BackendKeyPersistStoreReadgetgetManyPersistStoreWritedeleteinsertupdateinsert_ insertMany insertMany_insertEntityMany insertKeyrepsert repsertManyreplace updateGet$Database.Persist.Class.PersistEntityfromPersistValueJSONtoPersistValueJSONentityIdFromJSONentityIdToJSONkeyValueEntityFromJSONkeyValueEntityToJSON entityValues PersistEntityUniqueKeyPersistEntityBackend EntityField keyToValues keyFromValuespersistIdField entityDefpersistFieldDeftoPersistFieldsfromPersistValuespersistUniqueKeyspersistUniqueToFieldNamespersistUniqueToValues fieldLensBackendSpecificUpdateUpdate BackendUpdate updateField updateValue updateUpdate SelectOptAscDescOffsetByLimitToBackendSpecificFilterFilter FilterAndFilterOr BackendFilter filterField filterValue filterFilter FilterValue FilterValues UnsafeValueEntity entityKey entityVal#Database.Persist.Class.PersistField getPersistMap PersistFieldtoPersistValuefromPersistValueSomePersistFieldDatabase.Persist.Types.BasefromPersistValueTexttoEmbedEntityDefkeyAndEntityFieldsentityKeyFields entityPrimary CheckmarkActiveInactive IsNullableNullable NotNullable WhyNullable ByMaybeAttrByNullableAttr EntityDef entityHaskellentityDBentityId entityAttrs entityFields entityUniquesentityForeigns entityDerives entityExtra entitySumentityComments ExtraLine HaskellName unHaskellNameDBNameunDBNameAttr FieldType FTTypeConFTAppFTListFieldDef fieldHaskellfieldDB fieldType fieldSqlType fieldAttrs fieldStrictfieldReference fieldComments ReferenceDef NoReference ForeignRefEmbedRef CompositeRef SelfReferenceEmbedEntityDefembeddedHaskellembeddedFields EmbedFieldDef emFieldDB emFieldEmbed emFieldCycle UniqueDef uniqueHaskell uniqueDBName uniqueFields uniqueAttrs CompositeDefcompositeFieldscompositeAttrsForeignFieldDef ForeignDefforeignRefTableHaskellforeignRefTableDBNameforeignConstraintNameHaskellforeignConstraintNameDBName foreignFields foreignAttrsforeignNullablePersistException PersistErrorPersistMarshalErrorPersistInvalidFieldPersistForeignConstraintUnmetPersistMongoDBErrorPersistMongoDBUnsupported PersistValue PersistTextPersistByteString PersistInt64 PersistDoublePersistRational PersistBool PersistDayPersistTimeOfDayPersistUTCTime PersistNull PersistList PersistMapPersistObjectId PersistArrayPersistDbSpecificSqlType SqlStringSqlInt32SqlInt64SqlReal SqlNumericSqlBoolSqlDaySqlTime SqlDayTimeSqlBlobSqlOther PersistFilterEqNeGtLtGeLeInNotInUpdateException KeyNotFound UpsertErrorOnlyUniqueException PersistUpdateAssignAddSubtractMultiplyDivide$Database.Persist.Class.PersistConfig PersistConfigPersistConfigBackendPersistConfigPool loadConfigapplyEnvcreatePoolConfigrunPool