amazonica.aws.dynamodbv2 — com.signal-ai/amazonica 0.3.157-signal-1

Amazon DyanmoDBV2 support - Local Secondary Indexes

batch-execute-statement clj

(batch-execute-statement &
                         {:keys [return-consumed-capacity statements]
                          :as batch-execute-statement-request})

batch-get-item clj

(batch-get-item & [map])

(batch-get-item &
                {:keys [request-items return-consumed-capacity]
                 :as batch-get-item-request})

(batch-get-item map string)

batch-write-item clj

(batch-write-item & [map])

(batch-write-item &
                  {:keys [request-items return-consumed-capacity
                          return-item-collection-metrics]
                   :as batch-write-item-request})

client-class clj

create-backup clj

(create-backup & {:keys [backup-name table-name] :as create-backup-request})

create-global-table clj

(create-global-table &
                     {:keys [global-table-name replication-group]
                      :as create-global-table-request})

create-table clj

(create-table
  &
  {:keys [attribute-definitions billing-mode global-secondary-indexes key-schema
          local-secondary-indexes provisioned-throughput sse-specification
          stream-specification table-class table-name tags]
   :as create-table-request})

(create-table list-1 string list-2 provisioned-throughput)

delete-backup clj

(delete-backup & {:keys [backup-arn] :as delete-backup-request})

delete-item clj

(delete-item &
             {:keys [condition-expression conditional-operator expected
                     expression-attribute-names expression-attribute-values key
                     return-consumed-capacity return-item-collection-metrics
                     return-values table-name]
              :as delete-item-request})

(delete-item string map)

(delete-item string-1 map string-2)

delete-table clj

(delete-table & {:keys [blank bytes empty] :as string})

(delete-table & {:keys [table-name] :as delete-table-request})

describe-backup clj

(describe-backup & {:keys [backup-arn] :as describe-backup-request})

describe-continuous-backups clj

(describe-continuous-backups &
                             {:keys [table-name]
                              :as describe-continuous-backups-request})

describe-contributor-insights clj

(describe-contributor-insights &
                               {:keys [index-name table-name]
                                :as describe-contributor-insights-request})

describe-endpoints clj

(describe-endpoints & {:keys [] :as describe-endpoints-request})

describe-export clj

(describe-export & {:keys [export-arn] :as describe-export-request})

describe-global-table clj

(describe-global-table &
                       {:keys [global-table-name]
                        :as describe-global-table-request})

describe-global-table-settings clj

(describe-global-table-settings &
                                {:keys [global-table-name]
                                 :as describe-global-table-settings-request})

describe-kinesis-streaming-destination clj

(describe-kinesis-streaming-destination
  &
  {:keys [table-name] :as describe-kinesis-streaming-destination-request})

describe-limits clj

(describe-limits & {:keys [] :as describe-limits-request})

describe-table clj

(describe-table & {:keys [blank bytes empty] :as string})

(describe-table & {:keys [table-name] :as describe-table-request})

describe-table-replica-auto-scaling clj

(describe-table-replica-auto-scaling
  &
  {:keys [table-name] :as describe-table-replica-auto-scaling-request})

describe-time-to-live clj

(describe-time-to-live & {:keys [table-name] :as describe-time-to-live-request})

disable-kinesis-streaming-destination clj

(disable-kinesis-streaming-destination
  &
  {:keys [stream-arn table-name]
   :as disable-kinesis-streaming-destination-request})

enable-kinesis-streaming-destination clj

(enable-kinesis-streaming-destination
  &
  {:keys [stream-arn table-name]
   :as enable-kinesis-streaming-destination-request})

execute-statement clj

(execute-statement &
                   {:keys [consistent-read next-token parameters
                           return-consumed-capacity statement]
                    :as execute-statement-request})

execute-transaction clj

(execute-transaction &
                     {:keys [client-request-token return-consumed-capacity
                             transact-statements]
                      :as execute-transaction-request})

export-table-to-point-in-time clj

(export-table-to-point-in-time
  &
  {:keys [client-token export-format export-time s3-bucket s3-bucket-owner
          s3-prefix s3-sse-algorithm s3-sse-kms-key-id table-arn]
   :as export-table-to-point-in-time-request})

get-cached-response-metadata clj

(get-cached-response-metadata & [amazon-web-service-request])

get-item clj

(get-item &
          {:keys [attributes-to-get consistent-read expression-attribute-names
                  key projection-expression return-consumed-capacity table-name]
           :as get-item-request})

(get-item string map)

(get-item string map boolean)

list-backups clj

(list-backups &
              {:keys [backup-type exclusive-start-backup-arn limit table-name
                      time-range-lower-bound time-range-upper-bound]
               :as list-backups-request})

list-contributor-insights clj

(list-contributor-insights &
                           {:keys [max-results next-token table-name]
                            :as list-contributor-insights-request})

list-exports clj

(list-exports &
              {:keys [max-results next-token table-arn]
               :as list-exports-request})

list-global-tables clj

(list-global-tables &
                    {:keys [exclusive-start-global-table-name limit region-name]
                     :as list-global-tables-request})

list-tables clj

(list-tables)

(list-tables & [integer])

(list-tables & {:keys [blank bytes empty] :as string})

(list-tables &
             {:keys [exclusive-start-table-name limit] :as list-tables-request})

(list-tables string integer)

list-tags-of-resource clj

(list-tags-of-resource &
                       {:keys [next-token resource-arn]
                        :as list-tags-of-resource-request})

marshall-allow-empty-maps clj

(marshall-allow-empty-maps obj)

put-item clj

(put-item &
          {:keys [condition-expression conditional-operator expected
                  expression-attribute-names expression-attribute-values item
                  return-consumed-capacity return-item-collection-metrics
                  return-values table-name]
           :as put-item-request})

(put-item string map)

(put-item string-1 map string-2)

query clj

(query &
       {:keys [attributes-to-get conditional-operator consistent-read
               exclusive-start-key expression-attribute-names
               expression-attribute-values filter-expression index-name
               key-condition-expression key-conditions limit
               projection-expression query-filter return-consumed-capacity
               scan-index-forward select table-name]
        :as query-request})

restore-table-from-backup clj

(restore-table-from-backup
  &
  {:keys [backup-arn billing-mode-override global-secondary-index-override
          local-secondary-index-override provisioned-throughput-override
          sse-specification-override target-table-name]
   :as restore-table-from-backup-request})

restore-table-to-point-in-time clj

(restore-table-to-point-in-time
  &
  {:keys [billing-mode-override global-secondary-index-override
          local-secondary-index-override provisioned-throughput-override
          restore-date-time source-table-arn source-table-name
          sse-specification-override target-table-name
          use-latest-restorable-time]
   :as restore-table-to-point-in-time-request})

scan clj

(scan &
      {:keys [attributes-to-get conditional-operator consistent-read
              exclusive-start-key expression-attribute-names
              expression-attribute-values filter-expression index-name limit
              projection-expression return-consumed-capacity scan-filter segment
              select table-name total-segments]
       :as scan-request})

(scan string list)

(scan string map)

(scan string list map)

set-signer-region-override clj

(set-signer-region-override & {:keys [blank bytes empty] :as string})

show-functions clj

shutdown clj

(shutdown)

tag-resource clj

(tag-resource & {:keys [resource-arn tags] :as tag-resource-request})

transact-get-items clj

(transact-get-items &
                    {:keys [return-consumed-capacity transact-items]
                     :as transact-get-items-request})

transact-write-items clj

(transact-write-items &
                      {:keys [client-request-token return-consumed-capacity
                              return-item-collection-metrics transact-items]
                       :as transact-write-items-request})

untag-resource clj

(untag-resource & {:keys [resource-arn tag-keys] :as untag-resource-request})

update-continuous-backups clj

(update-continuous-backups &
                           {:keys [point-in-time-recovery-specification
                                   table-name]
                            :as update-continuous-backups-request})

update-contributor-insights clj

(update-contributor-insights &
                             {:keys [contributor-insights-action index-name
                                     table-name]
                              :as update-contributor-insights-request})

update-global-table clj

(update-global-table &
                     {:keys [global-table-name replica-updates]
                      :as update-global-table-request})

update-global-table-settings clj

(update-global-table-settings
  &
  {:keys [global-table-billing-mode
          global-table-global-secondary-index-settings-update global-table-name
          global-table-provisioned-write-capacity-auto-scaling-settings-update
          global-table-provisioned-write-capacity-units replica-settings-update]
   :as update-global-table-settings-request})

update-item clj

(update-item &
             {:keys [attribute-updates condition-expression conditional-operator
                     expected expression-attribute-names
                     expression-attribute-values key return-consumed-capacity
                     return-item-collection-metrics return-values table-name
                     update-expression]
              :as update-item-request})

(update-item string map-1 map-2)

(update-item string-1 map-1 map-2 string-2)

update-table clj

(update-table &
              {:keys [attribute-definitions billing-mode
                      global-secondary-index-updates provisioned-throughput
                      replica-updates sse-specification stream-specification
                      table-class table-name]
               :as update-table-request})

(update-table string provisioned-throughput)

update-table-replica-auto-scaling clj

(update-table-replica-auto-scaling
  &
  {:keys [global-secondary-index-updates
          provisioned-write-capacity-auto-scaling-update replica-updates
          table-name]
   :as update-table-replica-auto-scaling-request})

update-time-to-live clj

(update-time-to-live &
                     {:keys [table-name time-to-live-specification]
                      :as update-time-to-live-request})

waiters clj

(waiters)