packages feed

relational-record-examples 0.5.1.0 → 0.5.1.1

raw patch · 3 files changed

+3/−1 lines, 3 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Account: instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Account.Account
- Branch: instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Branch.Branch
- Business: instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Business.Business
- Customer: instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Customer.Customer
- Department: instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Department.Department
- Employee: instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Employee.Employee
- Individual: instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Individual.Individual
- Officer: instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Officer.Officer
- Product: instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Product.Product
- ProductType: instance Database.Relational.ProjectableClass.ShowConstantTermsSQL ProductType.ProductType
- Transaction: instance Database.Relational.ProjectableClass.ShowConstantTermsSQL Transaction.Transaction0
+ Account: instance Database.Relational.ProjectableClass.LiteralSQL Account.Account
+ Branch: instance Database.Relational.ProjectableClass.LiteralSQL Branch.Branch
+ Business: instance Database.Relational.ProjectableClass.LiteralSQL Business.Business
+ Customer: instance Database.Relational.ProjectableClass.LiteralSQL Customer.Customer
+ Database.Relational.Query.SQLite3: (!) :: PersistableWidth a => Record c a -> Pi a b -> Record c b
+ Database.Relational.Query.SQLite3: (!??) :: (PersistableWidth a, ProjectableFlattenMaybe Maybe b c) => Record cont Maybe a -> Pi a b -> Record cont c
+ Database.Relational.Query.SQLite3: ($$!) :: () => i -> r -> Number r i -> r
+ Database.Relational.Query.SQLite3: ($$) :: Binding r s i => i -> r -> Number r i -> r
+ Database.Relational.Query.SQLite3: (.*.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a
+ Database.Relational.Query.SQLite3: (.+.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a
+ Database.Relational.Query.SQLite3: (.-.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a
+ Database.Relational.Query.SQLite3: (./.) :: (OperatorContext c, Num a) => Record c a -> Record c a -> Record c a
+ Database.Relational.Query.SQLite3: (.<.) :: OperatorContext c => Record c ft -> Record c ft -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: (.<=.) :: OperatorContext c => Record c ft -> Record c ft -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: (.<>.) :: OperatorContext c => Record c ft -> Record c ft -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: (.=.) :: OperatorContext c => Record c ft -> Record c ft -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: (.>.) :: OperatorContext c => Record c ft -> Record c ft -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: (.>=.) :: OperatorContext c => Record c ft -> Record c ft -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: (.||.) :: OperatorContext c => Record c a -> Record c a -> Record c a
+ Database.Relational.Query.SQLite3: (<-#) :: Monad m => AssignTarget r v -> Record Flat v -> Assignings r m ()
+ Database.Relational.Query.SQLite3: (<.>) :: () => Pi a b -> Pi b c -> Pi a c
+ Database.Relational.Query.SQLite3: (<?.>) :: () => Pi a Maybe b -> Pi b c -> Pi a Maybe c
+ Database.Relational.Query.SQLite3: (<?.?>) :: () => Pi a Maybe b -> Pi b Maybe c -> Pi a Maybe c
+ Database.Relational.Query.SQLite3: (><) :: ProductIsoApplicative p => p a -> p b -> p (a, b)
+ Database.Relational.Query.SQLite3: (?!) :: PersistableWidth a => Record c Maybe a -> Pi a b -> Record c Maybe b
+ Database.Relational.Query.SQLite3: (?!?) :: PersistableWidth a => Record c Maybe a -> Pi a Maybe b -> Record c Maybe b
+ Database.Relational.Query.SQLite3: (?) :: PersistableWidth a => Record c Maybe a -> Pi a b -> Record c Maybe b
+ Database.Relational.Query.SQLite3: (?*?) :: (OperatorContext c, Num a) => Record c Maybe a -> Record c Maybe a -> Record c Maybe a
+ Database.Relational.Query.SQLite3: (?+?) :: (OperatorContext c, Num a) => Record c Maybe a -> Record c Maybe a -> Record c Maybe a
+ Database.Relational.Query.SQLite3: (?-?) :: (OperatorContext c, Num a) => Record c Maybe a -> Record c Maybe a -> Record c Maybe a
+ Database.Relational.Query.SQLite3: (?/?) :: (OperatorContext c, Num a) => Record c Maybe a -> Record c Maybe a -> Record c Maybe a
+ Database.Relational.Query.SQLite3: (??) :: PersistableWidth a => Record c Maybe a -> Pi a Maybe b -> Record c Maybe b
+ Database.Relational.Query.SQLite3: (?||?) :: (OperatorContext c, IsString a) => Record c Maybe a -> Record c Maybe a -> Record c Maybe a
+ Database.Relational.Query.SQLite3: Asc :: Order
+ Database.Relational.Query.SQLite3: BoundStatement :: !Statement -> [SqlValue] -> BoundStatement a
+ Database.Relational.Query.SQLite3: Delete :: String -> Delete p
+ Database.Relational.Query.SQLite3: Desc :: Order
+ Database.Relational.Query.SQLite3: Insert :: String -> Maybe (String, Int) -> Insert a
+ Database.Relational.Query.SQLite3: InsertQuery :: String -> InsertQuery p
+ Database.Relational.Query.SQLite3: KeyUpdate :: Pi a p -> String -> KeyUpdate p a
+ Database.Relational.Query.SQLite3: NoQuotation :: IdentifierQuotation
+ Database.Relational.Query.SQLite3: NullsFirst :: Nulls
+ Database.Relational.Query.SQLite3: NullsLast :: Nulls
+ Database.Relational.Query.SQLite3: PUNotSupported :: ProductUnitSupport
+ Database.Relational.Query.SQLite3: PUSupported :: ProductUnitSupport
+ Database.Relational.Query.SQLite3: Query :: String -> Query p a
+ Database.Relational.Query.SQLite3: Quotation :: Char -> IdentifierQuotation
+ Database.Relational.Query.SQLite3: SchemaNotQualified :: SchemaNameMode
+ Database.Relational.Query.SQLite3: SchemaQualified :: SchemaNameMode
+ Database.Relational.Query.SQLite3: SqlBigIntT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlBinaryT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlBitT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlBool :: Bool -> SqlValue
+ Database.Relational.Query.SQLite3: SqlByteString :: ByteString -> SqlValue
+ Database.Relational.Query.SQLite3: SqlChar :: Char -> SqlValue
+ Database.Relational.Query.SQLite3: SqlCharT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlColDesc :: SqlTypeId -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Bool -> SqlColDesc
+ Database.Relational.Query.SQLite3: SqlDateT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlDecimalT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlDiffTime :: NominalDiffTime -> SqlValue
+ Database.Relational.Query.SQLite3: SqlDouble :: Double -> SqlValue
+ Database.Relational.Query.SQLite3: SqlDoubleT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlEpochTime :: Integer -> SqlValue
+ Database.Relational.Query.SQLite3: SqlError :: String -> Int -> String -> SqlError
+ Database.Relational.Query.SQLite3: SqlFloatT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlGUIDT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlInt32 :: Int32 -> SqlValue
+ Database.Relational.Query.SQLite3: SqlInt64 :: Int64 -> SqlValue
+ Database.Relational.Query.SQLite3: SqlInteger :: Integer -> SqlValue
+ Database.Relational.Query.SQLite3: SqlIntegerT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlIntervalDayT :: SqlInterval
+ Database.Relational.Query.SQLite3: SqlIntervalDayToHourT :: SqlInterval
+ Database.Relational.Query.SQLite3: SqlIntervalDayToMinuteT :: SqlInterval
+ Database.Relational.Query.SQLite3: SqlIntervalDayToSecondT :: SqlInterval
+ Database.Relational.Query.SQLite3: SqlIntervalHourT :: SqlInterval
+ Database.Relational.Query.SQLite3: SqlIntervalHourToMinuteT :: SqlInterval
+ Database.Relational.Query.SQLite3: SqlIntervalHourToSecondT :: SqlInterval
+ Database.Relational.Query.SQLite3: SqlIntervalMinuteT :: SqlInterval
+ Database.Relational.Query.SQLite3: SqlIntervalMinuteToSecondT :: SqlInterval
+ Database.Relational.Query.SQLite3: SqlIntervalMonthT :: SqlInterval
+ Database.Relational.Query.SQLite3: SqlIntervalSecondT :: SqlInterval
+ Database.Relational.Query.SQLite3: SqlIntervalT :: SqlInterval -> SqlTypeId
+ Database.Relational.Query.SQLite3: SqlIntervalYearT :: SqlInterval
+ Database.Relational.Query.SQLite3: SqlIntervalYearToMonthT :: SqlInterval
+ Database.Relational.Query.SQLite3: SqlLocalDate :: Day -> SqlValue
+ Database.Relational.Query.SQLite3: SqlLocalTime :: LocalTime -> SqlValue
+ Database.Relational.Query.SQLite3: SqlLocalTimeOfDay :: TimeOfDay -> SqlValue
+ Database.Relational.Query.SQLite3: SqlLongVarBinaryT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlLongVarCharT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlNull :: SqlValue
+ Database.Relational.Query.SQLite3: SqlNumericT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlPOSIXTime :: POSIXTime -> SqlValue
+ Database.Relational.Query.SQLite3: SqlRational :: Rational -> SqlValue
+ Database.Relational.Query.SQLite3: SqlRealT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlSmallIntT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlString :: String -> SqlValue
+ Database.Relational.Query.SQLite3: SqlTimeDiff :: Integer -> SqlValue
+ Database.Relational.Query.SQLite3: SqlTimeT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlTimeWithZoneT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlTimestampT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlTimestampWithZoneT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlTinyIntT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlUTCDateTimeT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlUTCTime :: UTCTime -> SqlValue
+ Database.Relational.Query.SQLite3: SqlUTCTimeT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlUnknownT :: String -> SqlTypeId
+ Database.Relational.Query.SQLite3: SqlVarBinaryT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlVarCharT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlWCharT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlWLongVarCharT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlWVarCharT :: SqlTypeId
+ Database.Relational.Query.SQLite3: SqlWord32 :: Word32 -> SqlValue
+ Database.Relational.Query.SQLite3: SqlWord64 :: Word64 -> SqlValue
+ Database.Relational.Query.SQLite3: SqlZonedLocalTimeOfDay :: TimeOfDay -> TimeZone -> SqlValue
+ Database.Relational.Query.SQLite3: SqlZonedTime :: ZonedTime -> SqlValue
+ Database.Relational.Query.SQLite3: Update :: String -> Update p
+ Database.Relational.Query.SQLite3: [ConnWrapper] :: ConnWrapper
+ Database.Relational.Query.SQLite3: [bound] :: BoundStatement a -> !Statement
+ Database.Relational.Query.SQLite3: [chunkedInsert] :: Insert a -> Maybe (String, Int)
+ Database.Relational.Query.SQLite3: [colDecDigits] :: SqlColDesc -> Maybe Int
+ Database.Relational.Query.SQLite3: [colNullable] :: SqlColDesc -> Maybe Bool
+ Database.Relational.Query.SQLite3: [colOctetLength] :: SqlColDesc -> Maybe Int
+ Database.Relational.Query.SQLite3: [colSize] :: SqlColDesc -> Maybe Int
+ Database.Relational.Query.SQLite3: [colType] :: SqlColDesc -> SqlTypeId
+ Database.Relational.Query.SQLite3: [params] :: BoundStatement a -> [SqlValue]
+ Database.Relational.Query.SQLite3: [seErrorMsg] :: SqlError -> String
+ Database.Relational.Query.SQLite3: [seNativeError] :: SqlError -> Int
+ Database.Relational.Query.SQLite3: [seState] :: SqlError -> String
+ Database.Relational.Query.SQLite3: [untypeDelete] :: Delete p -> String
+ Database.Relational.Query.SQLite3: [untypeInsertQuery] :: InsertQuery p -> String
+ Database.Relational.Query.SQLite3: [untypeInsert] :: Insert a -> String
+ Database.Relational.Query.SQLite3: [untypeKeyUpdate] :: KeyUpdate p a -> String
+ Database.Relational.Query.SQLite3: [untypeQuery] :: Query p a -> String
+ Database.Relational.Query.SQLite3: [untypeUpdate] :: Update p -> String
+ Database.Relational.Query.SQLite3: [updateKey] :: KeyUpdate p a -> Pi a p
+ Database.Relational.Query.SQLite3: aggregateRelation :: () => QueryAggregate Record Aggregated r -> Relation () r
+ Database.Relational.Query.SQLite3: aggregateRelation' :: () => AggregatedQuery p r -> Relation p r
+ Database.Relational.Query.SQLite3: aggregatedUnique :: () => Relation ph r -> Pi r a -> Record Flat a -> Record Aggregated b -> UniqueRelation ph Flat b
+ Database.Relational.Query.SQLite3: all' :: MonadQuery m => m ()
+ Database.Relational.Query.SQLite3: and' :: OperatorContext c => Record c Maybe Bool -> Record c Maybe Bool -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: any' :: (AggregatedContext ac, SqlContext ac) => Predicate Flat -> Record ac Maybe Bool
+ Database.Relational.Query.SQLite3: asc :: Monad m => Record c t -> Orderings c m ()
+ Database.Relational.Query.SQLite3: askConfig :: ConfigureQuery Config
+ Database.Relational.Query.SQLite3: assignTo :: Monad m => Record Flat v -> AssignTarget r v -> Assignings r m ()
+ Database.Relational.Query.SQLite3: avg :: (Num a, Fractional b, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac Maybe b
+ Database.Relational.Query.SQLite3: avgMaybe :: (Num a, Fractional b, AggregatedContext ac, SqlContext ac) => Record Flat Maybe a -> Record ac Maybe b
+ Database.Relational.Query.SQLite3: bind :: ToSql SqlValue p => PreparedStatement p a -> p -> BoundStatement a
+ Database.Relational.Query.SQLite3: bindKeyUpdate :: ToSql SqlValue a => PreparedKeyUpdate p a -> a -> BoundStatement ()
+ Database.Relational.Query.SQLite3: bindTo :: ToSql SqlValue p => p -> PreparedStatement p a -> BoundStatement a
+ Database.Relational.Query.SQLite3: binding :: Binding r s i => SeqBinding r s i
+ Database.Relational.Query.SQLite3: bkey :: () => Record Flat r -> AggregatingPowerSet Record Aggregated Maybe r
+ Database.Relational.Query.SQLite3: bulkInsert :: (IConnection conn, ToSql SqlValue a) => conn -> Insert a -> [a] -> IO ()
+ Database.Relational.Query.SQLite3: bulkInsert' :: (IConnection conn, ToSql SqlValue a) => conn -> Insert a -> [a] -> IO ([Integer], [Integer])
+ Database.Relational.Query.SQLite3: bulkInsertInterleave :: (IConnection conn, ToSql SqlValue a) => conn -> Insert a -> [a] -> IO ([Integer], [Integer])
+ Database.Relational.Query.SQLite3: case' :: OperatorContext c => Record c a -> [(Record c a, Record c b)] -> Record c b -> Record c b
+ Database.Relational.Query.SQLite3: caseMaybe :: (OperatorContext c, PersistableWidth b) => Record c a -> [(Record c a, Record c Maybe b)] -> Record c Maybe b
+ Database.Relational.Query.SQLite3: caseSearch :: OperatorContext c => [(Predicate c, Record c a)] -> Record c a -> Record c a
+ Database.Relational.Query.SQLite3: caseSearchMaybe :: (OperatorContext c, PersistableWidth a) => [(Predicate c, Record c Maybe a)] -> Record c Maybe a
+ Database.Relational.Query.SQLite3: casesOrElse :: OperatorContext c => [(Predicate c, Record c a)] -> Record c a -> Record c a
+ Database.Relational.Query.SQLite3: casesOrElse' :: OperatorContext c => (Record c a, [(Record c a, Record c b)]) -> Record c b -> Record c b
+ Database.Relational.Query.SQLite3: catchSql :: () => IO a -> SqlError -> IO a -> IO a
+ Database.Relational.Query.SQLite3: chunkSizeOfInsert :: () => Insert a -> Int
+ Database.Relational.Query.SQLite3: chunksInsert :: (IConnection conn, ToSql SqlValue a) => conn -> Insert a -> [a] -> IO [[Integer]]
+ Database.Relational.Query.SQLite3: class (TableDerivable r, SequenceDerivable s i) => Binding r s i | r -> s
+ Database.Relational.Query.SQLite3: class FromSql q a
+ Database.Relational.Query.SQLite3: class HasColumnConstraint c a
+ Database.Relational.Query.SQLite3: class PersistableWidth ct => HasConstraintKey c r ct
+ Database.Relational.Query.SQLite3: class HasKeyConstraint c a
+ Database.Relational.Query.SQLite3: class IConnection conn
+ Database.Relational.Query.SQLite3: class LiteralSQL a
+ Database.Relational.Query.SQLite3: class MonadQuery m => MonadAggregate (m :: * -> *)
+ Database.Relational.Query.SQLite3: class Monad m => MonadPartition c (m :: * -> *)
+ Database.Relational.Query.SQLite3: class (Functor q, Monad q, Functor m, Monad m) => MonadQualify (q :: * -> *) (m :: * -> *)
+ Database.Relational.Query.SQLite3: class (Functor m, Monad m, MonadQualify ConfigureQuery m) => MonadQuery (m :: * -> *)
+ Database.Relational.Query.SQLite3: class (Functor m, Monad m) => MonadRestrict c (m :: * -> *)
+ Database.Relational.Query.SQLite3: class Eq q => PersistableType q
+ Database.Relational.Query.SQLite3: class PersistableWidth a
+ Database.Relational.Query.SQLite3: class ProjectableFlattenMaybe a b
+ Database.Relational.Query.SQLite3: class ProjectableMaybe (p :: * -> *)
+ Database.Relational.Query.SQLite3: class PersistableWidth ct => ScalarDegree ct
+ Database.Relational.Query.SQLite3: class TableDerivable s => SequenceDerivable s i | s -> i
+ Database.Relational.Query.SQLite3: class SqlContext c
+ Database.Relational.Query.SQLite3: class PersistableWidth r => TableDerivable r
+ Database.Relational.Query.SQLite3: class PersistableWidth a => ToSql q a
+ Database.Relational.Query.SQLite3: class UntypeableNoFetch (s :: * -> *)
+ Database.Relational.Query.SQLite3: clone :: IConnection conn => conn -> IO conn
+ Database.Relational.Query.SQLite3: columnConstraint :: HasColumnConstraint c a => ColumnConstraint c a
+ Database.Relational.Query.SQLite3: commit :: IConnection conn => conn -> IO ()
+ Database.Relational.Query.SQLite3: configureQuery :: () => ConfigureQuery q -> Config -> q
+ Database.Relational.Query.SQLite3: constraintKey :: HasConstraintKey c r ct => Key c r ct
+ Database.Relational.Query.SQLite3: count :: (Integral b, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac b
+ Database.Relational.Query.SQLite3: cube :: () => AggregatingPowerSet a -> AggregateKey a
+ Database.Relational.Query.SQLite3: cumeDist :: Record OverWindow Double
+ Database.Relational.Query.SQLite3: data AggregateKey a
+ Database.Relational.Query.SQLite3: data Aggregated
+ Database.Relational.Query.SQLite3: data BoundStatement a
+ Database.Relational.Query.SQLite3: data ColumnConstraint c r
+ Database.Relational.Query.SQLite3: data Config
+ Database.Relational.Query.SQLite3: data ConnWrapper
+ Database.Relational.Query.SQLite3: data ExecutedStatement a
+ Database.Relational.Query.SQLite3: data Exists
+ Database.Relational.Query.SQLite3: data Flat
+ Database.Relational.Query.SQLite3: data IdentifierQuotation
+ Database.Relational.Query.SQLite3: data Insert a
+ Database.Relational.Query.SQLite3: data InsertTarget p r
+ Database.Relational.Query.SQLite3: data Key c r ct
+ Database.Relational.Query.SQLite3: data KeyConstraint c r
+ Database.Relational.Query.SQLite3: data KeyUpdate p a
+ Database.Relational.Query.SQLite3: data NameConfig
+ Database.Relational.Query.SQLite3: data NotNull
+ Database.Relational.Query.SQLite3: data Nulls
+ Database.Relational.Query.SQLite3: data Number r i
+ Database.Relational.Query.SQLite3: data Order
+ Database.Relational.Query.SQLite3: data OverWindow
+ Database.Relational.Query.SQLite3: data PersistableSqlType q
+ Database.Relational.Query.SQLite3: data Pi r0 r1
+ Database.Relational.Query.SQLite3: data PlaceHolders p
+ Database.Relational.Query.SQLite3: data Power
+ Database.Relational.Query.SQLite3: data PreparedKeyUpdate p a
+ Database.Relational.Query.SQLite3: data PreparedStatement p a
+ Database.Relational.Query.SQLite3: data Primary
+ Database.Relational.Query.SQLite3: data ProductUnitSupport
+ Database.Relational.Query.SQLite3: data QueryUnique a
+ Database.Relational.Query.SQLite3: data Record c t
+ Database.Relational.Query.SQLite3: data RecordFromSql q a
+ Database.Relational.Query.SQLite3: data RecordList (p :: * -> *) t
+ Database.Relational.Query.SQLite3: data RecordToSql q a
+ Database.Relational.Query.SQLite3: data Relation p r
+ Database.Relational.Query.SQLite3: data Restriction p r
+ Database.Relational.Query.SQLite3: data SchemaNameMode
+ Database.Relational.Query.SQLite3: data SeqBinding r s i
+ Database.Relational.Query.SQLite3: data Sequence s i
+ Database.Relational.Query.SQLite3: data Set
+ Database.Relational.Query.SQLite3: data SetList
+ Database.Relational.Query.SQLite3: data SqlColDesc
+ Database.Relational.Query.SQLite3: data SqlError
+ Database.Relational.Query.SQLite3: data SqlInterval
+ Database.Relational.Query.SQLite3: data SqlTypeId
+ Database.Relational.Query.SQLite3: data SqlValue
+ Database.Relational.Query.SQLite3: data Statement
+ Database.Relational.Query.SQLite3: data SubQuery
+ Database.Relational.Query.SQLite3: data Table r
+ Database.Relational.Query.SQLite3: data Unique
+ Database.Relational.Query.SQLite3: data UniqueRelation p c r
+ Database.Relational.Query.SQLite3: data UpdateTarget p r
+ Database.Relational.Query.SQLite3: dbServerVer :: IConnection conn => conn -> String
+ Database.Relational.Query.SQLite3: dbTransactionSupport :: IConnection conn => conn -> Bool
+ Database.Relational.Query.SQLite3: defaultConfig :: Config
+ Database.Relational.Query.SQLite3: defaultNameConfig :: NameConfig
+ Database.Relational.Query.SQLite3: defineTableDefault :: Config -> String -> String -> [(String, TypeQ)] -> [Name] -> [Int] -> Maybe Int -> Q [Dec]
+ Database.Relational.Query.SQLite3: defineTableDefault' :: Config -> String -> String -> [(String, TypeQ)] -> [Name] -> Q [Dec]
+ Database.Relational.Query.SQLite3: defineTableFromDB :: IConnection conn => IO conn -> Driver conn -> String -> String -> [Name] -> Q [Dec]
+ Database.Relational.Query.SQLite3: defineTableFromDB' :: IConnection conn => IO conn -> Driver conn -> String -> String -> [(String, TypeQ)] -> [Name] -> Q [Dec]
+ Database.Relational.Query.SQLite3: delete :: TableDerivable r => RestrictedStatement r PlaceHolders p -> Delete p
+ Database.Relational.Query.SQLite3: delete' :: TableDerivable r => Config -> RestrictedStatement r PlaceHolders p -> Delete p
+ Database.Relational.Query.SQLite3: deleteNoPH :: TableDerivable r => RestrictedStatement r () -> Delete ()
+ Database.Relational.Query.SQLite3: deleteSQL :: () => Config -> Table r -> Restriction p r -> String
+ Database.Relational.Query.SQLite3: denseRank :: Integral a => Record OverWindow a
+ Database.Relational.Query.SQLite3: deriveComposite :: () => ColumnConstraint c r -> KeyConstraint c r
+ Database.Relational.Query.SQLite3: derivedCompositePrimary :: HasColumnConstraint Primary r => PrimaryConstraint r
+ Database.Relational.Query.SQLite3: derivedDelete :: TableDerivable r => RestrictedStatement r PlaceHolders p -> Delete p
+ Database.Relational.Query.SQLite3: derivedDelete' :: TableDerivable r => Config -> RestrictedStatement r PlaceHolders p -> Delete p
+ Database.Relational.Query.SQLite3: derivedInsert :: (PersistableWidth r, TableDerivable r) => Pi r r' -> Insert r'
+ Database.Relational.Query.SQLite3: derivedInsertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p
+ Database.Relational.Query.SQLite3: derivedInsertValue :: TableDerivable r => Register r PlaceHolders p -> Insert p
+ Database.Relational.Query.SQLite3: derivedInsertValue' :: TableDerivable r => Config -> Register r PlaceHolders p -> Insert p
+ Database.Relational.Query.SQLite3: derivedKeyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r
+ Database.Relational.Query.SQLite3: derivedNotNullColumnConstraint :: HasColumnConstraint Primary r => NotNullColumnConstraint r
+ Database.Relational.Query.SQLite3: derivedRelation :: TableDerivable r => Relation () r
+ Database.Relational.Query.SQLite3: derivedSequence :: SequenceDerivable s i => Sequence s i
+ Database.Relational.Query.SQLite3: derivedTable :: TableDerivable r => Table r
+ Database.Relational.Query.SQLite3: derivedUniqueColumnConstraint :: HasColumnConstraint Primary r => UniqueColumnConstraint r
+ Database.Relational.Query.SQLite3: derivedUniqueConstraint :: HasKeyConstraint Primary r => UniqueConstraint r
+ Database.Relational.Query.SQLite3: derivedUniqueKey :: HasConstraintKey Primary r ct => Key Unique r ct
+ Database.Relational.Query.SQLite3: derivedUniqueRelation :: TableDerivable r => Key Unique r k -> Record c k -> UniqueRelation () c r
+ Database.Relational.Query.SQLite3: derivedUpdate :: TableDerivable r => AssignStatement r PlaceHolders p -> Update p
+ Database.Relational.Query.SQLite3: derivedUpdate' :: TableDerivable r => Config -> AssignStatement r PlaceHolders p -> Update p
+ Database.Relational.Query.SQLite3: derivedUpdateAllColumn :: (PersistableWidth r, TableDerivable r) => RestrictedStatement r PlaceHolders p -> Update (r, p)
+ Database.Relational.Query.SQLite3: derivedUpdateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> RestrictedStatement r PlaceHolders p -> Update (r, p)
+ Database.Relational.Query.SQLite3: derivedWidth :: PersistableWidth a => (PersistableRecordWidth a, Int)
+ Database.Relational.Query.SQLite3: desc :: Monad m => Record c t -> Orderings c m ()
+ Database.Relational.Query.SQLite3: describeTable :: IConnection conn => conn -> String -> IO [(String, SqlColDesc)]
+ Database.Relational.Query.SQLite3: disconnect :: IConnection conn => conn -> IO ()
+ Database.Relational.Query.SQLite3: distinct :: MonadQuery m => m ()
+ Database.Relational.Query.SQLite3: dump :: () => Relation p r -> String
+ Database.Relational.Query.SQLite3: every :: (AggregatedContext ac, SqlContext ac) => Predicate Flat -> Record ac Maybe Bool
+ Database.Relational.Query.SQLite3: except :: () => Relation () a -> Relation () a -> Relation () a
+ Database.Relational.Query.SQLite3: except' :: () => Relation p a -> Relation q a -> Relation (p, q) a
+ Database.Relational.Query.SQLite3: exceptAll :: () => Relation () a -> Relation () a -> Relation () a
+ Database.Relational.Query.SQLite3: exceptAll' :: () => Relation p a -> Relation q a -> Relation (p, q) a
+ Database.Relational.Query.SQLite3: executeBound :: () => BoundStatement a -> IO ExecutedStatement a
+ Database.Relational.Query.SQLite3: executeBoundNoFetch :: BoundStatement () -> IO Integer
+ Database.Relational.Query.SQLite3: executeNoFetch :: ToSql SqlValue a => PreparedStatement a () -> a -> IO Integer
+ Database.Relational.Query.SQLite3: executePrepared :: ToSql SqlValue p => PreparedStatement p a -> p -> IO ExecutedStatement a
+ Database.Relational.Query.SQLite3: exists :: OperatorContext c => RecordList Record Exists r -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: extractCore :: () => QueryCore a -> ConfigureQuery (((a, [Predicate Flat]), JoinProduct), Duplication)
+ Database.Relational.Query.SQLite3: extractNumber :: () => Number r i -> i
+ Database.Relational.Query.SQLite3: fetch :: FromSql SqlValue a => ExecutedStatement a -> IO Maybe a
+ Database.Relational.Query.SQLite3: fetchAll :: FromSql SqlValue a => ExecutedStatement a -> IO [a]
+ Database.Relational.Query.SQLite3: fetchAll' :: FromSql SqlValue a => ExecutedStatement a -> IO [a]
+ Database.Relational.Query.SQLite3: fetchAllRows :: Statement -> IO [[SqlValue]]
+ Database.Relational.Query.SQLite3: fetchAllRows' :: Statement -> IO [[SqlValue]]
+ Database.Relational.Query.SQLite3: fetchAllRowsAL :: Statement -> IO [[(String, SqlValue)]]
+ Database.Relational.Query.SQLite3: fetchAllRowsAL' :: Statement -> IO [[(String, SqlValue)]]
+ Database.Relational.Query.SQLite3: fetchAllRowsMap :: Statement -> IO [Map String SqlValue]
+ Database.Relational.Query.SQLite3: fetchAllRowsMap' :: Statement -> IO [Map String SqlValue]
+ Database.Relational.Query.SQLite3: fetchRowAL :: Statement -> IO Maybe [(String, SqlValue)]
+ Database.Relational.Query.SQLite3: fetchRowMap :: Statement -> IO Maybe Map String SqlValue
+ Database.Relational.Query.SQLite3: fetchUnique :: FromSql SqlValue a => ExecutedStatement a -> IO Maybe a
+ Database.Relational.Query.SQLite3: fetchUnique' :: FromSql SqlValue a => ExecutedStatement a -> IO Maybe a
+ Database.Relational.Query.SQLite3: flatten :: (ProjectableFlattenMaybe a b, ProjectableMaybe p) => p a -> p b
+ Database.Relational.Query.SQLite3: flattenMaybe :: ProjectableMaybe p => p Maybe Maybe a -> p Maybe a
+ Database.Relational.Query.SQLite3: flattenPiMaybe :: (PersistableWidth a, ProjectableFlattenMaybe Maybe b c) => Record cont Maybe a -> Pi a b -> Record cont c
+ Database.Relational.Query.SQLite3: fromIntegral' :: (SqlContext c, Integral a, Num b) => Record c a -> Record c b
+ Database.Relational.Query.SQLite3: fromIntegralMaybe :: (SqlContext c, Integral a, Num b) => Record c Maybe a -> Record c Maybe b
+ Database.Relational.Query.SQLite3: fromMaybe :: (OperatorContext c, HasColumnConstraint NotNull r) => Record c r -> Record c Maybe r -> Record c r
+ Database.Relational.Query.SQLite3: fromRecord :: ToSql q a => a -> [q]
+ Database.Relational.Query.SQLite3: fromRelation :: Binding r s i => Relation () r -> Sequence s i
+ Database.Relational.Query.SQLite3: fromSql :: Convertible SqlValue a => SqlValue -> a
+ Database.Relational.Query.SQLite3: fst' :: (PersistableWidth a, PersistableWidth b) => Pi (a, b) a
+ Database.Relational.Query.SQLite3: full :: () => Relation () a -> Relation () b -> [JoinRestriction Maybe a Maybe b] -> Relation () (Maybe a, Maybe b)
+ Database.Relational.Query.SQLite3: full' :: () => Relation pa a -> Relation pb b -> [JoinRestriction Maybe a Maybe b] -> Relation (pa, pb) (Maybe a, Maybe b)
+ Database.Relational.Query.SQLite3: getTables :: IConnection conn => conn -> IO [String]
+ Database.Relational.Query.SQLite3: groupBy :: MonadAggregate m => Record Flat r -> m Record Aggregated r
+ Database.Relational.Query.SQLite3: groupBy' :: MonadAggregate m => AggregateKey Record Aggregated r -> m Record Aggregated r
+ Database.Relational.Query.SQLite3: groupingSets :: () => AggregatingSetList a -> AggregateKey a
+ Database.Relational.Query.SQLite3: handleSql :: () => SqlError -> IO a -> IO a -> IO a
+ Database.Relational.Query.SQLite3: handleSqlError :: () => IO a -> IO a
+ Database.Relational.Query.SQLite3: having :: MonadRestrict Aggregated m => Predicate Aggregated -> m ()
+ Database.Relational.Query.SQLite3: hdbcClientVer :: IConnection conn => conn -> String
+ Database.Relational.Query.SQLite3: hdbcDriverName :: IConnection conn => conn -> String
+ Database.Relational.Query.SQLite3: iToSql :: Int -> SqlValue
+ Database.Relational.Query.SQLite3: id' :: () => Pi a a
+ Database.Relational.Query.SQLite3: in' :: OperatorContext c => Record c t -> RecordList Record c t -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: infix 4 .=.
+ Database.Relational.Query.SQLite3: infix 8 `over`
+ Database.Relational.Query.SQLite3: infixl 1 ><
+ Database.Relational.Query.SQLite3: infixl 5 .||.
+ Database.Relational.Query.SQLite3: infixl 6 .+.
+ Database.Relational.Query.SQLite3: infixl 7 ./.
+ Database.Relational.Query.SQLite3: infixl 8 <.>
+ Database.Relational.Query.SQLite3: infixr 2 `or'`
+ Database.Relational.Query.SQLite3: infixr 3 `and'`
+ Database.Relational.Query.SQLite3: inlineVerifiedQuery :: IConnection conn => IO conn -> Name -> Relation p r -> Config -> QuerySuffix -> String -> Q [Dec]
+ Database.Relational.Query.SQLite3: inner :: () => Relation () a -> Relation () b -> [JoinRestriction a b] -> Relation () (a, b)
+ Database.Relational.Query.SQLite3: inner' :: () => Relation pa a -> Relation pb b -> [JoinRestriction a b] -> Relation (pa, pb) (a, b)
+ Database.Relational.Query.SQLite3: insert :: (PersistableWidth r, TableDerivable r) => Pi r r' -> Insert r'
+ Database.Relational.Query.SQLite3: insertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p
+ Database.Relational.Query.SQLite3: insertQuerySQL :: () => Config -> Table r -> Pi r r' -> Relation p r' -> String
+ Database.Relational.Query.SQLite3: insertTarget :: () => Register r () -> InsertTarget () r
+ Database.Relational.Query.SQLite3: insertTarget' :: () => Register r PlaceHolders p -> InsertTarget p r
+ Database.Relational.Query.SQLite3: insertValue :: TableDerivable r => Register r PlaceHolders p -> Insert p
+ Database.Relational.Query.SQLite3: insertValue' :: TableDerivable r => Config -> Register r PlaceHolders p -> Insert p
+ Database.Relational.Query.SQLite3: insertValueList :: (TableDerivable r, LiteralSQL r') => Pi r r' -> [r'] -> [Insert ()]
+ Database.Relational.Query.SQLite3: insertValueList' :: (TableDerivable r, LiteralSQL r') => Config -> Pi r r' -> [r'] -> [Insert ()]
+ Database.Relational.Query.SQLite3: insertValueNoPH :: TableDerivable r => Register r () -> Insert ()
+ Database.Relational.Query.SQLite3: intersect :: () => Relation () a -> Relation () a -> Relation () a
+ Database.Relational.Query.SQLite3: intersect' :: () => Relation p a -> Relation q a -> Relation (p, q) a
+ Database.Relational.Query.SQLite3: intersectAll :: () => Relation () a -> Relation () a -> Relation () a
+ Database.Relational.Query.SQLite3: intersectAll' :: () => Relation p a -> Relation q a -> Relation (p, q) a
+ Database.Relational.Query.SQLite3: isJust :: (OperatorContext c, HasColumnConstraint NotNull r) => Record c Maybe r -> Predicate c
+ Database.Relational.Query.SQLite3: isNothing :: (OperatorContext c, HasColumnConstraint NotNull r) => Record c Maybe r -> Predicate c
+ Database.Relational.Query.SQLite3: just :: ProjectableMaybe p => p a -> p Maybe a
+ Database.Relational.Query.SQLite3: key :: () => Record Flat r -> AggregatingSet Record Aggregated Maybe r
+ Database.Relational.Query.SQLite3: key' :: () => AggregateKey a -> AggregatingSet a
+ Database.Relational.Query.SQLite3: keyConstraint :: HasKeyConstraint c a => KeyConstraint c a
+ Database.Relational.Query.SQLite3: keyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r
+ Database.Relational.Query.SQLite3: left :: () => Relation () a -> Relation () b -> [JoinRestriction a Maybe b] -> Relation () (a, Maybe b)
+ Database.Relational.Query.SQLite3: left' :: () => Relation pa a -> Relation pb b -> [JoinRestriction a Maybe b] -> Relation (pa, pb) (a, Maybe b)
+ Database.Relational.Query.SQLite3: leftPh :: () => Relation (p, ()) r -> Relation p r
+ Database.Relational.Query.SQLite3: liftTargetAllColumn :: PersistableWidth r => Restriction () r -> UpdateTarget r r
+ Database.Relational.Query.SQLite3: liftTargetAllColumn' :: PersistableWidth r => Restriction p r -> UpdateTarget (r, p) r
+ Database.Relational.Query.SQLite3: like :: (OperatorContext c, IsString a, LiteralSQL a) => Record c a -> a -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: like' :: (OperatorContext c, IsString a) => Record c a -> Record c a -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: likeMaybe :: (OperatorContext c, IsString a, LiteralSQL a) => Record c Maybe a -> a -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: likeMaybe' :: (OperatorContext c, IsString a) => Record c Maybe a -> Record c Maybe a -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: list :: () => [p t] -> RecordList p t
+ Database.Relational.Query.SQLite3: listToUnique :: () => [a] -> IO Maybe a
+ Database.Relational.Query.SQLite3: makeRelationalRecord' :: Config -> Name -> Q [Dec]
+ Database.Relational.Query.SQLite3: mapInsert :: (IConnection conn, ToSql SqlValue a) => conn -> Insert a -> [a] -> IO [Integer]
+ Database.Relational.Query.SQLite3: mapNoFetch :: (UntypeableNoFetch s, IConnection conn, ToSql SqlValue a) => conn -> s a -> [a] -> IO [Integer]
+ Database.Relational.Query.SQLite3: mapUpdate :: (IConnection conn, ToSql SqlValue a) => conn -> Update a -> [a] -> IO [Integer]
+ Database.Relational.Query.SQLite3: max' :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac Maybe a
+ Database.Relational.Query.SQLite3: maxMaybe :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat Maybe a -> Record ac Maybe a
+ Database.Relational.Query.SQLite3: min' :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac Maybe a
+ Database.Relational.Query.SQLite3: minMaybe :: (Ord a, AggregatedContext ac, SqlContext ac) => Record Flat Maybe a -> Record ac Maybe a
+ Database.Relational.Query.SQLite3: nToSql :: Integral a => a -> SqlValue
+ Database.Relational.Query.SQLite3: negate' :: (OperatorContext c, Num a) => Record c a -> Record c a
+ Database.Relational.Query.SQLite3: negateMaybe :: (OperatorContext c, Num a) => Record c Maybe a -> Record c Maybe a
+ Database.Relational.Query.SQLite3: newtype Delete p
+ Database.Relational.Query.SQLite3: newtype InsertQuery p
+ Database.Relational.Query.SQLite3: newtype Query p a
+ Database.Relational.Query.SQLite3: newtype Update p
+ Database.Relational.Query.SQLite3: not' :: OperatorContext c => Record c Maybe Bool -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: notNullColumn :: () => PrimaryColumnConstraint r -> NotNullColumnConstraint r
+ Database.Relational.Query.SQLite3: nothing :: (OperatorContext c, SqlContext c, PersistableWidth a) => Record c Maybe a
+ Database.Relational.Query.SQLite3: on :: MonadQuery m => Predicate Flat -> m ()
+ Database.Relational.Query.SQLite3: on' :: () => [JoinRestriction a b] -> Relation pc (a, b) -> [JoinRestriction a b] -> Relation pc (a, b)
+ Database.Relational.Query.SQLite3: or' :: OperatorContext c => Record c Maybe Bool -> Record c Maybe Bool -> Record c Maybe Bool
+ Database.Relational.Query.SQLite3: orderBy :: Monad m => Record c t -> Order -> Orderings c m ()
+ Database.Relational.Query.SQLite3: orderBy' :: Monad m => Record c t -> Order -> Nulls -> Orderings c m ()
+ Database.Relational.Query.SQLite3: over :: SqlContext c => Record OverWindow a -> Window c () -> Record c a
+ Database.Relational.Query.SQLite3: partitionBy :: MonadPartition c m => Record c r -> m ()
+ Database.Relational.Query.SQLite3: percentRank :: Record OverWindow Double
+ Database.Relational.Query.SQLite3: persistableType :: PersistableType q => PersistableSqlType q
+ Database.Relational.Query.SQLite3: persistableWidth :: PersistableWidth a => PersistableRecordWidth a
+ Database.Relational.Query.SQLite3: piRegister :: PersistableWidth r => Pi r r' -> Register r PlaceHolders r'
+ Database.Relational.Query.SQLite3: placeholder :: (PersistableWidth t, SqlContext c, Monad m) => Record c t -> m a -> m (PlaceHolders t, a)
+ Database.Relational.Query.SQLite3: placeholder' :: (PersistableWidth t, SqlContext c) => Record c t -> a -> (PlaceHolders t, a)
+ Database.Relational.Query.SQLite3: posixToSql :: POSIXTime -> SqlValue
+ Database.Relational.Query.SQLite3: prepare :: IConnection conn => conn -> String -> IO Statement
+ Database.Relational.Query.SQLite3: prepareDelete :: IConnection conn => conn -> Delete p -> IO PreparedDelete p
+ Database.Relational.Query.SQLite3: prepareInsert :: IConnection conn => conn -> Insert a -> IO PreparedInsert a
+ Database.Relational.Query.SQLite3: prepareInsertQuery :: IConnection conn => conn -> InsertQuery p -> IO PreparedInsertQuery p
+ Database.Relational.Query.SQLite3: prepareKeyUpdate :: IConnection conn => conn -> KeyUpdate p a -> IO PreparedKeyUpdate p a
+ Database.Relational.Query.SQLite3: prepareNoFetch :: (UntypeableNoFetch s, IConnection conn) => conn -> s p -> IO PreparedStatement p ()
+ Database.Relational.Query.SQLite3: prepareQuery :: IConnection conn => conn -> Query p a -> IO PreparedQuery p a
+ Database.Relational.Query.SQLite3: prepareUpdate :: IConnection conn => conn -> Update p -> IO PreparedUpdate p
+ Database.Relational.Query.SQLite3: primary :: HasConstraintKey Primary a p => Relation () a -> Relation p a
+ Database.Relational.Query.SQLite3: primary' :: PersistableWidth p => Key Primary a p -> Relation () a -> Relation p a
+ Database.Relational.Query.SQLite3: primaryBinding :: (TableDerivable r, SequenceDerivable s i, HasConstraintKey Primary r i) => SeqBinding r s i
+ Database.Relational.Query.SQLite3: primarySelect :: HasConstraintKey Primary a p => Relation () a -> Relation p a
+ Database.Relational.Query.SQLite3: primaryUpdate :: HasConstraintKey Primary r p => Table r -> KeyUpdate p r
+ Database.Relational.Query.SQLite3: projectZip :: ProductIsoApplicative p => p a -> p b -> p (a, b)
+ Database.Relational.Query.SQLite3: projectionKey :: () => Key c r ct -> Pi r ct
+ Database.Relational.Query.SQLite3: proxiedClientName :: IConnection conn => conn -> String
+ Database.Relational.Query.SQLite3: proxiedClientVer :: IConnection conn => conn -> String
+ Database.Relational.Query.SQLite3: putEmpty :: () => () -> ToSqlM q ()
+ Database.Relational.Query.SQLite3: putRecord :: ToSql q a => a -> ToSqlM q ()
+ Database.Relational.Query.SQLite3: pwPlaceholder :: SqlContext c => PersistableRecordWidth a -> Record c a -> b -> (PlaceHolders a, b)
+ Database.Relational.Query.SQLite3: qualifyQuery :: () => a -> ConfigureQuery Qualified a
+ Database.Relational.Query.SQLite3: query :: (MonadQualify ConfigureQuery m, MonadQuery m) => Relation () r -> m Record Flat r
+ Database.Relational.Query.SQLite3: query' :: MonadQuery m => Relation p r -> m (PlaceHolders p, Record Flat r)
+ Database.Relational.Query.SQLite3: queryList :: MonadQualify ConfigureQuery m => Relation () r -> m RecordList Record c r
+ Database.Relational.Query.SQLite3: queryList' :: MonadQualify ConfigureQuery m => Relation p r -> m (PlaceHolders p, RecordList Record c r)
+ Database.Relational.Query.SQLite3: queryMaybe :: (MonadQualify ConfigureQuery m, MonadQuery m) => Relation () r -> m Record Flat Maybe r
+ Database.Relational.Query.SQLite3: queryMaybe' :: MonadQuery m => Relation p r -> m (PlaceHolders p, Record Flat Maybe r)
+ Database.Relational.Query.SQLite3: queryScalar :: (MonadQualify ConfigureQuery m, ScalarDegree r) => UniqueRelation () c r -> m Record c Maybe r
+ Database.Relational.Query.SQLite3: queryScalar' :: (MonadQualify ConfigureQuery m, ScalarDegree r) => UniqueRelation p c r -> m (PlaceHolders p, Record c Maybe r)
+ Database.Relational.Query.SQLite3: queryWidth :: Qualified SubQuery -> Int
+ Database.Relational.Query.SQLite3: quickQuery :: IConnection conn => conn -> String -> [SqlValue] -> IO [[SqlValue]]
+ Database.Relational.Query.SQLite3: quickQuery' :: IConnection conn => conn -> String -> [SqlValue] -> IO [[SqlValue]]
+ Database.Relational.Query.SQLite3: rank :: Integral a => Record OverWindow a
+ Database.Relational.Query.SQLite3: recordFromSql :: FromSql q a => RecordFromSql q a
+ Database.Relational.Query.SQLite3: recordToSql :: ToSql q a => RecordToSql q a
+ Database.Relational.Query.SQLite3: relation :: () => QuerySimple Record Flat r -> Relation () r
+ Database.Relational.Query.SQLite3: relation' :: () => SimpleQuery p r -> Relation p r
+ Database.Relational.Query.SQLite3: relationWidth :: () => Relation p r -> PersistableRecordWidth r
+ Database.Relational.Query.SQLite3: relationalQuery :: () => Relation p r -> Query p r
+ Database.Relational.Query.SQLite3: relationalQuery' :: () => Relation p r -> QuerySuffix -> Query p r
+ Database.Relational.Query.SQLite3: relationalQuerySQL :: () => Config -> Relation p r -> QuerySuffix -> String
+ Database.Relational.Query.SQLite3: restrict :: MonadRestrict c m => Predicate c -> m ()
+ Database.Relational.Query.SQLite3: restriction :: () => RestrictedStatement r () -> Restriction () r
+ Database.Relational.Query.SQLite3: restriction' :: () => RestrictedStatement r PlaceHolders p -> Restriction p r
+ Database.Relational.Query.SQLite3: right :: () => Relation () a -> Relation () b -> [JoinRestriction Maybe a b] -> Relation () (Maybe a, b)
+ Database.Relational.Query.SQLite3: right' :: () => Relation pa a -> Relation pb b -> [JoinRestriction Maybe a b] -> Relation (pa, pb) (Maybe a, b)
+ Database.Relational.Query.SQLite3: rightPh :: () => Relation ((), p) r -> Relation p r
+ Database.Relational.Query.SQLite3: rollback :: IConnection conn => conn -> IO ()
+ Database.Relational.Query.SQLite3: rollup :: () => AggregatingPowerSet a -> AggregateKey a
+ Database.Relational.Query.SQLite3: rowNumber :: Integral a => Record OverWindow a
+ Database.Relational.Query.SQLite3: runDelete :: (IConnection conn, ToSql SqlValue p) => conn -> Delete p -> p -> IO Integer
+ Database.Relational.Query.SQLite3: runInsert :: (IConnection conn, ToSql SqlValue a) => conn -> Insert a -> a -> IO Integer
+ Database.Relational.Query.SQLite3: runInsertQuery :: (IConnection conn, ToSql SqlValue p) => conn -> InsertQuery p -> p -> IO Integer
+ Database.Relational.Query.SQLite3: runKeyUpdate :: (IConnection conn, ToSql SqlValue a) => conn -> KeyUpdate p a -> a -> IO Integer
+ Database.Relational.Query.SQLite3: runNoFetch :: (UntypeableNoFetch s, IConnection conn, ToSql SqlValue a) => conn -> s a -> a -> IO Integer
+ Database.Relational.Query.SQLite3: runPreparedDelete :: ToSql SqlValue p => PreparedDelete p -> p -> IO Integer
+ Database.Relational.Query.SQLite3: runPreparedInsert :: ToSql SqlValue a => PreparedInsert a -> a -> IO Integer
+ Database.Relational.Query.SQLite3: runPreparedInsertQuery :: ToSql SqlValue p => PreparedInsertQuery p -> p -> IO Integer
+ Database.Relational.Query.SQLite3: runPreparedKeyUpdate :: ToSql SqlValue a => PreparedKeyUpdate p a -> a -> IO Integer
+ Database.Relational.Query.SQLite3: runPreparedNoFetch :: ToSql SqlValue a => PreparedStatement a () -> a -> IO Integer
+ Database.Relational.Query.SQLite3: runPreparedQuery :: (ToSql SqlValue p, FromSql SqlValue a) => PreparedQuery p a -> p -> IO [a]
+ Database.Relational.Query.SQLite3: runPreparedQuery' :: (ToSql SqlValue p, FromSql SqlValue a) => PreparedQuery p a -> p -> IO [a]
+ Database.Relational.Query.SQLite3: runPreparedUpdate :: ToSql SqlValue p => PreparedUpdate p -> p -> IO Integer
+ Database.Relational.Query.SQLite3: runQuery :: (IConnection conn, ToSql SqlValue p, FromSql SqlValue a) => conn -> Query p a -> p -> IO [a]
+ Database.Relational.Query.SQLite3: runQuery' :: (IConnection conn, ToSql SqlValue p, FromSql SqlValue a) => conn -> Query p a -> p -> IO [a]
+ Database.Relational.Query.SQLite3: runRaw :: IConnection conn => conn -> String -> IO ()
+ Database.Relational.Query.SQLite3: runStatement :: FromSql SqlValue a => BoundStatement a -> IO [a]
+ Database.Relational.Query.SQLite3: runStatement' :: FromSql SqlValue a => BoundStatement a -> IO [a]
+ Database.Relational.Query.SQLite3: runUpdate :: (IConnection conn, ToSql SqlValue p) => conn -> Update p -> p -> IO Integer
+ Database.Relational.Query.SQLite3: sExecute :: Statement -> [Maybe String] -> IO Integer
+ Database.Relational.Query.SQLite3: sExecuteMany :: Statement -> [[Maybe String]] -> IO ()
+ Database.Relational.Query.SQLite3: sFetchAllRows :: Statement -> IO [[Maybe String]]
+ Database.Relational.Query.SQLite3: sFetchAllRows' :: Statement -> IO [[Maybe String]]
+ Database.Relational.Query.SQLite3: sFetchRow :: Statement -> IO Maybe [Maybe String]
+ Database.Relational.Query.SQLite3: sRun :: IConnection conn => conn -> String -> [Maybe String] -> IO Integer
+ Database.Relational.Query.SQLite3: safeFromSql :: Convertible SqlValue a => SqlValue -> ConvertResult a
+ Database.Relational.Query.SQLite3: seqRelation :: TableDerivable s => Sequence s i -> Relation () s
+ Database.Relational.Query.SQLite3: set :: () => AggregatingSet a -> AggregatingSetList a
+ Database.Relational.Query.SQLite3: showConstantTermsSQL :: ShowConstantTermsSQL a => a -> [StringSQL]
+ Database.Relational.Query.SQLite3: showConstantTermsSQL' :: ShowConstantTermsSQL a => a -> DList StringSQL
+ Database.Relational.Query.SQLite3: showLiteral :: LiteralSQL a => a -> [StringSQL]
+ Database.Relational.Query.SQLite3: showLiteral' :: LiteralSQL a => a -> DList StringSQL
+ Database.Relational.Query.SQLite3: showNum :: (SqlContext c, Num a, IsString b) => Record c a -> Record c b
+ Database.Relational.Query.SQLite3: showNumMaybe :: (SqlContext c, Num a, IsString b) => Record c Maybe a -> Record c Maybe b
+ Database.Relational.Query.SQLite3: snd' :: (PersistableWidth a, PersistableWidth b) => Pi (a, b) b
+ Database.Relational.Query.SQLite3: some' :: (AggregatedContext ac, SqlContext ac) => Predicate Flat -> Record ac Maybe Bool
+ Database.Relational.Query.SQLite3: specifiedKey :: PersistableWidth p => Pi a p -> Relation () a -> Relation p a
+ Database.Relational.Query.SQLite3: sqlChunkFromInsertTarget :: () => Config -> Table r -> InsertTarget p r -> (StringSQL, Int)
+ Database.Relational.Query.SQLite3: sqlChunksFromRecordList :: LiteralSQL r' => Config -> Table r -> Pi r r' -> [r'] -> [StringSQL]
+ Database.Relational.Query.SQLite3: sqlExceptions :: SqlError -> Maybe SqlError
+ Database.Relational.Query.SQLite3: sqlFromInsertTarget :: () => Config -> Table r -> InsertTarget p r -> StringSQL
+ Database.Relational.Query.SQLite3: sqlFromRelation :: () => Relation p r -> StringSQL
+ Database.Relational.Query.SQLite3: sqlFromRelationWith :: () => Relation p r -> Config -> StringSQL
+ Database.Relational.Query.SQLite3: sqlFromUpdateTarget :: () => Config -> Table r -> UpdateTarget p r -> StringSQL
+ Database.Relational.Query.SQLite3: sqlNullValue :: PersistableType q => q
+ Database.Relational.Query.SQLite3: sqlWhereFromRestriction :: () => Config -> Table r -> Restriction p r -> StringSQL
+ Database.Relational.Query.SQLite3: sum' :: (Num a, AggregatedContext ac, SqlContext ac) => Record Flat a -> Record ac Maybe a
+ Database.Relational.Query.SQLite3: sumMaybe :: (Num a, AggregatedContext ac, SqlContext ac) => Record Flat Maybe a -> Record ac Maybe a
+ Database.Relational.Query.SQLite3: table :: () => Table r -> Relation () r
+ Database.Relational.Query.SQLite3: tableConstraint :: () => Key c r ct -> KeyConstraint c r
+ Database.Relational.Query.SQLite3: tableOf :: TableDerivable r => Relation () r -> Table r
+ Database.Relational.Query.SQLite3: takeRecord :: FromSql q a => [q] -> (a, [q])
+ Database.Relational.Query.SQLite3: throwSqlError :: () => SqlError -> IO a
+ Database.Relational.Query.SQLite3: toRecord :: FromSql q a => [q] -> a
+ Database.Relational.Query.SQLite3: toSql :: Convertible a SqlValue => a -> SqlValue
+ Database.Relational.Query.SQLite3: tuplePi2_0' :: (PersistableWidth a1, PersistableWidth a2) => Pi (a1, a2) a1
+ Database.Relational.Query.SQLite3: tuplePi2_1' :: (PersistableWidth a1, PersistableWidth a2) => Pi (a1, a2) a2
+ Database.Relational.Query.SQLite3: tuplePi3_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a1
+ Database.Relational.Query.SQLite3: tuplePi3_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a2
+ Database.Relational.Query.SQLite3: tuplePi3_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3) => Pi (a1, a2, a3) a3
+ Database.Relational.Query.SQLite3: tuplePi4_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a1
+ Database.Relational.Query.SQLite3: tuplePi4_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a2
+ Database.Relational.Query.SQLite3: tuplePi4_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a3
+ Database.Relational.Query.SQLite3: tuplePi4_3' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4) => Pi (a1, a2, a3, a4) a4
+ Database.Relational.Query.SQLite3: tuplePi5_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a1
+ Database.Relational.Query.SQLite3: tuplePi5_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a2
+ Database.Relational.Query.SQLite3: tuplePi5_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a3
+ Database.Relational.Query.SQLite3: tuplePi5_3' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a4
+ Database.Relational.Query.SQLite3: tuplePi5_4' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5) => Pi (a1, a2, a3, a4, a5) a5
+ Database.Relational.Query.SQLite3: tuplePi6_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a1
+ Database.Relational.Query.SQLite3: tuplePi6_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a2
+ Database.Relational.Query.SQLite3: tuplePi6_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a3
+ Database.Relational.Query.SQLite3: tuplePi6_3' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a4
+ Database.Relational.Query.SQLite3: tuplePi6_4' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a5
+ Database.Relational.Query.SQLite3: tuplePi6_5' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6) => Pi (a1, a2, a3, a4, a5, a6) a6
+ Database.Relational.Query.SQLite3: tuplePi7_0' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a1
+ Database.Relational.Query.SQLite3: tuplePi7_1' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a2
+ Database.Relational.Query.SQLite3: tuplePi7_2' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a3
+ Database.Relational.Query.SQLite3: tuplePi7_3' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a4
+ Database.Relational.Query.SQLite3: tuplePi7_4' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a5
+ Database.Relational.Query.SQLite3: tuplePi7_5' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a6
+ Database.Relational.Query.SQLite3: tuplePi7_6' :: (PersistableWidth a1, PersistableWidth a2, PersistableWidth a3, PersistableWidth a4, PersistableWidth a5, PersistableWidth a6, PersistableWidth a7) => Pi (a1, a2, a3, a4, a5, a6, a7) a7
+ Database.Relational.Query.SQLite3: type AggregatedQuery p r = OrderedQuery Aggregated Restrictings Aggregated AggregatingSetT QueryCore p r
+ Database.Relational.Query.SQLite3: type Assign r = Assignings r Restrict
+ Database.Relational.Query.SQLite3: type ConfigureQuery = Qualify QueryConfig Identity
+ Database.Relational.Query.SQLite3: type JoinRestriction a b = Record Flat a -> Record Flat b -> Predicate Flat
+ Database.Relational.Query.SQLite3: type NotNullColumnConstraint = ColumnConstraint NotNull
+ Database.Relational.Query.SQLite3: type OrderedQuery c (m :: * -> *) p r = Orderings c m (PlaceHolders p, Record c r)
+ Database.Relational.Query.SQLite3: type PI c a b = Record c a -> Record c b
+ Database.Relational.Query.SQLite3: type PersistableRecordWidth a = ProductConst Sum Int a
+ Database.Relational.Query.SQLite3: type Predicate c = Record c Maybe Bool
+ Database.Relational.Query.SQLite3: type PreparedDelete p = PreparedStatement p ()
+ Database.Relational.Query.SQLite3: type PreparedInsert a = PreparedStatement a ()
+ Database.Relational.Query.SQLite3: type PreparedInsertQuery p = PreparedStatement p ()
+ Database.Relational.Query.SQLite3: type PreparedQuery p a = PreparedStatement p a
+ Database.Relational.Query.SQLite3: type PreparedUpdate p = PreparedStatement p ()
+ Database.Relational.Query.SQLite3: type PrimaryColumnConstraint = ColumnConstraint Primary
+ Database.Relational.Query.SQLite3: type PrimaryConstraint = KeyConstraint Primary
+ Database.Relational.Query.SQLite3: type QueryAggregate = Orderings Aggregated Restrictings Aggregated AggregatingSetT QueryCore
+ Database.Relational.Query.SQLite3: type QueryCore = Restrictings Flat QueryJoin ConfigureQuery
+ Database.Relational.Query.SQLite3: type QuerySimple = Orderings Flat QueryCore
+ Database.Relational.Query.SQLite3: type QuerySuffix = [Keyword]
+ Database.Relational.Query.SQLite3: type Register r = Assignings r ConfigureQuery
+ Database.Relational.Query.SQLite3: type Restrict = Restrictings Flat ConfigureQuery
+ Database.Relational.Query.SQLite3: type ShowConstantTermsSQL = LiteralSQL
+ Database.Relational.Query.SQLite3: type SimpleQuery p r = OrderedQuery Flat QueryCore p r
+ Database.Relational.Query.SQLite3: type SqlBinOp = Keyword -> Keyword -> Keyword
+ Database.Relational.Query.SQLite3: type StringSQL = Keyword
+ Database.Relational.Query.SQLite3: type ToSqlM q a = Writer DList q a
+ Database.Relational.Query.SQLite3: type UniqueColumnConstraint = ColumnConstraint Unique
+ Database.Relational.Query.SQLite3: type UniqueConstraint = KeyConstraint Unique
+ Database.Relational.Query.SQLite3: type Window c = Orderings c PartitioningSet c
+ Database.Relational.Query.SQLite3: typedDelete :: () => Table r -> Restriction p r -> Delete p
+ Database.Relational.Query.SQLite3: typedDelete' :: () => Config -> Table r -> Restriction p r -> Delete p
+ Database.Relational.Query.SQLite3: typedInsert :: PersistableWidth r => Table r -> Pi r r' -> Insert r'
+ Database.Relational.Query.SQLite3: typedInsert' :: PersistableWidth r => Config -> Table r -> Pi r r' -> Insert r'
+ Database.Relational.Query.SQLite3: typedInsertQuery :: () => Table r -> Pi r r' -> Relation p r' -> InsertQuery p
+ Database.Relational.Query.SQLite3: typedInsertQuery' :: () => Config -> Table r -> Pi r r' -> Relation p r' -> InsertQuery p
+ Database.Relational.Query.SQLite3: typedInsertValue :: () => Table r -> InsertTarget p r -> Insert p
+ Database.Relational.Query.SQLite3: typedInsertValue' :: () => Config -> Table r -> InsertTarget p r -> Insert p
+ Database.Relational.Query.SQLite3: typedKeyUpdate :: () => Table a -> Pi a p -> KeyUpdate p a
+ Database.Relational.Query.SQLite3: typedKeyUpdateTable :: TableDerivable r => Relation () r -> Pi r p -> KeyUpdate p r
+ Database.Relational.Query.SQLite3: typedUpdate :: () => Table r -> UpdateTarget p r -> Update p
+ Database.Relational.Query.SQLite3: typedUpdate' :: () => Config -> Table r -> UpdateTarget p r -> Update p
+ Database.Relational.Query.SQLite3: typedUpdateAllColumn :: PersistableWidth r => Table r -> Restriction p r -> Update (r, p)
+ Database.Relational.Query.SQLite3: unUnique :: () => UniqueRelation p c r -> Relation p r
+ Database.Relational.Query.SQLite3: union :: () => Relation () a -> Relation () a -> Relation () a
+ Database.Relational.Query.SQLite3: union' :: () => Relation p a -> Relation q a -> Relation (p, q) a
+ Database.Relational.Query.SQLite3: unionAll :: () => Relation () a -> Relation () a -> Relation () a
+ Database.Relational.Query.SQLite3: unionAll' :: () => Relation p a -> Relation q a -> Relation (p, q) a
+ Database.Relational.Query.SQLite3: uniqueColumn :: () => PrimaryColumnConstraint r -> UniqueColumnConstraint r
+ Database.Relational.Query.SQLite3: uniqueKey :: PersistableWidth ct => Key Primary r ct -> Key Unique r ct
+ Database.Relational.Query.SQLite3: uniqueQuery' :: () => UniqueRelation p c r -> QueryUnique (PlaceHolders p, Record c r)
+ Database.Relational.Query.SQLite3: uniqueQueryMaybe' :: () => UniqueRelation p c r -> QueryUnique (PlaceHolders p, Record c Maybe r)
+ Database.Relational.Query.SQLite3: uniqueRelation' :: () => QueryUnique (PlaceHolders p, Record c r) -> UniqueRelation p c r
+ Database.Relational.Query.SQLite3: uniqueSelect :: PersistableWidth p => Key Unique a p -> Relation () a -> Relation p a
+ Database.Relational.Query.SQLite3: unitPH :: PlaceHolders ()
+ Database.Relational.Query.SQLite3: unitPlaceHolder :: PlaceHolders ()
+ Database.Relational.Query.SQLite3: unitSQL :: SubQuery -> String
+ Database.Relational.Query.SQLite3: unsafeAddPlaceHolders :: Functor f => f a -> f (PlaceHolders p, a)
+ Database.Relational.Query.SQLite3: unsafeAggregateOp :: (AggregatedContext ac, SqlContext ac) => Keyword -> Record Flat a -> Record ac b
+ Database.Relational.Query.SQLite3: unsafeBinOp :: SqlContext k => SqlBinOp -> Record k a -> Record k b -> Record k c
+ Database.Relational.Query.SQLite3: unsafePlaceHolders :: () => PlaceHolders p
+ Database.Relational.Query.SQLite3: unsafePrepare :: IConnection conn => conn -> String -> IO PreparedStatement p a
+ Database.Relational.Query.SQLite3: unsafeProjectSql :: SqlContext c => String -> Record c t
+ Database.Relational.Query.SQLite3: unsafeProjectSql' :: SqlContext c => StringSQL -> Record c t
+ Database.Relational.Query.SQLite3: unsafeProjectSqlTerms :: SqlContext c => [StringSQL] -> Record c t
+ Database.Relational.Query.SQLite3: unsafeShowSql :: () => Record c a -> String
+ Database.Relational.Query.SQLite3: unsafeShowSql' :: () => Record c a -> StringSQL
+ Database.Relational.Query.SQLite3: unsafeSpecifyBinding :: (TableDerivable r, SequenceDerivable s i) => Pi r i -> SeqBinding r s i
+ Database.Relational.Query.SQLite3: unsafeSpecifyNumber :: Binding r s i => i -> Number r i
+ Database.Relational.Query.SQLite3: unsafeSpecifySequence :: TableDerivable s => s -> i -> Pi s i -> Sequence s i
+ Database.Relational.Query.SQLite3: unsafeTypeRelation :: () => ConfigureQuery SubQuery -> Relation p r
+ Database.Relational.Query.SQLite3: unsafeTypedInsert' :: () => String -> String -> Int -> Insert a
+ Database.Relational.Query.SQLite3: unsafeTypedQuery :: () => String -> Query p a
+ Database.Relational.Query.SQLite3: unsafeTypedUpdate :: () => String -> Update p
+ Database.Relational.Query.SQLite3: unsafeUniOp :: SqlContext c2 => Keyword -> Keyword -> Record c1 a -> Record c2 b
+ Database.Relational.Query.SQLite3: unsafeUnique :: () => Relation p r -> UniqueRelation p c r
+ Database.Relational.Query.SQLite3: untypeChunkInsert :: () => Insert a -> String
+ Database.Relational.Query.SQLite3: untypeNoFetch :: UntypeableNoFetch s => s p -> String
+ Database.Relational.Query.SQLite3: untypePrepared :: () => PreparedStatement p a -> Statement
+ Database.Relational.Query.SQLite3: untypeRelation :: () => Relation p r -> ConfigureQuery SubQuery
+ Database.Relational.Query.SQLite3: update :: TableDerivable r => AssignStatement r PlaceHolders p -> Update p
+ Database.Relational.Query.SQLite3: update' :: TableDerivable r => Config -> AssignStatement r PlaceHolders p -> Update p
+ Database.Relational.Query.SQLite3: updateAllColumn :: (PersistableWidth r, TableDerivable r) => RestrictedStatement r PlaceHolders p -> Update (r, p)
+ Database.Relational.Query.SQLite3: updateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> RestrictedStatement r PlaceHolders p -> Update (r, p)
+ Database.Relational.Query.SQLite3: updateAllColumnNoPH :: (PersistableWidth r, TableDerivable r) => RestrictedStatement r () -> Update r
+ Database.Relational.Query.SQLite3: updateByConstraintKey :: () => Table r -> Key c r p -> KeyUpdate p r
+ Database.Relational.Query.SQLite3: updateNoPH :: TableDerivable r => AssignStatement r () -> Update ()
+ Database.Relational.Query.SQLite3: updateNumber :: (PersistableWidth s, Integral i, LiteralSQL i) => i -> Sequence s i -> Update ()
+ Database.Relational.Query.SQLite3: updateNumber' :: (PersistableWidth s, Integral i, LiteralSQL i) => Config -> i -> Sequence s i -> Update ()
+ Database.Relational.Query.SQLite3: updateOtherThanKeySQL :: () => Table r -> Pi r p -> String
+ Database.Relational.Query.SQLite3: updateSQL :: () => Config -> Table r -> UpdateTarget p r -> String
+ Database.Relational.Query.SQLite3: updateTarget :: () => AssignStatement r () -> UpdateTarget () r
+ Database.Relational.Query.SQLite3: updateTarget' :: () => AssignStatement r PlaceHolders p -> UpdateTarget p r
+ Database.Relational.Query.SQLite3: updateTargetAllColumn :: PersistableWidth r => RestrictedStatement r () -> UpdateTarget r r
+ Database.Relational.Query.SQLite3: updateTargetAllColumn' :: PersistableWidth r => RestrictedStatement r PlaceHolders p -> UpdateTarget (r, p) r
+ Database.Relational.Query.SQLite3: updateValuesByPrimary :: (HasKeyConstraint Primary ra, ToSql q ra) => ra -> [q]
+ Database.Relational.Query.SQLite3: updateValuesByUnique :: ToSql q ra => KeyConstraint Unique ra -> ra -> [q]
+ Database.Relational.Query.SQLite3: updateValuesWithKey :: ToSql q r => Pi r p -> r -> [q]
+ Database.Relational.Query.SQLite3: value :: (LiteralSQL t, OperatorContext c) => t -> Record c t
+ Database.Relational.Query.SQLite3: valueFalse :: OperatorContext c => Record c Maybe Bool
+ Database.Relational.Query.SQLite3: valueRecordFromSql :: () => q -> a -> RecordFromSql q a
+ Database.Relational.Query.SQLite3: valueRecordToSql :: () => a -> q -> RecordToSql q a
+ Database.Relational.Query.SQLite3: valueTrue :: OperatorContext c => Record c Maybe Bool
+ Database.Relational.Query.SQLite3: values :: (LiteralSQL t, OperatorContext c) => [t] -> RecordList Record c t
+ Database.Relational.Query.SQLite3: wheres :: MonadRestrict Flat m => Predicate Flat -> m ()
+ Database.Relational.Query.SQLite3: withPrepareDelete :: IConnection conn => conn -> Delete p -> PreparedDelete p -> IO a -> IO a
+ Database.Relational.Query.SQLite3: withPrepareInsertQuery :: IConnection conn => conn -> InsertQuery p -> PreparedInsertQuery p -> IO a -> IO a
+ Database.Relational.Query.SQLite3: withPrepareKeyUpdate :: IConnection conn => conn -> KeyUpdate p a -> PreparedKeyUpdate p a -> IO b -> IO b
+ Database.Relational.Query.SQLite3: withPrepareNoFetch :: (UntypeableNoFetch s, IConnection conn) => conn -> s p -> PreparedStatement p () -> IO a -> IO a
+ Database.Relational.Query.SQLite3: withPrepareQuery :: IConnection conn => conn -> Query p a -> PreparedQuery p a -> IO b -> IO b
+ Database.Relational.Query.SQLite3: withPrepareUpdate :: IConnection conn => conn -> Update p -> PreparedUpdate p -> IO a -> IO a
+ Database.Relational.Query.SQLite3: withTransaction :: IConnection conn => conn -> conn -> IO a -> IO a
+ Database.Relational.Query.SQLite3: withUnsafePrepare :: IConnection conn => conn -> String -> PreparedStatement p a -> IO b -> IO b
+ Database.Relational.Query.SQLite3: withWConn :: () => ConnWrapper -> forall conn. IConnection conn => conn -> b -> b
+ Department: instance Database.Relational.ProjectableClass.LiteralSQL Department.Department
+ Employee: instance Database.Relational.ProjectableClass.LiteralSQL Employee.Employee
+ Individual: instance Database.Relational.ProjectableClass.LiteralSQL Individual.Individual
+ Officer: instance Database.Relational.ProjectableClass.LiteralSQL Officer.Officer
+ Product: instance Database.Relational.ProjectableClass.LiteralSQL Product.Product
+ ProductType: instance Database.Relational.ProjectableClass.LiteralSQL ProductType.ProductType
+ Transaction: instance Database.Relational.ProjectableClass.LiteralSQL Transaction.Transaction0
- Account: insertQueryAccount :: forall p_alJf. Relation p_alJf Account -> InsertQuery p_alJf
+ Account: insertQueryAccount :: forall p_allk. Relation p_allk Account -> InsertQuery p_allk
- Branch: insertQueryBranch :: forall p_ajSj. Relation p_ajSj Branch -> InsertQuery p_ajSj
+ Branch: insertQueryBranch :: forall p_ajva. Relation p_ajva Branch -> InsertQuery p_ajva
- Business: insertQueryBusiness :: forall p_aiq5. Relation p_aiq5 Business -> InsertQuery p_aiq5
+ Business: insertQueryBusiness :: forall p_ai3O. Relation p_ai3O Business -> InsertQuery p_ai3O
- Customer: insertQueryCustomer :: forall p_a9Gr. Relation p_a9Gr Customer -> InsertQuery p_a9Gr
+ Customer: insertQueryCustomer :: forall p_a9DR. Relation p_a9DR Customer -> InsertQuery p_a9DR
- Department: insertQueryDepartment :: forall p_apm0. Relation p_apm0 Department -> InsertQuery p_apm0
+ Department: insertQueryDepartment :: forall p_apDm. Relation p_apDm Department -> InsertQuery p_apDm
- Employee: insertQueryEmployee :: forall p_aqgF. Relation p_aqgF Employee -> InsertQuery p_aqgF
+ Employee: insertQueryEmployee :: forall p_aqxf. Relation p_aqxf Employee -> InsertQuery p_aqxf
- Individual: insertQueryIndividual :: forall p_asYp. Relation p_asYp Individual -> InsertQuery p_asYp
+ Individual: insertQueryIndividual :: forall p_ated. Relation p_ated Individual -> InsertQuery p_ated
- Officer: insertQueryOfficer :: forall p_auon. Relation p_auon Officer -> InsertQuery p_auon
+ Officer: insertQueryOfficer :: forall p_auDp. Relation p_auDp Officer -> InsertQuery p_auDp
- Product: insertQueryProduct :: forall p_awzY. Relation p_awzY Product -> InsertQuery p_awzY
+ Product: insertQueryProduct :: forall p_awOe. Relation p_awOe Product -> InsertQuery p_awOe
- ProductType: insertQueryProductType :: forall p_ayba. Relation p_ayba ProductType -> InsertQuery p_ayba
+ ProductType: insertQueryProductType :: forall p_ayoE. Relation p_ayoE ProductType -> InsertQuery p_ayoE
- Transaction: insertQueryTransaction0 :: forall p_az3H. Relation p_az3H Transaction0 -> InsertQuery p_az3H
+ Transaction: insertQueryTransaction0 :: forall p_azgp. Relation p_azgp Transaction0 -> InsertQuery p_azgp

Files

relational-record-examples.cabal view
@@ -1,5 +1,5 @@ name:                relational-record-examples-version:             0.5.1.0+version:             0.5.1.1 synopsis:            Examples of Haskell Relationa Record description:         Provides examples of Haskell Relational Record license:             BSD3
src/examples.hs view
@@ -1,3 +1,4 @@+{-# OPTIONS_GHC -Wno-unused-top-binds #-} {-# LANGUAGE MonadComprehensions #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE TemplateHaskell #-}
src/specializedExamples.hs view
@@ -1,3 +1,4 @@+{-# OPTIONS_GHC -Wno-unused-top-binds #-} {-# LANGUAGE MonadComprehensions #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE TemplateHaskell #-}