2019-11-18 21:45:54 +03:00
|
|
|
-- | A simple implementation of /incremental build rules/, which can be used to avoid unnecessary
|
|
|
|
-- recomputation on incrementally-changing input. See 'Rule' for more details.
|
2021-09-24 01:56:37 +03:00
|
|
|
module Hasura.Incremental
|
|
|
|
( -- * The @Rule@ datatype
|
|
|
|
Rule,
|
|
|
|
Result,
|
|
|
|
build,
|
|
|
|
rebuild,
|
|
|
|
rebuildRule,
|
|
|
|
result,
|
|
|
|
|
|
|
|
-- * Abstract interface
|
|
|
|
ArrowDistribute (..),
|
|
|
|
ArrowCache (..),
|
|
|
|
|
|
|
|
-- * Fine-grained dependencies
|
|
|
|
Dependency,
|
|
|
|
Select (Selector),
|
|
|
|
selectD,
|
|
|
|
selectKeyD,
|
2022-09-14 15:59:37 +03:00
|
|
|
selectMaybeD,
|
2021-09-24 01:56:37 +03:00
|
|
|
Accesses,
|
|
|
|
|
|
|
|
-- * Cache invalidation
|
|
|
|
InvalidationKey,
|
|
|
|
initialInvalidationKey,
|
|
|
|
invalidate,
|
|
|
|
)
|
|
|
|
where
|
|
|
|
|
|
|
|
import Hasura.Incremental.Internal.Cache
|
|
|
|
import Hasura.Incremental.Internal.Dependency
|
|
|
|
import Hasura.Incremental.Internal.Rule
|
|
|
|
import Hasura.Incremental.Select
|
|
|
|
import Hasura.Prelude
|
2020-01-29 23:15:53 +03:00
|
|
|
|
|
|
|
-- | A simple helper type that can be used to implement explicit cache invalidation. Internally,
|
|
|
|
-- each 'InvalidationKey' is a counter; 'initialInvalidationKey' starts the counter at 0 and
|
|
|
|
-- 'invalidate' increments it by 1. Two 'InvalidationKey's are equal iff they have the same internal
|
|
|
|
-- count, so depending on an 'InvalidationKey' provides a mechanism to force portions of the build
|
|
|
|
-- process to be reexecuted by calling 'invalidate' before running the build.
|
|
|
|
newtype InvalidationKey = InvalidationKey Int
|
server: delete the `Cacheable` type class in favor of `Eq`
What is the `Cacheable` type class about?
```haskell
class Eq a => Cacheable a where
unchanged :: Accesses -> a -> a -> Bool
default unchanged :: (Generic a, GCacheable (Rep a)) => Accesses -> a -> a -> Bool
unchanged accesses a b = gunchanged (from a) (from b) accesses
```
Its only method is an alternative to `(==)`. The added value of `unchanged` (and the additional `Accesses` argument) arises _only_ for one type, namely `Dependency`. Indeed, the `Cacheable (Dependency a)` instance is non-trivial, whereas every other `Cacheable` instance is completely boilerplate (and indeed either generated from `Generic`, or simply `unchanged _ = (==)`). The `Cacheable (Dependency a)` instance is the only one where the `Accesses` argument is not just passed onwards.
The only callsite of the `unchanged` method is in the `ArrowCache (Rule m)` method. That is to say that the `Cacheable` type class is used to decide when we can re-use parts of the schema cache between Metadata operations.
So what is the `Cacheable (Dependency a)` instance about? Normally, the output of a `Rule m a b` is re-used when the new input (of type `a`) is equal to the old one. But sometimes, that's too coarse: it might be that a certain `Rule m a b` only depends on a small part of its input of type `a`. A `Dependency` allows us to spell out what parts of `a` are being depended on, and these parts are recorded as values of types `Access a` in the state `Accesses`.
If the input `a` changes, but not in a way that touches the recorded `Accesses`, then the output `b` of that rule can be re-used without recomputing.
So now you understand _why_ we're passing `Accesses` to the `unchanged` method: `unchanged` is an equality check in disguise that just needs some additional context.
But we don't need to pass `Accesses` as a function argument. We can use the `reflection` package to pass it as type-level context. So the core of this PR is that we change the instance declaration from
```haskell
instance (Cacheable a) => Cacheable (Dependency a) where
```
to
```haskell
instance (Given Accesses, Eq a) => Eq (Dependency a) where
```
and use `(==)` instead of `unchanged`.
If you haven't seen `reflection` before: it's like a `MonadReader`, but it doesn't require a `Monad`.
In order to pass the current `Accesses` value, instead of simply passing the `Accesses` as a function argument, we need to instantiate the `Given Accesses` context. We use the `give` method from the `reflection` package for that.
```haskell
give :: forall r. Accesses -> (Given Accesses => r) -> r
unchanged :: (Given Accesses => Eq a) => Accesses -> a -> a -> Bool
unchanged accesses a b = give accesses (a == b)
```
With these three components in place, we can delete the `Cacheable` type class entirely.
The remainder of this PR is just to remove the `Cacheable` type class and its instances.
PR-URL: https://github.com/hasura/graphql-engine-mono/pull/6877
GitOrigin-RevId: 7125f5e11d856e7672ab810a23d5bf5ad176e77f
2022-11-21 19:33:56 +03:00
|
|
|
deriving (Show, Eq, Ord)
|
2020-01-29 23:15:53 +03:00
|
|
|
|
|
|
|
initialInvalidationKey :: InvalidationKey
|
|
|
|
initialInvalidationKey = InvalidationKey 0
|
|
|
|
|
|
|
|
invalidate :: InvalidationKey -> InvalidationKey
|
|
|
|
invalidate (InvalidationKey n) = InvalidationKey (n + 1)
|