Safe Haskell	None
Language	Haskell2010

Database.Beam.Haskell.Syntax

Contents

DDL Syntax definitions
HsSyntax utilities
Orphans
Orphan instances

Description

Instances that allow us to use Haskell as a backend syntax. This allows us to use migrations defined a la SQL to generate a beam schema.

Mainly of interest to backends.

Unfortunately, we define some orphan Hashable instances that aren't defined for us in haskell-src-exts.

Synopsis

newtype HsDbField = HsDbField {
- buildHsDbField :: Type () -> Type ()
}
data HsConstraintDefinition = HsConstraintDefinition {
- hsConstraintDefinitionConstraint :: HsExpr
}
newtype HsEntityName = HsEntityName {
- getHsEntityName :: String
}
data HsImport
- = HsImportAll
- | HsImportSome (Set (ImportSpec ()))
importSome :: Text -> [ImportSpec ()] -> HsImports
importTyNamed :: Text -> ImportSpec ()
importVarNamed :: Text -> ImportSpec ()
newtype HsImports = HsImports (Map (ModuleName ()) HsImport)
data HsDataType = HsDataType {
- hsDataTypeMigration :: HsExpr
- hsDataTypeType :: HsType
- hsDataTypeSerialized :: BeamSerializedDataType
}
data HsType = HsType {
- hsTypeSyntax :: Type ()
- hsTypeImports :: HsImports
}
data HsExpr = HsExpr {
- hsExprSyntax :: Exp ()
- hsExprImports :: HsImports
- hsExprConstraints :: [Asst ()]
- hsExprTypeVariables :: Set (Name ())
}
data HsColumnSchema = HsColumnSchema {
- mkHsColumnSchema :: Text -> HsExpr
- hsColumnSchemaType :: HsType
}
data HsDecl = HsDecl {
- hsDeclSyntax :: Decl ()
- hsDeclImports :: HsImports
- hsDeclExports :: [ExportSpec ()]
}
data HsAction = HsAction {
- hsSyntaxMigration :: [(Maybe (Pat ()), HsExpr)]
- hsSyntaxEntities :: [HsEntity]
}
newtype HsBackendConstraint = HsBackendConstraint {
- buildHsBackendConstraint :: Type () -> Asst ()
}
data HsBeamBackend f
- = HsBeamBackendSingle HsType f
- | HsBeamBackendConstrained [HsBackendConstraint]
- | HsBeamBackendNone
data HsEntity = HsEntity {
- hsEntityBackend :: HsBeamBackend HsExpr
- hsEntityName :: HsEntityName
- hsEntityDecls :: [HsDecl]
- hsEntityDbDecl :: HsDbField
- hsEntityExp :: HsExpr
}
newtype HsFieldLookup = HsFieldLookup {
- hsFieldLookup :: Text -> Maybe (Text, Type ())
}
newtype HsTableConstraint = HsTableConstraint (Text -> HsFieldLookup -> HsTableConstraintDecls)
data HsTableConstraintDecls = HsTableConstraintDecls {
- hsTableConstraintInstance :: [InstDecl ()]
- hsTableConstraintDecls :: [HsDecl]
}
data HsModule = HsModule {
- hsModuleName :: String
- hsModuleEntities :: [HsEntity]
- hsModuleMigration :: [(Maybe (Pat ()), HsExpr)]
}
hsActionsToModule :: String -> [HsAction] -> HsModule
unqual :: String -> QName ()
entityDbFieldName :: HsEntity -> String
derivingDecl :: [InstRule ()] -> Deriving ()
dataDecl :: DeclHead () -> [QualConDecl ()] -> Maybe (Deriving ()) -> Decl ()
insDataDecl :: Type () -> [QualConDecl ()] -> Maybe (Deriving ()) -> InstDecl ()
databaseTypeDecl :: [HsEntity] -> Decl ()
migrationTypeDecl :: HsBeamBackend HsExpr -> [Type ()] -> Decl ()
migrationDecl :: HsBeamBackend HsExpr -> [Exp ()] -> [(Maybe (Pat ()), HsExpr)] -> [HsEntity] -> Decl ()
dbTypeDecl :: HsBeamBackend HsExpr -> Decl ()
dbDecl :: HsBeamBackend HsExpr -> [HsExpr] -> Decl ()
renderHsSchema :: HsModule -> Either String String
data HsNone = HsNone
data HsMigrateBackend = HsMigrateBackend
hsMkTableName :: (Char -> Char) -> TableName -> String
hsSchemaName :: SchemaName -> String
hsTableVarName :: TableName -> String
hsTableTypeName :: TableName -> String
hsErrorType :: String -> HsDataType
tyParens :: Type () -> Type ()
functionTy :: Type () -> Type () -> Type ()
tyTuple :: [Type ()] -> Type ()
tyApp :: Type () -> [Type ()] -> Type ()
tyConNamed :: String -> Type ()
tyVarNamed :: String -> Type ()
combineHsExpr :: (Exp () -> Exp () -> Exp ()) -> HsExpr -> HsExpr -> HsExpr
hsApp :: HsExpr -> [HsExpr] -> HsExpr
hsVisibleTyApp :: HsExpr -> Type () -> HsExpr
hsApApp :: HsExpr -> [HsExpr] -> HsExpr
hsStr :: Text -> HsExpr
hsRecCon :: Text -> [(Text, HsExpr)] -> HsExpr
hsMaybe :: Maybe HsExpr -> HsExpr
hsVar :: Text -> HsExpr
hsVarFrom :: Text -> Text -> HsExpr
hsTyCon :: Text -> HsExpr
hsInt :: (Integral a, Show a) => a -> HsExpr
hsOp :: Text -> QOp ()
hsInstance :: Text -> [Type ()] -> [InstDecl ()] -> Decl ()
hsDerivingInstance :: Text -> [Type ()] -> Decl ()
hsList :: [HsExpr] -> HsExpr
hsTuple :: [HsExpr] -> HsExpr
inst :: String -> InstRule ()
beamMigrateSqlBackend :: HsBackendConstraint

Documentation

newtype HsDbField Source #

Constructors

HsDbField
Fields buildHsDbField :: Type () -> Type ()

data HsConstraintDefinition Source #

Constructors

HsConstraintDefinition
Fields hsConstraintDefinitionConstraint :: HsExpr

Instances

Instances details

Generic HsConstraintDefinition Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Rep HsConstraintDefinition
Instance details Defined in Database.Beam.Haskell.Syntax type Rep HsConstraintDefinition = D1 ('MetaData "HsConstraintDefinition" "Database.Beam.Haskell.Syntax" "beam-migrate-0.5.3.2-inplace" 'False) (C1 ('MetaCons "HsConstraintDefinition" 'PrefixI 'True) (S1 ('MetaSel ('Just "hsConstraintDefinitionConstraint") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HsExpr)))

Methods

from :: HsConstraintDefinition -> Rep HsConstraintDefinition x #

to :: Rep HsConstraintDefinition x -> HsConstraintDefinition #

Show HsConstraintDefinition Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

showsPrec :: Int -> HsConstraintDefinition -> ShowS #

show :: HsConstraintDefinition -> String #

showList :: [HsConstraintDefinition] -> ShowS #

Sql92DisplaySyntax HsConstraintDefinition Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

displaySyntax :: HsConstraintDefinition -> String

IsSql92ColumnConstraintDefinitionSyntax HsConstraintDefinition Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Sql92ColumnConstraintDefinitionConstraintSyntax HsConstraintDefinition
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ColumnConstraintDefinitionConstraintSyntax HsConstraintDefinition = HsExpr
type Sql92ColumnConstraintDefinitionAttributesSyntax HsConstraintDefinition
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ColumnConstraintDefinitionAttributesSyntax HsConstraintDefinition = HsNone

Methods

constraintDefinitionSyntax :: Maybe Text -> Sql92ColumnConstraintDefinitionConstraintSyntax HsConstraintDefinition -> Maybe (Sql92ColumnConstraintDefinitionAttributesSyntax HsConstraintDefinition) -> HsConstraintDefinition Source #

Sql92SerializableConstraintDefinitionSyntax HsConstraintDefinition Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

serializeConstraint :: HsConstraintDefinition -> Value Source #

Eq HsConstraintDefinition Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

(==) :: HsConstraintDefinition -> HsConstraintDefinition -> Bool #

(/=) :: HsConstraintDefinition -> HsConstraintDefinition -> Bool #

Hashable HsConstraintDefinition Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

hashWithSalt :: Int -> HsConstraintDefinition -> Int #

hash :: HsConstraintDefinition -> Int #

type Rep HsConstraintDefinition Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Rep HsConstraintDefinition = D1 ('MetaData "HsConstraintDefinition" "Database.Beam.Haskell.Syntax" "beam-migrate-0.5.3.2-inplace" 'False) (C1 ('MetaCons "HsConstraintDefinition" 'PrefixI 'True) (S1 ('MetaSel ('Just "hsConstraintDefinitionConstraint") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HsExpr)))

type Sql92ColumnConstraintDefinitionAttributesSyntax HsConstraintDefinition Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ColumnConstraintDefinitionAttributesSyntax HsConstraintDefinition = HsNone

type Sql92ColumnConstraintDefinitionConstraintSyntax HsConstraintDefinition Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ColumnConstraintDefinitionConstraintSyntax HsConstraintDefinition = HsExpr

newtype HsEntityName Source #

Constructors

HsEntityName
Fields getHsEntityName :: String

Instances

Instances details

IsString HsEntityName Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods fromString :: String -> HsEntityName #
Show HsEntityName Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods showsPrec :: Int -> HsEntityName -> ShowS # show :: HsEntityName -> String # showList :: [HsEntityName] -> ShowS #
Eq HsEntityName Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods (==) :: HsEntityName -> HsEntityName -> Bool # (/=) :: HsEntityName -> HsEntityName -> Bool #
Ord HsEntityName Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods compare :: HsEntityName -> HsEntityName -> Ordering # (<) :: HsEntityName -> HsEntityName -> Bool # (<=) :: HsEntityName -> HsEntityName -> Bool # (>) :: HsEntityName -> HsEntityName -> Bool # (>=) :: HsEntityName -> HsEntityName -> Bool # max :: HsEntityName -> HsEntityName -> HsEntityName # min :: HsEntityName -> HsEntityName -> HsEntityName #

data HsImport Source #

Constructors

HsImportAll
HsImportSome (Set (ImportSpec ()))

Instances

Instances details

Monoid HsImport Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

mempty :: HsImport #

mappend :: HsImport -> HsImport -> HsImport #

mconcat :: [HsImport] -> HsImport #

Semigroup HsImport Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

(<>) :: HsImport -> HsImport -> HsImport #

sconcat :: NonEmpty HsImport -> HsImport #

stimes :: Integral b => b -> HsImport -> HsImport #

Generic HsImport Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Rep HsImport

Instance details

Defined in Database.Beam.Haskell.Syntax

type Rep HsImport = D1 ('MetaData "HsImport" "Database.Beam.Haskell.Syntax" "beam-migrate-0.5.3.2-inplace" 'False) (C1 ('MetaCons "HsImportAll" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "HsImportSome" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set (ImportSpec ())))))

Methods

from :: HsImport -> Rep HsImport x #

to :: Rep HsImport x -> HsImport #

Show HsImport Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

showsPrec :: Int -> HsImport -> ShowS #

show :: HsImport -> String #

showList :: [HsImport] -> ShowS #

Eq HsImport Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

(==) :: HsImport -> HsImport -> Bool #

(/=) :: HsImport -> HsImport -> Bool #

Hashable HsImport Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

hashWithSalt :: Int -> HsImport -> Int #

hash :: HsImport -> Int #

type Rep HsImport Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Rep HsImport = D1 ('MetaData "HsImport" "Database.Beam.Haskell.Syntax" "beam-migrate-0.5.3.2-inplace" 'False) (C1 ('MetaCons "HsImportAll" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "HsImportSome" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set (ImportSpec ())))))

importSome :: Text -> [ImportSpec ()] -> HsImports Source #

importTyNamed :: Text -> ImportSpec () Source #

importVarNamed :: Text -> ImportSpec () Source #

newtype HsImports Source #

Constructors

HsImports (Map (ModuleName ()) HsImport)

Instances

Instances details

Monoid HsImports Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods mempty :: HsImports # mappend :: HsImports -> HsImports -> HsImports # mconcat :: [HsImports] -> HsImports #
Semigroup HsImports Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods (<>) :: HsImports -> HsImports -> HsImports # sconcat :: NonEmpty HsImports -> HsImports # stimes :: Integral b => b -> HsImports -> HsImports #
Show HsImports Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods showsPrec :: Int -> HsImports -> ShowS # show :: HsImports -> String # showList :: [HsImports] -> ShowS #
Eq HsImports Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods (==) :: HsImports -> HsImports -> Bool # (/=) :: HsImports -> HsImports -> Bool #
Hashable HsImports Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods hashWithSalt :: Int -> HsImports -> Int # hash :: HsImports -> Int #

data HsDataType Source #

Constructors

HsDataType
Fields hsDataTypeMigration :: HsExpr hsDataTypeType :: HsType hsDataTypeSerialized :: BeamSerializedDataType

Instances

Instances details

Generic HsDataType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Rep HsDataType

Instance details

Defined in Database.Beam.Haskell.Syntax

type Rep HsDataType = D1 ('MetaData "HsDataType" "Database.Beam.Haskell.Syntax" "beam-migrate-0.5.3.2-inplace" 'False) (C1 ('MetaCons "HsDataType" 'PrefixI 'True) (S1 ('MetaSel ('Just "hsDataTypeMigration") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HsExpr) :*: (S1 ('MetaSel ('Just "hsDataTypeType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HsType) :*: S1 ('MetaSel ('Just "hsDataTypeSerialized") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 BeamSerializedDataType))))

Methods

from :: HsDataType -> Rep HsDataType x #

to :: Rep HsDataType x -> HsDataType #

Show HsDataType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

showsPrec :: Int -> HsDataType -> ShowS #

show :: HsDataType -> String #

showList :: [HsDataType] -> ShowS #

IsSql2003BinaryAndVarBinaryDataTypeSyntax HsDataType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

binaryType :: Maybe Word -> HsDataType

varBinaryType :: Maybe Word -> HsDataType

IsSql2008BigIntDataTypeSyntax HsDataType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

bigIntType :: HsDataType

IsSql92DataTypeSyntax HsDataType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

domainType :: Text -> HsDataType

charType :: Maybe Word -> Maybe Text -> HsDataType

varCharType :: Maybe Word -> Maybe Text -> HsDataType

nationalCharType :: Maybe Word -> HsDataType

nationalVarCharType :: Maybe Word -> HsDataType

bitType :: Maybe Word -> HsDataType

varBitType :: Maybe Word -> HsDataType

numericType :: Maybe (Word, Maybe Word) -> HsDataType

decimalType :: Maybe (Word, Maybe Word) -> HsDataType

intType :: HsDataType

smallIntType :: HsDataType

floatType :: Maybe Word -> HsDataType

doubleType :: HsDataType

realType :: HsDataType

dateType :: HsDataType

timeType :: Maybe Word -> Bool -> HsDataType

timestampType :: Maybe Word -> Bool -> HsDataType

Sql92DisplaySyntax HsDataType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

displaySyntax :: HsDataType -> String

IsSql99DataTypeSyntax HsDataType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

characterLargeObjectType :: HsDataType

binaryLargeObjectType :: HsDataType

booleanType :: HsDataType

arrayType :: HsDataType -> Int -> HsDataType

rowType :: [(Text, HsDataType)] -> HsDataType

HasDataTypeCreatedCheck HsDataType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

dataTypeHasBeenCreated :: HsDataType -> (forall preCondition. Typeable preCondition => [preCondition]) -> Bool Source #

Sql92SerializableDataTypeSyntax HsDataType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

serializeDataType :: HsDataType -> Value Source #

Eq HsDataType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

(==) :: HsDataType -> HsDataType -> Bool #

(/=) :: HsDataType -> HsDataType -> Bool #

Hashable HsDataType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

hashWithSalt :: Int -> HsDataType -> Int #

hash :: HsDataType -> Int #

type Rep HsDataType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Rep HsDataType = D1 ('MetaData "HsDataType" "Database.Beam.Haskell.Syntax" "beam-migrate-0.5.3.2-inplace" 'False) (C1 ('MetaCons "HsDataType" 'PrefixI 'True) (S1 ('MetaSel ('Just "hsDataTypeMigration") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HsExpr) :*: (S1 ('MetaSel ('Just "hsDataTypeType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HsType) :*: S1 ('MetaSel ('Just "hsDataTypeSerialized") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 BeamSerializedDataType))))

data HsType Source #

Constructors

HsType
Fields hsTypeSyntax :: Type () hsTypeImports :: HsImports

Instances

Instances details

Generic HsType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Rep HsType

Instance details

Defined in Database.Beam.Haskell.Syntax

type Rep HsType = D1 ('MetaData "HsType" "Database.Beam.Haskell.Syntax" "beam-migrate-0.5.3.2-inplace" 'False) (C1 ('MetaCons "HsType" 'PrefixI 'True) (S1 ('MetaSel ('Just "hsTypeSyntax") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type ())) :*: S1 ('MetaSel ('Just "hsTypeImports") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HsImports)))

Methods

from :: HsType -> Rep HsType x #

to :: Rep HsType x -> HsType #

Show HsType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

showsPrec :: Int -> HsType -> ShowS #

show :: HsType -> String #

showList :: [HsType] -> ShowS #

Eq HsType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

(==) :: HsType -> HsType -> Bool #

(/=) :: HsType -> HsType -> Bool #

Hashable HsType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

hashWithSalt :: Int -> HsType -> Int #

hash :: HsType -> Int #

type Rep HsType Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Rep HsType = D1 ('MetaData "HsType" "Database.Beam.Haskell.Syntax" "beam-migrate-0.5.3.2-inplace" 'False) (C1 ('MetaCons "HsType" 'PrefixI 'True) (S1 ('MetaSel ('Just "hsTypeSyntax") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Type ())) :*: S1 ('MetaSel ('Just "hsTypeImports") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HsImports)))

data HsExpr Source #

Constructors

HsExpr
Fields hsExprSyntax :: Exp () hsExprImports :: HsImports hsExprConstraints :: [Asst ()] hsExprTypeVariables :: Set (Name ())

Instances

Instances details

Generic HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Rep HsExpr

Instance details

Defined in Database.Beam.Haskell.Syntax

type Rep HsExpr = D1 ('MetaData "HsExpr" "Database.Beam.Haskell.Syntax" "beam-migrate-0.5.3.2-inplace" 'False) (C1 ('MetaCons "HsExpr" 'PrefixI 'True) ((S1 ('MetaSel ('Just "hsExprSyntax") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp ())) :*: S1 ('MetaSel ('Just "hsExprImports") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HsImports)) :*: (S1 ('MetaSel ('Just "hsExprConstraints") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Asst ()]) :*: S1 ('MetaSel ('Just "hsExprTypeVariables") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set (Name ()))))))

Methods

from :: HsExpr -> Rep HsExpr x #

to :: Rep HsExpr x -> HsExpr #

Show HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

showsPrec :: Int -> HsExpr -> ShowS #

show :: HsExpr -> String #

showList :: [HsExpr] -> ShowS #

IsSql92ExpressionSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Sql92ExpressionQuantifierSyntax HsExpr
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ExpressionQuantifierSyntax HsExpr = HsExpr
type Sql92ExpressionValueSyntax HsExpr
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ExpressionValueSyntax HsExpr = HsExpr
type Sql92ExpressionSelectSyntax HsExpr
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ExpressionSelectSyntax HsExpr = SqlSyntaxBuilder
type Sql92ExpressionFieldNameSyntax HsExpr
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ExpressionFieldNameSyntax HsExpr = HsExpr
type Sql92ExpressionCastTargetSyntax HsExpr
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ExpressionCastTargetSyntax HsExpr = HsDataType
type Sql92ExpressionExtractFieldSyntax HsExpr
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ExpressionExtractFieldSyntax HsExpr = HsExpr

Methods

valueE :: Sql92ExpressionValueSyntax HsExpr -> HsExpr

rowE :: [HsExpr] -> HsExpr

quantifierListE :: [HsExpr] -> HsExpr

coalesceE :: [HsExpr] -> HsExpr

caseE :: [(HsExpr, HsExpr)] -> HsExpr -> HsExpr

fieldE :: Sql92ExpressionFieldNameSyntax HsExpr -> HsExpr

betweenE :: HsExpr -> HsExpr -> HsExpr -> HsExpr

andE :: HsExpr -> HsExpr -> HsExpr

orE :: HsExpr -> HsExpr -> HsExpr

addE :: HsExpr -> HsExpr -> HsExpr

subE :: HsExpr -> HsExpr -> HsExpr

mulE :: HsExpr -> HsExpr -> HsExpr

divE :: HsExpr -> HsExpr -> HsExpr

likeE :: HsExpr -> HsExpr -> HsExpr

modE :: HsExpr -> HsExpr -> HsExpr

overlapsE :: HsExpr -> HsExpr -> HsExpr

nullIfE :: HsExpr -> HsExpr -> HsExpr

positionE :: HsExpr -> HsExpr -> HsExpr

eqE :: Maybe (Sql92ExpressionQuantifierSyntax HsExpr) -> HsExpr -> HsExpr -> HsExpr

neqE :: Maybe (Sql92ExpressionQuantifierSyntax HsExpr) -> HsExpr -> HsExpr -> HsExpr

ltE :: Maybe (Sql92ExpressionQuantifierSyntax HsExpr) -> HsExpr -> HsExpr -> HsExpr

gtE :: Maybe (Sql92ExpressionQuantifierSyntax HsExpr) -> HsExpr -> HsExpr -> HsExpr

leE :: Maybe (Sql92ExpressionQuantifierSyntax HsExpr) -> HsExpr -> HsExpr -> HsExpr

geE :: Maybe (Sql92ExpressionQuantifierSyntax HsExpr) -> HsExpr -> HsExpr -> HsExpr

eqMaybeE :: HsExpr -> HsExpr -> HsExpr -> HsExpr

neqMaybeE :: HsExpr -> HsExpr -> HsExpr -> HsExpr

castE :: HsExpr -> Sql92ExpressionCastTargetSyntax HsExpr -> HsExpr

notE :: HsExpr -> HsExpr

negateE :: HsExpr -> HsExpr

isNullE :: HsExpr -> HsExpr

isNotNullE :: HsExpr -> HsExpr

isTrueE :: HsExpr -> HsExpr

isNotTrueE :: HsExpr -> HsExpr

isFalseE :: HsExpr -> HsExpr

isNotFalseE :: HsExpr -> HsExpr

isUnknownE :: HsExpr -> HsExpr

isNotUnknownE :: HsExpr -> HsExpr

charLengthE :: HsExpr -> HsExpr

octetLengthE :: HsExpr -> HsExpr

bitLengthE :: HsExpr -> HsExpr

lowerE :: HsExpr -> HsExpr

upperE :: HsExpr -> HsExpr

trimE :: HsExpr -> HsExpr

absE :: HsExpr -> HsExpr

extractE :: Sql92ExpressionExtractFieldSyntax HsExpr -> HsExpr -> HsExpr

existsE :: Sql92ExpressionSelectSyntax HsExpr -> HsExpr

uniqueE :: Sql92ExpressionSelectSyntax HsExpr -> HsExpr

subqueryE :: Sql92ExpressionSelectSyntax HsExpr -> HsExpr

currentTimestampE :: HsExpr

defaultE :: HsExpr

inE :: HsExpr -> [HsExpr] -> HsExpr

inSelectE :: HsExpr -> Sql92ExpressionSelectSyntax HsExpr -> HsExpr

IsSql92ExtractFieldSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

secondsField :: HsExpr

minutesField :: HsExpr

hourField :: HsExpr

dayField :: HsExpr

monthField :: HsExpr

yearField :: HsExpr

IsSql92FieldNameSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

qualifiedField :: Text -> Text -> HsExpr

unqualifiedField :: Text -> HsExpr

IsSql92QuantifierSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

quantifyOverAll :: HsExpr

quantifyOverAny :: HsExpr

IsSql92ColumnConstraintSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Sql92ColumnConstraintMatchTypeSyntax HsExpr
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ColumnConstraintMatchTypeSyntax HsExpr = HsNone
type Sql92ColumnConstraintReferentialActionSyntax HsExpr
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ColumnConstraintReferentialActionSyntax HsExpr = HsNone
type Sql92ColumnConstraintExpressionSyntax HsExpr
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ColumnConstraintExpressionSyntax HsExpr = HsExpr

Eq HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

(==) :: HsExpr -> HsExpr -> Bool #

(/=) :: HsExpr -> HsExpr -> Bool #

Hashable HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

hashWithSalt :: Int -> HsExpr -> Int #

hash :: HsExpr -> Int #

HasSqlValueSyntax HsExpr Int32 Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

sqlValueSyntax :: Int32 -> HsExpr

HasSqlValueSyntax HsExpr Bool Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

sqlValueSyntax :: Bool -> HsExpr

type Rep HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Rep HsExpr = D1 ('MetaData "HsExpr" "Database.Beam.Haskell.Syntax" "beam-migrate-0.5.3.2-inplace" 'False) (C1 ('MetaCons "HsExpr" 'PrefixI 'True) ((S1 ('MetaSel ('Just "hsExprSyntax") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Exp ())) :*: S1 ('MetaSel ('Just "hsExprImports") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HsImports)) :*: (S1 ('MetaSel ('Just "hsExprConstraints") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Asst ()]) :*: S1 ('MetaSel ('Just "hsExprTypeVariables") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set (Name ()))))))

type Sql92ExpressionCastTargetSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ExpressionCastTargetSyntax HsExpr = HsDataType

type Sql92ExpressionExtractFieldSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ExpressionExtractFieldSyntax HsExpr = HsExpr

type Sql92ExpressionFieldNameSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ExpressionFieldNameSyntax HsExpr = HsExpr

type Sql92ExpressionQuantifierSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ExpressionQuantifierSyntax HsExpr = HsExpr

type Sql92ExpressionSelectSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ExpressionSelectSyntax HsExpr = SqlSyntaxBuilder

type Sql92ExpressionValueSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ExpressionValueSyntax HsExpr = HsExpr

type Sql92ColumnConstraintExpressionSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ColumnConstraintExpressionSyntax HsExpr = HsExpr

type Sql92ColumnConstraintMatchTypeSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ColumnConstraintMatchTypeSyntax HsExpr = HsNone

type Sql92ColumnConstraintReferentialActionSyntax HsExpr Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ColumnConstraintReferentialActionSyntax HsExpr = HsNone

data HsColumnSchema Source #

Constructors

HsColumnSchema
Fields mkHsColumnSchema :: Text -> HsExpr hsColumnSchemaType :: HsType

Instances

Instances details

Show HsColumnSchema Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

showsPrec :: Int -> HsColumnSchema -> ShowS #

show :: HsColumnSchema -> String #

showList :: [HsColumnSchema] -> ShowS #

Sql92DisplaySyntax HsColumnSchema Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

displaySyntax :: HsColumnSchema -> String

IsSql92ColumnSchemaSyntax HsColumnSchema Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Sql92ColumnSchemaColumnTypeSyntax HsColumnSchema
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ColumnSchemaColumnTypeSyntax HsColumnSchema = HsDataType
type Sql92ColumnSchemaExpressionSyntax HsColumnSchema
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ColumnSchemaExpressionSyntax HsColumnSchema = HsExpr
type Sql92ColumnSchemaColumnConstraintDefinitionSyntax HsColumnSchema
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92ColumnSchemaColumnConstraintDefinitionSyntax HsColumnSchema = HsConstraintDefinition

Methods

columnSchemaSyntax :: Sql92ColumnSchemaColumnTypeSyntax HsColumnSchema -> Maybe (Sql92ColumnSchemaExpressionSyntax HsColumnSchema) -> [Sql92ColumnSchemaColumnConstraintDefinitionSyntax HsColumnSchema] -> Maybe Text -> HsColumnSchema Source #

Eq HsColumnSchema Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

(==) :: HsColumnSchema -> HsColumnSchema -> Bool #

(/=) :: HsColumnSchema -> HsColumnSchema -> Bool #

Hashable HsColumnSchema Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

hashWithSalt :: Int -> HsColumnSchema -> Int #

hash :: HsColumnSchema -> Int #

type Sql92ColumnSchemaColumnConstraintDefinitionSyntax HsColumnSchema Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ColumnSchemaColumnConstraintDefinitionSyntax HsColumnSchema = HsConstraintDefinition

type Sql92ColumnSchemaColumnTypeSyntax HsColumnSchema Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ColumnSchemaColumnTypeSyntax HsColumnSchema = HsDataType

type Sql92ColumnSchemaExpressionSyntax HsColumnSchema Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92ColumnSchemaExpressionSyntax HsColumnSchema = HsExpr

data HsDecl Source #

Constructors

HsDecl
Fields hsDeclSyntax :: Decl () hsDeclImports :: HsImports hsDeclExports :: [ExportSpec ()]

data HsAction Source #

Constructors

HsAction
Fields hsSyntaxMigration :: [(Maybe (Pat ()), HsExpr)] hsSyntaxEntities :: [HsEntity]

Instances

Instances details

Monoid HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

mempty :: HsAction #

mappend :: HsAction -> HsAction -> HsAction #

mconcat :: [HsAction] -> HsAction #

Semigroup HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

(<>) :: HsAction -> HsAction -> HsAction #

sconcat :: NonEmpty HsAction -> HsAction #

stimes :: Integral b => b -> HsAction -> HsAction #

IsSql92AlterTableSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Sql92AlterTableTableNameSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92AlterTableTableNameSyntax HsAction = TableName
type Sql92AlterTableAlterTableActionSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92AlterTableAlterTableActionSyntax HsAction = HsNone

Methods

alterTableSyntax :: Sql92AlterTableTableNameSyntax HsAction -> Sql92AlterTableAlterTableActionSyntax HsAction -> HsAction Source #

IsSql92CreateSchemaSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Sql92CreateSchemaSchemaNameSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92CreateSchemaSchemaNameSyntax HsAction = SchemaName

Methods

createSchemaSyntax :: Sql92CreateSchemaSchemaNameSyntax HsAction -> HsAction Source #

IsSql92CreateTableSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Sql92CreateTableTableNameSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92CreateTableTableNameSyntax HsAction = TableName
type Sql92CreateTableColumnSchemaSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92CreateTableColumnSchemaSyntax HsAction = HsColumnSchema
type Sql92CreateTableTableConstraintSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92CreateTableTableConstraintSyntax HsAction = HsTableConstraint
type Sql92CreateTableOptionsSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92CreateTableOptionsSyntax HsAction = HsNone

Methods

createTableSyntax :: Maybe (Sql92CreateTableOptionsSyntax HsAction) -> Sql92CreateTableTableNameSyntax HsAction -> [(Text, Sql92CreateTableColumnSchemaSyntax HsAction)] -> [Sql92CreateTableTableConstraintSyntax HsAction] -> HsAction Source #

IsSql92DdlCommandSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Sql92DdlCommandCreateTableSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92DdlCommandCreateTableSyntax HsAction = HsAction
type Sql92DdlCommandAlterTableSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92DdlCommandAlterTableSyntax HsAction = HsAction
type Sql92DdlCommandDropTableSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92DdlCommandDropTableSyntax HsAction = HsAction

Methods

createTableCmd :: Sql92DdlCommandCreateTableSyntax HsAction -> HsAction Source #

dropTableCmd :: Sql92DdlCommandDropTableSyntax HsAction -> HsAction Source #

alterTableCmd :: Sql92DdlCommandAlterTableSyntax HsAction -> HsAction Source #

IsSql92DdlSchemaCommandSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Sql92DdlCommandCreateSchemaSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92DdlCommandCreateSchemaSyntax HsAction = HsAction
type Sql92DdlCommandDropSchemaSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92DdlCommandDropSchemaSyntax HsAction = HsAction

Methods

createSchemaCmd :: Sql92DdlCommandCreateSchemaSyntax HsAction -> HsAction Source #

dropSchemaCmd :: Sql92DdlCommandDropSchemaSyntax HsAction -> HsAction Source #

IsSql92DropSchemaSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Sql92DropSchemaSchemaNameSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92DropSchemaSchemaNameSyntax HsAction = SchemaName

Methods

dropSchemaSyntax :: Sql92DropSchemaSchemaNameSyntax HsAction -> HsAction Source #

IsSql92DropTableSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Sql92DropTableTableNameSyntax HsAction
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92DropTableTableNameSyntax HsAction = TableName

Methods

dropTableSyntax :: Sql92DropTableTableNameSyntax HsAction -> HsAction Source #

type Sql92AlterTableAlterTableActionSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92AlterTableAlterTableActionSyntax HsAction = HsNone

type Sql92AlterTableTableNameSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92AlterTableTableNameSyntax HsAction = TableName

type Sql92CreateSchemaSchemaNameSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92CreateSchemaSchemaNameSyntax HsAction = SchemaName

type Sql92CreateTableColumnSchemaSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92CreateTableColumnSchemaSyntax HsAction = HsColumnSchema

type Sql92CreateTableOptionsSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92CreateTableOptionsSyntax HsAction = HsNone

type Sql92CreateTableTableConstraintSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92CreateTableTableConstraintSyntax HsAction = HsTableConstraint

type Sql92CreateTableTableNameSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92CreateTableTableNameSyntax HsAction = TableName

type Sql92DdlCommandAlterTableSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92DdlCommandAlterTableSyntax HsAction = HsAction

type Sql92DdlCommandCreateSchemaSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92DdlCommandCreateSchemaSyntax HsAction = HsAction

type Sql92DdlCommandCreateTableSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92DdlCommandCreateTableSyntax HsAction = HsAction

type Sql92DdlCommandDropSchemaSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92DdlCommandDropSchemaSyntax HsAction = HsAction

type Sql92DdlCommandDropTableSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92DdlCommandDropTableSyntax HsAction = HsAction

type Sql92DropSchemaSchemaNameSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92DropSchemaSchemaNameSyntax HsAction = SchemaName

type Sql92DropTableTableNameSyntax HsAction Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92DropTableTableNameSyntax HsAction = TableName

newtype HsBackendConstraint Source #

Constructors

HsBackendConstraint
Fields buildHsBackendConstraint :: Type () -> Asst ()

data HsBeamBackend f Source #

Constructors

HsBeamBackendSingle HsType f
HsBeamBackendConstrained [HsBackendConstraint]
HsBeamBackendNone

Instances

Instances details

Monoid (HsBeamBackend f) Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods mempty :: HsBeamBackend f # mappend :: HsBeamBackend f -> HsBeamBackend f -> HsBeamBackend f # mconcat :: [HsBeamBackend f] -> HsBeamBackend f #
Semigroup (HsBeamBackend f) Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods (<>) :: HsBeamBackend f -> HsBeamBackend f -> HsBeamBackend f # sconcat :: NonEmpty (HsBeamBackend f) -> HsBeamBackend f # stimes :: Integral b => b -> HsBeamBackend f -> HsBeamBackend f #

data HsEntity Source #

Constructors

HsEntity
Fields hsEntityBackend :: HsBeamBackend HsExpr hsEntityName :: HsEntityName hsEntityDecls :: [HsDecl] hsEntityDbDecl :: HsDbField hsEntityExp :: HsExpr

newtype HsFieldLookup Source #

Constructors

HsFieldLookup
Fields hsFieldLookup :: Text -> Maybe (Text, Type ())

newtype HsTableConstraint Source #

Constructors

HsTableConstraint (Text -> HsFieldLookup -> HsTableConstraintDecls)

Instances

Instances details

IsSql92TableConstraintSyntax HsTableConstraint Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods primaryKeyConstraintSyntax :: [Text] -> HsTableConstraint Source #

data HsTableConstraintDecls Source #

Constructors

HsTableConstraintDecls
Fields hsTableConstraintInstance :: [InstDecl ()] hsTableConstraintDecls :: [HsDecl]

Instances

Instances details

Monoid HsTableConstraintDecls Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods mempty :: HsTableConstraintDecls # mappend :: HsTableConstraintDecls -> HsTableConstraintDecls -> HsTableConstraintDecls # mconcat :: [HsTableConstraintDecls] -> HsTableConstraintDecls #
Semigroup HsTableConstraintDecls Source #
Instance details Defined in Database.Beam.Haskell.Syntax Methods (<>) :: HsTableConstraintDecls -> HsTableConstraintDecls -> HsTableConstraintDecls # sconcat :: NonEmpty HsTableConstraintDecls -> HsTableConstraintDecls # stimes :: Integral b => b -> HsTableConstraintDecls -> HsTableConstraintDecls #

data HsModule Source #

Constructors

HsModule
Fields hsModuleName :: String hsModuleEntities :: [HsEntity] hsModuleMigration :: [(Maybe (Pat ()), HsExpr)]

hsActionsToModule :: String -> [HsAction] -> HsModule Source #

unqual :: String -> QName () Source #

entityDbFieldName :: HsEntity -> String Source #

derivingDecl :: [InstRule ()] -> Deriving () Source #

dataDecl :: DeclHead () -> [QualConDecl ()] -> Maybe (Deriving ()) -> Decl () Source #

insDataDecl :: Type () -> [QualConDecl ()] -> Maybe (Deriving ()) -> InstDecl () Source #

databaseTypeDecl :: [HsEntity] -> Decl () Source #

migrationTypeDecl :: HsBeamBackend HsExpr -> [Type ()] -> Decl () Source #

migrationDecl :: HsBeamBackend HsExpr -> [Exp ()] -> [(Maybe (Pat ()), HsExpr)] -> [HsEntity] -> Decl () Source #

dbTypeDecl :: HsBeamBackend HsExpr -> Decl () Source #

dbDecl :: HsBeamBackend HsExpr -> [HsExpr] -> Decl () Source #

renderHsSchema :: HsModule -> Either String String Source #

DDL Syntax definitions

data HsNone Source #

Constructors

HsNone

Instances

Instances details

Monoid HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

mempty :: HsNone #

mappend :: HsNone -> HsNone -> HsNone #

mconcat :: [HsNone] -> HsNone #

Semigroup HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

(<>) :: HsNone -> HsNone -> HsNone #

sconcat :: NonEmpty HsNone -> HsNone #

stimes :: Integral b => b -> HsNone -> HsNone #

Generic HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Rep HsNone
Instance details Defined in Database.Beam.Haskell.Syntax type Rep HsNone = D1 ('MetaData "HsNone" "Database.Beam.Haskell.Syntax" "beam-migrate-0.5.3.2-inplace" 'False) (C1 ('MetaCons "HsNone" 'PrefixI 'False) (U1 :: Type -> Type))

Methods

from :: HsNone -> Rep HsNone x #

to :: Rep HsNone x -> HsNone #

Show HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

showsPrec :: Int -> HsNone -> ShowS #

show :: HsNone -> String #

showList :: [HsNone] -> ShowS #

IsSql92AlterColumnActionSyntax HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

setNotNullSyntax :: HsNone Source #

setNullSyntax :: HsNone Source #

IsSql92AlterTableActionSyntax HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Associated Types

type Sql92AlterTableAlterColumnActionSyntax HsNone
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92AlterTableAlterColumnActionSyntax HsNone = HsNone
type Sql92AlterTableColumnSchemaSyntax HsNone
Instance details Defined in Database.Beam.Haskell.Syntax type Sql92AlterTableColumnSchemaSyntax HsNone = HsColumnSchema

Methods

alterColumnSyntax :: Text -> Sql92AlterTableAlterColumnActionSyntax HsNone -> HsNone Source #

addColumnSyntax :: Text -> Sql92AlterTableColumnSchemaSyntax HsNone -> HsNone Source #

dropColumnSyntax :: Text -> HsNone Source #

renameTableToSyntax :: Text -> HsNone Source #

renameColumnToSyntax :: Text -> Text -> HsNone Source #

IsSql92ConstraintAttributesSyntax HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

initiallyDeferredAttributeSyntax :: HsNone Source #

initiallyImmediateAttributeSyntax :: HsNone Source #

notDeferrableAttributeSyntax :: HsNone Source #

deferrableAttributeSyntax :: HsNone Source #

IsSql92MatchTypeSyntax HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

fullMatchSyntax :: HsNone Source #

partialMatchSyntax :: HsNone Source #

IsSql92ReferentialActionSyntax HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

referentialActionCascadeSyntax :: HsNone Source #

referentialActionSetNullSyntax :: HsNone Source #

referentialActionSetDefaultSyntax :: HsNone Source #

referentialActionNoActionSyntax :: HsNone Source #

Eq HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

(==) :: HsNone -> HsNone -> Bool #

(/=) :: HsNone -> HsNone -> Bool #

Ord HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

compare :: HsNone -> HsNone -> Ordering #

(<) :: HsNone -> HsNone -> Bool #

(<=) :: HsNone -> HsNone -> Bool #

(>) :: HsNone -> HsNone -> Bool #

(>=) :: HsNone -> HsNone -> Bool #

max :: HsNone -> HsNone -> HsNone #

min :: HsNone -> HsNone -> HsNone #

Hashable HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

Methods

hashWithSalt :: Int -> HsNone -> Int #

hash :: HsNone -> Int #

type Rep HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Rep HsNone = D1 ('MetaData "HsNone" "Database.Beam.Haskell.Syntax" "beam-migrate-0.5.3.2-inplace" 'False) (C1 ('MetaCons "HsNone" 'PrefixI 'False) (U1 :: Type -> Type))

type Sql92AlterTableAlterColumnActionSyntax HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92AlterTableAlterColumnActionSyntax HsNone = HsNone

type Sql92AlterTableColumnSchemaSyntax HsNone Source #

Instance details

Defined in Database.Beam.Haskell.Syntax

type Sql92AlterTableColumnSchemaSyntax HsNone = HsColumnSchema

data HsMigrateBackend Source #

Constructors

HsMigrateBackend

Instances

Instances details

BeamMigrateOnlySqlBackend HsMigrateBackend Source #
Instance details Defined in Database.Beam.Haskell.Syntax
type BeamSqlBackendSyntax HsMigrateBackend Source #
Instance details Defined in Database.Beam.Haskell.Syntax type BeamSqlBackendSyntax HsMigrateBackend = HsAction

hsMkTableName :: (Char -> Char) -> TableName -> String Source #

hsSchemaName :: SchemaName -> String Source #

hsTableVarName :: TableName -> String Source #

hsTableTypeName :: TableName -> String Source #

hsErrorType :: String -> HsDataType Source #

HsSyntax utilities

tyParens :: Type () -> Type () Source #

functionTy :: Type () -> Type () -> Type () Source #

tyTuple :: [Type ()] -> Type () Source #

tyApp :: Type () -> [Type ()] -> Type () Source #

tyConNamed :: String -> Type () Source #

tyVarNamed :: String -> Type () Source #

combineHsExpr :: (Exp () -> Exp () -> Exp ()) -> HsExpr -> HsExpr -> HsExpr Source #

hsApp :: HsExpr -> [HsExpr] -> HsExpr Source #

hsVisibleTyApp :: HsExpr -> Type () -> HsExpr Source #

hsApApp :: HsExpr -> [HsExpr] -> HsExpr Source #

hsStr :: Text -> HsExpr Source #

hsRecCon :: Text -> [(Text, HsExpr)] -> HsExpr Source #

hsMaybe :: Maybe HsExpr -> HsExpr Source #

hsVar :: Text -> HsExpr Source #

hsVarFrom :: Text -> Text -> HsExpr Source #

hsTyCon :: Text -> HsExpr Source #

hsInt :: (Integral a, Show a) => a -> HsExpr Source #

hsOp :: Text -> QOp () Source #

hsInstance :: Text -> [Type ()] -> [InstDecl ()] -> Decl () Source #

hsDerivingInstance :: Text -> [Type ()] -> Decl () Source #

hsList :: [HsExpr] -> HsExpr Source #

hsTuple :: [HsExpr] -> HsExpr Source #

inst :: String -> InstRule () Source #

beamMigrateSqlBackend :: HsBackendConstraint Source #

Orphans

Orphan instances

Hashable Boxed Source #
Instance details Methods hashWithSalt :: Int -> Boxed -> Int # hash :: Boxed -> Int #
Hashable (Activation ()) Source #
Instance details Methods hashWithSalt :: Int -> Activation () -> Int # hash :: Activation () -> Int #
Hashable (Alt ()) Source #
Instance details Methods hashWithSalt :: Int -> Alt () -> Int # hash :: Alt () -> Int #
Hashable (Annotation ()) Source #
Instance details Methods hashWithSalt :: Int -> Annotation () -> Int # hash :: Annotation () -> Int #
Hashable (Assoc ()) Source #
Instance details Methods hashWithSalt :: Int -> Assoc () -> Int # hash :: Assoc () -> Int #
Hashable (Asst ()) Source #
Instance details Methods hashWithSalt :: Int -> Asst () -> Int # hash :: Asst () -> Int #
Hashable (BangType ()) Source #
Instance details Methods hashWithSalt :: Int -> BangType () -> Int # hash :: BangType () -> Int #
Hashable (Binds ()) Source #
Instance details Methods hashWithSalt :: Int -> Binds () -> Int # hash :: Binds () -> Int #
Hashable (BooleanFormula ()) Source #
Instance details Methods hashWithSalt :: Int -> BooleanFormula () -> Int # hash :: BooleanFormula () -> Int #
Hashable (Bracket ()) Source #
Instance details Methods hashWithSalt :: Int -> Bracket () -> Int # hash :: Bracket () -> Int #
Hashable (CName ()) Source #
Instance details Methods hashWithSalt :: Int -> CName () -> Int # hash :: CName () -> Int #
Hashable (CallConv ()) Source #
Instance details Methods hashWithSalt :: Int -> CallConv () -> Int # hash :: CallConv () -> Int #
Hashable (ClassDecl ()) Source #
Instance details Methods hashWithSalt :: Int -> ClassDecl () -> Int # hash :: ClassDecl () -> Int #
Hashable (ConDecl ()) Source #
Instance details Methods hashWithSalt :: Int -> ConDecl () -> Int # hash :: ConDecl () -> Int #
Hashable (Context ()) Source #
Instance details Methods hashWithSalt :: Int -> Context () -> Int # hash :: Context () -> Int #
Hashable (DataOrNew ()) Source #
Instance details Methods hashWithSalt :: Int -> DataOrNew () -> Int # hash :: DataOrNew () -> Int #
Hashable (Decl ()) Source #
Instance details Methods hashWithSalt :: Int -> Decl () -> Int # hash :: Decl () -> Int #
Hashable (DeclHead ()) Source #
Instance details Methods hashWithSalt :: Int -> DeclHead () -> Int # hash :: DeclHead () -> Int #
Hashable (DerivStrategy ()) Source #
Instance details Methods hashWithSalt :: Int -> DerivStrategy () -> Int # hash :: DerivStrategy () -> Int #
Hashable (Deriving ()) Source #
Instance details Methods hashWithSalt :: Int -> Deriving () -> Int # hash :: Deriving () -> Int #
Hashable (Exp ()) Source #
Instance details Methods hashWithSalt :: Int -> Exp () -> Int # hash :: Exp () -> Int #
Hashable (FieldDecl ()) Source #
Instance details Methods hashWithSalt :: Int -> FieldDecl () -> Int # hash :: FieldDecl () -> Int #
Hashable (FieldUpdate ()) Source #
Instance details Methods hashWithSalt :: Int -> FieldUpdate () -> Int # hash :: FieldUpdate () -> Int #
Hashable (FunDep ()) Source #
Instance details Methods hashWithSalt :: Int -> FunDep () -> Int # hash :: FunDep () -> Int #
Hashable (GadtDecl ()) Source #
Instance details Methods hashWithSalt :: Int -> GadtDecl () -> Int # hash :: GadtDecl () -> Int #
Hashable (GuardedRhs ()) Source #
Instance details Methods hashWithSalt :: Int -> GuardedRhs () -> Int # hash :: GuardedRhs () -> Int #
Hashable (IPBind ()) Source #
Instance details Methods hashWithSalt :: Int -> IPBind () -> Int # hash :: IPBind () -> Int #
Hashable (IPName ()) Source #
Instance details Methods hashWithSalt :: Int -> IPName () -> Int # hash :: IPName () -> Int #
Hashable (ImportSpec ()) Source #
Instance details Methods hashWithSalt :: Int -> ImportSpec () -> Int # hash :: ImportSpec () -> Int #
Hashable (InjectivityInfo ()) Source #
Instance details Methods hashWithSalt :: Int -> InjectivityInfo () -> Int # hash :: InjectivityInfo () -> Int #
Hashable (InstDecl ()) Source #
Instance details Methods hashWithSalt :: Int -> InstDecl () -> Int # hash :: InstDecl () -> Int #
Hashable (InstHead ()) Source #
Instance details Methods hashWithSalt :: Int -> InstHead () -> Int # hash :: InstHead () -> Int #
Hashable (InstRule ()) Source #
Instance details Methods hashWithSalt :: Int -> InstRule () -> Int # hash :: InstRule () -> Int #
Hashable (Literal ()) Source #
Instance details Methods hashWithSalt :: Int -> Literal () -> Int # hash :: Literal () -> Int #
Hashable (Match ()) Source #
Instance details Methods hashWithSalt :: Int -> Match () -> Int # hash :: Match () -> Int #
Hashable (MaybePromotedName ()) Source #
Instance details Methods hashWithSalt :: Int -> MaybePromotedName () -> Int # hash :: MaybePromotedName () -> Int #
Hashable (ModuleName ()) Source #
Instance details Methods hashWithSalt :: Int -> ModuleName () -> Int # hash :: ModuleName () -> Int #
Hashable (Name ()) Source #
Instance details Methods hashWithSalt :: Int -> Name () -> Int # hash :: Name () -> Int #
Hashable (Namespace ()) Source #
Instance details Methods hashWithSalt :: Int -> Namespace () -> Int # hash :: Namespace () -> Int #
Hashable (Op ()) Source #
Instance details Methods hashWithSalt :: Int -> Op () -> Int # hash :: Op () -> Int #
Hashable (Overlap ()) Source #
Instance details Methods hashWithSalt :: Int -> Overlap () -> Int # hash :: Overlap () -> Int #
Hashable (PXAttr ()) Source #
Instance details Methods hashWithSalt :: Int -> PXAttr () -> Int # hash :: PXAttr () -> Int #
Hashable (Pat ()) Source #
Instance details Methods hashWithSalt :: Int -> Pat () -> Int # hash :: Pat () -> Int #
Hashable (PatField ()) Source #
Instance details Methods hashWithSalt :: Int -> PatField () -> Int # hash :: PatField () -> Int #
Hashable (PatternSynDirection ()) Source #
Instance details Methods hashWithSalt :: Int -> PatternSynDirection () -> Int # hash :: PatternSynDirection () -> Int #
Hashable (Promoted ()) Source #
Instance details Methods hashWithSalt :: Int -> Promoted () -> Int # hash :: Promoted () -> Int #
Hashable (QName ()) Source #
Instance details Methods hashWithSalt :: Int -> QName () -> Int # hash :: QName () -> Int #
Hashable (QOp ()) Source #
Instance details Methods hashWithSalt :: Int -> QOp () -> Int # hash :: QOp () -> Int #
Hashable (QualConDecl ()) Source #
Instance details Methods hashWithSalt :: Int -> QualConDecl () -> Int # hash :: QualConDecl () -> Int #
Hashable (QualStmt ()) Source #
Instance details Methods hashWithSalt :: Int -> QualStmt () -> Int # hash :: QualStmt () -> Int #
Hashable (RPat ()) Source #
Instance details Methods hashWithSalt :: Int -> RPat () -> Int # hash :: RPat () -> Int #
Hashable (RPatOp ()) Source #
Instance details Methods hashWithSalt :: Int -> RPatOp () -> Int # hash :: RPatOp () -> Int #
Hashable (ResultSig ()) Source #
Instance details Methods hashWithSalt :: Int -> ResultSig () -> Int # hash :: ResultSig () -> Int #
Hashable (Rhs ()) Source #
Instance details Methods hashWithSalt :: Int -> Rhs () -> Int # hash :: Rhs () -> Int #
Hashable (Role ()) Source #
Instance details Methods hashWithSalt :: Int -> Role () -> Int # hash :: Role () -> Int #
Hashable (Rule ()) Source #
Instance details Methods hashWithSalt :: Int -> Rule () -> Int # hash :: Rule () -> Int #
Hashable (RuleVar ()) Source #
Instance details Methods hashWithSalt :: Int -> RuleVar () -> Int # hash :: RuleVar () -> Int #
Hashable (Safety ()) Source #
Instance details Methods hashWithSalt :: Int -> Safety () -> Int # hash :: Safety () -> Int #
Hashable (Sign ()) Source #
Instance details Methods hashWithSalt :: Int -> Sign () -> Int # hash :: Sign () -> Int #
Hashable (SpecialCon ()) Source #
Instance details Methods hashWithSalt :: Int -> SpecialCon () -> Int # hash :: SpecialCon () -> Int #
Hashable (Splice ()) Source #
Instance details Methods hashWithSalt :: Int -> Splice () -> Int # hash :: Splice () -> Int #
Hashable (Stmt ()) Source #
Instance details Methods hashWithSalt :: Int -> Stmt () -> Int # hash :: Stmt () -> Int #
Hashable (TyVarBind ()) Source #
Instance details Methods hashWithSalt :: Int -> TyVarBind () -> Int # hash :: TyVarBind () -> Int #
Hashable (Type ()) Source #
Instance details Methods hashWithSalt :: Int -> Type () -> Int # hash :: Type () -> Int #
Hashable (TypeEqn ()) Source #
Instance details Methods hashWithSalt :: Int -> TypeEqn () -> Int # hash :: TypeEqn () -> Int #
Hashable (Unpackedness ()) Source #
Instance details Methods hashWithSalt :: Int -> Unpackedness () -> Int # hash :: Unpackedness () -> Int #
Hashable (XAttr ()) Source #
Instance details Methods hashWithSalt :: Int -> XAttr () -> Int # hash :: XAttr () -> Int #
Hashable (XName ()) Source #
Instance details Methods hashWithSalt :: Int -> XName () -> Int # hash :: XName () -> Int #