}      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 89 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~              None&'+-036;<=>?FQSTVh'!es that can be serialized to JSON!es that can be serialized to JSONA0Type classes for syntaxes which can be displayedBRender the syntax as a 0, representing the SQL expression it stands forL8Command syntaxes that can be used to issue DDL commands.  On update  On delete $ Column type Default value Column constraints Default collation M   $"!#%'&(/.-,+)*0213459876:@?>=;<ABCDEFGHIJKLMLKJIHGFEDCAB:;<=>?@5678934012()*+,-./%&' !"#$    !"#$%&'()*+,-./0123456789:;<=>?@ABNone&'-036;<=>?FKNQSTVhG M2Provides a collection of deserializers from aeson s for arbitrary types. The cmdX type parameter is a phantom type parameter. Notionally, all deserializers within this M relate to the cmd syntax.P 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 exactlyo. 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.S type for JSONV type for JSONY type for JSON\  type for JSON_ type for JSONbAn ) for JSON. Supports all superclasses of  declared in  beam-core.ekSome backends serialize data that can only be read by that backend. If so, they should wrap these data in e{, 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 backendfFHelper for serializing the precision and decimal count parameters to , etc.g+Helper function to deserialize data from a  . UbeamDeserializeMaybe _ Nothing = pure Nothing beamDeserializeMaybe d (Just v) = Just  $ beamDeserialize d v hFDeserialize the requested type from the given deserializers and aeson .j Deserializers for SQL92 syntaxesk.Deserializes data types that are instances of l-Deserialize data types that are instances of m,Deserialize data types that are instance of !MNOPQRSTUVWXYZ[\]^_`abcdefghijklm!bcd_`a\]^YZ[VWXSTUPQRefMNOhgijklm MNOPQRSTUVWXYZ[\]^_`abcdNone&'-036;<=>?FKQSTVhIsnPO>=@?MLAEUTSRYVZfeXdcbWaQ[`N_^KD]\CBJIHGF<;:9876543210/.-,+*)('&%$#"!      None&'-036;<=>?FQSTVhi) EA predicate that depedns on the name of a table and one of its fields5A predicate that depends on the name of a domain typeEA predicate that depends on the name of a table as well as its fieldsgSome predicates make sense in any backend. Others only make sense in one. This denotes the difference.=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.A 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.YAn english language description of this predicate. For example, "There is a table named  TableName"Whether 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 2 along with an identifier unique to your backend. Serialize a predicate to a JSON .Some 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 K 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.Convenience synonym for None&'-036;<=>?FQSTVhn[A data type in a given IsSql92DataTypeSyntax9 which describes a SQL type mapping to the Haskell type a0A schema for a field which hasn't been named yet)A schema for a field within a given tableA table schema, produced by  createTableNone&'-036;<=>?FQSTVhysAsserts that the given table has a primary key made of the given columns. The order of the columns is significant. Table name  Column names IAsserts that a particular column of a table has a given constraint. The syntax) type parameter should be an instance of   Table name  Column name Constraint definition \Asserts that the table specified has a column with the given data type. The type paramater syntax should be an instance of  . Table name  Column name  Data type =Asserts that a table with the given name exists in a database Table name M. for all the predicates defined in this moduleNone&'+-036;<=>?FQSTVhCConstraint synonym to use if you want to assert that a particular 6 syntax supports defaulting for a particular data type\Used to define a default SQL data type for a haskell type in a particular data type syntax.Beam 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 and P for any types they provide for which they would like checked schema migrations&Provide a data type for the given typeBCertain data types also come along with constraints. For example, SERIAL* types in Postgres generate an automatic DEFAULT constraint.You need an instance of this class for any type for which you want beam to be able to infer the SQL data type. If your data type does not have any constraint requirements, you can just declare an empty instanceEProvide arbitrary constraints on a field of the requested type. See 7 for more information on the formatting of constraints.#Concrete representation of the type2 if this field is in an embedded key or table,  otherwise#Concrete representation of the type%Concrete representation of the syntax0 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.None&'-036;<=>?FQSTVh nPurposefully 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.IThe 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.Like  but for checked databasesLike  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.ZThe type of the descriptor for this checked entity. Usually this wraps the corresponding  from ,, along with some mechanism for generating s.Like  but for checked entitiesProduce the corresponding DatabaseEntityDescriptiorProduce the set of s that apply to this entityLike 4 but for checked databases. Most often, this wraps % and provides some means to generate s Convert a  to a regular S. The return value is suitable for use in any regular beam query or DML statement.A  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.Modify a checked table.nThe first argument is a function that takes the original table name as input and produces a new table name.XThe second argument gives instructions on how to rename each field in the table. Use q 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. <modifyCheckedTable id (checkedTableModification { _field1 =  FirstName }) 4Produce a table field modification that does nothing1Most commonly supplied as the second argument to ; when you just want to rename the table, not the fields.None&'-03456;<=>?FKQSTVh,What to execute when applying the migration .What to execute when unapplying the migration hExecute a given migration, provided a command to execute arbitrary syntax. You usually use this with .63None&'-036;<=>?AFQSTVh"9Represents a constraint in the given column schema syntaxRRepresents the default value of a field with a given column schema syntax and typeMonad representing a series of  ALTER TABLE statements(A column in the process of being alteredAdd a  CREATE TABLE statement to this migration,The first argument is the name of the table.,The second argument is a table containing a - for each field. See documentation on the Field command for more information.Add a  DROP TABLE statement to this migration.0Copy a table schema from one database to anotherALTER TABLE ... RENAME TO command(ALTER TABLE ... RENAME COLUMN ... TO ... commandALTER TABLE ... DROP COLUMN ... commandALTER TABLE ... ADD COLUMN ... commandCompose a series of  ALTER TABLE commands Example usage Zmigrate (OldDb oldTbl) = do alterTable oldTbl $ oldTbl' -> field2 <- renameColumnTo NewNameForField2F (_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; Build 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 Rdata 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  *8 _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 FirstNameFieldx (varchar (Just 15)) notNull) (field "last_name" (varchar Nothing) notNull (defaultTo_ (val_ Smithj))) (field "hiredDate" (maybeType timestamp))) return (EmployeeDb employees) Build a  from a ?. GHC will complain if you supply more than one default value. The SQL92 NOT NULL constraintSQL92 INTEGER data typeSQL92 SMALLINT data typeSQL2008 Optional BIGINT data typeSQL2003 Optional BINARY data typeSQL2003 Optional  VARBINARY data typeSQL92 DATE data typeSQL92 CHAR data typeSQL92 VARCHAR data typeSQL92 DOUBLE data typeSQL92 NUMERIC data typeSQL92 TIMESTAMP WITH TIME ZONE data typeSQL92 TIMESTAMP WITHOUT TIME ZONE data typeSQL92 TIME data type SQL99 BOOLEAN data type SQL99 CLOB data type SQL99 BLOB data type SQL99 array data types Haskell requires 4s to match exactly. Use this function to convert a 2 that expects a concrete value to one expecting a Wrap a  in )     )      None&'-036;<=>?FQSTVhPUsed to designate that a field should provide a default auto-incrementing value.Usage: field Key int genericSerial 1Then, when inserting into the table, you can use default_S to request the database automatically assign a new value to the column. See runInsertReturningZ 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.None&'-036;<=>?FQSTVh}  !#"$%&'(*)+,-./0123456789:<;=>?@ABCDEFGHIJKL      None&'-036;<=>?FQSTVh Valid   shared among some backends.gSome backends use this to represent their constraint attributes. Does not need to be used in practice. Options for  CREATE TABLEX. Given as a separate ADT because the options may go in different places syntactically.0You never really need to use this type directly. Convert a  to its SQL92! representation in the returned  ByteString .  Serialize a   +*)(',&/ .%-$#"!None&'-036;<=>?FQSTVh ~None&'-036;<=>?FQSTVh<8>Produce a checked database for the given Haskell database typeSee  9http://tathougies.github.io/beam/schema-guide/migrations/ the manual' for more information on the defaults.88 None"#&'-036;<=>?FNQSTVht<%9(Represents the final results of a search:xThe search found a path from the source to the destination database, and has provided a set of commands that would work;)The search failed, but provided a set of  DatbaseStaters it encountered that were the closest to the destination database. By default, only 10 candidates are provided.<4Represents current state of a database graph search.If =, the destination database has been reached, and the given list of commands provides the path from the source database to the destination.If >&, the search has failed. The provided Os represent the closest we could make it to the destination database. By default, only the best 10 are kept around (to avoid unbounded memory growth).If ?, we are still searching. The caller is provided with the current state as well as a list of actions, provided as an opaque type f. The A" function can be used to get the H corresponding to any given f. The caller is free to cull the set of potential actions according however they'd like (for example, by prompting the user). The selected actions to explore should be passed to the C function. Use of the f existential type may seem obtuse, but it prevents the caller from injecting arbitrary actions. Instead the caller is limited to choosing only valid actions as provided by the suppled D.@#The current node we're searching atAConvert the opaque f type to a H. This can be used to present the actions to the user or to inspect the action to make a more informed choice on exploration strategies.BMThe possible actions that we can take, presented as an opaque list. Use the A$ function to get the corresponding H.C%Continue the search and get the next <D1Edge discovery mechanism. A newtype wrapper over G.An G] takes two arguments. The first is the set of predicates that exist in the current database.:The function should a set of edges from the database specified in the first argument to possible destination databases. For optimization purposes, the second argument is the set of predicates that ought to exist in the destination database. This can be used to eliminate edges that will not lead to a solution.This second argument is just an optimization and doesn't change the final result, although it can significantly impact the time it takes to get there.Both the current database set and the destination database set are given as polymorphic lists of predicates. When you instantiate the type, the current database predicate set is queried for predicates of that type. For example, Z provides a  DROP TABLEh action edge whenever it encounters a table that exists. In order to do this, it attempts to find all 5 that do not exist in the destination database. Its G may be implemented like such: dropTableActionProvider preConditions postConditions = do TableExistsPredicate srcTblNm <- preConditions ensuringNot_ $ $ do TableExistsPredicate destTblNm <- postConditions guard (srcTblNm == destTblNm)W is a function that causes the action provider to return no results if there are any elements in the provided list. In this case, it's used to stop  DROP TABLEK action generation for tables which must be present in the final database.GSee DH5Represents an edge (or a path) in the database graph.eGiven a particular starting point, the destination database is the database where each predicate in J) has been removed and each predicate in K has been added.J'Preconditions that will no longer applyK+Conditions that will apply after we're doneL\The sequence of commands that accomplish this movement in the database graph. For an edge, L9 contains one command; for a path, it will contain more.M&An english description of the movementN_A heuristic notion of complexity or weight; used to find the "easiest" path through the graph. Wrapper for Ox that keeps track of the command sequence length and goal distance. Used for sorting states when conducting the search.ODRepresents the state of a database as a migration is being generatedQrThe current set of predicates that apply to this database as well as their source (user or from previous actions)RHS.fromMap of Q, for maximal sharingSAThe current sequence of commands we've committed to in this stateTUsed to indicate whether a particular predicate is from the initial database state, or due to a sequence of actions we've committed too. Used to prevent runaway action generation based off of derived states.U4Predicate is from the original set given by the userVCPredicate is from an action we've committed to in this action chainWTProceeds only if no predicate matches the given pattern. See the implementation of Z for an example of usage.X]Used to ensure that only one predicate matches the given pattern. See the implementation of Y for an example of usage.YAction provider for SQL92  CREATE TABLE actions.ZAction provider for SQL92  DROP TABLE actions[Action provider for SQL92 ALTER TABLE ... ADD COLUMN ... actionsAction provider for SQL92 ALTER TABLE ... DROP COLUMN ... actions\Action provider for SQL92 )ALTER TABLE ... ALTER COLUMN ... SET NULL]Action provider for SQL92 .ALTER TABLE ... ALTER COLUMN ... SET NOT NULL^8Default action providers for any SQL92 compliant syntax.JIn particular, this provides edges consisting of the following statements: CREATE TABLE DROP TABLEALTER TABLE ... ADD COLUMN ...ALTER TABLE ... DROP COLUMN .../ALTER TABLE ... ALTER COLUMN ... SET [NOT] NULLReturns  if the state has been solved_An exhaustive solving strategy that simply continues the search, while exploring every possible action. If there is a solution, this will find it.`Conduct a breadth-first search of the database graph to find a path from the source database to the destination database, using the given DB to discovere "edges" (i.e., DDL commands) between the databases.See the documentation on <4 for more information on how to consume the result.fH;s can represent edges or paths. Monadically combining two HZs results in the path between the source of the first and the destination of the second. b here returns the action that does nothing (i.e., the edge going back to the same database state)`Edge discovery functionSource database stateDestination database state(9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`(TUVOPQRSHIJKLMNDEFGWXYZ[\]^<=>?@ABC9:;_`9:;<=>?@ABCDEFHIJKLMNOPQRSTUV None&'-036;<=>?FQSTVh rdIn order to support Haskell schema generation, backends need to provide a way to convert arbitrary DatabasePredicates generated by the backend's { function into appropriate predicates in the Haskell syntax. Not all predicates have any meaning when translated to Haskell, so backends can choose to drop any predicate (simply return ).tPMonomorphic wrapper for use with plugin loaders that cannot handle polymorphismv_Backends should create a value of this type and export it in an exposed module under the name migrationBackend1. See the module documentation for more details.lType of errors that can be thrown by backends during DDL statement execution. Currently just a synonym for Converters for the , , and R (when supplied with a function to convert a backend data type to a haskell one).Converter for G, when given a function to convert backend data type to a haskell one.>Some predicates have no dependence on a backend. For example, V has no parameters that depend on the backend. It can be converted straightforwardly: )trivialHsConverter @TableExistsPredicate TUtility function for converting a monomorphically typed predicate to a haskell one.rs can be combined monoidally.rstuvwxyz{|}~vwxyz{|}~rsturstuv wxyz{|}~ None&'-036;<=>?FQSTVh?&Attempt to find a SQL schema given an D" and a checked database. Returns M if no schema could be found, which usually means you have chosen the wrong D(, or the backend you're using is buggy.Given 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.v*s can usually be found in a module named Database.Beam. Backend.Migrate with the namemigrationBackend(Run a sequence of commands on a database+Given a function to convert a command to a o, produce a script that will execute the given migration. Usually, the function you provide eventually calls  displaySyntax to rendere the command.a9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`None&'-036;<=>?FQSTVh  !#"$%&'(*)+,-./0123456789:<;=>?@ABCDEFGHIJKL     89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_` !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aabccdeefgghiijkklmmnoopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{{||}}~                                     ! " # $ % & ' ( ) * + , , - . / / 0 1 2 3 4 5 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W W X X Y Y Z [ \ ] ^ _ ` a b c d e f g h i j k l mnopqrstuvnownoxqrynz{n|}n|~noqnnnnnnnnn   qr qrqr*beam-migrate-0.2.0.0-luEQn16wb5J06t50caeQcDatabase.Beam.Migrate.SQL.SQL92#Database.Beam.Migrate.SerializationDatabase.Beam.Haskell.SyntaxDatabase.Beam.Migrate.TypesDatabase.Beam.Migrate.SQLDatabase.Beam.Migrate.ChecksDatabase.Beam.Migrate.Generics Database.Beam.Migrate.SQL.Tables(Database.Beam.Migrate.SQL.BeamExtensions!Database.Beam.Migrate.SQL.BuilderDatabase.Beam.Migrate.ActionsDatabase.Beam.Migrate.BackendDatabase.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!Sql92AlterTableColumnSchemaSyntaxalterColumnSyntaxaddColumnSyntaxdropColumnSyntaxrenameTableToSyntaxrenameColumnToSyntaxIsSql92AlterTableSyntax%Sql92AlterTableAlterTableActionSyntaxalterTableSyntaxIsSql92DropTableSyntaxdropTableSyntaxIsSql92CreateTableSyntax"Sql92CreateTableColumnSchemaSyntax%Sql92CreateTableTableConstraintSyntaxSql92CreateTableOptionsSyntaxcreateTableSyntaxIsSql92DdlCommandSyntax Sql92DdlCommandCreateTableSyntaxSql92DdlCommandAlterTableSyntaxSql92DdlCommandDropTableSyntaxcreateTableCmd dropTableCmd alterTableCmdSql92DisplaySyntax displaySyntax%Sql92DdlCommandAlterTableActionSyntax)Sql92DdlCommandConstraintAttributesSyntax&Sql92DdlCommandReferentialActionSyntaxSql92DdlCommandMatchTypeSyntax%Sql92DdlCommandColumnConstraintSyntax$Sql92DdlColumnSchemaConstraintSyntax)Sql92DdlCommandConstraintDefinitionSyntax!Sql92DdlCommandColumnSchemaSyntaxSql92DdlCommandDataTypeSyntaxSql92SaneDdlCommandSyntaxBeamDeserializersbeamArbitraryDeserializersBeamSerializedExpressionfromBeamSerializedExpressionBeamSerializedReferentialAction#fromBeamSerializedReferentialActionBeamSerializedMatchTypefromBeamSerializedMatchTypeBeamSerializedConstraintfromBeamSerializedConstraint"BeamSerializedConstraintAttributes&fromBeamSerializedConstraintAttributes"BeamSerializedConstraintDefinition&fromBeamSerializedConstraintDefinitionBeamSerializedDataTypefromBeamSerializedDataTypebeamSerializeJSONserializePrecAndDecimalbeamDeserializeMaybebeamDeserializebeamDeserializersql92Deserializerssql99DataTypeDeserializers.sql2003BinaryAndVarBinaryDataTypeDeserializers"sql2008BigIntDataTypeDeserializers$fToJSONBeamSerializedDataType5$fIsSql2008BigIntDataTypeSyntaxBeamSerializedDataTypeA$fIsSql2003BinaryAndVarBinaryDataTypeSyntaxBeamSerializedDataType-$fIsSql99DataTypeSyntaxBeamSerializedDataType-$fIsSql92DataTypeSyntaxBeamSerializedDataTypeE$fIsSql92ConstraintAttributesSyntaxBeamSerializedConstraintAttributesK$fIsSql92ColumnConstraintDefinitionSyntaxBeamSerializedConstraintDefinition/$fIsSql92MatchTypeSyntaxBeamSerializedMatchType?$fIsSql92ReferentialActionSyntaxBeamSerializedReferentialAction7$fIsSql92ColumnConstraintSyntaxBeamSerializedConstraint#$fGCompareTYPEBeamDeserializerLabel$fGEqTYPEBeamDeserializerLabel$fMonoidBeamDeserializers$fMonoidBeamDeserializer$fShowBeamSerializedDataType$fEqBeamSerializedDataType($fShowBeamSerializedConstraintDefinition&$fEqBeamSerializedConstraintDefinition($fShowBeamSerializedConstraintAttributes&$fEqBeamSerializedConstraintAttributes*$fMonoidBeamSerializedConstraintAttributes$fShowBeamSerializedConstraint$fEqBeamSerializedConstraint$fShowBeamSerializedMatchType$fEqBeamSerializedMatchType%$fShowBeamSerializedReferentialAction#$fEqBeamSerializedReferentialAction$fShowBeamSerializedExpression$fEqBeamSerializedExpressionHsNoneHsModule hsModuleNamehsModuleEntitieshsModuleMigrationHsTableConstraintDeclshsTableConstraintInstancehsTableConstraintDeclsHsTableConstraint HsFieldLookup hsFieldLookupHsEntityhsEntityBackendhsEntitySyntax hsEntityName hsEntityDeclshsEntityDbDecl hsEntityExp HsBeamBackendHsBeamBackendSingleHsBeamBackendConstrainedHsBeamBackendNoneHsBackendConstraintbuildHsBackendConstraintHsActionhsSyntaxMigrationhsSyntaxEntitiesHsDecl hsDeclSyntax hsDeclImports hsDeclExportsHsColumnSchemamkHsColumnSchemahsColumnSchemaTypeHsExpr hsExprSyntax hsExprImportshsExprConstraintshsExprTypeVariablesHsType hsTypeSyntax hsTypeImports HsDataTypehsDataTypeMigrationhsDataTypeTypehsDataTypeSerialized HsImportsHsImport HsImportAll HsImportSome HsEntityNamegetHsEntityNameHsConstraintDefinition hsConstraintDefinitionConstraint HsDbFieldbuildHsDbField importSome importTyNamedimportVarNamedhsActionsToModuleunqualentityDbFieldNamedatabaseTypeDeclmigrationTypeDecl migrationDecl dbTypeDecldbDeclrenderHsSchema hsErrorTypetyParens functionTytyTupletyApp tyConNamed tyVarNamed combineHsExprhsApphsVisibleTyApphsApApphsStrhsRecConhsMaybehsVar hsVarFromhsTyConhsInthsOp hsInstancehsDerivingInstancehsListhsTupleinstsql92SaneDdlCommandSyntax $fHashableSet$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$fHashableKind$fHashableTyVarBind $fHashableQOp$fHashableType$fHashableName$fHashableLiteral$fHashableAsst$fHashableIPName$fHashableModuleName$fHashableQName $fHashableExp$fMonoidHsImport$fHashableHsImport$fMonoidHsImports$fHashableHsImports$fHashableHsType$fIsSql92FieldNameSyntaxHsExpr$fHasSqlValueSyntaxHsExprInt$fIsSql92QuantifierSyntaxHsExpr$fHashableHsExpr+$fSql92SerializableDataTypeSyntaxHsDataType)$fIsSql2008BigIntDataTypeSyntaxHsDataType5$fIsSql2003BinaryAndVarBinaryDataTypeSyntaxHsDataType!$fIsSql99DataTypeSyntaxHsDataType!$fIsSql92DataTypeSyntaxHsDataType$fIsSql92ExpressionSyntaxHsExpr$fSql92DisplaySyntaxHsDataType$fHashableHsDataTypeC$fSql92SerializableConstraintDefinitionSyntaxHsConstraintDefinition*$fSql92DisplaySyntaxHsConstraintDefinition $fHashableHsConstraintDefinition)$fIsSql92ColumnSchemaSyntaxHsColumnSchema"$fSql92DisplaySyntaxHsColumnSchema$fHashableHsColumnSchema$fEqHsColumnSchema$fShowHsColumnSchema$fMonoidHsBeamBackend $fIsSql92DropTableSyntaxHsAction!$fIsSql92DdlCommandSyntaxHsAction$fMonoidHsAction$fMonoidHsTableConstraintDecls/$fIsSql92TableConstraintSyntaxHsTableConstraint)$fIsSql92ConstraintAttributesSyntaxHsNone%$fIsSql92ColumnConstraintSyntaxHsExpr&$fIsSql92ReferentialActionSyntaxHsNone$fIsSql92MatchTypeSyntaxHsNone?$fIsSql92ColumnConstraintDefinitionSyntaxHsConstraintDefinition"$fIsSql92CreateTableSyntaxHsAction&$fIsSql92AlterColumnActionSyntaxHsNone%$fIsSql92AlterTableActionSyntaxHsNone!$fIsSql92AlterTableSyntaxHsAction$fMonoidHsNone$fHashableHsNone$fShowHsEntityName$fEqHsEntityName$fOrdHsEntityName$fIsStringHsEntityName$fShowHsImport $fEqHsImport$fGenericHsImport$fShowHsImports $fEqHsImports $fShowHsType $fEqHsType$fGenericHsType $fShowHsExpr $fEqHsExpr$fGenericHsExpr$fEqHsDataType$fShowHsDataType$fGenericHsDataType$fShowHsConstraintDefinition$fEqHsConstraintDefinition$fGenericHsConstraintDefinition $fShowHsNone $fEqHsNone $fOrdHsNone$fGenericHsNone FieldCheck DomainCheck TableCheckPredicateSpecificityPredicateSpecificityOnlyBackendPredicateSpecificityAllBackendsSomeDatabasePredicateDatabasePredicateenglishDescriptionpredicateSpecificityserializePredicatepredicateCascadesDropOnpDataType FieldSchemaTableFieldSchema TableSchemaTableHasPrimaryKeyhasPrimaryKey_tablehasPrimaryKey_colsTableColumnHasConstrainthasConstraint_tablehasConstraint_columnhasConstraint_defnTableHasColumnhasColumn_tablehasColumn_columnhasColumn_typeTableExistsPredicatebeamCheckDeserializers'$fDatabasePredicateTableExistsPredicate$fHashableTableExistsPredicate!$fDatabasePredicateTableHasColumn$fEqTableHasColumn$fHashableTableHasColumn+$fDatabasePredicateTableColumnHasConstraint"$fHashableTableColumnHasConstraint%$fDatabasePredicateTableHasPrimaryKey$fHashableTableHasPrimaryKey$fShowTableExistsPredicate$fEqTableExistsPredicate$fOrdTableExistsPredicate$fGenericTableExistsPredicate!$fGenericTableColumnHasConstraint$fShowTableHasPrimaryKey$fEqTableHasPrimaryKey$fGenericTableHasPrimaryKey$fEqTableColumnHasConstraintSql92HasDefaultDataTypeHasDefaultSqlDataTypedefaultSqlDataType HasDefaultSqlDataTypeConstraintsdefaultSqlDataTypeConstraintsCheckedFieldModificationCheckedDatabaseSettingsCheckedDatabaseEntityIsCheckedDatabaseEntityCheckedDatabaseEntityDescriptor(CheckedDatabaseEntityDefaultRequirementsunCheckcollectEntityCheckscheckedDbEntityAutounCheckDatabase collectChecksmodifyCheckedTablecheckedTableModification Migration MigrationFMigrationRunCommand_migrationUpCommand_migrationDownCommand_migrationNextMigrationSteps MigrationStepmigrationStepsToMigrationrunMigrationSilencedrunMigrationVerboseeraseMigrationType migrationStepupDown migrateScriptexecuteMigrationevaluateDatabase stepNames$fCategoryMigrationSteps$fArrowMigrationSteps$fFunctorMigrationF$fFunctorMigrationStepFieldReturnTypefield' Constraint DefaultValueTableMigrationColumnMigrationcolumnMigrationFieldNamecolumnMigrationFieldChecks createTable dropTablepreserve renameTableTorenameColumnTo dropColumn addColumn alterTablefield defaultTo_notNullintsmallintbigintbinary varbinarydatecharvarchardoublenumeric timestamptz timestamptimebooleancharacterLargeObjectbinaryLargeObjectarray maybeTypeautoTypeF$fFieldReturnTypedefaultGivencollationGivensyntaxresTyTableFieldSchema:$fFieldReturnTypedefaultGivencollationGivensyntaxresTy(->)2$fFieldReturnTypeTruecollationGivensyntaxresTy(->);$fFieldReturnTypedefaultGivencollationGivensyntaxresTy(->)03$fFieldReturnTypeFalsecollationGivensyntaxresTy(->)IsBeamSerialColumnSchemaSyntax genericSerialSqlConstraintAttributesBuilder_sqlConstraintAttributeTiming!_sqlConstraintAttributeDeferrableConstraintAttributeTimingInitiallyDeferredInitiallyImmediate"SqlSyntaxBuilderCreateTableOptionsfromSqlConstraintAttributes!sqlConstraintAttributesSerialized$$fSql92DisplaySyntaxSqlSyntaxBuilder0$fIsSql92ReferentialActionSyntaxSqlSyntaxBuilder($fIsSql92MatchTypeSyntaxSqlSyntaxBuilder/$fIsSql92ColumnConstraintSyntaxSqlSyntaxBuilder+$fIsSql92ColumnSchemaSyntaxSqlSyntaxBuilder.$fIsSql92TableConstraintSyntaxSqlSyntaxBuilder0$fIsSql92AlterColumnActionSyntaxSqlSyntaxBuilder/$fIsSql92AlterTableActionSyntaxSqlSyntaxBuilder)$fIsSql92AlterTableSyntaxSqlSyntaxBuilder($fIsSql92DropTableSyntaxSqlSyntaxBuilder)$fIsSql92DdlCommandSyntaxSqlSyntaxBuilder*$fIsSql92CreateTableSyntaxSqlSyntaxBuilder9$fIsSql92ColumnConstraintDefinitionSyntaxSqlSyntaxBuilderA$fIsSql92ConstraintAttributesSyntaxSqlConstraintAttributesBuilder&$fMonoidSqlConstraintAttributesBuilder&$fEqSqlSyntaxBuilderCreateTableOptions$fShowConstraintAttributeTiming$fEqConstraintAttributeTiming$fOrdConstraintAttributeTiming$fEnumConstraintAttributeTiming"$fBoundedConstraintAttributeTiming$$fShowSqlConstraintAttributesBuilder"$fEqSqlConstraintAttributesBuilderdefaultMigratableDbSettings FinalSolutionSolved CandidatesSolverProvideSolution SearchFailed ChooseActionschoosingActionsAtStategetPotentialActionChoicepotentialActionChoicescontinueSearchActionProvidergetPotentialActionsActionProviderFnPotentialActionactionPreConditionsactionPostConditionsactionCommands actionEnglish actionScore DatabaseStatedbStateCurrentState dbStateKeydbStateCmdSequenceDatabaseStateSourceDatabaseStateSourceOriginalDatabaseStateSourceDerived ensuringNot_justOne_createTableActionProviderdropTableActionProvideraddColumnProvideraddColumnNullProviderdropColumnNullProviderdefaultActionProvider finalSolutionheuristicSolver$fNFDataDatabaseStateSource$fNFDataDatabaseState$fOrdMeasuredDatabaseState$fEqMeasuredDatabaseState$fNFDataMeasuredDatabaseState$fMonoidPotentialAction$fMonoidActionProvider$fShowDatabaseStateSource$fEqDatabaseStateSource$fOrdDatabaseStateSource$fEnumDatabaseStateSource$fBoundedDatabaseStateSource$fGenericDatabaseStateSource$fShowDatabaseState$fShowMeasuredDatabaseState$fGenericMeasuredDatabaseState$fShowFinalSolutionHaskellPredicateConverterSomeBeamMigrationBackendBeamMigrationBackend backendNamebackendConnStringExplanationbackendRenderStepsbackendGetDbConstraintsbackendPredicateParsersbackendRenderSyntaxbackendFileExtensionbackendConvertToHaskellbackendActionProviderbackendTransactDdlErrorsql92HsPredicateConvertershasColumnConvertertrivialHsConverterhsPredicateConverter!$fMonoidHaskellPredicateConverter simpleSchemasimpleMigrationrunSimpleMigrationbackendMigrationScript(beam-core-0.6.0.0-2zsxKWzjnMqA4Z5UI8gy0ODatabase.Beam.Backend.SQL.SQL92IsSql92DataTypeSyntaxbaseGHC.BaseString$aeson-1.2.3.0-6RUtznXwKYiBjMbZOWVPv4Data.Aeson.Types.InternalValueIsSql92ExpressionSyntax decimalTypeMaybeDatabase.Beam.Backend.SQL.SQL99IsSql99DataTypeSyntax!Database.Beam.Backend.SQL.SQL2003)IsSql2003BinaryAndVarBinaryDataTypeSyntaxIsSql2008BigIntDataTypeSyntaxBeamDeserializerLabelBeamDeserializer'hashable-1.2.6.1-JDYnvpSucMf1h1i2CUUtVbData.Hashable.ClassHashableghc-prim GHC.ClassesEq GHC.TypesTrueFalse IsSql92SyntaxGMigratableTableSettingsgDefaultTblSettingsChecksHasNullableConstraintnullableConstraint Data.StringIsStringDatabase.Beam.Schema.TablesDatabaseSettingsDatabaseEntityIsDatabaseEntityDatabaseEntityDescriptor!DatabaseEntityDefaultRequirements dbEntityAutoCheckedDatabaseDomainTypeCheckedDatabaseTable&$fIsCheckedDatabaseEntitybeTableEntity1D:R:CheckedDatabaseEntityDescriptorbeTableEntity0+$fIsCheckedDatabaseEntitybeDomainTypeEntity6D:R:CheckedDatabaseEntityDescriptorbeDomainTypeEntity0Database.Beam.Backend.SQL runNoReturnDatabase.Beam.Query.InternalQExprDatabase.Beam.Backend.TypesAutobytestring-0.10.8.2 Data.ByteString.Builder.InternalBuilderGAutoMigratableDbdefaultMigratableDbSettings'MeasuredDatabaseStatedropColumnProvider solvedStatememptyNothingJust