Copyright	(c) Soostone Inc 2020
License	AllRightsReserved
Stability	experimental
Portability	POSIX
Safe Haskell	None
Language	Haskell2010

Napkin.Untyped.Monad

Description

Synopsis

data RefStore = RefStore {
- _refStore_feed :: [String]
- _refStore_blacklist :: Set String
}
refStore_feed :: Lens' RefStore [String]
refStore_blacklist :: Lens' RefStore (Set String)
class HasRefStore s where
- refRepo :: Lens' s RefStore
letters :: String
newRefStore :: RefStore
newRef :: (HasRefStore s, MonadState s m) => m (Ref a)
newQState :: QState
data QState = QState {
- _qsVars :: RefStore
- _qsQuery :: Query
}
qsVars :: Lens' QState RefStore
qsQuery :: Lens' QState Query
newtype Q a = Q {
- _runQ :: State QState a
}
runQ :: Q a -> (a, Query)
mkQ :: Q a -> Query
evalQ :: Q c -> c
modQ :: Query -> Q a -> Query
asQuery :: Iso' (Q ()) Query
with_ :: Query -> Q (Ref Relation)
withQ_ :: Q a -> Q (Ref Relation)
withQ'_ :: Q a -> Q (Ref Relation, Query)
withQAs_ :: Ref Query -> Q a -> Q (Ref Table)
withAs_ :: Selected Query -> Q (Ref Table)
withAs_' :: Selected Query -> NonEmpty (Ref SExp) -> Q (Ref Table)
withAsUnique :: Selected Query -> Q (Ref Table)
select_ :: SExp -> Q (Ref SExp)
selectAs_ :: Selected SExp -> Q (Ref SExp)
selectsAs_ :: [Selected SExp] -> Q [Ref SExp]
selectAs_' :: Alias SExp -> Q (Maybe (Ref SExp))
selectsAs_' :: [Alias SExp] -> Q [Maybe (Ref SExp)]
selectsGroupsAs_ :: [Selected SExp] -> Q ()
selectsGroupsAsRef_ :: [Selected SExp] -> Q ()
selectNonEmptyGroups :: [Selected SExp] -> Q ()
from_ :: Relation -> Q (Ref Relation)
fromIfNecessary :: Relation -> Q (Ref Relation)
fromSelected_ :: Selected Relation -> Q (Ref Relation)
fromAlias_ :: Alias Relation -> Q (Ref Relation)
fromRef_ :: Ref Relation -> Q (Ref Relation)
fromRel :: AsRelation r => r -> Q (Ref Relation)
fromSpecified :: Q Bool
fromOrJoin :: Alias Relation -> Either (Ref Relation -> Maybe SExp) [Ref SExp] -> Q (Ref Relation)
join_ :: JoinType -> Relation -> (Ref Relation -> Maybe SExp) -> Q (Ref Relation)
joinUsing_ :: JoinType -> Relation -> [Ref SExp] -> Q (Ref Relation)
joinRef_ :: JoinType -> Ref Relation -> (Ref Relation -> Maybe SExp) -> Q (Ref Relation)
joinSelected_ :: JoinType -> Selected Relation -> Either (Ref Relation -> Maybe SExp) [Ref SExp] -> Q (Ref Relation)
joinAlias_ :: JoinType -> Alias Relation -> Either (Ref Relation -> Maybe SExp) [Ref SExp] -> Q (Ref Relation)
joinOn_ :: JoinType -> Relation -> (Ref Relation -> SExp) -> Q (Ref Relation)
innerJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation)
crossJoin :: Relation -> Q (Ref Relation)
leftJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation)
rightJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation)
outerJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation)
having :: MonadState QState m => SExp -> m ()
havingL :: Applicative f => (Maybe SExp -> f (Maybe SExp)) -> QState -> f QState
where_ :: SExp -> Q ()
whereL :: (Maybe SExp -> Identity (Maybe SExp)) -> QState -> Identity QState
whereAdd :: MonadState QState m => SExp -> m ()
whereAddIn :: MonadState QState m => SExp -> [SExp] -> m ()
whereAddNotIn :: MonadState QState m => SExp -> [SExp] -> m ()
groupBy_ :: [SExp] -> Q ()
orderBy_ :: Order -> Q ()
limit_ :: MonadState QState m => Int -> m ()
offset_ :: MonadState QState m => Int -> m ()
mdef :: a -> Iso' (Maybe a) a
fromQuery :: Q a -> Relation
scopeRelation :: SExp -> Relation -> Relation
selectEverything :: [(Ref Relation, DefinedQuery)] -> Q ()
explicitSelectStarWith :: s -> Ref Relation -> Getting (Endo [Ref SExp]) s (Ref SExp) -> Q ()
explicitSelectStar :: HasDefinition s => s -> Ref Relation -> Q ()
selectStar :: Ref Relation -> Q (Ref Relation)
selectNonDuplicates :: Foldable t => t (Ref SExp) -> Q ()
mapSelectNonDuplicates :: Foldable t => t (Ref SExp) -> (Selected SExp -> Selected SExp) -> Q ()
union_ :: UnionType -> Query -> Query -> WithClauses -> Q ()
data UState = UState {
- _usVars :: RefStore
- _usQuery :: UpdateQuery
}
usVars :: Lens' UState RefStore
usQuery :: Lens' UState UpdateQuery
newtype U a = U {
- _runU :: State UState a
}
mkU :: Alias (Ref Table) -> (Ref Relation -> U a) -> UpdateQuery
updateWhereAdd :: MonadState UState m => SExp -> m ()
updateJoin_ :: JoinType -> Relation -> (Ref Relation -> Maybe SExp) -> U (Ref Relation)
updateJoinOn_ :: JoinType -> Relation -> (Ref Relation -> SExp) -> U (Ref Relation)
updateInnerJoin_ :: Relation -> (Ref Relation -> SExp) -> U (Ref Relation)
updateSet_ :: Name -> SExp -> U ()

Documentation

data RefStore #

Supply of fresh reference names to be used in monadic contexts where you need an infinite-ish supply.

Constructors

RefStore
Fields _refStore_feed :: [String] _refStore_blacklist :: Set String

Instances

Instances details

Eq RefStore #
Instance details Defined in Napkin.Untyped.Monad Methods (==) :: RefStore -> RefStore -> Bool # (/=) :: RefStore -> RefStore -> Bool #
Data RefStore #
Instance details Defined in Napkin.Untyped.Monad Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RefStore -> c RefStore # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RefStore # toConstr :: RefStore -> Constr # dataTypeOf :: RefStore -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RefStore) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RefStore) # gmapT :: (forall b. Data b => b -> b) -> RefStore -> RefStore # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RefStore -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RefStore -> r # gmapQ :: (forall d. Data d => d -> u) -> RefStore -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RefStore -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RefStore -> m RefStore # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RefStore -> m RefStore # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RefStore -> m RefStore #
Ord RefStore #
Instance details Defined in Napkin.Untyped.Monad Methods compare :: RefStore -> RefStore -> Ordering # (<) :: RefStore -> RefStore -> Bool # (<=) :: RefStore -> RefStore -> Bool # (>) :: RefStore -> RefStore -> Bool # (>=) :: RefStore -> RefStore -> Bool # max :: RefStore -> RefStore -> RefStore # min :: RefStore -> RefStore -> RefStore #
Show RefStore #
Instance details Defined in Napkin.Untyped.Monad Methods showsPrec :: Int -> RefStore -> ShowS # show :: RefStore -> String # showList :: [RefStore] -> ShowS #
Generic RefStore #
Instance details Defined in Napkin.Untyped.Monad Associated Types type Rep RefStore :: Type -> Type # Methods from :: RefStore -> Rep RefStore x # to :: Rep RefStore x -> RefStore #
HasRefStore RefStore #
Instance details Defined in Napkin.Untyped.Monad Methods refRepo :: Lens' RefStore RefStore #
type Rep RefStore #
Instance details Defined in Napkin.Untyped.Monad type Rep RefStore = D1 ('MetaData "RefStore" "Napkin.Untyped.Monad" "napkin-0.5.13-8705pBGlgyp7AIaYGNE2fM" 'False) (C1 ('MetaCons "RefStore" 'PrefixI 'True) (S1 ('MetaSel ('Just "_refStore_feed") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [String]) :*: S1 ('MetaSel ('Just "_refStore_blacklist") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set String))))

refStore_feed :: Lens' RefStore [String] #

refStore_blacklist :: Lens' RefStore (Set String) #

class HasRefStore s where #

Methods

refRepo :: Lens' s RefStore #

Instances

Instances details

HasRefStore RefStore #
Instance details Defined in Napkin.Untyped.Monad Methods refRepo :: Lens' RefStore RefStore #
HasRefStore QState #
Instance details Defined in Napkin.Untyped.Monad Methods refRepo :: Lens' QState RefStore #
HasRefStore UState #
Instance details Defined in Napkin.Untyped.Monad Methods refRepo :: Lens' UState RefStore #
HasRefStore SubQueryTransformState #
Instance details Defined in Napkin.Untyped.Ops.BigQuery Methods refRepo :: Lens' SubQueryTransformState RefStore #

letters :: String #

newRefStore :: RefStore #

newRef :: (HasRefStore s, MonadState s m) => m (Ref a) #

newQState :: QState #

data QState #

Constructors

QState
Fields _qsVars :: RefStore _qsQuery :: Query

Instances

Instances details

Eq QState #
Instance details Defined in Napkin.Untyped.Monad Methods (==) :: QState -> QState -> Bool # (/=) :: QState -> QState -> Bool #
Data QState #
Instance details Defined in Napkin.Untyped.Monad Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QState -> c QState # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QState # toConstr :: QState -> Constr # dataTypeOf :: QState -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c QState) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QState) # gmapT :: (forall b. Data b => b -> b) -> QState -> QState # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QState -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QState -> r # gmapQ :: (forall d. Data d => d -> u) -> QState -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> QState -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> QState -> m QState # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QState -> m QState # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QState -> m QState #
Show QState #
Instance details Defined in Napkin.Untyped.Monad Methods showsPrec :: Int -> QState -> ShowS # show :: QState -> String # showList :: [QState] -> ShowS #
HasRefStore QState #
Instance details Defined in Napkin.Untyped.Monad Methods refRepo :: Lens' QState RefStore #
MonadState QState Q #
Instance details Defined in Napkin.Untyped.Monad Methods get :: Q QState # put :: QState -> Q () # state :: (QState -> (a, QState)) -> Q a #

qsVars :: Lens' QState RefStore #

qsQuery :: Lens' QState Query #

newtype Q a #

Constructors

Q
Fields _runQ :: State QState a

Instances

Instances details

Monad Q #
Instance details Defined in Napkin.Untyped.Monad Methods (>>=) :: Q a -> (a -> Q b) -> Q b # (>>) :: Q a -> Q b -> Q b # return :: a -> Q a #
Functor Q #
Instance details Defined in Napkin.Untyped.Monad Methods fmap :: (a -> b) -> Q a -> Q b # (<$) :: a -> Q b -> Q a #
Applicative Q #
Instance details Defined in Napkin.Untyped.Monad Methods pure :: a -> Q a # (<>) :: Q (a -> b) -> Q a -> Q b # liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c # (>) :: Q a -> Q b -> Q b # (<*) :: Q a -> Q b -> Q a #
MonadState QState Q #
Instance details Defined in Napkin.Untyped.Monad Methods get :: Q QState # put :: QState -> Q () # state :: (QState -> (a, QState)) -> Q a #
MaybeQuery (Q ()) #
Instance details Defined in Napkin.Untyped.Monad Methods getQuery :: Q () -> Maybe Query #
HasDefinition (Q ()) #
Instance details Defined in Napkin.Untyped.Monad Methods defQuery :: Lens (Q ()) (Q ()) Query Query #
AsRelation (Q a) #
Instance details Defined in Napkin.Untyped.Monad Methods asRelation :: Q a -> Relation #
RenderSql Query backend => RenderSql (Q a) backend #	Monadic query interface
Instance details Defined in Napkin.Render.Types Methods renderSql :: backend -> Q a -> Doc #

runQ :: Q a -> (a, Query) #

mkQ :: Q a -> Query #

evalQ :: Q c -> c #

modQ :: Query -> Q a -> Query #

Alter a pre-existing Query monadically.

asQuery :: Iso' (Q ()) Query #

with_ :: Query -> Q (Ref Relation) #

withQ_ :: Q a -> Q (Ref Relation) #

Define a subquery using the WITH syntax. Note that this does not automatically include this table in a SELECT; you need to additionally include the resulting relation from withQ_ using the from_ operator.

withQ'_ :: Q a -> Q (Ref Relation, Query) #

withQAs_ :: Ref Query -> Q a -> Q (Ref Table) #

withAs_ :: Selected Query -> Q (Ref Table) #

Define a WITH subquery while retaining and re-using its given name. Useful in some scenarios where you want to keep the original name in further referring to the newly introduced subquery table.

withAs_' :: Selected Query -> NonEmpty (Ref SExp) -> Q (Ref Table) #

withAsUnique :: Selected Query -> Q (Ref Table) #

Use unique naming scheme along with Ref Relation to construct the WITH macro's name. This is useful when ensuring unique naming while not throwing out some human-readable information.

select_ :: SExp -> Q (Ref SExp) #

Smart selector that will use the variable's name if expression is a variable and assign a fresh variable name if it's something else without a name.

selectAs_ :: Selected SExp -> Q (Ref SExp) #

selectsAs_ :: [Selected SExp] -> Q [Ref SExp] #

selectAs_' :: Alias SExp -> Q (Maybe (Ref SExp)) #

Add optional aliasing to the Q.

selectsAs_' :: [Alias SExp] -> Q [Maybe (Ref SExp)] #

selectsGroupsAs_ :: [Selected SExp] -> Q () #

Select a field and also include it in GROUP BY. Do this intelligently, referring to it by its given name in most cases but by its direct expression definition in case of external functions to prevent overlap with fields that may already exist.

selectsGroupsAsRef_ :: [Selected SExp] -> Q () #

Like selectsGroupsAs_ but will use the name you gave to each field in the group by statement. Some backends like BigQuery require this while others like Redshift don't like it.

selectNonEmptyGroups :: [Selected SExp] -> Q () #

Special convenience case: Select and group while demanding that none of the group values is null.

from_ :: Relation -> Q (Ref Relation) #

fromIfNecessary :: Relation -> Q (Ref Relation) #

Add a from clause unless the relation is already in place.

fromSelected_ :: Selected Relation -> Q (Ref Relation) #

fromAlias_ :: Alias Relation -> Q (Ref Relation) #

fromRef_ :: Ref Relation -> Q (Ref Relation) #

Use a name directly and don't alias it one more time. | This can fail to create a proper alias if the Ref includes multiple names.

fromRel :: AsRelation r => r -> Q (Ref Relation) #

fromSpecified :: Q Bool #

Returns True iff the current Query already has an initial From table available.

fromOrJoin :: Alias Relation -> Either (Ref Relation -> Maybe SExp) [Ref SExp] -> Q (Ref Relation) #

join_ :: JoinType -> Relation -> (Ref Relation -> Maybe SExp) -> Q (Ref Relation) #

joinUsing_ :: JoinType -> Relation -> [Ref SExp] -> Q (Ref Relation) #

joinRef_ :: JoinType -> Ref Relation -> (Ref Relation -> Maybe SExp) -> Q (Ref Relation) #

joinSelected_ :: JoinType -> Selected Relation -> Either (Ref Relation -> Maybe SExp) [Ref SExp] -> Q (Ref Relation) #

joinAlias_ :: JoinType -> Alias Relation -> Either (Ref Relation -> Maybe SExp) [Ref SExp] -> Q (Ref Relation) #

joinOn_ :: JoinType -> Relation -> (Ref Relation -> SExp) -> Q (Ref Relation) #

innerJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation) #

crossJoin :: Relation -> Q (Ref Relation) #

leftJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation) #

rightJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation) #

outerJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation) #

having :: MonadState QState m => SExp -> m () #

havingL :: Applicative f => (Maybe SExp -> f (Maybe SExp)) -> QState -> f QState #

where_ :: SExp -> Q () #

whereL :: (Maybe SExp -> Identity (Maybe SExp)) -> QState -> Identity QState #

whereAdd :: MonadState QState m => SExp -> m () #

whereAddIn :: MonadState QState m => SExp -> [SExp] -> m () #

where x in y

whereAddNotIn :: MonadState QState m => SExp -> [SExp] -> m () #

where x not in y

groupBy_ :: [SExp] -> Q () #

orderBy_ :: Order -> Q () #

limit_ :: MonadState QState m => Int -> m () #

offset_ :: MonadState QState m => Int -> m () #

mdef :: a -> Iso' (Maybe a) a #

fromQuery :: Q a -> Relation #

Turn query into relation

scopeRelation :: SExp -> Relation -> Relation #

Make a query relation that applies predicate on the given relation in a subquery.

selectEverything :: [(Ref Relation, DefinedQuery)] -> Q () #

Introspects the given list of Queryies, along with their references in the current context, and selects every named field in them within the current context, while deduplicating repeat fields (by name). Good for the common case of joining tables and selecting everything possible in them.

explicitSelectStarWith #

Arguments

:: s	Object containing definitions
-> Ref Relation	Concrete reference within the context
-> Getting (Endo [Ref SExp]) s (Ref SExp)
-> Q ()

explicitSelectStar :: HasDefinition s => s -> Ref Relation -> Q () #

Instead of doing a select * that's impossible to introspect, explicitly select all fields from something that contains a definition - e.g. a Query.

selectStar :: Ref Relation -> Q (Ref Relation) #

select * from x

selectNonDuplicates :: Foldable t => t (Ref SExp) -> Q () #

Given a list of references, select those that have not yet been selected in current monadic block.

mapSelectNonDuplicates :: Foldable t => t (Ref SExp) -> (Selected SExp -> Selected SExp) -> Q () #

Given a list of references, select those that have not yet been selected in current monadic block with option to modify the finalized selection.

union_ :: UnionType -> Query -> Query -> WithClauses -> Q () #

data UState #

Constructors

UState
Fields _usVars :: RefStore _usQuery :: UpdateQuery

Instances

Instances details

Eq UState #
Instance details Defined in Napkin.Untyped.Monad Methods (==) :: UState -> UState -> Bool # (/=) :: UState -> UState -> Bool #
Data UState #
Instance details Defined in Napkin.Untyped.Monad Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UState -> c UState # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UState # toConstr :: UState -> Constr # dataTypeOf :: UState -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UState) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UState) # gmapT :: (forall b. Data b => b -> b) -> UState -> UState # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UState -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UState -> r # gmapQ :: (forall d. Data d => d -> u) -> UState -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UState -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UState -> m UState # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UState -> m UState # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UState -> m UState #
Show UState #
Instance details Defined in Napkin.Untyped.Monad Methods showsPrec :: Int -> UState -> ShowS # show :: UState -> String # showList :: [UState] -> ShowS #
HasRefStore UState #
Instance details Defined in Napkin.Untyped.Monad Methods refRepo :: Lens' UState RefStore #
MonadState UState U #
Instance details Defined in Napkin.Untyped.Monad Methods get :: U UState # put :: UState -> U () # state :: (UState -> (a, UState)) -> U a #

usVars :: Lens' UState RefStore #

usQuery :: Lens' UState UpdateQuery #

newtype U a #

Constructors

U
Fields _runU :: State UState a

Instances

Instances details

Monad U #
Instance details Defined in Napkin.Untyped.Monad Methods (>>=) :: U a -> (a -> U b) -> U b # (>>) :: U a -> U b -> U b # return :: a -> U a #
Functor U #
Instance details Defined in Napkin.Untyped.Monad Methods fmap :: (a -> b) -> U a -> U b # (<$) :: a -> U b -> U a #
Applicative U #
Instance details Defined in Napkin.Untyped.Monad Methods pure :: a -> U a # (<>) :: U (a -> b) -> U a -> U b # liftA2 :: (a -> b -> c) -> U a -> U b -> U c # (>) :: U a -> U b -> U b # (<*) :: U a -> U b -> U a #
MonadState UState U #
Instance details Defined in Napkin.Untyped.Monad Methods get :: U UState # put :: UState -> U () # state :: (UState -> (a, UState)) -> U a #

mkU :: Alias (Ref Table) -> (Ref Relation -> U a) -> UpdateQuery #

updateWhereAdd :: MonadState UState m => SExp -> m () #

updateJoin_ :: JoinType -> Relation -> (Ref Relation -> Maybe SExp) -> U (Ref Relation) #

updateJoinOn_ :: JoinType -> Relation -> (Ref Relation -> SExp) -> U (Ref Relation) #

updateInnerJoin_ :: Relation -> (Ref Relation -> SExp) -> U (Ref Relation) #

updateSet_ :: Name -> SExp -> U () #