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

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

-- |
-- Module      : Amazonka.Athena.DeleteNamedQuery
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Deletes the named query if you have access to the workgroup in which the
-- query was saved.
--
-- For code samples using the Amazon Web Services SDK for Java, see
-- <http://docs.aws.amazon.com/athena/latest/ug/code-samples.html Examples and Code Samples>
-- in the /Amazon Athena User Guide/.
module Amazonka.Athena.DeleteNamedQuery
  ( -- * Creating a Request
    DeleteNamedQuery (..),
    newDeleteNamedQuery,

    -- * Request Lenses
    deleteNamedQuery_namedQueryId,

    -- * Destructuring the Response
    DeleteNamedQueryResponse (..),
    newDeleteNamedQueryResponse,

    -- * Response Lenses
    deleteNamedQueryResponse_httpStatus,
  )
where

import Amazonka.Athena.Types
import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newDeleteNamedQuery' smart constructor.
data DeleteNamedQuery = DeleteNamedQuery'
  { -- | The unique ID of the query to delete.
    DeleteNamedQuery -> Text
namedQueryId :: Prelude.Text
  }
  deriving (DeleteNamedQuery -> DeleteNamedQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteNamedQuery -> DeleteNamedQuery -> Bool
$c/= :: DeleteNamedQuery -> DeleteNamedQuery -> Bool
== :: DeleteNamedQuery -> DeleteNamedQuery -> Bool
$c== :: DeleteNamedQuery -> DeleteNamedQuery -> Bool
Prelude.Eq, ReadPrec [DeleteNamedQuery]
ReadPrec DeleteNamedQuery
Int -> ReadS DeleteNamedQuery
ReadS [DeleteNamedQuery]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteNamedQuery]
$creadListPrec :: ReadPrec [DeleteNamedQuery]
readPrec :: ReadPrec DeleteNamedQuery
$creadPrec :: ReadPrec DeleteNamedQuery
readList :: ReadS [DeleteNamedQuery]
$creadList :: ReadS [DeleteNamedQuery]
readsPrec :: Int -> ReadS DeleteNamedQuery
$creadsPrec :: Int -> ReadS DeleteNamedQuery
Prelude.Read, Int -> DeleteNamedQuery -> ShowS
[DeleteNamedQuery] -> ShowS
DeleteNamedQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteNamedQuery] -> ShowS
$cshowList :: [DeleteNamedQuery] -> ShowS
show :: DeleteNamedQuery -> String
$cshow :: DeleteNamedQuery -> String
showsPrec :: Int -> DeleteNamedQuery -> ShowS
$cshowsPrec :: Int -> DeleteNamedQuery -> ShowS
Prelude.Show, forall x. Rep DeleteNamedQuery x -> DeleteNamedQuery
forall x. DeleteNamedQuery -> Rep DeleteNamedQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DeleteNamedQuery x -> DeleteNamedQuery
$cfrom :: forall x. DeleteNamedQuery -> Rep DeleteNamedQuery x
Prelude.Generic)

-- |
-- Create a value of 'DeleteNamedQuery' 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:
--
-- 'namedQueryId', 'deleteNamedQuery_namedQueryId' - The unique ID of the query to delete.
newDeleteNamedQuery ::
  -- | 'namedQueryId'
  Prelude.Text ->
  DeleteNamedQuery
newDeleteNamedQuery :: Text -> DeleteNamedQuery
newDeleteNamedQuery Text
pNamedQueryId_ =
  DeleteNamedQuery' {$sel:namedQueryId:DeleteNamedQuery' :: Text
namedQueryId = Text
pNamedQueryId_}

-- | The unique ID of the query to delete.
deleteNamedQuery_namedQueryId :: Lens.Lens' DeleteNamedQuery Prelude.Text
deleteNamedQuery_namedQueryId :: Lens' DeleteNamedQuery Text
deleteNamedQuery_namedQueryId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteNamedQuery' {Text
namedQueryId :: Text
$sel:namedQueryId:DeleteNamedQuery' :: DeleteNamedQuery -> Text
namedQueryId} -> Text
namedQueryId) (\s :: DeleteNamedQuery
s@DeleteNamedQuery' {} Text
a -> DeleteNamedQuery
s {$sel:namedQueryId:DeleteNamedQuery' :: Text
namedQueryId = Text
a} :: DeleteNamedQuery)

instance Core.AWSRequest DeleteNamedQuery where
  type
    AWSResponse DeleteNamedQuery =
      DeleteNamedQueryResponse
  request :: (Service -> Service)
-> DeleteNamedQuery -> Request DeleteNamedQuery
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy DeleteNamedQuery
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse DeleteNamedQuery)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> DeleteNamedQueryResponse
DeleteNamedQueryResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable DeleteNamedQuery where
  hashWithSalt :: Int -> DeleteNamedQuery -> Int
hashWithSalt Int
_salt DeleteNamedQuery' {Text
namedQueryId :: Text
$sel:namedQueryId:DeleteNamedQuery' :: DeleteNamedQuery -> Text
..} =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
namedQueryId

instance Prelude.NFData DeleteNamedQuery where
  rnf :: DeleteNamedQuery -> ()
rnf DeleteNamedQuery' {Text
namedQueryId :: Text
$sel:namedQueryId:DeleteNamedQuery' :: DeleteNamedQuery -> Text
..} = forall a. NFData a => a -> ()
Prelude.rnf Text
namedQueryId

instance Data.ToHeaders DeleteNamedQuery where
  toHeaders :: DeleteNamedQuery -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"AmazonAthena.DeleteNamedQuery" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON DeleteNamedQuery where
  toJSON :: DeleteNamedQuery -> Value
toJSON DeleteNamedQuery' {Text
namedQueryId :: Text
$sel:namedQueryId:DeleteNamedQuery' :: DeleteNamedQuery -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [forall a. a -> Maybe a
Prelude.Just (Key
"NamedQueryId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
namedQueryId)]
      )

instance Data.ToPath DeleteNamedQuery where
  toPath :: DeleteNamedQuery -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery DeleteNamedQuery where
  toQuery :: DeleteNamedQuery -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newDeleteNamedQueryResponse' smart constructor.
data DeleteNamedQueryResponse = DeleteNamedQueryResponse'
  { -- | The response's http status code.
    DeleteNamedQueryResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DeleteNamedQueryResponse -> DeleteNamedQueryResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteNamedQueryResponse -> DeleteNamedQueryResponse -> Bool
$c/= :: DeleteNamedQueryResponse -> DeleteNamedQueryResponse -> Bool
== :: DeleteNamedQueryResponse -> DeleteNamedQueryResponse -> Bool
$c== :: DeleteNamedQueryResponse -> DeleteNamedQueryResponse -> Bool
Prelude.Eq, ReadPrec [DeleteNamedQueryResponse]
ReadPrec DeleteNamedQueryResponse
Int -> ReadS DeleteNamedQueryResponse
ReadS [DeleteNamedQueryResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteNamedQueryResponse]
$creadListPrec :: ReadPrec [DeleteNamedQueryResponse]
readPrec :: ReadPrec DeleteNamedQueryResponse
$creadPrec :: ReadPrec DeleteNamedQueryResponse
readList :: ReadS [DeleteNamedQueryResponse]
$creadList :: ReadS [DeleteNamedQueryResponse]
readsPrec :: Int -> ReadS DeleteNamedQueryResponse
$creadsPrec :: Int -> ReadS DeleteNamedQueryResponse
Prelude.Read, Int -> DeleteNamedQueryResponse -> ShowS
[DeleteNamedQueryResponse] -> ShowS
DeleteNamedQueryResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteNamedQueryResponse] -> ShowS
$cshowList :: [DeleteNamedQueryResponse] -> ShowS
show :: DeleteNamedQueryResponse -> String
$cshow :: DeleteNamedQueryResponse -> String
showsPrec :: Int -> DeleteNamedQueryResponse -> ShowS
$cshowsPrec :: Int -> DeleteNamedQueryResponse -> ShowS
Prelude.Show, forall x.
Rep DeleteNamedQueryResponse x -> DeleteNamedQueryResponse
forall x.
DeleteNamedQueryResponse -> Rep DeleteNamedQueryResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DeleteNamedQueryResponse x -> DeleteNamedQueryResponse
$cfrom :: forall x.
DeleteNamedQueryResponse -> Rep DeleteNamedQueryResponse x
Prelude.Generic)

-- |
-- Create a value of 'DeleteNamedQueryResponse' 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:
--
-- 'httpStatus', 'deleteNamedQueryResponse_httpStatus' - The response's http status code.
newDeleteNamedQueryResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DeleteNamedQueryResponse
newDeleteNamedQueryResponse :: Int -> DeleteNamedQueryResponse
newDeleteNamedQueryResponse Int
pHttpStatus_ =
  DeleteNamedQueryResponse'
    { $sel:httpStatus:DeleteNamedQueryResponse' :: Int
httpStatus =
        Int
pHttpStatus_
    }

-- | The response's http status code.
deleteNamedQueryResponse_httpStatus :: Lens.Lens' DeleteNamedQueryResponse Prelude.Int
deleteNamedQueryResponse_httpStatus :: Lens' DeleteNamedQueryResponse Int
deleteNamedQueryResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteNamedQueryResponse' {Int
httpStatus :: Int
$sel:httpStatus:DeleteNamedQueryResponse' :: DeleteNamedQueryResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: DeleteNamedQueryResponse
s@DeleteNamedQueryResponse' {} Int
a -> DeleteNamedQueryResponse
s {$sel:httpStatus:DeleteNamedQueryResponse' :: Int
httpStatus = Int
a} :: DeleteNamedQueryResponse)

instance Prelude.NFData DeleteNamedQueryResponse where
  rnf :: DeleteNamedQueryResponse -> ()
rnf DeleteNamedQueryResponse' {Int
httpStatus :: Int
$sel:httpStatus:DeleteNamedQueryResponse' :: DeleteNamedQueryResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus