aF`      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_NoneKRepresents a value containing all the configuration options for a specific N backend. This abstraction makes it easier to write code that can easily swap  backends.  Load the config settings from a ` , most likely taken from a YAML  config file. ;Modify the config settings based on environment variables. ACreate a new connection pool based on the given config settings. <Run a database action by taking a connection from the pool. aaNoneCA SQL data type. Naming attempts to reflect the underlying Haskell L datatypes, eg SqlString instead of SqlVarchar. Different SQL databases may . have different translations for these types. a backend-specific name Always uses UTC timezone (HA raw value which can be stored in any backend and can be marshalled to  and from a  PersistField. )Using ): allows you to use types specific to a particular backend G For example, below is a simple example of the PostGIS geography type:    data Geo = Geo ByteString   instance PersistField Geo where 0 toPersistValue (Geo t) = PersistDbSpecific t  OfromPersistValue (PersistDbSpecific t) = Right $ Geo $ Data.ByteString.concat [', t, ']  fromPersistValue _ = Left 3Geo values must be converted from PersistDbSpecific  #instance PersistFieldSql Geo where  sqlType _ = SqlOther GEOGRAPHY(POINT,4326)  #toPoint :: Double -> Double -> Geo 1 toPoint lat lon = Geo $ Data.ByteString.concat ['POINT( , ps $ lon,   , ps $ lat, )'] $ where ps = Data.Text.pack . show QIf Foo has a geography field, we can then perform insertions like the following:   insert $ Foo (toPoint 44 44) *(Intended especially for MongoDB backend =Generic Exception GUsed instead of FieldDef & to generate a smaller amount of code R+An EmbedFieldDef is the same as a FieldDef ( But it is only used for embeddedFields * so it only has data needed for embedding V.An EmbedEntityDef is the same as an EntityDef ( But it is only used for fieldReference * so it only has data needed for embedding Z There are 3 kinds of references 3 1) composite (to fields that exist in the record)  2) single field  3) embedded  embedding isn't really a reference ]A ForeignRef has a late binding to the EntityDef it references via HaskellName and has the Haskell type of the foreign key in the form of FieldType aname of the field euser annotations for a field f/a strict field in the data type. Default: true kOptional module and name. The reason why a field is nullable is very important. A % field that is nullable because of a Maybe tag will have its  type changed from A to Maybe A. OTOH, a field that is  nullable because of a nullable tag will remain with the same  type. A + should be used as a field type whenever a ? uniqueness constraint should guarantee that a certain kind of @ record may appear at most once, but other kinds of records may  appear any number of times. NOTE: You need to mark any  Checkmark fields as nullable  (see the following example). For example, suppose there's a Location entity that $ represents where a user has lived:    Location  user UserId  name Text  current Checkmark nullable  UniqueLocation user current The UniqueLocation! constraint allows any number of   Locations to be current. However, there may be  at most one current Location per user (i.e., either zero  or one per user). 8This data type works because of the way that SQL treats  NULL4able fields within uniqueness constraints. The SQL  standard says that NULL values should be considered  different, so we represent  as SQL NULL, thus  allowing any number of  records. On the other hand,  we represent  as TRUE, so the uniqueness constraint  will disallow more than one  record. Note:0 There may be DBMSs that do not respect the SQL  standard's treatment of NULL values on uniqueness : constraints, please check if this data type works before  relying on it. The SQL BOOLEAN type is used because it's the smallest data ) type available. Note that we never use FALSE, just TRUE  and NULL. Provides the same behavior Maybe () would if  () was a valid  PersistField. ,When used on a uniqueness constraint, there  may be any number of  records. ,When used on a uniqueness constraint, there  may be at most one  record.   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~bcdefghijk  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&    '&%$#"! (6543210/.-,+*)7=<;:98>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ^]\[_`abcdefghkjilmnopqrst uvwxyz{|}~bcdefghijkNone.A value which can be marshalled to and from a (. 'lmnopqrstuvwxyz{|}~$lmnopqrstuvwxyz{|}~ None2Datatype that represents an entity, with both its  and $ its Haskell record representation. 2When using a SQL-based backend (such as SQLite or  PostgreSQL), an  may take any number of columns > depending on how many fields it has. In order to reconstruct " your entity on the Haskell side,  persistent needs all of < your entity columns and in the right order. Note that you  don'&t need to worry about this when using  persistent's API : since everything is handled correctly behind the scenes. =However, if you want to issue a raw SQL command that returns  an ., then you have to be careful with the column  order. While you could use SELECT Entity.* WHERE ... and < that would work most of the time, there are times when the = order of the columns on your database is different from the  order that  persistent( expects (for example, if you add a new ? field in the middle of you entity definition and then use the  migration code --  persistent! will expect the column to be in < the middle, but your DBMS will put it as the last column). > So, instead of using a query like the one above, you may use     (from the  Database.Persist.GenericSql module) with its /entity  selection placeholder/ (a double question mark ?? ). Using  rawSql$ the query above must be written as SELECT ?? WHERE  ... Then rawSql will replace ?? with the list of all ? columns that we need from your entity in the right order. If ' your query returns two entities (i.e. (Entity backend a,  Entity backend b)), then you must you use SELECT ??, ??  WHERE ... , and so on.  Filters which are available for select,  updateWhere and   deleteWhere4. Each filter constructor specifies the field being G filtered on, the type of comparison applied (equals, not equals, etc) & and the argument for the comparison. 1Persistent users use combinators to create these 4convenient for internal use, not needed for the API query options $Persistent users use these directly updataing a database entity 1Persistent users use combinators to create these 7Persistent serialized Haskell records to the database.  A Database , (A row in SQL, a document in MongoDB, etc)  corresponds to a  plus a Haskell record. NFor every Haskell record type stored in the database there is a corresponding  instance. A An instance of PersistEntity contains meta-data for the record. @ PersistEntity also helps abstract over different record types. 0 That way the same query interface can return a @, with each query returning different types of Haskell records. PSome advanced type system capabilities are used to make this process type-safe.  Persistent users usually don'>t need to understand the class associated data and functions. :Persistent allows multiple different backends (databases) :By default, a backend will automatically generate the key A Instead you can specify a Primary key made up of unique values. An 6 is parameterised by the Haskell record it belongs to ' and the additional type of that field Unique keys besided the Key a lower-level key operation a lower-level key operation 1a meta-operation to retrieve the Key EntityField 0retrieve the EntityDef meta-data for the record return meta-data for a given  8A meta-operation to get the database fields of a record LA lower-level operation to convert from database values to a Haskell record 1A meta operation to retrieve all the Unique keys A lower level operation A lower level operation Use a PersistField as a lens  Predefined toJSON . The resulting JSON looks like  {"key": 1, "value": {"name": ...}}. The typical usage is:   instance ToJSON User where % toJSON = keyValueEntityToJSON  Predefined  parseJSON. The input JSON looks like  {"key": 1, "value": {"name": ...}}. The typical usage is:   instance FromJSON User where * parseJSON = keyValueEntityFromJSON  Predefined toJSON . The resulting JSON looks like  {"id": 1, "name": ...}. The typical usage is:   instance ToJSON User where  toJSON = entityIdToJSON  Predefined  parseJSON. The input JSON looks like  {"id": 1, "name": ...}. The typical usage is:   instance FromJSON User where $ parseJSON = entityIdFromJSON 9Realistically this is only going to be used for MongoDB, ! so lets use MongoDB conventions 0-None  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~tuvwxyz{|}~spqrmnolhkji_`abcdefgZ^]\[VWXYRSTULMNOPQHIJKG>?@ABCDEF7=<;:98(6543210/.-,+*)'&%$#"!   None fields in other entity A line. We don')t care about spaces in the middle of the  line. Also, we don')t care about the ammount of indentation. A token used by the parser.  Token tok is token tok already unquoted. Spaces n are n consecutive spaces. 5Whether fields are by default strict. Default value: True.  Since 1.2 @Parses a quasi-quoted syntax into a list of entity definitions. Tokenize a string. <A string of tokens is empty when it has only spaces. There  can't be two consecutive , so this takes O(1) time. =Remove leading spaces and remove spaces in the middle of the  tokens. 6Divide lines into blocks and make entity definitions.  Construct an entity definition. 1name entity attributes indented lines   None*Get a record by identifier, if available. HCreate a new record in the database, returning an automatically created $ key (in SQL an auto-increment id). Same as  , but doesn' t return a Key. )Create multiple records in the database.  If you don't need the inserted Keys, use  >SQL backends currently use the slow default implementation of   mapM insert Same as  , but doesn' t return any Keys. @SQL backends currently use an efficient implementation for this  unlike . 9Create a new record in the database using the given key. 3Put the record in the database with the given key.  Unlike *, if a record with the given key does not + exist then a new record will be inserted. 2Replace the record in the database with the given < key. Note that the result is undefined if such record does  not exist, so you must use ' insertKey or  in  these cases. DDelete a specific record by identifier. Does nothing if record does  not exist. /Update individual fields on a specific record. @Update individual fields on a specific record, and retrieve the " updated value from the database. HNote that this function will throw an exception if the given key is not  found in the database. 8Same as get, but for a non-null (not Maybe) foreign key J Unsafe unless your database is enforcing that the foreign key is valid Icurry this to make a convenience function that loads an associated model  foreign = belongsTo foerignId same as belongsTo, but uses getJust# and therefore is similarly unsafe   None EUpdate individual fields on any record matching the given criterion. 1Delete all records matching the given criterion. EGet all records matching the given criterion in the specified order.  Returns also the identifiers. ,get just the first record for the criterion Get the /s of all records matching the given criterion. <The total number of records fulfilling the given criterion. EGet all records matching the given criterion in the specified order.  Returns also the identifiers. Get the /s of all records matching the given criterion. Call " but return the result as a list. Call " but return the result as a list. NoneNone 1Queries against unique keys (other than the id). HPlease read the general Persistent documentation to learn how to create  Unique keys.  SQL backends automatically create uniqueness constraints, but for MongoDB you must manually place a unique index on the field. Some functions in this module (insertUnique, insertBy, and replaceUnique) first query the unique indexes to check for conflicts. u You could instead optimistically attempt to perform the operation (e.g. replace instead of replaceUnique). However, g there is some fragility to trying to catch the correct exception and determing the column of failure. C an exception will automatically abort the current SQL transaction GGet a record by unique key, if available. Returns also the identifier. BDelete a specific record by unique key. Does nothing if no record  matches. Like , but returns  when the record  couldn'2t be inserted because of a uniqueness constraint. 1update based on a uniquness constraint or insert +insert the new record if it does not exist B update the existing record that matches the uniqueness contraint AThrows an exception if there is more than 1 uniqueness contraint JInsert a value, checking for conflicts with any unique constraints. If a 5 duplicate exists in the database, it is returned as . Otherwise, the  new 'Key is returned as . *Return the single unique key for a record A modification of , which takes the  itself instead  of a ! value. Returns a value matching one of the unique keys. This 9 function makes the most sense on entities with a single   constructor. JAttempt to replace the record of the given key with the given new record. ^ First query the unique fields to make sure the replacement maintains uniqueness constraints.  Return  if the replacement was made. % If uniqueness is violated, return a  with the  violation Since 1.2.2.0 KCheck whether there are any conflicts for unique keys with this entity and $ existing entities in the database. Returns C if the entity would be unique, and could thus safely be inserted. + on a conflict returns the conflicting key new record to insert 1updates to perform if the record already exists. 6 leaving this empty is the equivalent of performing a  on a unique key. /the record in the database after the operation  NoneIINoneA single column (see rawSql). Any  PersistField may be  used here, including ( (which does not do any  processing). Ctable name, column names, id name, either 1 or 2 statements to run 3      !"1      !"     "! None$1Create the list of columns for the given entity. #$#$#$None%assign a field a value & assign a field by addition (+=) '#assign a field by subtraction (-=) (&assign a field by multiplication (*=) )assign a field by division (/=) 0In 1NotIn 2the OR of two lists of filters %&'()*+,-./0123456  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~%&'()*+,-./0123456%&'()*+,.-/0123456%&'()*+,-./0123456None78A class for all numeric SQL keys, for easy conversion to/from Int64 values.  Since 2.0.2 <1Class for data types that may be retrived from a rawSql  query. =9Number of columns that this data type needs and the list  of substitutions for SELECT placeholders ??. >7A string telling the user why the column count is what  it is. ?2Transform a row of the result into the data type.  Since 1.0.1. @789:;<=>?@A 789:;<=>?@A:789:;<=>?@ANoneG8Execute a raw SQL statement and return its results as a  list. If you' re using s# (which is quite likely), then you  must4 use entity selection placeholders (double question  mark, ?? ). These ??$ placeholders are then replaced for : the names of the columns that we need for your entities.  You'll receive an error if you don't use the placeholders.  Please see the s! documentation for more details. 0You may put value placeholders (question marks, ? ) in your @ SQL query. These placeholders are then replaced by the values > you pass on the second parameter, already correctly escaped.  You may want to use  to help you constructing  the placeholder values.  Since you'&re giving a raw SQL statement, you don' t get any " guarantees regarding safety. If G is not able to parse > the results of your query back, then an exception is raised. : However, most common problems are mitigated by using the  entity selection placeholder ??, and you shouldn' t see any  error at all if you' re not using . BCDEFG+SQL statement, possibly with placeholders. !Values to fill the placeholders. BCDEFGBCDEFGNoneHJGet a connection from the pool, run the given action, and then return the  connection to the pool. ILike *, but times out the operation if resource ? allocation does not complete within the given timeout period.  Since 2.0.0 HITimeout period in microseconds JKLMcreate a new connection connection count NOPQ HIJKLMNOPQ HIJKLMNOPQNoneWSame as V2, but returns a list of the SQL commands executed % instead of printing them to stderr. JSort the alter DB statements so tables are created before constraints are  added. RSTUVW is silent? XYRSTUVWXYRSTUVWXYNoneZ@AZZNone[Same as +, but returns the number of rows affected.  Since 1.1.5 \Same as +, but returns the number of rows affected.  Since 1.1.5 ]CGenerates sql for limit and offset for postgres, sqlite and mysql.    [\  include table name? include WHERE? include table name? include the table name ][\]    [\  ]NoneNone^4Commit the current transaction and begin a new one.  Since 1.2.0 _7Roll back the current transaction and begin a new one.  Since 1.2.0 ^_Y  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHJKLMNOPQRSTUVWXYZ[\]^_^"!      <=>?:;@A789HIJKLMNOPQRSTUVWXY@AZBCDEG[\^_F$#]^_ !"#$%&&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVVWXYZ[\]^__`abbcdefgghijjklmnopqrrstuvwxyz{|}~        +                         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~          persistent-2.0.3Database.Persist.ClassDatabase.Persist.TypesDatabase.PersistDatabase.Persist.QuasiDatabase.Persist.Sql$Database.Persist.Class.PersistConfigDatabase.Persist.Types.Base#Database.Persist.Class.PersistField$Database.Persist.Class.PersistEntityDatabase.Persist.GenericSqlrawSql#Database.Persist.Class.PersistStore#Database.Persist.Class.PersistQuery$Database.Persist.Class.DeleteCascade$Database.Persist.Class.PersistUniqueDatabase.Persist.Sql.TypesDatabase.Persist.Sql.InternalDatabase.Persist.Sql.ClassDatabase.Persist.Sql.RawDatabase.Persist.Sql.RunDatabase.Persist.Sql.Migration(Database.Persist.Sql.Orphan.PersistStore(Database.Persist.Sql.Orphan.PersistQuery)Database.Persist.Sql.Orphan.PersistUnique PersistConfigPersistConfigBackendPersistConfigPool loadConfigapplyEnvcreatePoolConfigrunPool PersistUpdateDivideMultiplySubtractAddAssignOnlyUniqueExceptionUpdateException UpsertError KeyNotFound PersistFilterBackendSpecificFilterNotInInLeGeLtGtNeEqSqlTypeSqlOtherSqlBlob SqlDayTimeSqlTimeSqlDaySqlBool SqlNumericSqlRealSqlInt64SqlInt32 SqlString PersistValuePersistDbSpecificPersistObjectId PersistMap PersistList PersistNullPersistUTCTimePersistTimeOfDay PersistDay PersistBoolPersistRational PersistDouble PersistInt64PersistByteString PersistTextPersistExceptionPersistMongoDBUnsupportedPersistMongoDBErrorPersistForeignConstraintUnmetPersistInvalidFieldPersistMarshalError PersistError ForeignDefforeignRefTableHaskellforeignRefTableDBNameforeignConstraintNameHaskellforeignConstraintNameDBName foreignFields foreignAttrsforeignNullableForeignFieldDef CompositeDefcompositeFieldscompositeAttrs UniqueDef uniqueHaskell uniqueDBName uniqueFields uniqueAttrs EmbedFieldDef emFieldDB emFieldEmbedEmbedEntityDefembeddedHaskellembeddedFields ReferenceDef CompositeRefEmbedRef ForeignRef NoReferenceFieldDef fieldHaskellfieldDB fieldType fieldSqlType fieldAttrs fieldStrictfieldReference FieldTypeFTListFTApp FTTypeConAttrDBNameunDBName HaskellName unHaskellName ExtraLine EntityDef entityHaskellentityDBentityId entityAttrs entityFields entityUniquesentityForeigns entityDerives entityExtra entitySum WhyNullableByNullableAttr ByMaybeAttr IsNullable NotNullableNullable CheckmarkInactiveActive entityPrimarytoEmbedEntityDeftoEmbedFieldDeffromPersistValueTextSomePersistField PersistFieldtoPersistValuefromPersistValue getPersistMapEntity entityKey entityValFilter BackendFilterFilterOr FilterAnd filterField filterValue filterFilter SelectOptLimitToOffsetByDescAscUpdate BackendUpdate updateField updateValue updateUpdate PersistEntityPersistEntityBackendKey EntityFieldUnique keyToValues keyFromValuespersistIdField entityDefpersistFieldDeftoPersistFieldsfromPersistValuespersistUniqueKeyspersistUniqueToFieldNamespersistUniqueToValues fieldLenskeyValueEntityToJSONkeyValueEntityFromJSONentityIdToJSONentityIdFromJSONPersistSettings psToDBNamepsStrictFieldsupperCaseSettingslowerCaseSettingsparsenullable PersistStore BackendKeygetinsertinsert_ insertMany insertMany_ insertKeyrepsertreplacedeleteupdate updateGetHasPersistBackendpersistBackend liftPersistgetJust belongsTo belongsToJust PersistQuery updateWhere deleteWhereselectSourceRes selectFirst selectKeysRescount selectSource selectKeys selectListselectKeysList DeleteCascade deleteCascadedeleteCascadeWhere PersistUniquegetBydeleteBy insertUniqueupsertinsertBy onlyUnique getByValue replaceUnique checkUniqueSingleunSingleConnectionPool MigrationCautiousMigrationSql SqlPersistM SqlPersist SqlPersistT SqlBackendPersistentSqlExceptionCouldn'tGetSQLConnectionStatementAlreadyFinalizedColumncNamecNullcSqlTypecDefaultcDefaultConstraintNamecMaxLen cReference Statement stmtFinalize stmtReset stmtExecute stmtQueryLogFunc Connection connPrepare connInsertSql connStmtMap connCloseconnMigrateSql connBegin connCommit connRollbackconnEscapeName connNoLimit connRDBMSconnLimitOffset connLogFuncInsertSqlResult ISRManyKeys ISRInsertGet ISRSingledefaultAttribute mkColumns=.+=.-=.*=./=.==.!=.<.<=.>.>=.<-./<-.||. listToJSON mapToJSON toJsonTextlimitOffsetOrderIsSqlKeytoSqlKey fromSqlKeyPersistFieldSqlsqlTypeRawSql rawSqlColsrawSqlColCountReasonrawSqlProcessRow defaultIdName sqlIdNamerawQuery rawQueryRes rawExecuterawExecuteCount getStmtConn runSqlPoolwithResourceTimeout runSqlConnrunSqlPersistMrunSqlPersistMPool withSqlPool createSqlPool askLogFunc withSqlConnclose'parseMigrationparseMigration'printMigration getMigration runMigrationrunMigrationSilentrunMigrationUnsafemigrate withRawQuerydeleteWhereCountupdateWhereCountdecorateSQLWithLimitOffsettransactionSavetransactionUndo aeson-0.7.0.6Data.Aeson.Types.InternalValue$fPersistConfigEither$fExceptionOnlyUniqueException$fShowOnlyUniqueException$fExceptionUpdateException$fShowUpdateException$fFromJSONPersistValue$fToJSONPersistValue$fPathPiecePersistValue$fErrorPersistException$fExceptionPersistException$fPathPieceCheckmarkfromPersistListfromPersistMap$fPersistFieldCheckmark$fPersistFieldSomePersistField$fPersistFieldPersistValue$fPersistFieldMap$fPersistField(,)$fPersistFieldSet$fPersistFieldVector$fPersistField[]$fPersistFieldMaybe$fPersistFieldUTCTime$fPersistFieldTimeOfDay$fPersistFieldDay$fPersistFieldBool$fPersistFieldRatio$fPersistFieldFixed$fPersistFieldDouble$fPersistFieldWord64$fPersistFieldWord32$fPersistFieldWord16$fPersistFieldWord8$fPersistFieldWord$fPersistFieldInt64$fPersistFieldInt32$fPersistFieldInt16$fPersistFieldInt8$fPersistFieldInt$fPersistFieldMarkupM$fPersistFieldText$fPersistFieldText0$fPersistFieldByteString$fPersistField[]0idFieldBackendSpecificUpdateerrMsg$fPersistFieldEntity_unboundFieldsLineTokenSpacestokenizeempty removeSpaces parseLines mkEntityDefUnboundForeignDef_unboundForeignDefUnboundEntityDef_unboundForeignDefsunboundEntityDef lineIndenttokens ParseState PSSuccessPSFailPSDoneparseFieldTypefixForeignKeysAll lookupKeyVal lookupPrefixjust1 mkAutoIdField keyConName splitExtras takeColsExtakeCols getDbNametakeConstrainttakeId takeCompositetakeUniq takeForeign takeDerivesbase Data.MaybeNothing Data.EitherLeftRightJustonlyUniqueEithercheckUniqueKeys!$fExceptionPersistentSqlException'$fHasPersistBackendConnectionConnectionrefNameresolveTableName $fRawSqlMaybefrom3to3from4to4from5to5from6to6from7to7from8to8 extractMaybe$fPersistFieldSqlEntity$fPersistFieldSqlRatio$fPersistFieldSqlFixed$fPersistFieldSqlCheckmark$fPersistFieldSqlPersistValue$fPersistFieldSqlMap$fPersistFieldSql(,)$fPersistFieldSqlSet$fPersistFieldSqlVector$fPersistFieldSql[]$fPersistFieldSqlUTCTime$fPersistFieldSqlTimeOfDay$fPersistFieldSqlDay$fPersistFieldSqlBool$fPersistFieldSqlDouble$fPersistFieldSqlWord64$fPersistFieldSqlWord32$fPersistFieldSqlWord16$fPersistFieldSqlWord8$fPersistFieldSqlWord$fPersistFieldSqlInt64$fPersistFieldSqlInt32$fPersistFieldSqlInt16$fPersistFieldSqlInt8$fPersistFieldSqlInt$fPersistFieldSqlMarkupM$fPersistFieldSqlText$fPersistFieldSqlText0$fPersistFieldSqlByteString$fPersistFieldSql[]0$fRawSql(,,,,,,,)$fRawSql(,,,,,,)$fRawSql(,,,,,)$fRawSql(,,,,) $fRawSql(,,,) $fRawSql(,,) $fRawSql(,)$fRawSqlEntity$fRawSqlSinglegetStmtresource-pool-0.2.3.1 Data.Pool withResourcesortMigrationsallSql unsafeSqlsafeSql runMigration'executeMigrate dummyFromKey insrepHelperupdateFieldDefupdatePersistValue$fPersistStoreConnection$fIsSqlKeyBackendKey SqlBackendKeyunSqlBackendKeyOrNullOrNullNo OrNullYes fieldName isIdFielddummyFromFiltsgetFiltsValuesfilterClauseHelper filterClause orderClause$fPersistQueryConnectiondummyFromUnique$fPersistUniqueConnection