mirror of
https://github.com/hasura/graphql-engine.git
synced 2024-12-18 04:51:35 +03:00
dec8579db8
### Description Each Backend executes queries against the database in a slightly different stack: Postgres uses its own `TXeT`, MSSQL uses a variant of it, BigQuery is simply in `ExceptT QErr IO`... To accommodate those variations, we had originally introduced an `ExecutionMonad b` type family in `BackendExecute`, allowing each backend to describe its own stack. It was then up to that backend's `BackendTransport` instance to implement running said stack, and converting the result back into our main app monad. However, this was not without complications: `TraceT` is one of them: as it usually needs to be on the top of the stack, converting from one stack to the other implies the use `interpTraceT`, which is quite monstrous. Furthermore, as part of the Entitlement Services work, we're trying to move to a "Services" architecture in which the entire engine runs in one base monad, that delegates features and dependencies to monad constraints; and as a result we'd like to minimize the number of different monad stacks we have to maintain and translate from and to in the codebase. To improve things, this PR changes `ExecutionMonad b` from an _absolute_ stack to a _relative_ one: i.e.: what needs to be stacked on top of our base monad for the execution. In `Transport`, we then only need to pop the top of the stack, and voila. This greatly simplifies the implementation of the backends, as there's no longer any need to do any stack transformation: MySQL's implementation becomes a `runIdentityT`! This also removes most mentions of `TraceT` from the execution code since it's no longer required: we can rely on the base monad's existing `MonadTrace` constraint. To continue encapsulating monadic actions in `DBStepInfo` and avoid threading a bunch of `forall` all over the place, this PR introduces a small local helper: `OnBaseMonad`. One only downside of all this is that this requires adding `MonadBaseControl IO m` constraint all over the place: previously, we would run directly on `IO` and lift, and would therefore not need to bring that constraint all the way. PR-URL: https://github.com/hasura/graphql-engine-mono/pull/7789 GitOrigin-RevId: e9b2e431c5c47fa9851abf87545c0415ff6d1a12
195 lines
7.3 KiB
Haskell
195 lines
7.3 KiB
Haskell
{-# LANGUAGE UndecidableInstances #-}
|
|
{-# OPTIONS_GHC -fno-warn-orphans #-}
|
|
|
|
-- | Postgres Instances Transport
|
|
--
|
|
-- Defines the MSSQL instance of 'BackendTransport' and how to interact with the
|
|
-- database for running queries, mutations, subscriptions, and so on.
|
|
module Hasura.Backends.Postgres.Instances.Transport
|
|
( runPGMutationTransaction,
|
|
)
|
|
where
|
|
|
|
import Control.Monad.Trans.Control
|
|
import Data.Aeson qualified as J
|
|
import Data.ByteString qualified as B
|
|
import Data.HashMap.Strict.InsOrd qualified as OMap
|
|
import Data.Text.Extended
|
|
import Database.PG.Query qualified as PG
|
|
import Hasura.Backends.Postgres.Connection.MonadTx
|
|
import Hasura.Backends.Postgres.Execute.Subscription qualified as PGL
|
|
import Hasura.Backends.Postgres.Execute.Types
|
|
import Hasura.Backends.Postgres.Instances.Execute qualified as EQ
|
|
import Hasura.Backends.Postgres.SQL.Value
|
|
import Hasura.Backends.Postgres.Translate.Select (PostgresAnnotatedFieldJSON)
|
|
import Hasura.Base.Error
|
|
import Hasura.EncJSON
|
|
import Hasura.GraphQL.Execute.Backend
|
|
import Hasura.GraphQL.Execute.Subscription.Plan
|
|
import Hasura.GraphQL.Logging
|
|
import Hasura.GraphQL.Namespace
|
|
( RootFieldAlias,
|
|
RootFieldMap,
|
|
mkUnNamespacedRootFieldAlias,
|
|
)
|
|
import Hasura.GraphQL.Transport.Backend
|
|
import Hasura.GraphQL.Transport.HTTP.Protocol
|
|
import Hasura.Logging qualified as L
|
|
import Hasura.Name qualified as Name
|
|
import Hasura.Prelude
|
|
import Hasura.RQL.DDL.ConnectionTemplate (BackendResolvedConnectionTemplate (..), ResolvedConnectionTemplateWrapper (..))
|
|
import Hasura.RQL.Types.Backend
|
|
import Hasura.SQL.AnyBackend qualified as AB
|
|
import Hasura.SQL.Backend
|
|
import Hasura.Server.Types (RequestId)
|
|
import Hasura.Session
|
|
import Hasura.Tracing
|
|
|
|
instance
|
|
( Backend ('Postgres pgKind),
|
|
PostgresAnnotatedFieldJSON pgKind
|
|
) =>
|
|
BackendTransport ('Postgres pgKind)
|
|
where
|
|
runDBQuery = runPGQuery
|
|
runDBMutation = runPGMutation
|
|
runDBSubscription = runPGSubscription
|
|
runDBStreamingSubscription = runPGStreamingSubscription
|
|
runDBQueryExplain = runPGQueryExplain
|
|
|
|
runPGQuery ::
|
|
( MonadIO m,
|
|
MonadBaseControl IO m,
|
|
MonadError QErr m,
|
|
MonadQueryLog m,
|
|
MonadTrace m
|
|
) =>
|
|
RequestId ->
|
|
GQLReqUnparsed ->
|
|
RootFieldAlias ->
|
|
UserInfo ->
|
|
L.Logger L.Hasura ->
|
|
SourceConfig ('Postgres pgKind) ->
|
|
OnBaseMonad (PG.TxET QErr) EncJSON ->
|
|
Maybe EQ.PreparedSql ->
|
|
ResolvedConnectionTemplate ('Postgres pgKind) ->
|
|
-- | Also return the time spent in the PG query; for telemetry.
|
|
m (DiffTime, EncJSON)
|
|
runPGQuery reqId query fieldName _userInfo logger sourceConfig tx genSql resolvedConnectionTemplate = do
|
|
-- log the generated SQL and the graphql query
|
|
logQueryLog logger $ mkQueryLog query fieldName genSql reqId (resolvedConnectionTemplate <$ resolvedConnectionTemplate)
|
|
withElapsedTime $
|
|
trace ("Postgres Query for root field " <>> fieldName) $
|
|
runQueryTx (_pscExecCtx sourceConfig) (GraphQLQuery resolvedConnectionTemplate) $
|
|
runOnBaseMonad tx
|
|
|
|
runPGMutation ::
|
|
( MonadIO m,
|
|
MonadBaseControl IO m,
|
|
MonadError QErr m,
|
|
MonadQueryLog m,
|
|
MonadTrace m
|
|
) =>
|
|
RequestId ->
|
|
GQLReqUnparsed ->
|
|
RootFieldAlias ->
|
|
UserInfo ->
|
|
L.Logger L.Hasura ->
|
|
SourceConfig ('Postgres pgKind) ->
|
|
OnBaseMonad (PG.TxET QErr) EncJSON ->
|
|
Maybe EQ.PreparedSql ->
|
|
ResolvedConnectionTemplate ('Postgres pgKind) ->
|
|
m (DiffTime, EncJSON)
|
|
runPGMutation reqId query fieldName userInfo logger sourceConfig tx _genSql resolvedConnectionTemplate = do
|
|
-- log the graphql query
|
|
logQueryLog logger $ mkQueryLog query fieldName Nothing reqId (resolvedConnectionTemplate <$ resolvedConnectionTemplate)
|
|
withElapsedTime $
|
|
trace ("Postgres Mutation for root field " <>> fieldName) $
|
|
runTxWithCtxAndUserInfo userInfo (_pscExecCtx sourceConfig) (Tx PG.ReadWrite Nothing) (GraphQLQuery resolvedConnectionTemplate) $
|
|
runOnBaseMonad tx
|
|
|
|
runPGSubscription ::
|
|
(MonadIO m, MonadBaseControl IO m) =>
|
|
SourceConfig ('Postgres pgKind) ->
|
|
MultiplexedQuery ('Postgres pgKind) ->
|
|
[(CohortId, CohortVariables)] ->
|
|
ResolvedConnectionTemplate ('Postgres pgKind) ->
|
|
m (DiffTime, Either QErr [(CohortId, B.ByteString)])
|
|
runPGSubscription sourceConfig query variables resolvedConnectionTemplate =
|
|
withElapsedTime $
|
|
runExceptT $
|
|
runQueryTx (_pscExecCtx sourceConfig) (GraphQLQuery resolvedConnectionTemplate) $
|
|
PGL.executeMultiplexedQuery query variables
|
|
|
|
runPGStreamingSubscription ::
|
|
(MonadIO m, MonadBaseControl IO m) =>
|
|
SourceConfig ('Postgres pgKind) ->
|
|
MultiplexedQuery ('Postgres pgKind) ->
|
|
[(CohortId, CohortVariables)] ->
|
|
ResolvedConnectionTemplate ('Postgres pgKind) ->
|
|
m (DiffTime, Either QErr [(CohortId, B.ByteString, CursorVariableValues)])
|
|
runPGStreamingSubscription sourceConfig query variables resolvedConnectionTemplate =
|
|
withElapsedTime $
|
|
runExceptT $ do
|
|
res <- runQueryTx (_pscExecCtx sourceConfig) (GraphQLQuery resolvedConnectionTemplate) $ PGL.executeStreamingMultiplexedQuery query variables
|
|
pure $ res <&> (\(cohortId, cohortRes, cursorVariableVals) -> (cohortId, cohortRes, PG.getViaJSON cursorVariableVals))
|
|
|
|
runPGQueryExplain ::
|
|
forall pgKind m.
|
|
( MonadIO m,
|
|
MonadBaseControl IO m,
|
|
MonadError QErr m,
|
|
MonadTrace m
|
|
) =>
|
|
DBStepInfo ('Postgres pgKind) ->
|
|
m EncJSON
|
|
runPGQueryExplain (DBStepInfo _ sourceConfig _ action resolvedConnectionTemplate) =
|
|
runQueryTx (_pscExecCtx sourceConfig) (GraphQLQuery resolvedConnectionTemplate) $
|
|
runOnBaseMonad action
|
|
|
|
mkQueryLog ::
|
|
GQLReqUnparsed ->
|
|
RootFieldAlias ->
|
|
Maybe EQ.PreparedSql ->
|
|
RequestId ->
|
|
Maybe (ResolvedConnectionTemplate ('Postgres pgKind)) ->
|
|
QueryLog
|
|
mkQueryLog gqlQuery fieldName preparedSql requestId resolvedConnectionTemplate =
|
|
QueryLog gqlQuery ((fieldName,) <$> generatedQuery) requestId (QueryLogKindDatabase (mkBackendResolvedConnectionTemplate <$> resolvedConnectionTemplate))
|
|
where
|
|
mkBackendResolvedConnectionTemplate ::
|
|
ResolvedConnectionTemplate ('Postgres pgKind) ->
|
|
BackendResolvedConnectionTemplate
|
|
mkBackendResolvedConnectionTemplate =
|
|
BackendResolvedConnectionTemplate . AB.mkAnyBackend @('Postgres 'Vanilla) . ResolvedConnectionTemplateWrapper
|
|
generatedQuery =
|
|
preparedSql <&> \(EQ.PreparedSql query args) ->
|
|
GeneratedQuery (PG.getQueryText query) (J.toJSON $ pgScalarValueToJson . snd <$> args)
|
|
|
|
-- ad-hoc transaction optimisation
|
|
-- see Note [Backwards-compatible transaction optimisation]
|
|
|
|
runPGMutationTransaction ::
|
|
( MonadIO m,
|
|
MonadBaseControl IO m,
|
|
MonadError QErr m,
|
|
MonadQueryLog m,
|
|
MonadTrace m
|
|
) =>
|
|
RequestId ->
|
|
GQLReqUnparsed ->
|
|
UserInfo ->
|
|
L.Logger L.Hasura ->
|
|
SourceConfig ('Postgres pgKind) ->
|
|
ResolvedConnectionTemplate ('Postgres pgKind) ->
|
|
RootFieldMap (DBStepInfo ('Postgres pgKind)) ->
|
|
m (DiffTime, RootFieldMap EncJSON)
|
|
runPGMutationTransaction reqId query userInfo logger sourceConfig resolvedConnectionTemplate mutations = do
|
|
logQueryLog logger $ mkQueryLog query (mkUnNamespacedRootFieldAlias Name._transaction) Nothing reqId (resolvedConnectionTemplate <$ resolvedConnectionTemplate)
|
|
withElapsedTime $
|
|
runTxWithCtxAndUserInfo userInfo (_pscExecCtx sourceConfig) (Tx PG.ReadWrite Nothing) (GraphQLQuery resolvedConnectionTemplate) $
|
|
flip OMap.traverseWithKey mutations \fieldName dbsi ->
|
|
trace ("Postgres Mutation for root field " <>> fieldName) $
|
|
runOnBaseMonad $
|
|
dbsiAction dbsi
|