h&9      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                      Safe-Inferred!().047: beam-migrate!es that can be serialized to JSON beam-migrate!es that can be serialized to JSONM beam-migrateSyntax equalities for any reasonable DDL syntax, only including types defined here.N beam-migrateSyntax equalities that any reasonable DDL syntax would follow, including equalities between beam-migrate and beam-core types.  beam-migrate On update  beam-migrate On delete $ beam-migrate Column type  beam-migrateDefault value  beam-migrateColumn constraints  beam-migrateDefault collation    $"#!%'&(/.-,+)*03124657<;8:9=CBA@>?DEFGHIJKLMNNMLKJIHGFED=CBA@>?7<;8:94650312(/.-,+)*%'& $"#!   Safe-Inferred!()047:@ O beam-migrateA predicate that depends on the name of a table and one of its fieldsQ beam-migrate5A predicate that depends on the name of a domain typeS beam-migrateAn optional predicate that depends on the name of a table as well as its fieldsU beam-migrateA name in a schemaW beam-migrateSome predicates make sense in any backend. Others only make sense in one. This denotes the difference.Z beam-migrate=A Database predicate is a value of any type which satisfies \. We often want to store these in lists and sets, so we need a monomorphic container that can store these polymorphic values.\ beam-migrateA predicate is a type that describes some condition that the database schema must meet. Beam represents database schemas as the set of all predicates that apply to a database schema. The  and  instances allow us to build HashSet1s of predicates to represent schemas in this way.] beam-migrateAn english language description of this predicate. For example, "There is a table named  TableName"^ beam-migrateWhether or not this predicate applies to all backends or only one backend. This is used when attempting to translate schemas between backends. If you are unsure, provide X2 along with an identifier unique to your backend._ beam-migrate Serialize a predicate to a JSON .` beam-migrateSome predicates require other predicates to be true. For example, in order for a table to have a column, that table must exist. This function takes in the current predicate and another arbitrary database predicate. It should return  if this predicate needs the other predicate to be true in order to exist. By default, this simply returns ), which makes sense for many predicates.a beam-migrateConvenience synonym for ZOPQRSTUVWYXZ[\`_^]a Safe-Inferred!().047:^m beam-migrate0A schema for a field which hasn't been named yeto beam-migrate)A schema for a field within a given tableq beam-migrateA table schema, produced by  createTablebcdefghijklmnopq Safe-Inferred!()047:#r beam-migrate2Provides a collection of deserializers from aeson s for arbitrary types. The cmd type parameter is a phantom type parameter. Notionally, all deserializers within this r relate to the cmd syntax.u beam-migrate is too complex for us to store in JSON. Additionally, many backends provide substantial amounts of extensions to the syntax that would make storing this highly unfeasible. Expressions are therefore represented as their full text rendering.>This means that expressions only match as equal if they match exactly. While this may seem overly pedantic, it's not much of a concern if your migrations are generated solely by  beam-migrate?. If you've modified the schema yourself, you may have to use IsCustomSqlSyntax! to provide an exact expression.x beam-migrate type for JSON{ beam-migrate type for JSON~ beam-migrate type for JSON beam-migrate  type for JSON beam-migrate type for JSON beam-migrateAn ) for JSON. Supports all superclasses of  declared in  beam-core. beam-migrateSome backends serialize data that can only be read by that backend. If so, they should wrap these data in , which provides a standard syntax for specifying backend specific data, as well as which backend the data are valid for.The first argument is a string that is unique to a given backend beam-migrateHelper for serializing the precision and decimal count parameters to , etc. beam-migrate+Helper function to deserialize data from a  . beamDeserializeMaybe _ Nothing = pure Nothing beamDeserializeMaybe d (Just v) = Just  $ beamDeserialize d v  beam-migrateDeserialize the requested type from the given deserializers and aeson . beam-migrate Deserializers for SQL92 syntaxes beam-migrate.Deserializes data types that are instances of  beam-migrate-Deserialize data types that are instances of  beam-migrate,Deserialize data types that are instance of !rstuvwxyz{|}~!~{|}xyzuvwrst Safe-Inferred!()047:' beam-migrateAsserts that the given table has a primary key made of the given columns. The order of the columns is significant. beam-migrate Table name  beam-migrate Column names  beam-migrateAsserts that a particular column of a table has a given constraint. The syntax) type parameter should be an instance of   beam-migrate Table name  beam-migrate Column name  beam-migrateConstraint definition  beam-migrateAsserts that the table specified has a column with the given data type. The type paramater syntax should be an instance of  . beam-migrate Table name  beam-migrate Column name  beam-migrate Data type  beam-migrateA class that can check whether a particular data type is present in a set of preconditions. beam-migrate=Asserts that a table with the given name exists in a database beam-migrate Table name  beam-migrater. for all the predicates defined in this module Safe-Inferred!().047:, beam-migrateUsed to define a default SQL data type for a haskell type in a particular backend, as well as any constraints that are neededBeam defines instances for several standard SQL types, which are polymorphic over any standard data type syntax. Backends or extensions which provide custom types should instantiate instances of this class for any types they provide for which they would like checked schema migrations beam-migrate&Provide a data type for the given type beam-migrateProvide arbitrary constraints on a field of the requested type. See O7 for more information on the formatting of constraints. beam-migrate#Concrete representation of the type beam-migrate&Concrete representation of the backend beam-migrate2 if this field is in an embedded key or table,  otherwise beam-migrate#Concrete representation of the type beam-migrate&Concrete representation of the backend beam-migrate0 if this field is embedded in a foreign key,  otherwise. For example, SERIAL types in postgres get a DEFAULT constraint, but SERIAL" types in a foreign key do not. Safe-Inferred!()047:7 beam-migratePurposefully opaque type describing how to modify a table field. Used to parameterize the second argument to 5. For now, the only way to construct a value is the 1 instance, which allows you to rename the field. beam-migrateThe type of a checked database descriptor. Conceptually, this is just a  with a set of predicates. Use  to get the regular  object and  to access the predicates. beam-migrateLike  but for checked databases beam-migrateLike  in  beam-core2, but for entities against which we can generate \&s. Conceptually, this is the same as +, but with one extra function to generate \s from the description. beam-migrateThe type of the descriptor for this checked entity. Usually this wraps the corresponding  from ,, along with some mechanism for generating \s. beam-migrateLike  but for checked entities beam-migrateProduce the corresponding  beam-migrate2A lens to access the internal unchecked descriptor beam-migrateProduce the set of \s that apply to this entity beam-migrateLike 4 but for checked databases. Most often, this wraps % and provides some means to generate \s beam-migrate Convert a  to a regular . The return value is suitable for use in any regular beam query or DML statement. beam-migrateA  beam-migrate database schema is defined completely by the set of predicates that apply to it. This function allows you to access this definition for a  object. beam-migrateModify a checked table.The first argument is a function that takes the original table name as input and produces a new table name.The second argument gives instructions on how to rename each field in the table. Use  to create a value of this type which does no renaming. Each field in the table supplied here has the type 0. Most commonly, the programmer will use the OverloadedStrings instance to provide a new name.Examples3Rename a table, without renaming any of its fields: modifyCheckedTable (_ -> NewTblNm) checkedTableModification *Modify a table, renaming the field called _field1 in Haskell to  FirstName. Note that below,  FirstName represents a  object.  field2 <- renameColumnTo NewNameForField2 (_field2 oldTbl') dropColumn (_field3 oldTbl') renameTableTo  NewTableName field4 <- addColumn (field  ANewColumn smallint notNull (defaultTo_ (val_ 0))) return (NewTable (_field1 oldTbl') field2 field4) (The above would result in commands like:  ALTER TABLE  oldtable RENAME COLUMN  field2 TO NewNameForField2; ALTER TABLE  oldtable DROP COLUMN  field3; ALTER TABLE  oldtable RENAME TO  NewTableName; ALTER TABLE  NewTableName ADD COLUMN  ANewColumn SMALLINT NOT NULL DEFAULT 0;  beam-migrateBuild a schema for a field. This function takes the name and type of the field and a variable number of modifiers, such as constraints and default values. GHC will complain at you if the modifiers do not make sense. For example, you cannot apply the  constraint to a column with a  type."Example of creating a table named Employee with three columns:  FirstName, LastName, and HireDate data Employee f = Employee { _firstName :: C f Text , _lastName :: C f Text , _hireDate :: C f (Maybe LocalTime) } deriving Generic instance Beamable Employee instance Table Employee where data PrimaryKey Employee f = EmployeeKey (C f Text) (C f Text) deriving Generic primaryKey = EmployeeKey <$> _firstName <*> _lastName instance Beamable PrimaryKey Employee f data EmployeeDb entity = EmployeeDb { _employees :: entity (TableEntity Employee) } deriving Generic instance Database EmployeeDb migration :: IsSql92DdlCommandSyntax syntax => Migration syntax () EmployeeDb migration = do employees <- createTable EmployeesTable# (Employee (field FirstNameField (varchar (Just 15)) notNull) (field "last_name" (varchar Nothing) notNull (defaultTo_ (val_ Smith))) (field "hiredDate" (maybeType timestamp))) return (EmployeeDb employees)  beam-migrateBuild a  from a ?. GHC will complain if you supply more than one default value. beam-migrate The SQL92 NOT NULL constraint beam-migrateSQL UNIQUE constraint Safe-Inferred!()047:Tj beam-migrateUsed to designate that a field should provide a default auto-incrementing value.Usage: field Key genericSerial 1Then, when inserting into the table, you can use default_ to request the database automatically assign a new value to the column. See runInsertReturning for another Beam extension that may help if you want to know which value was assigned.Note that this is only provided for convenience. Backends often implement auto-incrementing keys wildly differently. Many have restrictions on where  may appear and may fail at run-time if these conditions aren't met. Please refer to the backend of your choice for more information. Safe-Inferred!()047:T   $#"!!"#%&'(/.-,+*))*03211245657<;89:89:;=CBA@?>>?@DEFGHIJKLMNbcdefghijklmnopqqopmnlkjihgfedcb  Safe-Inferred!()047:W beam-migrateValid   shared among some backends. beam-migrateSome backends use this to represent their constraint attributes. Does not need to be used in practice. beam-migrate Options for  CREATE TABLE. Given as a separate ADT because the options may go in different places syntactically.0You never really need to use this type directly. beam-migrate Convert a  to its SQL92! representation in the returned  ByteString . beam-migrate Serialize a    Safe-Inferred!()047:X< Safe-Inferred!()047:YX beam-migrate>Produce a checked database for the given Haskell database typeSee  Some predicates have no dependence on a backend. For example,  has no parameters that depend on the backend. It can be converted straightforwardly: )trivialHsConverter @TableExistsPredicate  beam-migrateUtility function for converting a monomorphically typed predicate to a haskell one. beam-migrates can be combined monoidally. Safe-Inferred!()047:<   $#"!!"#%&'(/.-,+*))*03211245657<;89:89:;=CBA@?>>?@DEFGHIJKLMNOPQRSTUVWXYZ[\`_]^abcdefghijklmnopq  Safe-Inferred!()047: Safe-Inferred!()047: beam-migrateSelects a class of predicates to ignore if detected (e.g. metadata tables for migrations, other schemas, etc.). beam-migrateResult type for  beam-migrateExpected predicates from the + which were not found in the live database beam-migratePredicates found in the live database which are not present in the  and are not ignored beam-migrateResult type for  beam-migrateCalled before we're about to run an irreversible migration step. Return  to run the step, or  to abort immediately. beam-migrateCalled at the beginning of each step with the step index and description beam-migrateCalled at the end of each step with the step index and description beam-migrateCalled before a command is about to run. The first argument is the step index and the second is a string representing the command about to be run. beam-migrateCalled when a query fails beam-migrateCalled when the migration log has a discontinuity at the supplied index beam-migrateThe migration log at the given index is not what was expected. The first text is the actual commit id, the second, the expected beam-migrateThe database is ahead of the given migrations. The parameter supplies the number of entries passed the given migrations the database has. beam-migrateDefault set of . Refuses to run irreversible migrations, and fails in case of error, using . beam-migrateEquivalent to calling  with .Tries to bring the database up to date, using the database log and the given =. Fails if the migration is irreversible, or an error occurs. beam-migrateCheck for the beam-migrate log. If it exists, use it and the supplied migrations to bring the database up-to-date. Otherwise, create the log and run all migrations.Accepts a set of hooks that can be used to customize behavior. See the documentation for * for more information. Calling this with  is the same as using . beam-migrate&Attempt to find a SQL schema given an " and a checked database. Returns  if no schema could be found, which usually means you have chosen the wrong (, or the backend you're using is buggy. beam-migrateGiven a  and a , attempt to create the schema from scratch in the current database.May  if we cannot find a schema beam-migrateGiven a , attempt to automatically bring the current database up-to-date with the given . Fails (via ) if this involves an irreversible migration (one that may result in data loss). beam-migrateGiven a migration backend, a handle to a database, and a checked database, attempt to find a schema. This should always return 8, unless the backend has incomplete migrations support.*s can usually be found in a module named Database.Beam. Backend.Migrate with the namemigrationBackend beam-migrateVerify that the given, beam database matches the actual schema. On success, returns , on failure, returns " and a list of missing predicates. beam-migrateIgnore predicates relating to tables matching the given name predicate. beam-migrateIgnore any unknown predicates. This probably only makes sense to use if you are only querying and not writing to the database. beam-migrateChecks the given database settings against the live database. This is similar to , but detects and returns unknown predicates that are true about the live database (e.g. unknown tables, fields, etc.). beam-migrate(Run a sequence of commands on a database beam-migrate+Given a function to convert a command to a , produce a script that will execute the given migration. Usually, the function you provide eventually calls  to rendere the command. beam-migrateGiven a , get a string representing a Haskell module that would be a good starting point for further development.+For example, for a postgres database named chinook import Database.Beam.Migrate.Simple import Database.Beam.Postgres (runBeamPostgres) import Database.Beam.Postgres.Migrate (migrationBackend) import Database.PostgreSQL.Simple getSchema :: IO String getSchema = do pg <- connectPostgreSQL runBeamPostgres pg (haskellSchema migrationBackend)Backends that have a migration backend typically export it under the module name Database.Beam.Backend.Migrate.OPQRSTUVWXYZ[\`_]^a" !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcddeeffgghijkklmnopqrstuvwxyz{|}}~~                                                                                                                                                                                                                                                                                                                                                                                                                                          beam-migrate-0.5.2.0-inplaceDatabase.Beam.Migrate.SQL.SQL92Database.Beam.Migrate.TypesDatabase.Beam.Migrate.SQL#Database.Beam.Migrate.SerializationDatabase.Beam.Migrate.ChecksDatabase.Beam.Migrate.Generics Database.Beam.Migrate.SQL.Tables(Database.Beam.Migrate.SQL.BeamExtensions!Database.Beam.Migrate.SQL.BuilderDatabase.Beam.Haskell.SyntaxDatabase.Beam.Migrate.ActionsDatabase.Beam.Migrate.BackendDatabase.Beam.Migrate.LogDatabase.Beam.Migrate.Simple&Database.Beam.Migrate.Types.PredicatesDatabase.Beam.Migrate.SQL.Types%Database.Beam.Migrate.Generics.Tables+Database.Beam.Migrate.Types.CheckedEntities$Database.Beam.Migrate.Generics.TypesDatabase.Beam.Migrate+Sql92SerializableConstraintDefinitionSyntaxserializeConstraintSql92SerializableDataTypeSyntaxserializeDataTypeIsSql92ColumnConstraintSyntax$Sql92ColumnConstraintMatchTypeSyntax,Sql92ColumnConstraintReferentialActionSyntax%Sql92ColumnConstraintExpressionSyntaxnotNullConstraintSyntaxuniqueColumnConstraintSyntax primaryKeyColumnConstraintSyntaxcheckColumnConstraintSyntaxreferencesConstraintSyntax!IsSql92ConstraintAttributesSyntax initiallyDeferredAttributeSyntax!initiallyImmediateAttributeSyntaxnotDeferrableAttributeSyntaxdeferrableAttributeSyntax'IsSql92ColumnConstraintDefinitionSyntax/Sql92ColumnConstraintDefinitionConstraintSyntax/Sql92ColumnConstraintDefinitionAttributesSyntaxconstraintDefinitionSyntaxIsSql92ReferentialActionSyntaxreferentialActionCascadeSyntaxreferentialActionSetNullSyntax!referentialActionSetDefaultSyntaxreferentialActionNoActionSyntaxIsSql92MatchTypeSyntaxfullMatchSyntaxpartialMatchSyntaxIsSql92TableConstraintSyntaxprimaryKeyConstraintSyntaxIsSql92ColumnSchemaSyntax!Sql92ColumnSchemaColumnTypeSyntax!Sql92ColumnSchemaExpressionSyntax1Sql92ColumnSchemaColumnConstraintDefinitionSyntaxcolumnSchemaSyntaxIsSql92AlterColumnActionSyntaxsetNotNullSyntax setNullSyntaxIsSql92AlterTableActionSyntax&Sql92AlterTableAlterColumnActionSyntax!Sql92AlterTableColumnSchemaSyntaxalterColumnSyntaxaddColumnSyntaxdropColumnSyntaxrenameTableToSyntaxrenameColumnToSyntaxIsSql92AlterTableSyntaxSql92AlterTableTableNameSyntax%Sql92AlterTableAlterTableActionSyntaxalterTableSyntaxIsSql92DropTableSyntaxSql92DropTableTableNameSyntaxdropTableSyntaxIsSql92CreateTableSyntaxSql92CreateTableTableNameSyntax"Sql92CreateTableColumnSchemaSyntax%Sql92CreateTableTableConstraintSyntaxSql92CreateTableOptionsSyntaxcreateTableSyntaxIsSql92DdlCommandSyntax Sql92DdlCommandCreateTableSyntaxSql92DdlCommandAlterTableSyntaxSql92DdlCommandDropTableSyntaxcreateTableCmd dropTableCmd alterTableCmd%Sql92DdlCommandAlterTableActionSyntax)Sql92DdlCommandConstraintAttributesSyntax&Sql92DdlCommandReferentialActionSyntaxSql92DdlCommandMatchTypeSyntax%Sql92DdlCommandColumnConstraintSyntax$Sql92DdlColumnSchemaConstraintSyntax)Sql92DdlCommandConstraintDefinitionSyntax!Sql92DdlCommandColumnSchemaSyntaxSql92DdlCommandDataTypeSyntax$Sql92SaneDdlCommandSyntaxMigrateOnlySql92SaneDdlCommandSyntax FieldCheck DomainCheck TableCheck QualifiedNamePredicateSpecificityPredicateSpecificityOnlyBackendPredicateSpecificityAllBackendsSomeDatabasePredicateDatabasePredicateenglishDescriptionpredicateSpecificityserializePredicatepredicateCascadesDropOnp(BeamSqlBackendConstraintAttributesSyntax%BeamSqlBackendReferentialActionSyntaxBeamSqlBackendMatchTypeSyntaxBeamSqlBackendAlterTableSyntax BeamSqlBackendColumnSchemaSyntax#BeamMigrateSqlBackendDataTypeSyntax.BeamSqlBackendColumnConstraintDefinitionSyntaxBeamSqlBackendConstraintSyntaxBeamMigrateSql99BackendBeamMigrateSqlBackendBeamMigrateOnlySqlBackend FieldSchemaTableFieldSchema TableSchemaBeamDeserializersbeamArbitraryDeserializersBeamSerializedExpressionfromBeamSerializedExpressionBeamSerializedReferentialAction#fromBeamSerializedReferentialActionBeamSerializedMatchTypefromBeamSerializedMatchTypeBeamSerializedConstraintfromBeamSerializedConstraint"BeamSerializedConstraintAttributes&fromBeamSerializedConstraintAttributes"BeamSerializedConstraintDefinition&fromBeamSerializedConstraintDefinitionBeamSerializedDataTypefromBeamSerializedDataTypebeamSerializeJSONserializePrecAndDecimalbeamDeserializeMaybebeamDeserializebeamDeserializersql92Deserializerssql99DataTypeDeserializers.sql2003BinaryAndVarBinaryDataTypeDeserializers"sql2008BigIntDataTypeDeserializers$fToJSONBeamSerializedDataType5$fIsSql2008BigIntDataTypeSyntaxBeamSerializedDataType$fIsSql2003BinaryAndVarBinaryDataTypeSyntaxBeamSerializedDataType-$fIsSql99DataTypeSyntaxBeamSerializedDataType-$fIsSql92DataTypeSyntaxBeamSerializedDataType$fIsSql92ConstraintAttributesSyntaxBeamSerializedConstraintAttributes$fIsSql92ColumnConstraintDefinitionSyntaxBeamSerializedConstraintDefinition/$fIsSql92MatchTypeSyntaxBeamSerializedMatchType?$fIsSql92ReferentialActionSyntaxBeamSerializedReferentialAction7$fIsSql92ColumnConstraintSyntaxBeamSerializedConstraint#$fGCompareTYPEBeamDeserializerLabel$fGEqTYPEBeamDeserializerLabel$fMonoidBeamDeserializers$fSemigroupBeamDeserializers$fMonoidBeamDeserializer$fSemigroupBeamDeserializer$fShowBeamSerializedExpression$fEqBeamSerializedExpression%$fShowBeamSerializedReferentialAction#$fEqBeamSerializedReferentialAction$fShowBeamSerializedMatchType$fEqBeamSerializedMatchType$fShowBeamSerializedConstraint$fEqBeamSerializedConstraint($fShowBeamSerializedConstraintAttributes&$fEqBeamSerializedConstraintAttributes*$fMonoidBeamSerializedConstraintAttributes-$fSemigroupBeamSerializedConstraintAttributes($fShowBeamSerializedConstraintDefinition&$fEqBeamSerializedConstraintDefinition$fShowBeamSerializedDataType$fEqBeamSerializedDataTypeTableHasPrimaryKeyhasPrimaryKey_tablehasPrimaryKey_colsTableColumnHasConstrainthasConstraint_tablehasConstraint_columnhasConstraint_defnTableHasColumnhasColumn_tablehasColumn_columnhasColumn_typeHasDataTypeCreatedCheckdataTypeHasBeenCreatedTableExistsPredicatebeamCheckDeserializers'$fDatabasePredicateTableExistsPredicate$fHashableTableExistsPredicate!$fDatabasePredicateTableHasColumn$fEqTableHasColumn$fHashableTableHasColumn+$fDatabasePredicateTableColumnHasConstraint"$fHashableTableColumnHasConstraint%$fDatabasePredicateTableHasPrimaryKey$fHashableTableHasPrimaryKey$fShowTableHasPrimaryKey$fEqTableHasPrimaryKey$fGenericTableHasPrimaryKey!$fGenericTableColumnHasConstraint$fShowTableExistsPredicate$fEqTableExistsPredicate$fOrdTableExistsPredicate$fGenericTableExistsPredicate$fEqTableColumnHasConstraintHasDefaultSqlDataTypedefaultSqlDataTypedefaultSqlDataTypeConstraintsHasNullableConstraintNullableStatusCheckedFieldModificationCheckedDatabaseSettingsCheckedDatabaseEntityIsCheckedDatabaseEntityCheckedDatabaseEntityDescriptor(CheckedDatabaseEntityDefaultRequirementsunCheck unCheckedcollectEntityCheckscheckedDbEntityAutorenameCheckedEntityunCheckDatabase collectCheckscheckedFieldNamedmodifyCheckedTablecheckedTableModificationMigrationCommandmigrationCommand migrationCommandDataLossPossibleMigrationDataLossMigrationLosesDataMigrationKeepsData Migration MigrationFMigrationRunCommand_migrationUpCommand_migrationDownCommand_migrationNextMigrationSteps MigrationSteprunMigrationStepsrunMigrationSilencederaseMigrationType migrationStepupDown migrateScriptexecuteMigrationmigrationDataLossevaluateDatabase stepNames$fMonoidMigrationDataLoss$fSemigroupMigrationDataLoss$fShowMigrationDataLoss$fCategoryTYPEMigrationSteps$fArrowMigrationSteps$fShowMigrationCommand$fFunctorMigrationF$fFunctorMigrationStep IsNotNullFieldReturnTypefield'NotNullConstraint Constraint DefaultValueTableMigrationColumnMigrationcolumnMigrationFieldNamecolumnMigrationFieldChecks createTable dropTablepreserve renameTableTorenameColumnTo dropColumn addColumn alterTablefield defaultTo_notNullunique$fFieldReturnTypedefaultGivencollationGivenberesTyTableFieldSchema5$fFieldReturnTypedefaultGivencollationGivenberesTyFUN-$fFieldReturnTypeTruecollationGivenberesTyFUN6$fFieldReturnTypedefaultGivencollationGivenberesTyFUN0.$fFieldReturnTypeFalsecollationGivenberesTyFUN6$fFieldReturnTypedefaultGivencollationGivenberesTyFUN1$fMonadTableMigration$fApplicativeTableMigration$fFunctorTableMigrationBeamSqlBackendHasSerial genericSerialSqlConstraintAttributesBuilder_sqlConstraintAttributeTiming!_sqlConstraintAttributeDeferrableConstraintAttributeTimingInitiallyDeferredInitiallyImmediate"SqlSyntaxBuilderCreateTableOptionsfromSqlConstraintAttributes!sqlConstraintAttributesSerialized$$fSql92DisplaySyntaxSqlSyntaxBuilder0$fIsSql92ReferentialActionSyntaxSqlSyntaxBuilder($fIsSql92MatchTypeSyntaxSqlSyntaxBuilder/$fIsSql92ColumnConstraintSyntaxSqlSyntaxBuilder+$fIsSql92ColumnSchemaSyntaxSqlSyntaxBuilder.$fIsSql92TableConstraintSyntaxSqlSyntaxBuilder0$fIsSql92AlterColumnActionSyntaxSqlSyntaxBuilder/$fIsSql92AlterTableActionSyntaxSqlSyntaxBuilder)$fIsSql92AlterTableSyntaxSqlSyntaxBuilder($fIsSql92DropTableSyntaxSqlSyntaxBuilder)$fIsSql92DdlCommandSyntaxSqlSyntaxBuilder*$fIsSql92CreateTableSyntaxSqlSyntaxBuilder9$fIsSql92ColumnConstraintDefinitionSyntaxSqlSyntaxBuilder$fIsSql92ConstraintAttributesSyntaxSqlConstraintAttributesBuilder&$fMonoidSqlConstraintAttributesBuilder)$fSemigroupSqlConstraintAttributesBuilder$$fShowSqlConstraintAttributesBuilder"$fEqSqlConstraintAttributesBuilder$fShowConstraintAttributeTiming$fEqConstraintAttributeTiming$fOrdConstraintAttributeTiming$fEnumConstraintAttributeTiming"$fBoundedConstraintAttributeTiming&$fEqSqlSyntaxBuilderCreateTableOptionsdefaultMigratableDbSettingsHsMigrateBackendHsNoneHsModule hsModuleNamehsModuleEntitieshsModuleMigrationHsTableConstraintDeclshsTableConstraintInstancehsTableConstraintDeclsHsTableConstraint HsFieldLookup hsFieldLookupHsEntityhsEntityBackend hsEntityName hsEntityDeclshsEntityDbDecl hsEntityExp HsBeamBackendHsBeamBackendSingleHsBeamBackendConstrainedHsBeamBackendNoneHsBackendConstraintbuildHsBackendConstraintHsActionhsSyntaxMigrationhsSyntaxEntitiesHsDecl hsDeclSyntax hsDeclImports hsDeclExportsHsColumnSchemamkHsColumnSchemahsColumnSchemaTypeHsExpr hsExprSyntax hsExprImportshsExprConstraintshsExprTypeVariablesHsType hsTypeSyntax hsTypeImports HsDataTypehsDataTypeMigrationhsDataTypeTypehsDataTypeSerialized HsImportsHsImport HsImportAll HsImportSome HsEntityNamegetHsEntityNameHsConstraintDefinition hsConstraintDefinitionConstraint HsDbFieldbuildHsDbField importSome importTyNamedimportVarNamedhsActionsToModuleunqualentityDbFieldName derivingDecldataDecl insDataDecldatabaseTypeDeclmigrationTypeDecl migrationDecl dbTypeDecldbDeclrenderHsSchema hsMkTableNamehsTableVarNamehsTableTypeName hsErrorTypetyParens functionTytyTupletyApp tyConNamed tyVarNamed combineHsExprhsApphsVisibleTyApphsApApphsStrhsRecConhsMaybehsVar hsVarFromhsTyConhsInthsOp hsInstancehsDerivingInstancehsListhsTupleinstbeamMigrateSqlBackend$fHashableMaybePromotedName$fHashableDerivStrategy$fHashableCName$fHashableNamespace$fHashableImportSpec$fHashableBangType$fHashableGuardedRhs$fHashableRole$fHashableBooleanFormula$fHashableAnnotation$fHashableRuleVar$fHashableActivation$fHashableRule$fHashableSafety$fHashableCallConv$fHashablePatternSynDirection$fHashableMatch $fHashableOp$fHashableAssoc$fHashableInstDecl$fHashableOverlap$fHashableClassDecl$fHashableFunDep$fHashableInstHead$fHashableGadtDecl$fHashableFieldDecl$fHashableInstRule$fHashableDeriving$fHashableConDecl$fHashableXAttr$fHashableQualConDecl$fHashableBracket$fHashableDataOrNew$fHashableQualStmt$fHashableTypeEqn$fHashableFieldUpdate $fHashableRhs$fHashablePXAttr$fHashableInjectivityInfo$fHashableUnpackedness $fHashableAlt$fHashableResultSig$fHashableXName$fHashableRPatOp$fHashableStmt$fHashableRPat$fHashableIPBind$fHashableDeclHead$fHashableDecl$fHashablePatField$fHashableSplice$fHashableBinds$fHashablePromoted$fHashableBoxed$fHashableSign $fHashablePat$fHashableSpecialCon$fHashableContext$fHashableTyVarBind $fHashableQOp$fHashableType$fHashableName$fHashableLiteral$fHashableAsst$fHashableIPName$fHashableModuleName$fHashableQName $fHashableExp$fMonoidHsImport$fSemigroupHsImport$fHashableHsImport$fMonoidHsImports$fSemigroupHsImports$fHashableHsImports$fHashableHsType$fIsSql92FieldNameSyntaxHsExpr$fHasSqlValueSyntaxHsExprBool$fHasSqlValueSyntaxHsExprInt32$fIsSql92QuantifierSyntaxHsExpr!$fIsSql92ExtractFieldSyntaxHsExpr$fHashableHsExpr+$fSql92SerializableDataTypeSyntaxHsDataType)$fIsSql2008BigIntDataTypeSyntaxHsDataType5$fIsSql2003BinaryAndVarBinaryDataTypeSyntaxHsDataType!$fIsSql99DataTypeSyntaxHsDataType!$fIsSql92DataTypeSyntaxHsDataType$fIsSql92ExpressionSyntaxHsExpr#$fHasDataTypeCreatedCheckHsDataType$fSql92DisplaySyntaxHsDataType$fHashableHsDataType$fSql92SerializableConstraintDefinitionSyntaxHsConstraintDefinition*$fSql92DisplaySyntaxHsConstraintDefinition $fHashableHsConstraintDefinition)$fIsSql92ColumnSchemaSyntaxHsColumnSchema"$fSql92DisplaySyntaxHsColumnSchema$fHashableHsColumnSchema$fEqHsColumnSchema$fShowHsColumnSchema$fMonoidHsBeamBackend$fSemigroupHsBeamBackend $fIsSql92DropTableSyntaxHsAction!$fIsSql92DdlCommandSyntaxHsAction$fMonoidHsAction$fSemigroupHsAction$fMonoidHsTableConstraintDecls!$fSemigroupHsTableConstraintDecls/$fIsSql92TableConstraintSyntaxHsTableConstraint)$fIsSql92ConstraintAttributesSyntaxHsNone%$fIsSql92ColumnConstraintSyntaxHsExpr&$fIsSql92ReferentialActionSyntaxHsNone$fIsSql92MatchTypeSyntaxHsNone?$fIsSql92ColumnConstraintDefinitionSyntaxHsConstraintDefinition"$fIsSql92CreateTableSyntaxHsAction&$fIsSql92AlterColumnActionSyntaxHsNone%$fIsSql92AlterTableActionSyntaxHsNone!$fIsSql92AlterTableSyntaxHsAction$fMonoidHsNone$fSemigroupHsNone$fHashableHsNone+$fBeamMigrateOnlySqlBackendHsMigrateBackend $fShowHsNone $fEqHsNone $fOrdHsNone$fGenericHsNone$fShowHsConstraintDefinition$fEqHsConstraintDefinition$fGenericHsConstraintDefinition$fEqHsDataType$fShowHsDataType$fGenericHsDataType $fShowHsExpr $fEqHsExpr$fGenericHsExpr $fShowHsType $fEqHsType$fGenericHsType$fShowHsImports $fEqHsImports$fShowHsImport $fEqHsImport$fGenericHsImport$fShowHsEntityName$fEqHsEntityName$fOrdHsEntityName$fIsStringHsEntityName FinalSolutionSolved CandidatesSolverProvideSolution SearchFailed ChooseActionschoosingActionsAtStategetPotentialActionChoicepotentialActionChoicescontinueSearchActionProvidergetPotentialActionsActionProviderFnPotentialActionactionPreConditionsactionPostConditionsactionCommands actionEnglish actionScore DatabaseStatedbStateCurrentState dbStateKeydbStateCmdSequenceDatabaseStateSourceDatabaseStateSourceOriginalDatabaseStateSourceDerived ensuringNot_justOne_createTableActionProviderdropTableActionProvideraddColumnProvideraddColumnNullProviderdropColumnNullProviderdefaultActionProvider finalSolutionheuristicSolver$fNFDataDatabaseStateSource$fNFDataDatabaseState$fOrdMeasuredDatabaseState$fEqMeasuredDatabaseState$fNFDataMeasuredDatabaseState$fMonoidPotentialAction$fSemigroupPotentialAction$fMonoidActionProvider$fSemigroupActionProvider$fGenericMeasuredDatabaseState$fShowDatabaseStateSource$fEqDatabaseStateSource$fOrdDatabaseStateSource$fEnumDatabaseStateSource$fBoundedDatabaseStateSource$fGenericDatabaseStateSource$fShowFinalSolution$fShowMeasuredDatabaseState$fShowDatabaseStateHaskellPredicateConverterSomeCheckedDatabaseSettingsSomeBeamMigrationBackendBeamMigrationBackend backendNamebackendConnStringExplanationbackendGetDbConstraintsbackendPredicateParsersbackendRenderSyntaxbackendFileExtensionbackendConvertToHaskellbackendActionProviderbackendTransactDdlErrorsql92HsPredicateConvertershasColumnConvertertrivialHsConverterhsPredicateConverter!$fMonoidHaskellPredicateConverter$$fSemigroupHaskellPredicateConverter BeamMigrateDb_beamMigrateVersionTbl_beamMigrateLogEntriesBeamMigrateVersionKeyBeamMigrateVersionBeamMigrateVersionT_beamMigrateVersion LogEntryKeyLogEntry LogEntryT _logEntryId_logEntryCommitId _logEntryDatebeamMigratableDb beamMigrateDbbeamMigrateDbMigrationbeamMigrateSchemaVersiongetLatestLogEntryupdateSchemaToCurrent recordCommitensureBackendTablescheckForBackendTables$fBeamablePrimaryKey$fTableLogEntryT$fBeamableLogEntryT$fBeamablePrimaryKey0$fTableBeamMigrateVersionT$fBeamableBeamMigrateVersionT$fDatabasebeBeamMigrateDb$fGenericBeamMigrateDb$fGenericPrimaryKey$fGenericBeamMigrateVersionT$fGenericPrimaryKey0$fGenericLogEntryT$fShowPrimaryKey$fShowBeamMigrateVersionT$fShowPrimaryKey0$fShowLogEntryTIgnorePredicatesunIgnorePredicates CheckResultmissingPredicatesunexpectedPredicatesVerificationResultVerificationSucceededVerificationFailedBringUpToDateHooksrunIrreversibleHook startStepHook endStepHookrunCommandHookqueryFailedHookdiscontinuousMigrationsHooklogMismatchHookdatabaseAheadHookdefaultUpToDateHooks bringUpToDatebringUpToDateWithHooks simpleSchema createSchema autoMigratesimpleMigration verifySchema ignoreTables ignoreAll checkSchemarunSimpleMigrationbackendMigrationScript haskellSchema$fSemigroupIgnorePredicates$fMonoidIgnorePredicates$fEqCheckResult$fShowCheckResult$fShowVerificationResultbeam-core-0.10.0.0-inplaceDatabase.Beam.Backend.SQL.SQL92IsSql92DataTypeSyntax'hashable-1.3.5.0-Hd8HSYZ7DN8KsO4HNlPmYPData.Hashable.ClassHashableghc-prim GHC.ClassesEq$aeson-2.0.3.0-9MbFrYVk7aQFAnObTEUIaKData.Aeson.Types.InternalValue GHC.TypesTrueFalseqname qnameAsTextqnameAsTableNameIsSql92ExpressionSyntax decimalTypebase GHC.MaybeMaybeDatabase.Beam.Backend.SQL.SQL99IsSql99DataTypeSyntax!Database.Beam.Backend.SQL.SQL2003)IsSql2003BinaryAndVarBinaryDataTypeSyntaxIsSql2008BigIntDataTypeSyntaxGMigratableTableSettingsgDefaultTblSettingsChecks Data.StringIsStringDatabase.Beam.Schema.TablesDatabaseSettingsDatabaseEntityIsDatabaseEntityDatabaseEntityDescriptor!DatabaseEntityDefaultRequirements dbEntityAutoCheckedDatabaseDomainTypeCheckedDatabaseTableDatabase.Beam.Backend.SQL runNoReturnNothingDatabase.Beam.Query.InternalQExprbytestring-0.10.12.1 Data.ByteString.Builder.InternalBuilderGAutoMigratableDbdefaultMigratableDbSettings'MeasuredDatabaseStatedropColumnProvider solvedStateGHC.BasememptyString PrimaryKeyControl.Monad.FailfailJust displaySyntax