2021-09-22 18:34:53 +03:00
|
|
|
{-# LANGUAGE ApplicativeDo #-}
|
2021-04-12 13:18:29 +03:00
|
|
|
{-# OPTIONS_GHC -fno-warn-orphans #-}
|
|
|
|
|
|
|
|
module Hasura.Backends.BigQuery.Instances.Schema () where
|
|
|
|
|
2021-09-24 01:56:37 +03:00
|
|
|
import Data.Aeson qualified as J
|
|
|
|
import Data.Has
|
|
|
|
import Data.HashMap.Strict qualified as Map
|
|
|
|
import Data.List.NonEmpty qualified as NE
|
|
|
|
import Data.Text qualified as T
|
|
|
|
import Data.Text.Extended
|
|
|
|
import Hasura.Backends.BigQuery.Types qualified as BigQuery
|
|
|
|
import Hasura.Base.Error
|
|
|
|
import Hasura.GraphQL.Parser hiding (EnumValueInfo, field)
|
|
|
|
import Hasura.GraphQL.Parser qualified as P
|
|
|
|
import Hasura.GraphQL.Parser.Internal.Parser hiding (field)
|
|
|
|
import Hasura.GraphQL.Schema.Backend
|
|
|
|
import Hasura.GraphQL.Schema.BoolExp
|
|
|
|
import Hasura.GraphQL.Schema.Build qualified as GSB
|
|
|
|
import Hasura.GraphQL.Schema.Common
|
|
|
|
import Hasura.GraphQL.Schema.Select
|
|
|
|
import Hasura.Prelude
|
|
|
|
import Hasura.RQL.IR
|
|
|
|
import Hasura.RQL.IR.Select qualified as IR
|
|
|
|
import Hasura.RQL.Types
|
|
|
|
import Language.GraphQL.Draft.Syntax qualified as G
|
2021-05-11 18:18:31 +03:00
|
|
|
|
2021-04-12 13:18:29 +03:00
|
|
|
----------------------------------------------------------------
|
|
|
|
-- BackendSchema instance
|
|
|
|
|
|
|
|
instance BackendSchema 'BigQuery where
|
|
|
|
-- top level parsers
|
2021-09-24 01:56:37 +03:00
|
|
|
buildTableQueryFields = GSB.buildTableQueryFields
|
|
|
|
buildTableRelayQueryFields = bqBuildTableRelayQueryFields
|
2021-06-15 18:53:20 +03:00
|
|
|
buildTableInsertMutationFields = bqBuildTableInsertMutationFields
|
|
|
|
buildTableUpdateMutationFields = bqBuildTableUpdateMutationFields
|
|
|
|
buildTableDeleteMutationFields = bqBuildTableDeleteMutationFields
|
2021-09-24 01:56:37 +03:00
|
|
|
buildFunctionQueryFields = bqBuildFunctionQueryFields
|
|
|
|
buildFunctionRelayQueryFields = bqBuildFunctionRelayQueryFields
|
|
|
|
buildFunctionMutationFields = bqBuildFunctionMutationFields
|
2021-06-15 18:53:20 +03:00
|
|
|
|
2021-04-12 13:18:29 +03:00
|
|
|
-- backend extensions
|
2021-09-24 01:56:37 +03:00
|
|
|
relayExtension = Nothing
|
|
|
|
nodesAggExtension = Just ()
|
2021-06-15 18:53:20 +03:00
|
|
|
|
|
|
|
-- table arguments
|
|
|
|
tableArguments = bqTableArgs
|
|
|
|
|
2021-04-12 13:18:29 +03:00
|
|
|
-- indivdual components
|
2021-09-24 01:56:37 +03:00
|
|
|
columnParser = bqColumnParser
|
|
|
|
jsonPathArg = bqJsonPathArg
|
|
|
|
orderByOperators = bqOrderByOperators
|
|
|
|
comparisonExps = bqComparisonExps
|
|
|
|
mkCountType = bqMkCountType
|
2021-04-12 13:18:29 +03:00
|
|
|
aggregateOrderByCountType = BigQuery.IntegerScalarType
|
2021-09-24 01:56:37 +03:00
|
|
|
computedField = bqComputedField
|
|
|
|
node = bqNode
|
2021-06-15 18:53:20 +03:00
|
|
|
|
2021-04-12 13:18:29 +03:00
|
|
|
-- SQL literals
|
|
|
|
columnDefaultValue = error "TODO: Make impossible by the type system. BigQuery doesn't support insertions."
|
|
|
|
|
2021-10-01 15:52:19 +03:00
|
|
|
-- Extra insert data
|
|
|
|
getExtraInsertData = const ()
|
|
|
|
|
2021-04-12 13:18:29 +03:00
|
|
|
----------------------------------------------------------------
|
|
|
|
-- Top level parsers
|
|
|
|
|
2021-09-24 01:56:37 +03:00
|
|
|
bqBuildTableRelayQueryFields ::
|
|
|
|
MonadBuildSchema 'BigQuery r m n =>
|
|
|
|
SourceName ->
|
|
|
|
TableName 'BigQuery ->
|
|
|
|
TableInfo 'BigQuery ->
|
|
|
|
G.Name ->
|
|
|
|
NESeq (ColumnInfo 'BigQuery) ->
|
|
|
|
SelPermInfo 'BigQuery ->
|
2021-11-26 00:07:53 +03:00
|
|
|
m [a]
|
|
|
|
bqBuildTableRelayQueryFields _sourceName _tableName _tableInfo _gqlName _pkeyColumns _selPerms =
|
2021-06-15 18:53:20 +03:00
|
|
|
pure []
|
2021-04-12 13:18:29 +03:00
|
|
|
|
2021-09-24 01:56:37 +03:00
|
|
|
bqBuildTableInsertMutationFields ::
|
|
|
|
MonadBuildSchema 'BigQuery r m n =>
|
|
|
|
SourceName ->
|
|
|
|
TableName 'BigQuery ->
|
|
|
|
TableInfo 'BigQuery ->
|
|
|
|
G.Name ->
|
|
|
|
InsPermInfo 'BigQuery ->
|
|
|
|
Maybe (SelPermInfo 'BigQuery) ->
|
|
|
|
Maybe (UpdPermInfo 'BigQuery) ->
|
2021-11-26 00:07:53 +03:00
|
|
|
m [a]
|
|
|
|
bqBuildTableInsertMutationFields _sourceName _tableName _tableInfo _gqlName _insPerms _selPerms _updPerms =
|
2021-04-12 13:18:29 +03:00
|
|
|
pure []
|
|
|
|
|
2021-09-24 01:56:37 +03:00
|
|
|
bqBuildTableUpdateMutationFields ::
|
|
|
|
MonadBuildSchema 'BigQuery r m n =>
|
|
|
|
SourceName ->
|
|
|
|
TableName 'BigQuery ->
|
|
|
|
TableInfo 'BigQuery ->
|
|
|
|
G.Name ->
|
|
|
|
UpdPermInfo 'BigQuery ->
|
|
|
|
Maybe (SelPermInfo 'BigQuery) ->
|
2021-11-26 00:07:53 +03:00
|
|
|
m [a]
|
|
|
|
bqBuildTableUpdateMutationFields _sourceName _tableName _tableInfo _gqlName _updPerns _selPerms =
|
2021-04-12 13:18:29 +03:00
|
|
|
pure []
|
|
|
|
|
2021-09-24 01:56:37 +03:00
|
|
|
bqBuildTableDeleteMutationFields ::
|
|
|
|
MonadBuildSchema 'BigQuery r m n =>
|
|
|
|
SourceName ->
|
|
|
|
TableName 'BigQuery ->
|
|
|
|
TableInfo 'BigQuery ->
|
|
|
|
G.Name ->
|
|
|
|
DelPermInfo 'BigQuery ->
|
|
|
|
Maybe (SelPermInfo 'BigQuery) ->
|
2021-11-26 00:07:53 +03:00
|
|
|
m [a]
|
|
|
|
bqBuildTableDeleteMutationFields _sourceName _tableName _tableInfo _gqlName _delPerns _selPerms =
|
2021-04-12 13:18:29 +03:00
|
|
|
pure []
|
|
|
|
|
2021-09-24 01:56:37 +03:00
|
|
|
bqBuildFunctionQueryFields ::
|
|
|
|
MonadBuildSchema 'BigQuery r m n =>
|
|
|
|
SourceName ->
|
|
|
|
FunctionName 'BigQuery ->
|
|
|
|
FunctionInfo 'BigQuery ->
|
|
|
|
TableName 'BigQuery ->
|
|
|
|
SelPermInfo 'BigQuery ->
|
2021-11-26 00:07:53 +03:00
|
|
|
m [a]
|
|
|
|
bqBuildFunctionQueryFields _ _ _ _ _ =
|
2021-04-12 13:18:29 +03:00
|
|
|
pure []
|
|
|
|
|
2021-09-24 01:56:37 +03:00
|
|
|
bqBuildFunctionRelayQueryFields ::
|
|
|
|
MonadBuildSchema 'BigQuery r m n =>
|
|
|
|
SourceName ->
|
|
|
|
FunctionName 'BigQuery ->
|
|
|
|
FunctionInfo 'BigQuery ->
|
|
|
|
TableName 'BigQuery ->
|
|
|
|
NESeq (ColumnInfo 'BigQuery) ->
|
|
|
|
SelPermInfo 'BigQuery ->
|
2021-11-26 00:07:53 +03:00
|
|
|
m [a]
|
|
|
|
bqBuildFunctionRelayQueryFields _sourceName _functionName _functionInfo _tableName _pkeyColumns _selPerms =
|
2021-06-15 18:53:20 +03:00
|
|
|
pure []
|
2021-04-12 13:18:29 +03:00
|
|
|
|
2021-09-24 01:56:37 +03:00
|
|
|
bqBuildFunctionMutationFields ::
|
|
|
|
MonadBuildSchema 'BigQuery r m n =>
|
|
|
|
SourceName ->
|
|
|
|
FunctionName 'BigQuery ->
|
|
|
|
FunctionInfo 'BigQuery ->
|
|
|
|
TableName 'BigQuery ->
|
|
|
|
SelPermInfo 'BigQuery ->
|
2021-11-26 00:07:53 +03:00
|
|
|
m [a]
|
|
|
|
bqBuildFunctionMutationFields _ _ _ _ _ =
|
2021-04-12 13:18:29 +03:00
|
|
|
pure []
|
|
|
|
|
2021-06-15 18:53:20 +03:00
|
|
|
----------------------------------------------------------------
|
|
|
|
-- Table arguments
|
|
|
|
|
2021-09-24 01:56:37 +03:00
|
|
|
bqTableArgs ::
|
|
|
|
forall r m n.
|
|
|
|
MonadBuildSchema 'BigQuery r m n =>
|
|
|
|
SourceName ->
|
|
|
|
TableInfo 'BigQuery ->
|
|
|
|
SelPermInfo 'BigQuery ->
|
|
|
|
m (InputFieldsParser n (IR.SelectArgsG 'BigQuery (UnpreparedValue 'BigQuery)))
|
2021-06-15 18:53:20 +03:00
|
|
|
bqTableArgs sourceName tableInfo selectPermissions = do
|
2021-09-24 01:56:37 +03:00
|
|
|
whereParser <- tableWhereArg sourceName tableInfo selectPermissions
|
2021-06-15 18:53:20 +03:00
|
|
|
orderByParser <- tableOrderByArg sourceName tableInfo selectPermissions
|
|
|
|
pure do
|
2021-09-24 01:56:37 +03:00
|
|
|
whereArg <- whereParser
|
2021-06-15 18:53:20 +03:00
|
|
|
orderByArg <- orderByParser
|
2021-09-24 01:56:37 +03:00
|
|
|
limitArg <- tableLimitArg
|
|
|
|
offsetArg <- tableOffsetArg
|
|
|
|
pure $
|
|
|
|
IR.SelectArgs
|
|
|
|
{ IR._saWhere = whereArg,
|
|
|
|
IR._saOrderBy = orderByArg,
|
|
|
|
IR._saLimit = limitArg,
|
|
|
|
IR._saOffset = offsetArg,
|
|
|
|
-- not supported on BigQuery for now
|
|
|
|
IR._saDistinct = Nothing
|
|
|
|
}
|
2021-06-15 18:53:20 +03:00
|
|
|
|
2021-04-12 13:18:29 +03:00
|
|
|
----------------------------------------------------------------
|
|
|
|
-- Individual components
|
|
|
|
|
2021-09-24 01:56:37 +03:00
|
|
|
bqColumnParser ::
|
2021-10-29 17:42:07 +03:00
|
|
|
(MonadSchema n m, MonadError QErr m, MonadReader r m, Has MkTypename r) =>
|
2021-09-24 01:56:37 +03:00
|
|
|
ColumnType 'BigQuery ->
|
|
|
|
G.Nullability ->
|
|
|
|
m (Parser 'Both n (ValueWithOrigin (ColumnValue 'BigQuery)))
|
2021-06-15 18:53:20 +03:00
|
|
|
bqColumnParser columnType (G.Nullability isNullable) =
|
server: remove remnants of query plan caching (fix #1795)
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
2021-07-27 14:51:52 +03:00
|
|
|
peelWithOrigin . fmap (ColumnValue columnType) <$> case columnType of
|
2021-04-12 13:18:29 +03:00
|
|
|
ColumnScalar scalarType -> case scalarType of
|
|
|
|
-- bytestrings
|
|
|
|
-- we only accept string literals
|
2021-09-24 01:56:37 +03:00
|
|
|
BigQuery.BytesScalarType -> pure $ possiblyNullable scalarType $ BigQuery.StringValue <$> P.string
|
2021-04-12 13:18:29 +03:00
|
|
|
-- text
|
2021-09-24 01:56:37 +03:00
|
|
|
BigQuery.StringScalarType -> pure $ possiblyNullable scalarType $ BigQuery.StringValue <$> P.string
|
2021-04-12 13:18:29 +03:00
|
|
|
-- floating point values
|
|
|
|
-- TODO: we do not perform size checks here, meaning we would accept an
|
|
|
|
-- out-of-bounds value as long as it can be represented by a GraphQL float; this
|
|
|
|
-- will in all likelihood error on the BigQuery side. Do we want to handle those
|
|
|
|
-- properly here?
|
2021-09-24 01:56:37 +03:00
|
|
|
BigQuery.FloatScalarType -> pure $ possiblyNullable scalarType $ BigQuery.FloatValue . BigQuery.doubleToFloat64 <$> P.float
|
|
|
|
BigQuery.IntegerScalarType -> pure $ possiblyNullable scalarType $ BigQuery.IntegerValue . BigQuery.intToInt64 . fromIntegral <$> P.int
|
|
|
|
BigQuery.DecimalScalarType -> pure $ possiblyNullable scalarType $ BigQuery.DecimalValue . BigQuery.doubleToDecimal <$> P.float
|
|
|
|
BigQuery.BigDecimalScalarType -> pure $ possiblyNullable scalarType $ BigQuery.BigDecimalValue . BigQuery.doubleToBigDecimal <$> P.float
|
2021-04-12 13:18:29 +03:00
|
|
|
-- boolean type
|
2021-09-24 01:56:37 +03:00
|
|
|
BigQuery.BoolScalarType -> pure $ possiblyNullable scalarType $ BigQuery.BoolValue <$> P.boolean
|
|
|
|
BigQuery.DateScalarType -> pure $ possiblyNullable scalarType $ BigQuery.DateValue . BigQuery.Date <$> P.string
|
|
|
|
BigQuery.TimeScalarType -> pure $ possiblyNullable scalarType $ BigQuery.TimeValue . BigQuery.Time <$> P.string
|
|
|
|
BigQuery.DatetimeScalarType -> pure $ possiblyNullable scalarType $ BigQuery.DatetimeValue . BigQuery.Datetime <$> P.string
|
|
|
|
BigQuery.GeographyScalarType -> pure $ possiblyNullable scalarType $ BigQuery.GeographyValue . BigQuery.Geography <$> P.string
|
2021-04-22 14:31:54 +03:00
|
|
|
BigQuery.TimestampScalarType -> do
|
2021-10-29 17:42:07 +03:00
|
|
|
let schemaType = P.Nullable . P.TNamed $ P.mkDefinition (P.Typename stringScalar) Nothing P.TIScalar
|
2021-09-24 01:56:37 +03:00
|
|
|
pure $
|
|
|
|
possiblyNullable scalarType $
|
|
|
|
Parser
|
|
|
|
{ pType = schemaType,
|
|
|
|
pParser =
|
|
|
|
valueToJSON (P.toGraphQLType schemaType)
|
|
|
|
>=> fmap (BigQuery.StringValue . BigQuery.utctimeToISO8601Text)
|
|
|
|
. either (parseErrorWith ParseFailed . qeError) pure
|
|
|
|
. runAesonParser (J.withText "TimestampColumn" BigQuery.textToUTCTime)
|
|
|
|
}
|
2021-05-11 18:18:31 +03:00
|
|
|
ty -> throwError $ internalError $ T.pack $ "Type currently unsupported for BigQuery: " ++ show ty
|
2021-04-12 13:18:29 +03:00
|
|
|
ColumnEnumReference (EnumReference tableName enumValues) ->
|
|
|
|
case nonEmpty (Map.toList enumValues) of
|
|
|
|
Just enumValuesList -> do
|
2021-04-22 00:44:37 +03:00
|
|
|
tableGQLName <- tableGraphQLName @'BigQuery tableName `onLeft` throwError
|
2021-10-29 17:42:07 +03:00
|
|
|
enumName <- P.mkTypename $ tableGQLName <> $$(G.litName "_enum")
|
2021-04-12 13:18:29 +03:00
|
|
|
pure $ possiblyNullable BigQuery.StringScalarType $ P.enum enumName Nothing (mkEnumValue <$> enumValuesList)
|
|
|
|
Nothing -> throw400 ValidationFailed "empty enum values"
|
|
|
|
where
|
|
|
|
possiblyNullable _scalarType
|
|
|
|
| isNullable = fmap (fromMaybe BigQuery.NullValue) . P.nullable
|
2021-09-24 01:56:37 +03:00
|
|
|
| otherwise = id
|
2021-04-12 13:18:29 +03:00
|
|
|
mkEnumValue :: (EnumValue, EnumValueInfo) -> (P.Definition P.EnumValueInfo, ScalarValue 'BigQuery)
|
|
|
|
mkEnumValue (EnumValue value, EnumValueInfo description) =
|
2021-09-24 01:56:37 +03:00
|
|
|
( P.mkDefinition value (G.Description <$> description) P.EnumValueInfo,
|
|
|
|
BigQuery.StringValue $ G.unName value
|
2021-04-12 13:18:29 +03:00
|
|
|
)
|
|
|
|
throughJSON scalarName =
|
|
|
|
let schemaType = P.NonNullable $ P.TNamed $ P.mkDefinition scalarName Nothing P.TIScalar
|
2021-09-24 01:56:37 +03:00
|
|
|
in Parser
|
|
|
|
{ pType = schemaType,
|
|
|
|
pParser =
|
|
|
|
valueToJSON (P.toGraphQLType schemaType)
|
|
|
|
>=> either (parseErrorWith ParseFailed . qeError) pure . runAesonParser J.parseJSON
|
|
|
|
}
|
|
|
|
|
|
|
|
bqJsonPathArg ::
|
|
|
|
MonadParse n =>
|
|
|
|
ColumnType 'BigQuery ->
|
|
|
|
InputFieldsParser n (Maybe (IR.ColumnOp 'BigQuery))
|
2021-06-15 18:53:20 +03:00
|
|
|
bqJsonPathArg _columnType = pure Nothing
|
2021-04-12 13:18:29 +03:00
|
|
|
|
2021-09-24 01:56:37 +03:00
|
|
|
bqOrderByOperators ::
|
|
|
|
NonEmpty
|
|
|
|
( Definition P.EnumValueInfo,
|
|
|
|
(BasicOrderType 'BigQuery, NullsOrderType 'BigQuery)
|
2021-04-12 13:18:29 +03:00
|
|
|
)
|
2021-09-24 01:56:37 +03:00
|
|
|
bqOrderByOperators =
|
|
|
|
NE.fromList
|
|
|
|
[ ( define $$(G.litName "asc") "in ascending order, nulls first",
|
|
|
|
(BigQuery.AscOrder, BigQuery.NullsFirst)
|
|
|
|
),
|
|
|
|
( define $$(G.litName "asc_nulls_first") "in ascending order, nulls first",
|
|
|
|
(BigQuery.AscOrder, BigQuery.NullsFirst)
|
|
|
|
),
|
|
|
|
( define $$(G.litName "asc_nulls_last") "in ascending order, nulls last",
|
|
|
|
(BigQuery.AscOrder, BigQuery.NullsLast)
|
|
|
|
),
|
|
|
|
( define $$(G.litName "desc") "in descending order, nulls last",
|
|
|
|
(BigQuery.DescOrder, BigQuery.NullsLast)
|
|
|
|
),
|
|
|
|
( define $$(G.litName "desc_nulls_first") "in descending order, nulls first",
|
|
|
|
(BigQuery.DescOrder, BigQuery.NullsFirst)
|
|
|
|
),
|
|
|
|
( define $$(G.litName "desc_nulls_last") "in descending order, nulls last",
|
|
|
|
(BigQuery.DescOrder, BigQuery.NullsLast)
|
|
|
|
)
|
|
|
|
]
|
2021-04-12 13:18:29 +03:00
|
|
|
where
|
|
|
|
define name desc = P.mkDefinition name (Just desc) P.EnumValueInfo
|
|
|
|
|
2021-09-24 01:56:37 +03:00
|
|
|
bqComparisonExps ::
|
|
|
|
forall m n r.
|
2021-10-29 17:42:07 +03:00
|
|
|
(BackendSchema 'BigQuery, MonadSchema n m, MonadError QErr m, MonadReader r m, Has QueryContext r, Has MkTypename r) =>
|
2021-09-24 01:56:37 +03:00
|
|
|
ColumnType 'BigQuery ->
|
|
|
|
m (Parser 'Input n [ComparisonExp 'BigQuery])
|
2021-06-15 18:53:20 +03:00
|
|
|
bqComparisonExps = P.memoize 'comparisonExps $ \columnType -> do
|
2021-08-06 22:57:37 +03:00
|
|
|
collapseIfNull <- asks $ qcDangerousBooleanCollapse . getter
|
2021-04-12 13:18:29 +03:00
|
|
|
-- see Note [Columns in comparison expression are never nullable]
|
2021-09-24 01:56:37 +03:00
|
|
|
typedParser <- columnParser columnType (G.Nullability False)
|
2021-04-22 00:44:37 +03:00
|
|
|
nullableTextParser <- columnParser (ColumnScalar @'BigQuery BigQuery.StringScalarType) (G.Nullability True)
|
2021-10-29 17:42:07 +03:00
|
|
|
-- textParser <- columnParser (ColumnScalar @'BigQuery BigQuery.StringScalarType) (G.Nullability False)
|
|
|
|
let name = P.Typename $ P.getName typedParser <> $$(G.litName "_BigQuery_comparison_exp")
|
2021-09-24 01:56:37 +03:00
|
|
|
desc =
|
|
|
|
G.Description $
|
|
|
|
"Boolean expression to compare columns of type "
|
|
|
|
<> P.getName typedParser
|
|
|
|
<<> ". All fields are combined with logical 'AND'."
|
2021-10-29 17:42:07 +03:00
|
|
|
-- textListParser = fmap openValueOrigin <$> P.list textParser
|
server: remove remnants of query plan caching (fix #1795)
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
2021-07-27 14:51:52 +03:00
|
|
|
columnListParser = fmap openValueOrigin <$> P.list typedParser
|
2021-08-06 22:57:37 +03:00
|
|
|
mkListLiteral :: [ColumnValue 'BigQuery] -> UnpreparedValue 'BigQuery
|
|
|
|
mkListLiteral =
|
|
|
|
P.UVLiteral . BigQuery.ListExpression . fmap (BigQuery.ValueExpression . cvValue)
|
2021-09-24 01:56:37 +03:00
|
|
|
pure $
|
|
|
|
P.object name (Just desc) $
|
|
|
|
fmap catMaybes $
|
|
|
|
sequenceA $
|
|
|
|
concat
|
|
|
|
[ equalityOperators
|
|
|
|
collapseIfNull
|
|
|
|
(mkParameter <$> typedParser)
|
|
|
|
(mkListLiteral <$> columnListParser),
|
|
|
|
comparisonOperators
|
|
|
|
collapseIfNull
|
|
|
|
(mkParameter <$> typedParser)
|
|
|
|
]
|
|
|
|
|
|
|
|
bqMkCountType ::
|
|
|
|
-- | distinct values
|
|
|
|
Maybe Bool ->
|
|
|
|
Maybe [Column 'BigQuery] ->
|
|
|
|
CountType 'BigQuery
|
|
|
|
bqMkCountType _ Nothing = BigQuery.StarCountable
|
2021-06-15 18:53:20 +03:00
|
|
|
bqMkCountType (Just True) (Just cols) =
|
2021-04-12 13:18:29 +03:00
|
|
|
maybe BigQuery.StarCountable BigQuery.DistinctCountable $ nonEmpty cols
|
2021-09-24 01:56:37 +03:00
|
|
|
bqMkCountType _ (Just cols) =
|
2021-04-12 13:18:29 +03:00
|
|
|
maybe BigQuery.StarCountable BigQuery.NonNullFieldCountable $ nonEmpty cols
|
|
|
|
|
|
|
|
-- | Computed field parser.
|
|
|
|
-- Currently unsupported: returns Nothing for now.
|
2021-09-24 01:56:37 +03:00
|
|
|
bqComputedField ::
|
|
|
|
MonadBuildSchema 'BigQuery r m n =>
|
|
|
|
SourceName ->
|
|
|
|
ComputedFieldInfo 'BigQuery ->
|
|
|
|
TableName 'BigQuery ->
|
|
|
|
SelPermInfo 'BigQuery ->
|
|
|
|
m (Maybe (FieldParser n (AnnotatedField 'BigQuery)))
|
2021-06-15 18:53:20 +03:00
|
|
|
bqComputedField _sourceName _fieldInfo _table _selectPemissions = pure Nothing
|
2021-05-20 09:28:35 +03:00
|
|
|
|
2021-04-12 13:18:29 +03:00
|
|
|
-- | Remote join field parser.
|
|
|
|
-- Currently unsupported: returns Nothing for now.
|
2021-09-24 01:56:37 +03:00
|
|
|
bqRemoteRelationshipField ::
|
|
|
|
MonadBuildSchema 'BigQuery r m n =>
|
|
|
|
RemoteFieldInfo 'BigQuery ->
|
|
|
|
m (Maybe [FieldParser n (AnnotatedField 'BigQuery)])
|
2021-06-15 18:53:20 +03:00
|
|
|
bqRemoteRelationshipField _remoteFieldInfo = pure Nothing
|
2021-04-12 13:18:29 +03:00
|
|
|
|
|
|
|
-- | The 'node' root field of a Relay request. Relay is currently unsupported on BigQuery,
|
|
|
|
-- meaning this parser will never be called: any attempt to create this parser should
|
|
|
|
-- therefore fail.
|
2021-09-24 01:56:37 +03:00
|
|
|
bqNode ::
|
|
|
|
MonadBuildSchema 'BigQuery r m n =>
|
|
|
|
m
|
|
|
|
( Parser
|
|
|
|
'Output
|
|
|
|
n
|
|
|
|
( HashMap
|
|
|
|
(TableName 'BigQuery)
|
|
|
|
( SourceName,
|
|
|
|
SourceConfig 'BigQuery,
|
|
|
|
SelPermInfo 'BigQuery,
|
|
|
|
PrimaryKeyColumns 'BigQuery,
|
|
|
|
AnnotatedFields 'BigQuery
|
|
|
|
)
|
|
|
|
)
|
|
|
|
)
|
2021-06-15 18:53:20 +03:00
|
|
|
bqNode = throw500 "BigQuery does not support relay; `node` should never be exposed in the schema."
|