| Safe Haskell | Safe |
|---|---|
| Language | Haskell2010 |
Database.Selda.SqlType
Description
Types representable as columns in Selda's subset of SQL.
Synopsis
- class Typeable a => SqlType a where
- mkLit :: a -> Lit a
- sqlType :: Proxy a -> SqlTypeRep
- fromSql :: SqlValue -> a
- defaultValue :: Lit a
- class (Typeable a, Bounded a, Enum a) => SqlEnum a where
- data Lit a where
- LText :: !Text -> Lit Text
- LInt :: !Int -> Lit Int
- LDouble :: !Double -> Lit Double
- LBool :: !Bool -> Lit Bool
- LDateTime :: !Text -> Lit UTCTime
- LDate :: !Text -> Lit Day
- LTime :: !Text -> Lit TimeOfDay
- LJust :: SqlType a => !(Lit a) -> Lit (Maybe a)
- LBlob :: !ByteString -> Lit ByteString
- LNull :: SqlType a => Lit (Maybe a)
- LCustom :: Lit a -> Lit b
- data RowID
- data ID a
- data SqlValue where
- data SqlTypeRep
- invalidRowId :: RowID
- isInvalidRowId :: RowID -> Bool
- toRowId :: Int -> RowID
- fromRowId :: RowID -> Int
- fromId :: ID a -> Int
- toId :: Int -> ID a
- invalidId :: ID a
- isInvalidId :: ID a -> Bool
- untyped :: ID a -> RowID
- compLit :: Lit a -> Lit b -> Ordering
- litType :: Lit a -> SqlTypeRep
- sqlDateTimeFormat :: String
- sqlDateFormat :: String
- sqlTimeFormat :: String
Documentation
class Typeable a => SqlType a where #
Any datatype representable in (Selda's subset of) SQL.
Minimal complete definition
Nothing
Methods
Create a literal of this type.
mkLit :: (Typeable a, SqlEnum a) => a -> Lit a #
Create a literal of this type.
sqlType :: Proxy a -> SqlTypeRep #
The SQL representation for this type.
Convert an SqlValue into this type.
fromSql :: (Typeable a, SqlEnum a) => SqlValue -> a #
Convert an SqlValue into this type.
defaultValue :: Lit a #
Default value when using def at this type.
defaultValue :: (Typeable a, SqlEnum a) => Lit a #
Default value when using def at this type.
Instances
| SqlType Bool # | |
| SqlType Double # | |
| SqlType Int # | |
| SqlType Ordering # | |
| SqlType ByteString # | |
Defined in Database.Selda.SqlType Methods mkLit :: ByteString -> Lit ByteString # sqlType :: Proxy ByteString -> SqlTypeRep # fromSql :: SqlValue -> ByteString # | |
| SqlType ByteString # | |
Defined in Database.Selda.SqlType Methods mkLit :: ByteString -> Lit ByteString # sqlType :: Proxy ByteString -> SqlTypeRep # fromSql :: SqlValue -> ByteString # | |
| SqlType Text # | |
| SqlType TimeOfDay # | |
| SqlType UTCTime # | |
| SqlType Day # | |
| SqlType RowID # | |
| SqlType a => SqlType (Maybe a) # | |
| Typeable a => SqlType (ID a) # | |
| ((TypeError (((Text "'Only " :<>: ShowType a) :<>: Text "' is not a proper SQL type.") :$$: Text "Use 'the' to access the value of the column.") :: Constraint), Typeable a) => SqlType (Only a) # | |
class (Typeable a, Bounded a, Enum a) => SqlEnum a where #
Any type that's bounded, enumerable and has a text representation, and thus representable as a Selda enumerable.
While it would be more efficient to store enumerables as integers, this makes hand-rolled SQL touching the values inscrutable, and will break if the user a) derives Enum and b) changes the order of their constructors. Long-term, this should be implemented in PostgreSQL as a proper enum anyway, which mostly renders the performance argument moot.
An SQL literal.
Constructors
| LText :: !Text -> Lit Text | |
| LInt :: !Int -> Lit Int | |
| LDouble :: !Double -> Lit Double | |
| LBool :: !Bool -> Lit Bool | |
| LDateTime :: !Text -> Lit UTCTime | |
| LDate :: !Text -> Lit Day | |
| LTime :: !Text -> Lit TimeOfDay | |
| LJust :: SqlType a => !(Lit a) -> Lit (Maybe a) | |
| LBlob :: !ByteString -> Lit ByteString | |
| LNull :: SqlType a => Lit (Maybe a) | |
| LCustom :: Lit a -> Lit b |
A row identifier for some table. This is the type of auto-incrementing primary keys.
A typed row identifier.
Generic tables should use this instead of RowID.
Use untyped to erase the type of a row identifier, and cast from the
Database.Selda.Unsafe module if you for some reason need to add a type
to a row identifier.
Some value that is representable in SQL.
data SqlTypeRep #
Representation of an SQL type.
Instances
| Eq SqlTypeRep # | |
Defined in Database.Selda.SqlType | |
| Ord SqlTypeRep # | |
Defined in Database.Selda.SqlType Methods compare :: SqlTypeRep -> SqlTypeRep -> Ordering # (<) :: SqlTypeRep -> SqlTypeRep -> Bool # (<=) :: SqlTypeRep -> SqlTypeRep -> Bool # (>) :: SqlTypeRep -> SqlTypeRep -> Bool # (>=) :: SqlTypeRep -> SqlTypeRep -> Bool # max :: SqlTypeRep -> SqlTypeRep -> SqlTypeRep # min :: SqlTypeRep -> SqlTypeRep -> SqlTypeRep # | |
| Show SqlTypeRep # | |
Defined in Database.Selda.SqlType Methods showsPrec :: Int -> SqlTypeRep -> ShowS # show :: SqlTypeRep -> String # showList :: [SqlTypeRep] -> ShowS # | |
invalidRowId :: RowID #
A row identifier which is guaranteed to not match any row in any table.
isInvalidRowId :: RowID -> Bool #
Is the given row identifier invalid? I.e. is it guaranteed to not match any row in any table?
Create a row identifier from an integer. Use with caution, preferably only when reading user input.
Create a typed row identifier from an integer. Use with caution, preferably only when reading user input.
Create a typed row identifier from an integer. Use with caution, preferably only when reading user input.
isInvalidId :: ID a -> Bool #
Is the given typed row identifier invalid? I.e. is it guaranteed to not match any row in any table?
litType :: Lit a -> SqlTypeRep #
The SQL type representation for the given literal.
Format string used to represent date and time when talking to the database backend.
sqlDateFormat :: String #
Format string used to represent date when talking to the database backend.
sqlTimeFormat :: String #
Format string used to represent time of day when talking to the database backend.