{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.RDS.Types.ConnectionPoolConfigurationInfo
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.RDS.Types.ConnectionPoolConfigurationInfo where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude

-- | Displays the settings that control the size and behavior of the
-- connection pool associated with a @DBProxyTarget@.
--
-- /See:/ 'newConnectionPoolConfigurationInfo' smart constructor.
data ConnectionPoolConfigurationInfo = ConnectionPoolConfigurationInfo'
  { -- | Controls how actively the proxy closes idle database connections in the
    -- connection pool. A high value enables the proxy to leave a high
    -- percentage of idle connections open. A low value causes the proxy to
    -- close idle client connections and return the underlying database
    -- connections to the connection pool. For Aurora MySQL, it is expressed as
    -- a percentage of the @max_connections@ setting for the RDS DB instance or
    -- Aurora DB cluster used by the target group.
    ConnectionPoolConfigurationInfo -> Maybe Int
maxIdleConnectionsPercent :: Prelude.Maybe Prelude.Int,
    -- | Each item in the list represents a class of SQL operations that normally
    -- cause all later statements in a session using a proxy to be pinned to
    -- the same underlying database connection. Including an item in the list
    -- exempts that class of SQL operations from the pinning behavior.
    -- Currently, the only allowed value is @EXCLUDE_VARIABLE_SETS@.
    ConnectionPoolConfigurationInfo -> Maybe [Text]
sessionPinningFilters :: Prelude.Maybe [Prelude.Text],
    -- | The maximum size of the connection pool for each target in a target
    -- group. For Aurora MySQL, it is expressed as a percentage of the
    -- @max_connections@ setting for the RDS DB instance or Aurora DB cluster
    -- used by the target group.
    ConnectionPoolConfigurationInfo -> Maybe Int
maxConnectionsPercent :: Prelude.Maybe Prelude.Int,
    -- | The number of seconds for a proxy to wait for a connection to become
    -- available in the connection pool. Only applies when the proxy has opened
    -- its maximum number of connections and all connections are busy with
    -- client sessions.
    ConnectionPoolConfigurationInfo -> Maybe Int
connectionBorrowTimeout :: Prelude.Maybe Prelude.Int,
    -- | One or more SQL statements for the proxy to run when opening each new
    -- database connection. Typically used with @SET@ statements to make sure
    -- that each connection has identical settings such as time zone and
    -- character set. This setting is empty by default. For multiple
    -- statements, use semicolons as the separator. You can also include
    -- multiple variables in a single @SET@ statement, such as @SET x=1, y=2@.
    ConnectionPoolConfigurationInfo -> Maybe Text
initQuery :: Prelude.Maybe Prelude.Text
  }
  deriving (ConnectionPoolConfigurationInfo
-> ConnectionPoolConfigurationInfo -> Bool
(ConnectionPoolConfigurationInfo
 -> ConnectionPoolConfigurationInfo -> Bool)
-> (ConnectionPoolConfigurationInfo
    -> ConnectionPoolConfigurationInfo -> Bool)
-> Eq ConnectionPoolConfigurationInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConnectionPoolConfigurationInfo
-> ConnectionPoolConfigurationInfo -> Bool
$c/= :: ConnectionPoolConfigurationInfo
-> ConnectionPoolConfigurationInfo -> Bool
== :: ConnectionPoolConfigurationInfo
-> ConnectionPoolConfigurationInfo -> Bool
$c== :: ConnectionPoolConfigurationInfo
-> ConnectionPoolConfigurationInfo -> Bool
Prelude.Eq, ReadPrec [ConnectionPoolConfigurationInfo]
ReadPrec ConnectionPoolConfigurationInfo
Int -> ReadS ConnectionPoolConfigurationInfo
ReadS [ConnectionPoolConfigurationInfo]
(Int -> ReadS ConnectionPoolConfigurationInfo)
-> ReadS [ConnectionPoolConfigurationInfo]
-> ReadPrec ConnectionPoolConfigurationInfo
-> ReadPrec [ConnectionPoolConfigurationInfo]
-> Read ConnectionPoolConfigurationInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ConnectionPoolConfigurationInfo]
$creadListPrec :: ReadPrec [ConnectionPoolConfigurationInfo]
readPrec :: ReadPrec ConnectionPoolConfigurationInfo
$creadPrec :: ReadPrec ConnectionPoolConfigurationInfo
readList :: ReadS [ConnectionPoolConfigurationInfo]
$creadList :: ReadS [ConnectionPoolConfigurationInfo]
readsPrec :: Int -> ReadS ConnectionPoolConfigurationInfo
$creadsPrec :: Int -> ReadS ConnectionPoolConfigurationInfo
Prelude.Read, Int -> ConnectionPoolConfigurationInfo -> ShowS
[ConnectionPoolConfigurationInfo] -> ShowS
ConnectionPoolConfigurationInfo -> String
(Int -> ConnectionPoolConfigurationInfo -> ShowS)
-> (ConnectionPoolConfigurationInfo -> String)
-> ([ConnectionPoolConfigurationInfo] -> ShowS)
-> Show ConnectionPoolConfigurationInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConnectionPoolConfigurationInfo] -> ShowS
$cshowList :: [ConnectionPoolConfigurationInfo] -> ShowS
show :: ConnectionPoolConfigurationInfo -> String
$cshow :: ConnectionPoolConfigurationInfo -> String
showsPrec :: Int -> ConnectionPoolConfigurationInfo -> ShowS
$cshowsPrec :: Int -> ConnectionPoolConfigurationInfo -> ShowS
Prelude.Show, (forall x.
 ConnectionPoolConfigurationInfo
 -> Rep ConnectionPoolConfigurationInfo x)
-> (forall x.
    Rep ConnectionPoolConfigurationInfo x
    -> ConnectionPoolConfigurationInfo)
-> Generic ConnectionPoolConfigurationInfo
forall x.
Rep ConnectionPoolConfigurationInfo x
-> ConnectionPoolConfigurationInfo
forall x.
ConnectionPoolConfigurationInfo
-> Rep ConnectionPoolConfigurationInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ConnectionPoolConfigurationInfo x
-> ConnectionPoolConfigurationInfo
$cfrom :: forall x.
ConnectionPoolConfigurationInfo
-> Rep ConnectionPoolConfigurationInfo x
Prelude.Generic)

-- |
-- Create a value of 'ConnectionPoolConfigurationInfo' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'maxIdleConnectionsPercent', 'connectionPoolConfigurationInfo_maxIdleConnectionsPercent' - Controls how actively the proxy closes idle database connections in the
-- connection pool. A high value enables the proxy to leave a high
-- percentage of idle connections open. A low value causes the proxy to
-- close idle client connections and return the underlying database
-- connections to the connection pool. For Aurora MySQL, it is expressed as
-- a percentage of the @max_connections@ setting for the RDS DB instance or
-- Aurora DB cluster used by the target group.
--
-- 'sessionPinningFilters', 'connectionPoolConfigurationInfo_sessionPinningFilters' - Each item in the list represents a class of SQL operations that normally
-- cause all later statements in a session using a proxy to be pinned to
-- the same underlying database connection. Including an item in the list
-- exempts that class of SQL operations from the pinning behavior.
-- Currently, the only allowed value is @EXCLUDE_VARIABLE_SETS@.
--
-- 'maxConnectionsPercent', 'connectionPoolConfigurationInfo_maxConnectionsPercent' - The maximum size of the connection pool for each target in a target
-- group. For Aurora MySQL, it is expressed as a percentage of the
-- @max_connections@ setting for the RDS DB instance or Aurora DB cluster
-- used by the target group.
--
-- 'connectionBorrowTimeout', 'connectionPoolConfigurationInfo_connectionBorrowTimeout' - The number of seconds for a proxy to wait for a connection to become
-- available in the connection pool. Only applies when the proxy has opened
-- its maximum number of connections and all connections are busy with
-- client sessions.
--
-- 'initQuery', 'connectionPoolConfigurationInfo_initQuery' - One or more SQL statements for the proxy to run when opening each new
-- database connection. Typically used with @SET@ statements to make sure
-- that each connection has identical settings such as time zone and
-- character set. This setting is empty by default. For multiple
-- statements, use semicolons as the separator. You can also include
-- multiple variables in a single @SET@ statement, such as @SET x=1, y=2@.
newConnectionPoolConfigurationInfo ::
  ConnectionPoolConfigurationInfo
newConnectionPoolConfigurationInfo :: ConnectionPoolConfigurationInfo
newConnectionPoolConfigurationInfo =
  ConnectionPoolConfigurationInfo' :: Maybe Int
-> Maybe [Text]
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> ConnectionPoolConfigurationInfo
ConnectionPoolConfigurationInfo'
    { $sel:maxIdleConnectionsPercent:ConnectionPoolConfigurationInfo' :: Maybe Int
maxIdleConnectionsPercent =
        Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:sessionPinningFilters:ConnectionPoolConfigurationInfo' :: Maybe [Text]
sessionPinningFilters = Maybe [Text]
forall a. Maybe a
Prelude.Nothing,
      $sel:maxConnectionsPercent:ConnectionPoolConfigurationInfo' :: Maybe Int
maxConnectionsPercent = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:connectionBorrowTimeout:ConnectionPoolConfigurationInfo' :: Maybe Int
connectionBorrowTimeout = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:initQuery:ConnectionPoolConfigurationInfo' :: Maybe Text
initQuery = Maybe Text
forall a. Maybe a
Prelude.Nothing
    }

-- | Controls how actively the proxy closes idle database connections in the
-- connection pool. A high value enables the proxy to leave a high
-- percentage of idle connections open. A low value causes the proxy to
-- close idle client connections and return the underlying database
-- connections to the connection pool. For Aurora MySQL, it is expressed as
-- a percentage of the @max_connections@ setting for the RDS DB instance or
-- Aurora DB cluster used by the target group.
connectionPoolConfigurationInfo_maxIdleConnectionsPercent :: Lens.Lens' ConnectionPoolConfigurationInfo (Prelude.Maybe Prelude.Int)
connectionPoolConfigurationInfo_maxIdleConnectionsPercent :: (Maybe Int -> f (Maybe Int))
-> ConnectionPoolConfigurationInfo
-> f ConnectionPoolConfigurationInfo
connectionPoolConfigurationInfo_maxIdleConnectionsPercent = (ConnectionPoolConfigurationInfo -> Maybe Int)
-> (ConnectionPoolConfigurationInfo
    -> Maybe Int -> ConnectionPoolConfigurationInfo)
-> Lens
     ConnectionPoolConfigurationInfo
     ConnectionPoolConfigurationInfo
     (Maybe Int)
     (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectionPoolConfigurationInfo' {Maybe Int
maxIdleConnectionsPercent :: Maybe Int
$sel:maxIdleConnectionsPercent:ConnectionPoolConfigurationInfo' :: ConnectionPoolConfigurationInfo -> Maybe Int
maxIdleConnectionsPercent} -> Maybe Int
maxIdleConnectionsPercent) (\s :: ConnectionPoolConfigurationInfo
s@ConnectionPoolConfigurationInfo' {} Maybe Int
a -> ConnectionPoolConfigurationInfo
s {$sel:maxIdleConnectionsPercent:ConnectionPoolConfigurationInfo' :: Maybe Int
maxIdleConnectionsPercent = Maybe Int
a} :: ConnectionPoolConfigurationInfo)

-- | Each item in the list represents a class of SQL operations that normally
-- cause all later statements in a session using a proxy to be pinned to
-- the same underlying database connection. Including an item in the list
-- exempts that class of SQL operations from the pinning behavior.
-- Currently, the only allowed value is @EXCLUDE_VARIABLE_SETS@.
connectionPoolConfigurationInfo_sessionPinningFilters :: Lens.Lens' ConnectionPoolConfigurationInfo (Prelude.Maybe [Prelude.Text])
connectionPoolConfigurationInfo_sessionPinningFilters :: (Maybe [Text] -> f (Maybe [Text]))
-> ConnectionPoolConfigurationInfo
-> f ConnectionPoolConfigurationInfo
connectionPoolConfigurationInfo_sessionPinningFilters = (ConnectionPoolConfigurationInfo -> Maybe [Text])
-> (ConnectionPoolConfigurationInfo
    -> Maybe [Text] -> ConnectionPoolConfigurationInfo)
-> Lens
     ConnectionPoolConfigurationInfo
     ConnectionPoolConfigurationInfo
     (Maybe [Text])
     (Maybe [Text])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectionPoolConfigurationInfo' {Maybe [Text]
sessionPinningFilters :: Maybe [Text]
$sel:sessionPinningFilters:ConnectionPoolConfigurationInfo' :: ConnectionPoolConfigurationInfo -> Maybe [Text]
sessionPinningFilters} -> Maybe [Text]
sessionPinningFilters) (\s :: ConnectionPoolConfigurationInfo
s@ConnectionPoolConfigurationInfo' {} Maybe [Text]
a -> ConnectionPoolConfigurationInfo
s {$sel:sessionPinningFilters:ConnectionPoolConfigurationInfo' :: Maybe [Text]
sessionPinningFilters = Maybe [Text]
a} :: ConnectionPoolConfigurationInfo) ((Maybe [Text] -> f (Maybe [Text]))
 -> ConnectionPoolConfigurationInfo
 -> f ConnectionPoolConfigurationInfo)
-> ((Maybe [Text] -> f (Maybe [Text]))
    -> Maybe [Text] -> f (Maybe [Text]))
-> (Maybe [Text] -> f (Maybe [Text]))
-> ConnectionPoolConfigurationInfo
-> f ConnectionPoolConfigurationInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Text] [Text] [Text] [Text]
-> Iso (Maybe [Text]) (Maybe [Text]) (Maybe [Text]) (Maybe [Text])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Text] [Text] [Text] [Text]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The maximum size of the connection pool for each target in a target
-- group. For Aurora MySQL, it is expressed as a percentage of the
-- @max_connections@ setting for the RDS DB instance or Aurora DB cluster
-- used by the target group.
connectionPoolConfigurationInfo_maxConnectionsPercent :: Lens.Lens' ConnectionPoolConfigurationInfo (Prelude.Maybe Prelude.Int)
connectionPoolConfigurationInfo_maxConnectionsPercent :: (Maybe Int -> f (Maybe Int))
-> ConnectionPoolConfigurationInfo
-> f ConnectionPoolConfigurationInfo
connectionPoolConfigurationInfo_maxConnectionsPercent = (ConnectionPoolConfigurationInfo -> Maybe Int)
-> (ConnectionPoolConfigurationInfo
    -> Maybe Int -> ConnectionPoolConfigurationInfo)
-> Lens
     ConnectionPoolConfigurationInfo
     ConnectionPoolConfigurationInfo
     (Maybe Int)
     (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectionPoolConfigurationInfo' {Maybe Int
maxConnectionsPercent :: Maybe Int
$sel:maxConnectionsPercent:ConnectionPoolConfigurationInfo' :: ConnectionPoolConfigurationInfo -> Maybe Int
maxConnectionsPercent} -> Maybe Int
maxConnectionsPercent) (\s :: ConnectionPoolConfigurationInfo
s@ConnectionPoolConfigurationInfo' {} Maybe Int
a -> ConnectionPoolConfigurationInfo
s {$sel:maxConnectionsPercent:ConnectionPoolConfigurationInfo' :: Maybe Int
maxConnectionsPercent = Maybe Int
a} :: ConnectionPoolConfigurationInfo)

-- | The number of seconds for a proxy to wait for a connection to become
-- available in the connection pool. Only applies when the proxy has opened
-- its maximum number of connections and all connections are busy with
-- client sessions.
connectionPoolConfigurationInfo_connectionBorrowTimeout :: Lens.Lens' ConnectionPoolConfigurationInfo (Prelude.Maybe Prelude.Int)
connectionPoolConfigurationInfo_connectionBorrowTimeout :: (Maybe Int -> f (Maybe Int))
-> ConnectionPoolConfigurationInfo
-> f ConnectionPoolConfigurationInfo
connectionPoolConfigurationInfo_connectionBorrowTimeout = (ConnectionPoolConfigurationInfo -> Maybe Int)
-> (ConnectionPoolConfigurationInfo
    -> Maybe Int -> ConnectionPoolConfigurationInfo)
-> Lens
     ConnectionPoolConfigurationInfo
     ConnectionPoolConfigurationInfo
     (Maybe Int)
     (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectionPoolConfigurationInfo' {Maybe Int
connectionBorrowTimeout :: Maybe Int
$sel:connectionBorrowTimeout:ConnectionPoolConfigurationInfo' :: ConnectionPoolConfigurationInfo -> Maybe Int
connectionBorrowTimeout} -> Maybe Int
connectionBorrowTimeout) (\s :: ConnectionPoolConfigurationInfo
s@ConnectionPoolConfigurationInfo' {} Maybe Int
a -> ConnectionPoolConfigurationInfo
s {$sel:connectionBorrowTimeout:ConnectionPoolConfigurationInfo' :: Maybe Int
connectionBorrowTimeout = Maybe Int
a} :: ConnectionPoolConfigurationInfo)

-- | One or more SQL statements for the proxy to run when opening each new
-- database connection. Typically used with @SET@ statements to make sure
-- that each connection has identical settings such as time zone and
-- character set. This setting is empty by default. For multiple
-- statements, use semicolons as the separator. You can also include
-- multiple variables in a single @SET@ statement, such as @SET x=1, y=2@.
connectionPoolConfigurationInfo_initQuery :: Lens.Lens' ConnectionPoolConfigurationInfo (Prelude.Maybe Prelude.Text)
connectionPoolConfigurationInfo_initQuery :: (Maybe Text -> f (Maybe Text))
-> ConnectionPoolConfigurationInfo
-> f ConnectionPoolConfigurationInfo
connectionPoolConfigurationInfo_initQuery = (ConnectionPoolConfigurationInfo -> Maybe Text)
-> (ConnectionPoolConfigurationInfo
    -> Maybe Text -> ConnectionPoolConfigurationInfo)
-> Lens
     ConnectionPoolConfigurationInfo
     ConnectionPoolConfigurationInfo
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectionPoolConfigurationInfo' {Maybe Text
initQuery :: Maybe Text
$sel:initQuery:ConnectionPoolConfigurationInfo' :: ConnectionPoolConfigurationInfo -> Maybe Text
initQuery} -> Maybe Text
initQuery) (\s :: ConnectionPoolConfigurationInfo
s@ConnectionPoolConfigurationInfo' {} Maybe Text
a -> ConnectionPoolConfigurationInfo
s {$sel:initQuery:ConnectionPoolConfigurationInfo' :: Maybe Text
initQuery = Maybe Text
a} :: ConnectionPoolConfigurationInfo)

instance Core.FromXML ConnectionPoolConfigurationInfo where
  parseXML :: [Node] -> Either String ConnectionPoolConfigurationInfo
parseXML [Node]
x =
    Maybe Int
-> Maybe [Text]
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> ConnectionPoolConfigurationInfo
ConnectionPoolConfigurationInfo'
      (Maybe Int
 -> Maybe [Text]
 -> Maybe Int
 -> Maybe Int
 -> Maybe Text
 -> ConnectionPoolConfigurationInfo)
-> Either String (Maybe Int)
-> Either
     String
     (Maybe [Text]
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> ConnectionPoolConfigurationInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x [Node] -> Text -> Either String (Maybe Int)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"MaxIdleConnectionsPercent")
      Either
  String
  (Maybe [Text]
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> ConnectionPoolConfigurationInfo)
-> Either String (Maybe [Text])
-> Either
     String
     (Maybe Int
      -> Maybe Int -> Maybe Text -> ConnectionPoolConfigurationInfo)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x [Node] -> Text -> Either String (Maybe [Node])
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"SessionPinningFilters"
                      Either String (Maybe [Node]) -> [Node] -> Either String [Node]
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ [Node]
forall a. Monoid a => a
Prelude.mempty
                      Either String [Node]
-> ([Node] -> Either String (Maybe [Text]))
-> Either String (Maybe [Text])
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= ([Node] -> Either String [Text])
-> [Node] -> Either String (Maybe [Text])
forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (Text -> [Node] -> Either String [Text]
forall a. FromXML a => Text -> [Node] -> Either String [a]
Core.parseXMLList Text
"member")
                  )
      Either
  String
  (Maybe Int
   -> Maybe Int -> Maybe Text -> ConnectionPoolConfigurationInfo)
-> Either String (Maybe Int)
-> Either
     String (Maybe Int -> Maybe Text -> ConnectionPoolConfigurationInfo)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Int)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"MaxConnectionsPercent")
      Either
  String (Maybe Int -> Maybe Text -> ConnectionPoolConfigurationInfo)
-> Either String (Maybe Int)
-> Either String (Maybe Text -> ConnectionPoolConfigurationInfo)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Int)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"ConnectionBorrowTimeout")
      Either String (Maybe Text -> ConnectionPoolConfigurationInfo)
-> Either String (Maybe Text)
-> Either String ConnectionPoolConfigurationInfo
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"InitQuery")

instance
  Prelude.Hashable
    ConnectionPoolConfigurationInfo

instance
  Prelude.NFData
    ConnectionPoolConfigurationInfo