Liking cljdoc? Tell your friends :D
Clojure only.

amazonica.aws.glue

batch-create-partitionclj

(batch-create-partition &
                        {:keys [catalog-id database-name partition-input-list
                                table-name]
                         :as batch-create-partition-request})

batch-delete-connectionclj

(batch-delete-connection &
                         {:keys [catalog-id connection-name-list]
                          :as batch-delete-connection-request})

batch-delete-partitionclj

(batch-delete-partition &
                        {:keys [catalog-id database-name partitions-to-delete
                                table-name]
                         :as batch-delete-partition-request})

batch-delete-tableclj

(batch-delete-table &
                    {:keys [catalog-id database-name tables-to-delete
                            transaction-id]
                     :as batch-delete-table-request})

batch-delete-table-versionclj

(batch-delete-table-version &
                            {:keys [catalog-id database-name table-name
                                    version-ids]
                             :as batch-delete-table-version-request})

batch-get-blueprintsclj

(batch-get-blueprints &
                      {:keys [include-blueprint include-parameter-spec names]
                       :as batch-get-blueprints-request})

batch-get-crawlersclj

(batch-get-crawlers & {:keys [crawler-names] :as batch-get-crawlers-request})

batch-get-dev-endpointsclj

(batch-get-dev-endpoints &
                         {:keys [dev-endpoint-names]
                          :as batch-get-dev-endpoints-request})

batch-get-jobsclj

(batch-get-jobs & {:keys [job-names] :as batch-get-jobs-request})

batch-get-partitionclj

(batch-get-partition &
                     {:keys [catalog-id database-name partitions-to-get
                             table-name]
                      :as batch-get-partition-request})

batch-get-triggersclj

(batch-get-triggers & {:keys [trigger-names] :as batch-get-triggers-request})

batch-get-workflowsclj

(batch-get-workflows &
                     {:keys [include-graph names]
                      :as batch-get-workflows-request})

batch-stop-job-runclj

(batch-stop-job-run &
                    {:keys [job-name job-run-ids]
                     :as batch-stop-job-run-request})

batch-update-partitionclj

(batch-update-partition &
                        {:keys [catalog-id database-name entries table-name]
                         :as batch-update-partition-request})

cancel-ml-task-runclj

(cancel-ml-task-run &
                    {:keys [task-run-id transform-id]
                     :as cancel-mltask-run-request})

cancel-mltask-runclj

(cancel-mltask-run &
                   {:keys [task-run-id transform-id]
                    :as cancel-mltask-run-request})

check-schema-version-validityclj

(check-schema-version-validity &
                               {:keys [data-format schema-definition]
                                :as check-schema-version-validity-request})

client-classclj

create-blueprintclj

(create-blueprint &
                  {:keys [blueprint-location description name tags]
                   :as create-blueprint-request})

create-classifierclj

(create-classifier &
                   {:keys [csv-classifier grok-classifier json-classifier
                           xml-classifier]
                    :as create-classifier-request})

create-connectionclj

(create-connection &
                   {:keys [catalog-id connection-input tags]
                    :as create-connection-request})

create-crawlerclj

(create-crawler &
                {:keys [classifiers configuration crawler-security-configuration
                        database-name description lineage-configuration name
                        recrawl-policy role schedule schema-change-policy
                        table-prefix tags targets]
                 :as create-crawler-request})

create-databaseclj

(create-database &
                 {:keys [catalog-id database-input]
                  :as create-database-request})

create-dev-endpointclj

(create-dev-endpoint &
                     {:keys [arguments endpoint-name extra-jars-s3-path
                             extra-python-libs-s3-path glue-version
                             number-of-nodes number-of-workers public-key
                             public-keys role-arn security-configuration
                             security-group-ids subnet-id tags worker-type]
                      :as create-dev-endpoint-request})

create-jobclj

(create-job &
            {:keys [allocated-capacity command connections default-arguments
                    description execution-property glue-version log-uri
                    max-capacity max-retries name non-overridable-arguments
                    notification-property number-of-workers role
                    security-configuration tags timeout worker-type]
             :as create-job-request})

create-ml-transformclj

(create-ml-transform &
                     {:keys [description glue-version input-record-tables
                             max-capacity max-retries name number-of-workers
                             parameters role tags timeout transform-encryption
                             worker-type]
                      :as create-mltransform-request})

create-mltransformclj

(create-mltransform &
                    {:keys [description glue-version input-record-tables
                            max-capacity max-retries name number-of-workers
                            parameters role tags timeout transform-encryption
                            worker-type]
                     :as create-mltransform-request})

create-partitionclj

(create-partition &
                  {:keys [catalog-id database-name partition-input table-name]
                   :as create-partition-request})

create-partition-indexclj

(create-partition-index &
                        {:keys [catalog-id database-name partition-index
                                table-name]
                         :as create-partition-index-request})

create-registryclj

(create-registry &
                 {:keys [description registry-name tags]
                  :as create-registry-request})

create-schemaclj

(create-schema &
               {:keys [compatibility data-format description registry-id
                       schema-definition schema-name tags]
                :as create-schema-request})

create-scriptclj

(create-script &
               {:keys [dag-edges dag-nodes language] :as create-script-request})

create-security-configurationclj

(create-security-configuration &
                               {:keys [encryption-configuration name]
                                :as create-security-configuration-request})

create-tableclj

(create-table &
              {:keys [catalog-id database-name partition-indexes table-input
                      transaction-id]
               :as create-table-request})

create-triggerclj

(create-trigger &
                {:keys [actions description event-batching-condition name
                        predicate schedule start-on-creation tags type
                        workflow-name]
                 :as create-trigger-request})

create-user-defined-functionclj

(create-user-defined-function &
                              {:keys [catalog-id database-name function-input]
                               :as create-user-defined-function-request})

create-workflowclj

(create-workflow &
                 {:keys [default-run-properties description max-concurrent-runs
                         name tags]
                  :as create-workflow-request})

delete-blueprintclj

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

delete-classifierclj

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

delete-column-statistics-for-partitionclj

(delete-column-statistics-for-partition
  &
  {:keys [catalog-id column-name database-name partition-values table-name]
   :as delete-column-statistics-for-partition-request})

delete-column-statistics-for-tableclj

(delete-column-statistics-for-table
  &
  {:keys [catalog-id column-name database-name table-name]
   :as delete-column-statistics-for-table-request})

delete-connectionclj

(delete-connection &
                   {:keys [catalog-id connection-name]
                    :as delete-connection-request})

delete-crawlerclj

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

delete-databaseclj

(delete-database & {:keys [catalog-id name] :as delete-database-request})

delete-dev-endpointclj

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

delete-jobclj

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

delete-ml-transformclj

(delete-ml-transform & {:keys [transform-id] :as delete-mltransform-request})

delete-mltransformclj

(delete-mltransform & {:keys [transform-id] :as delete-mltransform-request})

delete-partitionclj

(delete-partition &
                  {:keys [catalog-id database-name partition-values table-name]
                   :as delete-partition-request})

delete-partition-indexclj

(delete-partition-index &
                        {:keys [catalog-id database-name index-name table-name]
                         :as delete-partition-index-request})

delete-registryclj

(delete-registry & {:keys [registry-id] :as delete-registry-request})

delete-resource-policyclj

(delete-resource-policy &
                        {:keys [policy-hash-condition resource-arn]
                         :as delete-resource-policy-request})

delete-schemaclj

(delete-schema & {:keys [schema-id] :as delete-schema-request})

delete-schema-versionsclj

(delete-schema-versions &
                        {:keys [schema-id versions]
                         :as delete-schema-versions-request})

delete-security-configurationclj

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

delete-tableclj

(delete-table &
              {:keys [catalog-id database-name name transaction-id]
               :as delete-table-request})

delete-table-versionclj

(delete-table-version &
                      {:keys [catalog-id database-name table-name version-id]
                       :as delete-table-version-request})

delete-triggerclj

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

delete-user-defined-functionclj

(delete-user-defined-function &
                              {:keys [catalog-id database-name function-name]
                               :as delete-user-defined-function-request})

delete-workflowclj

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

get-blueprintclj

(get-blueprint &
               {:keys [include-blueprint include-parameter-spec name]
                :as get-blueprint-request})

get-blueprint-runclj

(get-blueprint-run &
                   {:keys [blueprint-name run-id]
                    :as get-blueprint-run-request})

get-blueprint-runsclj

(get-blueprint-runs &
                    {:keys [blueprint-name max-results next-token]
                     :as get-blueprint-runs-request})

get-cached-response-metadataclj

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

get-catalog-import-statusclj

(get-catalog-import-status &
                           {:keys [catalog-id]
                            :as get-catalog-import-status-request})

get-classifierclj

(get-classifier & {:keys [name] :as get-classifier-request})

get-classifiersclj

(get-classifiers & {:keys [max-results next-token] :as get-classifiers-request})

get-column-statistics-for-partitionclj

(get-column-statistics-for-partition
  &
  {:keys [catalog-id column-names database-name partition-values table-name]
   :as get-column-statistics-for-partition-request})

get-column-statistics-for-tableclj

(get-column-statistics-for-table &
                                 {:keys [catalog-id column-names database-name
                                         table-name]
                                  :as get-column-statistics-for-table-request})

get-connectionclj

(get-connection &
                {:keys [catalog-id hide-password name]
                 :as get-connection-request})

get-connectionsclj

(get-connections &
                 {:keys [catalog-id filter hide-password max-results next-token]
                  :as get-connections-request})

get-crawlerclj

(get-crawler & {:keys [name] :as get-crawler-request})

get-crawler-metricsclj

(get-crawler-metrics &
                     {:keys [crawler-name-list max-results next-token]
                      :as get-crawler-metrics-request})

get-crawlersclj

(get-crawlers & {:keys [max-results next-token] :as get-crawlers-request})

get-data-catalog-encryption-settingsclj

(get-data-catalog-encryption-settings
  &
  {:keys [catalog-id] :as get-data-catalog-encryption-settings-request})

get-databaseclj

(get-database & {:keys [catalog-id name] :as get-database-request})

get-databasesclj

(get-databases &
               {:keys [catalog-id max-results next-token resource-share-type]
                :as get-databases-request})

get-dataflow-graphclj

(get-dataflow-graph & {:keys [python-script] :as get-dataflow-graph-request})

get-dev-endpointclj

(get-dev-endpoint & {:keys [endpoint-name] :as get-dev-endpoint-request})

get-dev-endpointsclj

(get-dev-endpoints &
                   {:keys [max-results next-token]
                    :as get-dev-endpoints-request})

get-jobclj

(get-job & {:keys [job-name] :as get-job-request})

get-job-bookmarkclj

(get-job-bookmark & {:keys [job-name run-id] :as get-job-bookmark-request})

get-job-runclj

(get-job-run &
             {:keys [job-name predecessors-included run-id]
              :as get-job-run-request})

get-job-runsclj

(get-job-runs &
              {:keys [job-name max-results next-token]
               :as get-job-runs-request})

get-jobsclj

(get-jobs & {:keys [max-results next-token] :as get-jobs-request})

get-mappingclj

(get-mapping & {:keys [location sinks source] :as get-mapping-request})

get-ml-task-runclj

(get-ml-task-run &
                 {:keys [task-run-id transform-id] :as get-mltask-run-request})

get-ml-task-runsclj

(get-ml-task-runs &
                  {:keys [filter max-results next-token sort transform-id]
                   :as get-mltask-runs-request})

get-ml-transformclj

(get-ml-transform & {:keys [transform-id] :as get-mltransform-request})

get-ml-transformsclj

(get-ml-transforms &
                   {:keys [filter max-results next-token sort]
                    :as get-mltransforms-request})

get-mltask-runclj

(get-mltask-run & {:keys [task-run-id transform-id] :as get-mltask-run-request})

get-mltask-runsclj

(get-mltask-runs &
                 {:keys [filter max-results next-token sort transform-id]
                  :as get-mltask-runs-request})

get-mltransformclj

(get-mltransform & {:keys [transform-id] :as get-mltransform-request})

get-mltransformsclj

(get-mltransforms &
                  {:keys [filter max-results next-token sort]
                   :as get-mltransforms-request})

get-partitionclj

(get-partition &
               {:keys [catalog-id database-name partition-values table-name]
                :as get-partition-request})

get-partition-indexesclj

(get-partition-indexes &
                       {:keys [catalog-id database-name next-token table-name]
                        :as get-partition-indexes-request})

get-partitionsclj

(get-partitions &
                {:keys [catalog-id database-name exclude-column-schema
                        expression max-results next-token query-as-of-time
                        segment table-name transaction-id]
                 :as get-partitions-request})

get-planclj

(get-plan &
          {:keys [additional-plan-options-map language location mapping sinks
                  source]
           :as get-plan-request})

get-registryclj

(get-registry & {:keys [registry-id] :as get-registry-request})

get-resource-policiesclj

(get-resource-policies &
                       {:keys [max-results next-token]
                        :as get-resource-policies-request})

get-resource-policyclj

(get-resource-policy & {:keys [resource-arn] :as get-resource-policy-request})

get-schemaclj

(get-schema & {:keys [schema-id] :as get-schema-request})

get-schema-by-definitionclj

(get-schema-by-definition &
                          {:keys [schema-definition schema-id]
                           :as get-schema-by-definition-request})

get-schema-versionclj

(get-schema-version &
                    {:keys [schema-id schema-version-id schema-version-number]
                     :as get-schema-version-request})

get-schema-versions-diffclj

(get-schema-versions-diff &
                          {:keys [first-schema-version-number schema-diff-type
                                  schema-id second-schema-version-number]
                           :as get-schema-versions-diff-request})

get-security-configurationclj

(get-security-configuration &
                            {:keys [name]
                             :as get-security-configuration-request})

get-security-configurationsclj

(get-security-configurations &
                             {:keys [max-results next-token]
                              :as get-security-configurations-request})

get-tableclj

(get-table &
           {:keys [catalog-id database-name name query-as-of-time
                   transaction-id]
            :as get-table-request})

get-table-versionclj

(get-table-version &
                   {:keys [catalog-id database-name table-name version-id]
                    :as get-table-version-request})

get-table-versionsclj

(get-table-versions &
                    {:keys [catalog-id database-name max-results next-token
                            table-name]
                     :as get-table-versions-request})

get-tablesclj

(get-tables &
            {:keys [catalog-id database-name expression max-results next-token
                    query-as-of-time transaction-id]
             :as get-tables-request})

get-tagsclj

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

get-triggerclj

(get-trigger & {:keys [name] :as get-trigger-request})

get-triggersclj

(get-triggers &
              {:keys [dependent-job-name max-results next-token]
               :as get-triggers-request})

get-user-defined-functionclj

(get-user-defined-function &
                           {:keys [catalog-id database-name function-name]
                            :as get-user-defined-function-request})

get-user-defined-functionsclj

(get-user-defined-functions &
                            {:keys [catalog-id database-name max-results
                                    next-token pattern]
                             :as get-user-defined-functions-request})

get-workflowclj

(get-workflow & {:keys [include-graph name] :as get-workflow-request})

get-workflow-runclj

(get-workflow-run &
                  {:keys [include-graph name run-id]
                   :as get-workflow-run-request})

get-workflow-run-propertiesclj

(get-workflow-run-properties &
                             {:keys [name run-id]
                              :as get-workflow-run-properties-request})

get-workflow-runsclj

(get-workflow-runs &
                   {:keys [include-graph max-results name next-token]
                    :as get-workflow-runs-request})

import-catalog-to-glueclj

(import-catalog-to-glue &
                        {:keys [catalog-id] :as import-catalog-to-glue-request})

list-blueprintsclj

(list-blueprints &
                 {:keys [max-results next-token tags]
                  :as list-blueprints-request})

list-crawlersclj

(list-crawlers &
               {:keys [max-results next-token tags] :as list-crawlers-request})

list-dev-endpointsclj

(list-dev-endpoints &
                    {:keys [max-results next-token tags]
                     :as list-dev-endpoints-request})

list-jobsclj

(list-jobs & {:keys [max-results next-token tags] :as list-jobs-request})

list-ml-transformsclj

(list-ml-transforms &
                    {:keys [filter max-results next-token sort tags]
                     :as list-mltransforms-request})

list-mltransformsclj

(list-mltransforms &
                   {:keys [filter max-results next-token sort tags]
                    :as list-mltransforms-request})

list-registriesclj

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

list-schema-versionsclj

(list-schema-versions &
                      {:keys [max-results next-token schema-id]
                       :as list-schema-versions-request})

list-schemasclj

(list-schemas &
              {:keys [max-results next-token registry-id]
               :as list-schemas-request})

list-triggersclj

(list-triggers &
               {:keys [dependent-job-name max-results next-token tags]
                :as list-triggers-request})

list-workflowsclj

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

put-data-catalog-encryption-settingsclj

(put-data-catalog-encryption-settings
  &
  {:keys [catalog-id data-catalog-encryption-settings]
   :as put-data-catalog-encryption-settings-request})

put-resource-policyclj

(put-resource-policy &
                     {:keys [enable-hybrid policy-exists-condition
                             policy-hash-condition policy-in-json resource-arn]
                      :as put-resource-policy-request})

put-schema-version-metadataclj

(put-schema-version-metadata &
                             {:keys [metadata-key-value schema-id
                                     schema-version-id schema-version-number]
                              :as put-schema-version-metadata-request})

put-workflow-run-propertiesclj

(put-workflow-run-properties &
                             {:keys [name run-id run-properties]
                              :as put-workflow-run-properties-request})

query-schema-version-metadataclj

(query-schema-version-metadata &
                               {:keys [max-results metadata-list next-token
                                       schema-id schema-version-id
                                       schema-version-number]
                                :as query-schema-version-metadata-request})

register-schema-versionclj

(register-schema-version &
                         {:keys [schema-definition schema-id]
                          :as register-schema-version-request})

remove-schema-version-metadataclj

(remove-schema-version-metadata &
                                {:keys [metadata-key-value schema-id
                                        schema-version-id schema-version-number]
                                 :as remove-schema-version-metadata-request})

reset-job-bookmarkclj

(reset-job-bookmark & {:keys [job-name run-id] :as reset-job-bookmark-request})

resume-workflow-runclj

(resume-workflow-run &
                     {:keys [name node-ids run-id]
                      :as resume-workflow-run-request})

search-tablesclj

(search-tables &
               {:keys [catalog-id filters max-results next-token
                       resource-share-type search-text sort-criteria]
                :as search-tables-request})

show-functionsclj

shutdownclj

(shutdown)

start-blueprint-runclj

(start-blueprint-run &
                     {:keys [blueprint-name parameters role-arn]
                      :as start-blueprint-run-request})

start-crawlerclj

(start-crawler & {:keys [name] :as start-crawler-request})

start-crawler-scheduleclj

(start-crawler-schedule &
                        {:keys [crawler-name]
                         :as start-crawler-schedule-request})

start-export-labels-task-runclj

(start-export-labels-task-run &
                              {:keys [output-s3-path transform-id]
                               :as start-export-labels-task-run-request})

start-import-labels-task-runclj

(start-import-labels-task-run &
                              {:keys [input-s3-path replace-all-labels
                                      transform-id]
                               :as start-import-labels-task-run-request})

start-job-runclj

(start-job-run &
               {:keys [allocated-capacity arguments job-name job-run-id
                       max-capacity notification-property number-of-workers
                       security-configuration timeout worker-type]
                :as start-job-run-request})

start-ml-evaluation-task-runclj

(start-ml-evaluation-task-run &
                              {:keys [transform-id]
                               :as start-mlevaluation-task-run-request})

start-ml-labeling-set-generation-task-runclj

(start-ml-labeling-set-generation-task-run
  &
  {:keys [output-s3-path transform-id]
   :as start-mllabeling-set-generation-task-run-request})

start-mlevaluation-task-runclj

(start-mlevaluation-task-run &
                             {:keys [transform-id]
                              :as start-mlevaluation-task-run-request})

start-mllabeling-set-generation-task-runclj

(start-mllabeling-set-generation-task-run
  &
  {:keys [output-s3-path transform-id]
   :as start-mllabeling-set-generation-task-run-request})

start-triggerclj

(start-trigger & {:keys [name] :as start-trigger-request})

start-workflow-runclj

(start-workflow-run & {:keys [name] :as start-workflow-run-request})

stop-crawlerclj

(stop-crawler & {:keys [name] :as stop-crawler-request})

stop-crawler-scheduleclj

(stop-crawler-schedule &
                       {:keys [crawler-name] :as stop-crawler-schedule-request})

stop-triggerclj

(stop-trigger & {:keys [name] :as stop-trigger-request})

stop-workflow-runclj

(stop-workflow-run & {:keys [name run-id] :as stop-workflow-run-request})

tag-resourceclj

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

untag-resourceclj

(untag-resource &
                {:keys [resource-arn tags-to-remove]
                 :as untag-resource-request})

update-blueprintclj

(update-blueprint &
                  {:keys [blueprint-location description name]
                   :as update-blueprint-request})

update-classifierclj

(update-classifier &
                   {:keys [csv-classifier grok-classifier json-classifier
                           xml-classifier]
                    :as update-classifier-request})

update-column-statistics-for-partitionclj

(update-column-statistics-for-partition
  &
  {:keys [catalog-id column-statistics-list database-name partition-values
          table-name]
   :as update-column-statistics-for-partition-request})

update-column-statistics-for-tableclj

(update-column-statistics-for-table
  &
  {:keys [catalog-id column-statistics-list database-name table-name]
   :as update-column-statistics-for-table-request})

update-connectionclj

(update-connection &
                   {:keys [catalog-id connection-input name]
                    :as update-connection-request})

update-crawlerclj

(update-crawler &
                {:keys [classifiers configuration crawler-security-configuration
                        database-name description lineage-configuration name
                        recrawl-policy role schedule schema-change-policy
                        table-prefix targets]
                 :as update-crawler-request})

update-crawler-scheduleclj

(update-crawler-schedule &
                         {:keys [crawler-name schedule]
                          :as update-crawler-schedule-request})

update-databaseclj

(update-database &
                 {:keys [catalog-id database-input name]
                  :as update-database-request})

update-dev-endpointclj

(update-dev-endpoint &
                     {:keys [add-arguments add-public-keys custom-libraries
                             delete-arguments delete-public-keys endpoint-name
                             public-key update-etl-libraries]
                      :as update-dev-endpoint-request})

update-jobclj

(update-job & {:keys [job-name job-update] :as update-job-request})

update-ml-transformclj

(update-ml-transform &
                     {:keys [description glue-version max-capacity max-retries
                             name number-of-workers parameters role timeout
                             transform-id worker-type]
                      :as update-mltransform-request})

update-mltransformclj

(update-mltransform &
                    {:keys [description glue-version max-capacity max-retries
                            name number-of-workers parameters role timeout
                            transform-id worker-type]
                     :as update-mltransform-request})

update-partitionclj

(update-partition &
                  {:keys [catalog-id database-name partition-input
                          partition-value-list table-name]
                   :as update-partition-request})

update-registryclj

(update-registry &
                 {:keys [description registry-id] :as update-registry-request})

update-schemaclj

(update-schema &
               {:keys [compatibility description schema-id
                       schema-version-number]
                :as update-schema-request})

update-tableclj

(update-table &
              {:keys [catalog-id database-name skip-archive table-input
                      transaction-id]
               :as update-table-request})

update-triggerclj

(update-trigger & {:keys [name trigger-update] :as update-trigger-request})

update-user-defined-functionclj

(update-user-defined-function &
                              {:keys [catalog-id database-name function-input
                                      function-name]
                               :as update-user-defined-function-request})

update-workflowclj

(update-workflow &
                 {:keys [default-run-properties description max-concurrent-runs
                         name]
                  :as update-workflow-request})

cljdoc is a website building & hosting documentation for Clojure/Script libraries

Keyboard shortcutsReport a problemcljdoc on GitHub
× close