{-# 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.ConnectionPoolConfiguration
-- 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.ConnectionPoolConfiguration where

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

-- | Specifies the settings that control the size and behavior of the
-- connection pool associated with a @DBProxyTargetGroup@.
--
-- /See:/ 'newConnectionPoolConfiguration' smart constructor.
data ConnectionPoolConfiguration = ConnectionPoolConfiguration'
  { -- | 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.
    --
    -- Default: 50
    --
    -- Constraints: between 0 and @MaxConnectionsPercent@
    ConnectionPoolConfiguration -> 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.
    --
    -- Default: no session pinning filters
    ConnectionPoolConfiguration -> 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.
    --
    -- Default: 100
    --
    -- Constraints: between 1 and 100
    ConnectionPoolConfiguration -> 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.
    --
    -- Default: 120
    --
    -- Constraints: between 1 and 3600, or 0 representing unlimited
    ConnectionPoolConfiguration -> 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. 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@.
    --
    -- Default: no initialization query
    ConnectionPoolConfiguration -> Maybe Text
initQuery :: Prelude.Maybe Prelude.Text
  }
  deriving (ConnectionPoolConfiguration -> ConnectionPoolConfiguration -> Bool
(ConnectionPoolConfiguration
 -> ConnectionPoolConfiguration -> Bool)
-> (ConnectionPoolConfiguration
    -> ConnectionPoolConfiguration -> Bool)
-> Eq ConnectionPoolConfiguration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConnectionPoolConfiguration -> ConnectionPoolConfiguration -> Bool
$c/= :: ConnectionPoolConfiguration -> ConnectionPoolConfiguration -> Bool
== :: ConnectionPoolConfiguration -> ConnectionPoolConfiguration -> Bool
$c== :: ConnectionPoolConfiguration -> ConnectionPoolConfiguration -> Bool
Prelude.Eq, ReadPrec [ConnectionPoolConfiguration]
ReadPrec ConnectionPoolConfiguration
Int -> ReadS ConnectionPoolConfiguration
ReadS [ConnectionPoolConfiguration]
(Int -> ReadS ConnectionPoolConfiguration)
-> ReadS [ConnectionPoolConfiguration]
-> ReadPrec ConnectionPoolConfiguration
-> ReadPrec [ConnectionPoolConfiguration]
-> Read ConnectionPoolConfiguration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ConnectionPoolConfiguration]
$creadListPrec :: ReadPrec [ConnectionPoolConfiguration]
readPrec :: ReadPrec ConnectionPoolConfiguration
$creadPrec :: ReadPrec ConnectionPoolConfiguration
readList :: ReadS [ConnectionPoolConfiguration]
$creadList :: ReadS [ConnectionPoolConfiguration]
readsPrec :: Int -> ReadS ConnectionPoolConfiguration
$creadsPrec :: Int -> ReadS ConnectionPoolConfiguration
Prelude.Read, Int -> ConnectionPoolConfiguration -> ShowS
[ConnectionPoolConfiguration] -> ShowS
ConnectionPoolConfiguration -> String
(Int -> ConnectionPoolConfiguration -> ShowS)
-> (ConnectionPoolConfiguration -> String)
-> ([ConnectionPoolConfiguration] -> ShowS)
-> Show ConnectionPoolConfiguration
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConnectionPoolConfiguration] -> ShowS
$cshowList :: [ConnectionPoolConfiguration] -> ShowS
show :: ConnectionPoolConfiguration -> String
$cshow :: ConnectionPoolConfiguration -> String
showsPrec :: Int -> ConnectionPoolConfiguration -> ShowS
$cshowsPrec :: Int -> ConnectionPoolConfiguration -> ShowS
Prelude.Show, (forall x.
 ConnectionPoolConfiguration -> Rep ConnectionPoolConfiguration x)
-> (forall x.
    Rep ConnectionPoolConfiguration x -> ConnectionPoolConfiguration)
-> Generic ConnectionPoolConfiguration
forall x.
Rep ConnectionPoolConfiguration x -> ConnectionPoolConfiguration
forall x.
ConnectionPoolConfiguration -> Rep ConnectionPoolConfiguration x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ConnectionPoolConfiguration x -> ConnectionPoolConfiguration
$cfrom :: forall x.
ConnectionPoolConfiguration -> Rep ConnectionPoolConfiguration x
Prelude.Generic)

-- |
-- Create a value of 'ConnectionPoolConfiguration' 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', 'connectionPoolConfiguration_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.
--
-- Default: 50
--
-- Constraints: between 0 and @MaxConnectionsPercent@
--
-- 'sessionPinningFilters', 'connectionPoolConfiguration_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.
--
-- Default: no session pinning filters
--
-- 'maxConnectionsPercent', 'connectionPoolConfiguration_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.
--
-- Default: 100
--
-- Constraints: between 1 and 100
--
-- 'connectionBorrowTimeout', 'connectionPoolConfiguration_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.
--
-- Default: 120
--
-- Constraints: between 1 and 3600, or 0 representing unlimited
--
-- 'initQuery', 'connectionPoolConfiguration_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. 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@.
--
-- Default: no initialization query
newConnectionPoolConfiguration ::
  ConnectionPoolConfiguration
newConnectionPoolConfiguration :: ConnectionPoolConfiguration
newConnectionPoolConfiguration =
  ConnectionPoolConfiguration' :: Maybe Int
-> Maybe [Text]
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> ConnectionPoolConfiguration
ConnectionPoolConfiguration'
    { $sel:maxIdleConnectionsPercent:ConnectionPoolConfiguration' :: Maybe Int
maxIdleConnectionsPercent =
        Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:sessionPinningFilters:ConnectionPoolConfiguration' :: Maybe [Text]
sessionPinningFilters = Maybe [Text]
forall a. Maybe a
Prelude.Nothing,
      $sel:maxConnectionsPercent:ConnectionPoolConfiguration' :: Maybe Int
maxConnectionsPercent = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:connectionBorrowTimeout:ConnectionPoolConfiguration' :: Maybe Int
connectionBorrowTimeout = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:initQuery:ConnectionPoolConfiguration' :: 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.
--
-- Default: 50
--
-- Constraints: between 0 and @MaxConnectionsPercent@
connectionPoolConfiguration_maxIdleConnectionsPercent :: Lens.Lens' ConnectionPoolConfiguration (Prelude.Maybe Prelude.Int)
connectionPoolConfiguration_maxIdleConnectionsPercent :: (Maybe Int -> f (Maybe Int))
-> ConnectionPoolConfiguration -> f ConnectionPoolConfiguration
connectionPoolConfiguration_maxIdleConnectionsPercent = (ConnectionPoolConfiguration -> Maybe Int)
-> (ConnectionPoolConfiguration
    -> Maybe Int -> ConnectionPoolConfiguration)
-> Lens
     ConnectionPoolConfiguration
     ConnectionPoolConfiguration
     (Maybe Int)
     (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectionPoolConfiguration' {Maybe Int
maxIdleConnectionsPercent :: Maybe Int
$sel:maxIdleConnectionsPercent:ConnectionPoolConfiguration' :: ConnectionPoolConfiguration -> Maybe Int
maxIdleConnectionsPercent} -> Maybe Int
maxIdleConnectionsPercent) (\s :: ConnectionPoolConfiguration
s@ConnectionPoolConfiguration' {} Maybe Int
a -> ConnectionPoolConfiguration
s {$sel:maxIdleConnectionsPercent:ConnectionPoolConfiguration' :: Maybe Int
maxIdleConnectionsPercent = Maybe Int
a} :: ConnectionPoolConfiguration)

-- | 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.
--
-- Default: no session pinning filters
connectionPoolConfiguration_sessionPinningFilters :: Lens.Lens' ConnectionPoolConfiguration (Prelude.Maybe [Prelude.Text])
connectionPoolConfiguration_sessionPinningFilters :: (Maybe [Text] -> f (Maybe [Text]))
-> ConnectionPoolConfiguration -> f ConnectionPoolConfiguration
connectionPoolConfiguration_sessionPinningFilters = (ConnectionPoolConfiguration -> Maybe [Text])
-> (ConnectionPoolConfiguration
    -> Maybe [Text] -> ConnectionPoolConfiguration)
-> Lens
     ConnectionPoolConfiguration
     ConnectionPoolConfiguration
     (Maybe [Text])
     (Maybe [Text])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectionPoolConfiguration' {Maybe [Text]
sessionPinningFilters :: Maybe [Text]
$sel:sessionPinningFilters:ConnectionPoolConfiguration' :: ConnectionPoolConfiguration -> Maybe [Text]
sessionPinningFilters} -> Maybe [Text]
sessionPinningFilters) (\s :: ConnectionPoolConfiguration
s@ConnectionPoolConfiguration' {} Maybe [Text]
a -> ConnectionPoolConfiguration
s {$sel:sessionPinningFilters:ConnectionPoolConfiguration' :: Maybe [Text]
sessionPinningFilters = Maybe [Text]
a} :: ConnectionPoolConfiguration) ((Maybe [Text] -> f (Maybe [Text]))
 -> ConnectionPoolConfiguration -> f ConnectionPoolConfiguration)
-> ((Maybe [Text] -> f (Maybe [Text]))
    -> Maybe [Text] -> f (Maybe [Text]))
-> (Maybe [Text] -> f (Maybe [Text]))
-> ConnectionPoolConfiguration
-> f ConnectionPoolConfiguration
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.
--
-- Default: 100
--
-- Constraints: between 1 and 100
connectionPoolConfiguration_maxConnectionsPercent :: Lens.Lens' ConnectionPoolConfiguration (Prelude.Maybe Prelude.Int)
connectionPoolConfiguration_maxConnectionsPercent :: (Maybe Int -> f (Maybe Int))
-> ConnectionPoolConfiguration -> f ConnectionPoolConfiguration
connectionPoolConfiguration_maxConnectionsPercent = (ConnectionPoolConfiguration -> Maybe Int)
-> (ConnectionPoolConfiguration
    -> Maybe Int -> ConnectionPoolConfiguration)
-> Lens
     ConnectionPoolConfiguration
     ConnectionPoolConfiguration
     (Maybe Int)
     (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectionPoolConfiguration' {Maybe Int
maxConnectionsPercent :: Maybe Int
$sel:maxConnectionsPercent:ConnectionPoolConfiguration' :: ConnectionPoolConfiguration -> Maybe Int
maxConnectionsPercent} -> Maybe Int
maxConnectionsPercent) (\s :: ConnectionPoolConfiguration
s@ConnectionPoolConfiguration' {} Maybe Int
a -> ConnectionPoolConfiguration
s {$sel:maxConnectionsPercent:ConnectionPoolConfiguration' :: Maybe Int
maxConnectionsPercent = Maybe Int
a} :: ConnectionPoolConfiguration)

-- | 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.
--
-- Default: 120
--
-- Constraints: between 1 and 3600, or 0 representing unlimited
connectionPoolConfiguration_connectionBorrowTimeout :: Lens.Lens' ConnectionPoolConfiguration (Prelude.Maybe Prelude.Int)
connectionPoolConfiguration_connectionBorrowTimeout :: (Maybe Int -> f (Maybe Int))
-> ConnectionPoolConfiguration -> f ConnectionPoolConfiguration
connectionPoolConfiguration_connectionBorrowTimeout = (ConnectionPoolConfiguration -> Maybe Int)
-> (ConnectionPoolConfiguration
    -> Maybe Int -> ConnectionPoolConfiguration)
-> Lens
     ConnectionPoolConfiguration
     ConnectionPoolConfiguration
     (Maybe Int)
     (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectionPoolConfiguration' {Maybe Int
connectionBorrowTimeout :: Maybe Int
$sel:connectionBorrowTimeout:ConnectionPoolConfiguration' :: ConnectionPoolConfiguration -> Maybe Int
connectionBorrowTimeout} -> Maybe Int
connectionBorrowTimeout) (\s :: ConnectionPoolConfiguration
s@ConnectionPoolConfiguration' {} Maybe Int
a -> ConnectionPoolConfiguration
s {$sel:connectionBorrowTimeout:ConnectionPoolConfiguration' :: Maybe Int
connectionBorrowTimeout = Maybe Int
a} :: ConnectionPoolConfiguration)

-- | 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. 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@.
--
-- Default: no initialization query
connectionPoolConfiguration_initQuery :: Lens.Lens' ConnectionPoolConfiguration (Prelude.Maybe Prelude.Text)
connectionPoolConfiguration_initQuery :: (Maybe Text -> f (Maybe Text))
-> ConnectionPoolConfiguration -> f ConnectionPoolConfiguration
connectionPoolConfiguration_initQuery = (ConnectionPoolConfiguration -> Maybe Text)
-> (ConnectionPoolConfiguration
    -> Maybe Text -> ConnectionPoolConfiguration)
-> Lens
     ConnectionPoolConfiguration
     ConnectionPoolConfiguration
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectionPoolConfiguration' {Maybe Text
initQuery :: Maybe Text
$sel:initQuery:ConnectionPoolConfiguration' :: ConnectionPoolConfiguration -> Maybe Text
initQuery} -> Maybe Text
initQuery) (\s :: ConnectionPoolConfiguration
s@ConnectionPoolConfiguration' {} Maybe Text
a -> ConnectionPoolConfiguration
s {$sel:initQuery:ConnectionPoolConfiguration' :: Maybe Text
initQuery = Maybe Text
a} :: ConnectionPoolConfiguration)

instance Prelude.Hashable ConnectionPoolConfiguration

instance Prelude.NFData ConnectionPoolConfiguration

instance Core.ToQuery ConnectionPoolConfiguration where
  toQuery :: ConnectionPoolConfiguration -> QueryString
toQuery ConnectionPoolConfiguration' {Maybe Int
Maybe [Text]
Maybe Text
initQuery :: Maybe Text
connectionBorrowTimeout :: Maybe Int
maxConnectionsPercent :: Maybe Int
sessionPinningFilters :: Maybe [Text]
maxIdleConnectionsPercent :: Maybe Int
$sel:initQuery:ConnectionPoolConfiguration' :: ConnectionPoolConfiguration -> Maybe Text
$sel:connectionBorrowTimeout:ConnectionPoolConfiguration' :: ConnectionPoolConfiguration -> Maybe Int
$sel:maxConnectionsPercent:ConnectionPoolConfiguration' :: ConnectionPoolConfiguration -> Maybe Int
$sel:sessionPinningFilters:ConnectionPoolConfiguration' :: ConnectionPoolConfiguration -> Maybe [Text]
$sel:maxIdleConnectionsPercent:ConnectionPoolConfiguration' :: ConnectionPoolConfiguration -> Maybe Int
..} =
    [QueryString] -> QueryString
forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"MaxIdleConnectionsPercent"
          ByteString -> Maybe Int -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Core.=: Maybe Int
maxIdleConnectionsPercent,
        ByteString
"SessionPinningFilters"
          ByteString -> QueryString -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Core.=: Maybe QueryString -> QueryString
forall a. ToQuery a => a -> QueryString
Core.toQuery
            ( ByteString -> [Text] -> QueryString
forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Core.toQueryList ByteString
"member"
                ([Text] -> QueryString) -> Maybe [Text] -> Maybe QueryString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
sessionPinningFilters
            ),
        ByteString
"MaxConnectionsPercent"
          ByteString -> Maybe Int -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Core.=: Maybe Int
maxConnectionsPercent,
        ByteString
"ConnectionBorrowTimeout"
          ByteString -> Maybe Int -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Core.=: Maybe Int
connectionBorrowTimeout,
        ByteString
"InitQuery" ByteString -> Maybe Text -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Core.=: Maybe Text
initQuery
      ]