Generated banner for Dsql
Generated logo for Dsql

Dsql

AWS LabsOfficialPublished by AWS Labs

  • Skill
  • Tool integration
  • Data and AI
  • Apache-2.0
  • Low risk
  • Has scripts

From the author

Build with Aurora DSQL — manage schemas, execute queries, handle migrations, diagnose query plans, diagnose cluster performance, load data, and develop applications with a serverless, distributed SQL database. Covers IAM auth, multi-tenant patterns, MySQL-to-DSQL and PostgreSQL-to-DSQL schema conversion, foreign key constraints, OCC retry patterns, ORM migration (Django/EF Core/Hibernate/Rails/SQLAlchemy), DDL operations, query plan explainability, system diagnostics via CloudWatch AAS, SQL compatibility validation, and bulk data loading. Load before answering DSQL limit or error-code questions; it has limits docs omit. Triggers on phrases like: DSQL, Aurora DSQL, distributed SQL database, serverless PostgreSQL-compatible database, migrate to DSQL, DSQL query plan, DSQL EXPLAIN ANALYZE, DSQL ENUM, DSQL foreign key, DSQL OCC retry, DSQL multi-region, DSQL JSONB, DSQL GIN index, load into DSQL, load CSV into DSQL, bulk load DSQL, aurora-dsql-loader, DSQL slow, DSQL performance, DSQL wait events, DSQL AAS.
— the description by AWS Labs

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The dsql skill provides a structured framework for interacting with Amazon Aurora DSQL. It encompasses schema management, migration strategies from MySQL and PostgreSQL, performance diagnostics, and bulk data loading. The skill integrates with MCP tools for direct database operations and provides extensive documentation on IAM authentication, multi-tenant patterns, and transaction management to ensure safe and efficient database operations.

What it does

  • Executes SQL queries and DDL operations via MCP tools.
  • Provides migration paths and type mapping for MySQL and PostgreSQL to DSQL.
  • Offers diagnostic workflows for cluster performance and query plan explainability.
  • Facilitates bulk data loading using specialized loaders.
  • Enforces best practices for IAM authentication and scoped database roles.
  • Validates SQL compatibility and provides linting for DSQL-specific constraints.

When to use it

  • When building or migrating applications to Aurora DSQL.
  • When performing schema changes or complex DDL migrations.
  • When troubleshooting performance issues or query plan inefficiencies.
  • When setting up multi-tenant database architectures.
  • When bulk loading data into a DSQL cluster.

Advantages

  • Ensures adherence to DSQL-specific transaction and concurrency limits.
  • Promotes secure access patterns through IAM and scoped roles.
  • Provides clear, phased workflows for complex tasks like performance tuning.
  • Reduces migration friction with automated linting and type mapping guidance.
  • Standardizes diagnostic reporting for query plan analysis.

Usage examples

“How do I migrate my existing PostgreSQL schema to Aurora DSQL?”
The agent will guide you through pg-migrations/type-mapping.md and schema-objects.md, providing steps to convert indexes, enums, and data types while ensuring compatibility.
“My query is running slowly on DSQL, can you help?”
The agent will initiate Workflow 9 (Query Plan Explainability) to analyze the query plan, check for full scans, and provide a structured diagnostic report.
“How do I set up a multi-tenant table in DSQL?”
The agent will provide instructions on using tenant_id in your schema design, enforcing it in WHERE clauses, and using separate transact calls for DDL.
“What are the transaction limits for DSQL?”
The agent will consult the limits-and-error-codes.md or awsknowledge tool to provide the exact limits for row modifications, data size, and duration.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/awslabs/dsql/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip dsql.zip -d .agents/skills

Documentation by AWS Labs

Amazon Aurora DSQL Skill

Aurora DSQL is a serverless, PostgreSQL-compatible distributed SQL database. This skill covers direct query execution via MCP tools, schema management, migrations, multi-tenant isolation, IAM auth, and bulk data loading via aurora-dsql-loader.


Reference Files

Load these files as needed for detailed guidance:

Core:
ReferenceWhen to LoadContains
development-guide.mdALWAYS before schema changes or DB operationsBest practices, DDL rules, transaction limits, foreign key constraints
foreign-keys.mdMUST load for foreign key operations or migrationsFK syntax, actions, validation, tenant keys
language.mdMUST load for language-specific choicesDriver selection, DSQL Connectors, connection code
access-control.mdMUST load for roles, grants, or sensitive dataScoped role setup, IAM-to-database role mapping
troubleshooting.mdSHOULD load for errors or unexpected behaviorOCC and 23503, FK, connections, cluster state
limits-and-error-codes.mdSHOULD load before sizing batches, keys or indexes, or on 54000/0A000/54011Every limit, rejection and quota with SQLSTATE and exact message
dsql-examples.mdLoad for implementation examplesMulti-tenant access, batch operations, identity and sequences, connection pooling
onboarding.mdUser requests "Get started with DSQL"Interactive step-by-step guide
occ-retry-patterns.mdMUST load for OCC retry code or conflict mitigationConnectors, 40001 retry, non-retryable 23503, FK read conflicts, idempotent design
MCP:
ReferenceWhen to LoadContains
mcp-setup.mdAlways for MCP server guidanceSetup instructions, 2 configuration options
mcp-tools.mdFor MCP tool syntax and examplesTool parameters, input validation
dsql-lint.mdMUST load before running dsql_lint or processing external SQLTool reference, fix statuses, unfixable error resolution
DDL Migrations:
ReferenceWhen to LoadContains
ddl-migrations/overview.mdMUST load for ALTER TYPE, SET NOT NULL, MODIFY PRIMARY KEYDirect ALTER coverage and last-resort table recreation
ddl-migrations/column-operations.mdDROP COLUMN, ALTER TYPE, SET/DROP NOT NULL/DEFAULTColumn-level migration patterns
ddl-migrations/constraint-operations.mdADD/DROP CONSTRAINT, VALIDATE CONSTRAINT, MODIFY PRIMARY KEYConstraint and structural changes
ddl-migrations/batched-migration.mdTables exceeding 3,000 rowsBatching patterns, progress tracking
MySQL Migrations:
ReferenceWhen to LoadContains
mysql-migrations/type-mapping.mdMUST load for MySQL → DSQL migrationData type mappings, feature alternatives
mysql-migrations/ddl-operations.mdTranslating MySQL DDL to DSQLAUTO_INCREMENT, ENUM, SET, FK patterns
mysql-migrations/full-example.mdComplete MySQL table migrationEnd-to-end example with decision summary
PostgreSQL Migrations:
ReferenceWhen to LoadContains
pg-migrations/type-mapping.mdMUST load for DSQL NUMERIC or PG type questionsC collation rules, NUMERIC(p,s), JSON/JSONB
pg-migrations/index-conversion.mdMUST load for any index conversion or index support questionGIN/GiST/BRIN → btree, operator class removal, partial + expression indexes, sort order
pg-migrations/schema-objects.mdMUST load for ENUM, materialized views, extensions, multi-schema, CREATE FUNCTIONENUM → CHECK, views, role/IAM mapping, LANGUAGE sql functions
pg-migrations/multi-region.mdMulti-region, active-active, or HA questionsArchitecture, geographic partitioning
ORM Guides:
ReferenceWhen to LoadContains
orm-guides/overview.mdMigrating an ORM or using ORM locking with DSQLAdapter names, locking, and key gotchas for Django/EF Core/Hibernate/Rails/SQLAlchemy
Data Loading:
ReferenceWhen to LoadContains
data-loading.mdPlanning or running bulk loads with aurora-dsql-loaderFresh-vs-warm partitions, resume/retry, --on-conflict semantics, throughput diagnostics
System Diagnostics:
ReferenceWhen to LoadContains
system-diagnostics/workflow.mdMUST load at Workflow 12 entry — cluster performance diagnosticsPrerequisites, 5 diagnostic phases, temporal comparison, handoff
system-diagnostics/wait-events.mdALWAYS load when interpreting AAS resultsCanonical DSQL wait event descriptions and investigation guidance
system-diagnostics/promql-patterns.mdLoad when constructing PromQL queriesReusable query templates for AAS breakdown, top-SQL, temporal compare
Query Plan Explainability:
ReferenceWhen to LoadContains
query-plan/workflow.mdMUST load at Workflow 9 entry — gates all other filesTrigger criteria, context disambiguation, routing, phased workflow
query-plan/plan-interpretation.mdMUST load at Workflow 9 Phase 0DSQL node types, Node Duration math, estimation-error bands
query-plan/catalog-queries.mdMUST load at Workflow 9 Phase 0pg_class/pg_stats/pg_indexes SQL, correlated-predicate verification
query-plan/guc-experiments.mdMUST load at Workflow 9 Phase 0GUC experiment procedures, 30-second skip protocol
query-plan/report-format.mdMUST load at Workflow 9 Phase 0Required report structure, element checklist, support request template
query-plan/query-rewrites-generic.mdSHOULD load at Phase 0; sub-files on-demandIndex of 10 generic rewrite patterns
query-plan/query-rewrites-dsql-specific.mdSHOULD load at Phase 0; sub-files on-demandIndex of DSQL-specific rewrite patterns

Choosing How to Connect: MCP vs CLI/psql

The aurora-dsql MCP server binds a single cluster at startup (--cluster_endpoint), so using it for another cluster means editing .mcp.json and restarting the session.

  • Use the aurora-dsql MCP tools (readonly_query, transact, get_schema) ONLY when the server already targets the cluster you need.

  • Otherwise — unconfigured, disabled, or bound to a different cluster — do NOT reconfigure it. Use the CLI + psql path instead: scripts/psql-connect.sh <cluster-id> --region <region> --command "SELECT ..." (mints an IAM token and runs via psql).

  • If you cannot confirm which cluster the MCP targets, confirm first or use the CLI/psql path — running against the wrong cluster is worse than the check.

The doc-only MCP tools (dsql_lint, dsql_*_documentation, dsql_recommend) need no cluster. The CloudWatch MCP (Workflow 12) takes region/cluster_id per call, so one running server can query clusters in any PromQL-enabled region (pass each cluster's region on the call). Details: connectivity-tools.md.

MCP Tools Available

The aurora-dsql MCP server provides these tools:

Database Operations:

  1. readonly_query - Execute SELECT queries (returns list of dicts)

  2. transact - Execute DDL/DML statements in transaction (takes list of SQL statements)

  3. get_schema - Get table structure for a specific table

SQL Validation:

  1. dsql_lint - Validate SQL for DSQL compatibility and optionally auto-fix issues. Use before executing externally-sourced SQL.

Documentation & Knowledge:

  1. dsql_search_documentation - Search Aurora DSQL documentation

  2. dsql_read_documentation - Read specific documentation pages

  3. dsql_recommend - Get DSQL best practice recommendations

Note: There is no list_tables tool. Use readonly_query with information_schema.

See mcp-setup.md for detailed setup instructions. See mcp-tools.md for detailed usage and examples.

AWS Knowledge MCP (awsknowledge)

Consult for verifying DSQL service limits before advising users. The numeric limits below are defaults that may change — when a user's decision depends on an exact limit, verify it first:

LimitDefaultVerify query
Max row modifications per transaction3,000aurora dsql transaction limits
Max data size per transaction10 MiBaurora dsql transaction limits
Max transaction duration5 minutesaurora dsql transaction limits
Max connections per cluster10,000aurora dsql connection limits
Auth token expiry15 minutesaurora dsql authentication token
Max connection duration60 minutesaurora dsql connection limits
Max indexes per table24 incl. PKaurora dsql index limits
Max columns per index8aurora dsql index limits
IDENTITY/SEQUENCE CACHE values1 or >= 65536aurora dsql sequence cache
Supported column data typesSee docsaurora dsql supported data types

When to verify: Before recommending batch sizes, connection pool settings, or schema designs where hitting a limit would cause failures; any time the exact number can affect user decision. For the full limit set with each SQLSTATE and its exact error message, see limits-and-error-codes.md; where it marks a value observed and the docs differ, use the observed value.

Fallback: If awsknowledge is unavailable, use the defaults above and flag that limits should be verified against DSQL documentation.

CLI Scripts Available

Bash scripts in scripts/ for cluster management (create, delete, list, cluster info), psql connection, and bulk data loading from local/s3 csv/tsv/parquet files. See scripts/README.md for usage and hook configuration.


Quick Start

  1. Pick a connection path: confirm the aurora-dsql MCP targets your cluster; if not, use the CLI/psql path instead — see Choosing How to Connect. The steps below name MCP tools; the equivalent SQL runs the same way through psql-connect.sh --command "...".

  2. Explore: Use readonly_query with information_schema to list tables. Use get_schema for table structure.

  3. Query: Use readonly_query for SELECT queries. MUST include tenant_id in WHERE for multi-tenant apps. MUST build SQL with safe_query.build().

  4. Schema changes: Use transact with one DDL per transaction. MUST batch DML under 3,000 rows. MUST use CREATE INDEX ASYNC in a separate call. Use dsql_lint to validate first.

  5. Bulk load data: Use aurora-dsql-loader for CSV/TSV/Parquet. Load data-loading.md for details. Use --dry-run first.


Performance Routing

When the user reports a performance problem, use this table to select the correct workflow:

User signalRoute to
General performance complaint, "cluster is slow", "something changed", latency regression, no specific query identifiedWorkflow 12 (System Diagnostics) — observe via CloudWatch first
Specific query or query_id to investigate, "explain this plan", "why is this query slow"Workflow 9 (Query Plan Explainability) — direct EXPLAIN analysis
OCC conflicts, commit errors, retry stormsWorkflow 12 (System Diagnostics) — confirm via CW metrics before investigating
Cost optimization, "where is compute time spent"Workflow 12 (System Diagnostics) — identify top contributors first

Rule: When in doubt, start with Workflow 12. It identifies specific queries to investigate and routes to Workflow 9 with context.


Common Workflows

Workflow 1: Create Multi-Tenant Schema
  1. Create tenant-owned tables with tenant_id using separate transact calls

  2. Use composite tenant FKs for tenant-owned parents and ordinary FKs for shared parents

  3. Create tenant and query-pattern indexes with separate CREATE INDEX ASYNC calls

  4. Verify with get_schema

  • MUST issue each DDL in its own transact call: transact(["CREATE TABLE ..."])

  • MUST serialize arrays into a single-column representation — DSQL has no array column type; PREFER JSONB (operators work directly); MAY use TEXT when the column is opaque to the database; ASK the user. For JSONB arrays, expand at query time with jsonb_array_elements_text(data)

Workflow 2: Safe Data Migration

MUST validate every DDL with dsql_lint(fix=true) before executing. DML does not require linting.

  1. Validate DDL with dsql_lint(sql=..., fix=true) — handle diagnostics per dsql-lint.md

  2. Execute the reviewed fixed_sql when present, otherwise the reviewed source statement

  3. Add column in its own transact call

  4. Populate existing rows with UPDATE (batched under 3,000 rows)

  5. Verify with readonly_query COUNT

  6. Create an index if needed: validate then execute the reviewed DDL in its own transact call

  • MUST issue each ALTER TABLE in its own transact call — DSQL rejects multi-DDL transactions with multiple ddl statements not supported in a transaction

  • MUST add column with only name and type; apply DEFAULT via separate UPDATE

  • MUST batch updates under 3,000 rows in separate transact calls

Recovery: Resume failed batches by filtering WHERE new_column IS NULL.

Workflow 3: Bulk Data Loading

Use aurora-dsql-loader for CSV, TSV, or Parquet loads. MUST load data-loading.md before advising on throughput or diagnosing slow loads.

  1. Validate with --dry-run first

  2. Run with --manifest-dir on persistent storage (not /tmp — tmpfs on AL2023, lost on crash) and --header if file has a header row

  3. On failure: resume with --resume-job-id; for duplicates use --on-conflict do-nothing

  4. For large tables: create secondary indexes after load using CREATE INDEX ASYNC

Workflow 4: Foreign Key Constraints

MUST load and follow foreign-keys.md before creating, altering, dropping, or migrating foreign keys.

Workflow 5: Query with Tenant Isolation
  1. MUST authorize the caller against the tenant — format validation does not establish authorization

  2. MUST build SQL with safe_query.build() — use allow()/regex() for values (emits 'v'), ident() for table/column names (emits "v"). See input-validation.md

  3. MUST include tenant_id in the WHERE clause; reject cross-tenant access at the application layer

Workflow 6: Set Up Scoped Database Roles

MUST load access-control.md for role setup, IAM mapping, and schema permissions.

Workflow 7: Table Recreation DDL Migration

For ALTER COLUMN TYPE, SET NOT NULL, or MODIFY PRIMARY KEY, MUST load ddl-migrations/overview.md. Use a direct ALTER form when supported; otherwise, present a user-approved table-recreation plan.

Workflow 8: Validate and Migrate to DSQL

MUST load dsql-lint.md before running dsql_lint. Run dsql_lint(sql=source_sql, fix=true) to validate and auto-convert. For MySQL-origin SQL, MUST cross-check against mysql-migrations/type-mapping.md even when lint returns clean. On parse_error, fall back to manual conversion then re-lint.

Workflow 9: Query Plan Explainability

Explains why the DSQL optimizer chose a particular plan. Triggered by slow queries, high DPU, unexpected Full Scans, or plans the user doesn't understand. REQUIRES a structured Markdown diagnostic report as the deliverable.

MUST load query-plan/workflow.md at entry — it defines trigger criteria, context disambiguation, routing, and the full phased workflow (Phase 0–4). Workflow.md specifies which reference files to load at each phase.

Safety. Plan capture uses readonly_query exclusively. Rewrite DML to SELECT for plan capture. MUST NOT use transact --allow-writes for plan capture.

Workflow 10: Full PostgreSQL → DSQL Schema Migration

MUST load pg-migrations/type-mapping.md, pg-migrations/index-conversion.md, pg-migrations/schema-objects.md, and foreign-keys.md. Run dsql_lint(fix=true) first for mechanical fixes, preserve foreign-key relationships, translate unsupported source syntax or options, then apply semantic conversions from the pg-migrations references for unfixable diagnostics and patterns the linter cannot handle. Re-lint the final output before deploying.

Workflow 11: ORM Migration and Locking (Django/EF Core/Hibernate/Rails/SQLAlchemy)

Load orm-guides/overview.md for adapter names, locking guidance, and framework-specific gotchas.

Workflow 12: System Diagnostics (CloudWatch AAS)

Diagnose cluster performance by querying db.active_sessions.avg via PromQL. Detects temporal anomalies in wait event distribution, identifies regressed queries, and routes to Workflow 9 for per-query investigation.

Requires: CloudWatch MCP server (awslabs.cloudwatch-mcp-server) enabled and configured with PromQL access in the same region as the cluster — see mcp/mcp-setup.md for enabling it, region requirements, and the session restart needed for its tools to register.

MUST load system-diagnostics/workflow.md at entry — it defines prerequisites, 5 diagnostic phases, temporal baselines, and the routing to Workflow 9 for identified queries.

Error Scenarios

  • awsknowledge returns no results: Use the default limits in the table above and note that limits should be verified against DSQL documentation.

  • dsql_lint unavailable or timing out: See the Error Handling section of dsql-lint.md. Do not silently skip validation — inform the user and require explicit confirmation before proceeding with manual rules from development-guide.md.

  • OCC serialization error (40001): Retry with backoff, and keep (OC001) in the loop too — see occ-retry-patterns.md.

  • Foreign key violation (23503): Correct the relationship or referential action; MUST NOT send it through the 40001 retry loop — see troubleshooting.md.

  • Transaction exceeds limits: Split batches under 3,000 rows and 10 MiB; size is checked at COMMIT — see limits-and-error-codes.md to size them and batched-migration.md for the pattern.

  • Token expiration mid-operation: Generate a fresh IAM token — see authentication-guide.md. See troubleshooting.md for other issues.

Additional Resources

Files

LICENSE


                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an MCP server, Needs Python, Needs Node.js

Security

What our scanner noticed· Low risk

  • Instructions that use the network
  • Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
AWS Labs
Publisher
AWS Labs (Official)
Source
awslabs/agent-plugins · plugins/databases-on-aws/skills/dsql · commit fbefb37
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • NOTICE (added by AutoGineer from NOTICE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by AWS Labs.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download dsql.zip