mirror of
https://github.com/hasura/graphql-engine.git
synced 2024-12-18 13:02:11 +03:00
7bead93827
Query plan caching was introduced by - I believe - hasura/graphql-engine#1934 in order to reduce the query response latency. During the development of PDV in hasura/graphql-engine#4111, it was found out that the new architecture (for which query plan caching wasn't implemented) performed comparably to the pre-PDV architecture with caching. Hence, it was decided to leave query plan caching until some day in the future when it was deemed necessary. Well, we're in the future now, and there still isn't a convincing argument for query plan caching. So the time has come to remove some references to query plan caching from the codebase. For the most part, any code being removed would probably not be very well suited to the post-PDV architecture of query execution, so arguably not much is lost. Apart from simplifying the code, this PR will contribute towards making the GraphQL schema generation more modular, testable, and easier to profile. I'd like to eventually work towards a situation in which it's easy to generate a GraphQL schema parser *in isolation*, without being connected to a database, and then parse a GraphQL query *in isolation*, without even listening any HTTP port. It is important that both of these operations can be examined in detail, and in isolation, since they are two major performance bottlenecks, as well as phases where many important upcoming features hook into. Implementation The following have been removed: - The entirety of `server/src-lib/Hasura/GraphQL/Execute/Plan.hs` - The core phases of query parsing and execution no longer have any references to query plan caching. Note that this is not to be confused with query *response* caching, which is not affected by this PR. This includes removal of the types: - - `Opaque`, which is replaced by a tuple. Note that the old implementation was broken and did not adequately hide the constructors. - - `QueryReusability` (and the `markNotReusable` method). Notably, the implementation of the `ParseT` monad now consists of two, rather than three, monad transformers. - Cache-related tests (in `server/src-test/Hasura/CacheBoundedSpec.hs`) have been removed . - References to query plan caching in the documentation. - The `planCacheOptions` in the `TenantConfig` type class was removed. However, during parsing, unrecognized fields in the YAML config get ignored, so this does not cause a breaking change. (Confirmed manually, as well as in consultation with @sordina.) - The metrics no longer send cache hit/miss messages. There are a few places in which one can still find references to query plan caching: - We still accept the `--query-plan-cache-size` command-line option for backwards compatibility. The `HASURA_QUERY_PLAN_CACHE_SIZE` environment variable is not read. https://github.com/hasura/graphql-engine-mono/pull/1815 GitOrigin-RevId: 17d92b254ec093c62a7dfeec478658ede0813eb7
104 lines
4.6 KiB
Haskell
104 lines
4.6 KiB
Haskell
module Hasura.GraphQL.Execute.Query
|
|
( convertQuerySelSet
|
|
, parseGraphQLQuery
|
|
) where
|
|
|
|
import Hasura.Prelude
|
|
|
|
import qualified Data.Aeson as J
|
|
import qualified Data.Environment as Env
|
|
import qualified Data.HashMap.Strict as Map
|
|
import qualified Data.HashMap.Strict.InsOrd as OMap
|
|
import qualified Language.GraphQL.Draft.Syntax as G
|
|
import qualified Network.HTTP.Client as HTTP
|
|
import qualified Network.HTTP.Types as HTTP
|
|
|
|
import qualified Hasura.GraphQL.Execute.RemoteJoin.Collect as RJ
|
|
import qualified Hasura.GraphQL.Transport.HTTP.Protocol as GH
|
|
import qualified Hasura.Logging as L
|
|
import qualified Hasura.SQL.AnyBackend as AB
|
|
|
|
import Hasura.Base.Error
|
|
import Hasura.GraphQL.Context
|
|
import Hasura.GraphQL.Execute.Action
|
|
import Hasura.GraphQL.Execute.Backend
|
|
import Hasura.GraphQL.Execute.Common
|
|
import Hasura.GraphQL.Execute.Instances ()
|
|
import Hasura.GraphQL.Execute.Remote
|
|
import Hasura.GraphQL.Execute.Resolve
|
|
import Hasura.GraphQL.Parser
|
|
import Hasura.GraphQL.Parser.Directives
|
|
import Hasura.RQL.IR
|
|
import Hasura.RQL.Types
|
|
import Hasura.Server.Version (HasVersion)
|
|
import Hasura.Session
|
|
|
|
|
|
parseGraphQLQuery
|
|
:: MonadError QErr m
|
|
=> GQLContext
|
|
-> [G.VariableDefinition]
|
|
-> Maybe (HashMap G.Name J.Value)
|
|
-> [G.Directive G.Name]
|
|
-> G.SelectionSet G.NoFragments G.Name
|
|
-> m ( InsOrdHashMap G.Name (QueryRootField UnpreparedValue)
|
|
, [G.Directive Variable]
|
|
, G.SelectionSet G.NoFragments Variable
|
|
)
|
|
parseGraphQLQuery gqlContext varDefs varValsM directives fields = do
|
|
(resolvedDirectives, resolvedSelSet) <- resolveVariables varDefs (fromMaybe Map.empty varValsM) directives fields
|
|
parsedQuery <- (gqlQueryParser gqlContext >>> (`onLeft` reportParseErrors)) resolvedSelSet
|
|
pure (parsedQuery, resolvedDirectives, resolvedSelSet)
|
|
|
|
|
|
convertQuerySelSet
|
|
:: forall m .
|
|
( MonadError QErr m
|
|
, HasVersion
|
|
, MonadGQLExecutionCheck m
|
|
)
|
|
=> Env.Environment
|
|
-> L.Logger L.Hasura
|
|
-> GQLContext
|
|
-> UserInfo
|
|
-> HTTP.Manager
|
|
-> HTTP.RequestHeaders
|
|
-> [G.Directive G.Name]
|
|
-> G.SelectionSet G.NoFragments G.Name
|
|
-> [G.VariableDefinition]
|
|
-> Maybe GH.VariableValues
|
|
-> SetGraphqlIntrospectionOptions
|
|
-> m (ExecutionPlan, [QueryRootField UnpreparedValue], G.SelectionSet G.NoFragments Variable, DirectiveMap)
|
|
convertQuerySelSet env logger gqlContext userInfo manager reqHeaders directives fields varDefs varValsM
|
|
introspectionDisabledRoles = do
|
|
-- Parse the GraphQL query into the RQL AST
|
|
(unpreparedQueries, normalizedDirectives, normalizedSelectionSet) <-
|
|
parseGraphQLQuery gqlContext varDefs varValsM directives fields
|
|
|
|
-- Transform the query plans into an execution plan
|
|
let usrVars = _uiSession userInfo
|
|
|
|
-- Process directives on the query
|
|
dirMap <- (`onLeft` reportParseErrors) =<<
|
|
runParseT (parseDirectives customDirectives (G.DLExecutable G.EDLQUERY) normalizedDirectives)
|
|
|
|
executionPlan <- for unpreparedQueries \case
|
|
RFDB sourceName exists ->
|
|
AB.dispatchAnyBackend @BackendExecute exists
|
|
\(SourceConfigWith (sourceConfig :: (SourceConfig b)) (QDBR db)) -> do
|
|
let (noRelsDBAST, remoteJoins) = RJ.getRemoteJoins db
|
|
dbStepInfo <- mkDBQueryPlan @b userInfo sourceName sourceConfig noRelsDBAST
|
|
pure $ ExecStepDB [] (AB.mkAnyBackend dbStepInfo) remoteJoins
|
|
RFRemote rf -> do
|
|
RemoteFieldG remoteSchemaInfo remoteField <- runVariableCache $ for rf $ resolveRemoteVariable userInfo
|
|
pure $ buildExecStepRemote remoteSchemaInfo G.OperationTypeQuery [G.SelectionField remoteField]
|
|
RFAction action -> do
|
|
let (noRelsDBAST, remoteJoins) = RJ.getRemoteJoinsActionQuery action
|
|
(actionExecution, actionName, fch) <- pure $ case noRelsDBAST of
|
|
AQQuery s -> (AEPSync $ resolveActionExecution env logger userInfo s (ActionExecContext manager reqHeaders usrVars), _aaeName s, _aaeForwardClientHeaders s)
|
|
AQAsync s -> (AEPAsyncQuery $ AsyncActionQueryExecutionPlan (_aaaqActionId s) $ resolveAsyncActionQuery userInfo s, _aaaqName s, _aaaqForwardClientHeaders s)
|
|
pure $ ExecStepAction actionExecution (ActionsInfo actionName fch) remoteJoins
|
|
RFRaw r -> flip onLeft throwError =<< executeIntrospection userInfo r introspectionDisabledRoles
|
|
|
|
pure (executionPlan, OMap.elems unpreparedQueries, normalizedSelectionSet, dirMap)
|