= AWS Timestream Component
:doctitle: AWS Timestream
:shortname: aws2-timestream
:artifactid: camel-aws2-timestream
:description: Write records and execute queries on AWS time-series database
:since: 4.1
:supportlevel: Stable
:tabs-sync-option:
:component-header: Only producer is supported
//Manually maintained attributes
:group: AWS
:camel-spring-boot-name: aws2-timestream

*Since Camel {since}*

*{component-header}*

The AWS2 Timestream component supports the following operations on
https://aws.amazon.com/timestream/[AWS Timestream]:

* Write Operations
** Describe Write Endpoints
** Create, Describe, Resume, List Batch Load Tasks
** Create, Delete, Update, Describe, List Databases
** Create, Delete, Update, Describe, List Tables
** Write Records


* Query Operations
** Describe Query Endpoints
** Prepare Query, Query, Cancel Query
** Create, Delete, Execute, Update, Describe, List Scheduled Queries

Prerequisites

You must have a valid Amazon Web Services developer account, and be
signed up to use Amazon Timestream. More information is available at
https://aws.amazon.com/timestream/[AWS Timestream].


== URI Format

-------------------------
aws2-timestream://clientType:label[?options]
-------------------------

You can append query options to the URI in the following format:

`?options=value&option2=value&...`


// component-configure options: START

// component-configure options: END

// component options: START
include::partial$component-configure-options.adoc[]
include::partial$component-endpoint-options.adoc[]
// component options: END

// endpoint options: START

// endpoint options: END


Required Timestream component options

Based on the type of operation to be performed, the type of client (write/query) needs to be provided
as clientType URI path parameter

You have to provide either the awsTimestreamWriteClient(for write operations) or awsTimestreamQueryClient(for query operations) in the
Registry or your accessKey and secretKey to access
the https://aws.amazon.com/timestream/[AWS Timestream] service.

// component headers: START
include::partial$component-endpoint-headers.adoc[]
// component headers: END

== Usage

=== Static credentials, Default Credential Provider and Profile Credentials Provider

You have the possibility of avoiding the usage of explicit static credentials by specifying the useDefaultCredentialsProvider option and set it to true.

The order of evaluation for Default Credentials Provider is the following:

 - Java system properties - `aws.accessKeyId` and `aws.secretKey`.
 - Environment variables - `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`.
 - Web Identity Token from AWS STS.
 - The shared credentials and config files.
 - Amazon ECS container credentials - loaded from the Amazon ECS if the environment variable `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` is set.
 - Amazon EC2 Instance profile credentials.

You have also the possibility of using Profile Credentials Provider, by specifying the useProfileCredentialsProvider option to true and profileCredentialsName to the profile name.

Only one of static, default and profile credentials could be used at the same time.

For more information about this you can look at https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html[AWS credentials documentation]

=== Timestream Producer operations

Camel-AWS Timestream component provides the following operation on the producer side:

* Write Operations
** describeEndpoints
** createBatchLoadTask
** describeBatchLoadTask
** resumeBatchLoadTask
** listBatchLoadTasks
** createDatabase
** deleteDatabase
** describeDatabase
** updateDatabase
** listDatabases
** createTable
** deleteTable
** describeTable
** updateTable
** listTables
** writeRecords


* Query Operations
** describeEndpoints
** createScheduledQuery
** deleteScheduledQuery
** executeScheduledQuery
** updateScheduledQuery
** describeScheduledQuery
** listScheduledQueries
** prepareQuery
** query
** cancelQuery

== Examples

=== Producer Examples

* Write Operation
** createDatabase: this operation will create a timestream database

[source,java]
--------------------------------------------------------------------------------
from("direct:createDatabase")
    .setHeader(Timestream2Constants.DATABASE_NAME, constant("testDb"))
    .setHeader(Timestream2Constants.KMS_KEY_ID, constant("testKmsKey"))
    .to("aws2-timestream://write:test?awsTimestreamWriteClient=#awsTimestreamWriteClient&operation=createDatabase")
--------------------------------------------------------------------------------

* Query Operation
** query: this operation will execute a timestream query

[source,java]
--------------------------------------------------------------------------------
from("direct:query")
    .setHeader(Timestream2Constants.QUERY_STRING, constant("SELECT * FROM testDb.testTable ORDER BY time DESC LIMIT 10"))
    .to("aws2-timestream://query:test?awsTimestreamQueryClient=#awsTimestreamQueryClient&operation=query")
--------------------------------------------------------------------------------

=== Using a POJO as body

Sometimes building an AWS Request can be complex because of multiple options. We introduce the possibility to use a POJO as the body.
In AWS Timestream there are multiple operations you can submit, as an example for Create state machine
 request, you can do something like:

* Write Operation
** createDatabase: this operation will create a timestream database

[source,java]
------------------------------------------------------------------------------------------------------
from("direct:start")
  .setBody(CreateDatabaseRequest.builder().database(Database.builder().databaseName("testDb").kmsKeyId("testKmsKey").build()).build())
  .to("aws2-timestream://write:test?awsTimestreamWriteClient=#awsTimestreamWriteClient&operation=createDatabase&pojoRequest=true")
------------------------------------------------------------------------------------------------------

* Query Operation
** query: this operation will execute a timestream query

[source,java]
--------------------------------------------------------------------------------
from("direct:query")
    .setBody(QueryRequest.builder().queryString("SELECT * FROM testDb.testTable ORDER BY time DESC LIMIT 10").build())
    .to("aws2-timestream://query:test?awsTimestreamQueryClient=#awsTimestreamQueryClient&operation=query&pojoRequest=true")
--------------------------------------------------------------------------------

In this way, you'll pass the request directly without the need of passing headers and options specifically related to this operation.

== Dependencies

Maven users will need to add the following dependency to their pom.xml.

*pom.xml*

[source,xml]
---------------------------------------
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-aws2-timestream</artifactId>
    <version>${camel-version}</version>
</dependency>
---------------------------------------

where `$\{camel-version}` must be replaced by the actual version of Camel.


include::spring-boot:partial$starter.adoc[]
