Skip to main content
Glama
728,702 tools. Updated 2026-10-31 14:00

"SQL Queries for Snowflake Database Administration" matching MCP tools:

  • Run a read-only SQL query against an app's Postgres database and return up to 200 result rows. SELECT only — writes and DDL (INSERT/UPDATE/DELETE/ALTER/DROP/…) are rejected server-side; use vibekit_chat or vibekit_submit_task to have the agent make data or schema changes. Call vibekit_db_schema first to learn the tables. SQL string, max 5000 chars.
    ConnectorNo auth
  • Create a database user for a Cloud SQL instance. * This tool returns a long-running operation. Use the `get_operation` tool to poll its status until the operation completes. * When you use the `create_user` tool, specify the type of user: `CLOUD_IAM_USER`, `CLOUD_IAM_SERVICE_ACCOUNT`, or `BUILT_IN`. * By default the newly created user is assigned the `cloudsqlsuperuser` role, unless you specify other database roles explicitly in the request. * You can use a newly created user with the `execute_sql` tool if the user is a currently logged in IAM user. The `execute_sql` tool executes the SQL statements using the privileges of the database user logged in using IAM database authentication. The `create_user` tool has the following limitations: * To create a built-in user with password, use the `password_secret_version` field to provide password using the Google Cloud Secret Manager. The value of `password_secret_version` should be the resource name of the secret version, like `projects/12345/locations/us-central1/secrets/my-password-secret/versions/1` or `projects/12345/locations/us-central1/secrets/my-password-secret/versions/latest`. The caller needs to have `secretmanager.secretVersions.access` permission on the secret version. * The `create_user` tool doesn't support creating a user for SQL Server. To create an IAM user in PostgreSQL: * The database username must be the IAM user's email address and all lowercase. For example, to create user for PostgreSQL IAM user `example-user@example.com`, you can use the following request: ``` { "name": "example-user@example.com", "type": "CLOUD_IAM_USER", "instance":"test-instance", "project": "test-project" } ``` The created database username for the IAM user is `example-user@example.com`. To create an IAM service account in PostgreSQL: * The database username must be created without the `.gserviceaccount.com` suffix even though the full email address for the account is`service-account-name@project-id.iam.gserviceaccount.com`. For example, to create an IAM service account for PostgreSQL you can use the following request format: ``` { "name": "test@test-project.iam", "type": "CLOUD_IAM_SERVICE_ACCOUNT", "instance": "test-instance", "project": "test-project" } ``` The created database username for the IAM service account is `test@test-project.iam`. To create an IAM user or IAM service account in MySQL: * When Cloud SQL for MySQL stores a username, it truncates the @ and the domain name from the user or service account's email address. For example, `example-user@example.com` becomes `example-user`. * For this reason, you can't add two IAM users or service accounts with the same username but different domain names to the same Cloud SQL instance. * For example, to create user for the MySQL IAM user `example-user@example.com`, use the following request: ``` { "name": "example-user@example.com", "type": "CLOUD_IAM_USER", "instance": "test-instance", "project": "test-project" } ``` The created database username for the IAM user is `example-user`. * For example, to create the MySQL IAM service account `service-account-name@project-id.iam.gserviceaccount.com`, use the following request: ``` { "name": "service-account-name@project-id.iam.gserviceaccount.com", "type": "CLOUD_IAM_SERVICE_ACCOUNT", "instance": "test-instance", "project": "test-project" } ``` The created database username for the IAM service account is `service-account-name`.
    ConnectorNo auth
  • List the SQL databases (D1 or Neon Postgres) on my account, including which owned site (if any) each is attached to. Call this BEFORE db_query/db_schema-style work to discover a databaseId — those live on a per-database MCP server reached via GET /api/v1/databases/{id} (see llms.txt), which this id feeds.
    ConnectorNo auth
  • Run a READ-ONLY SQL query against the project's Postgres database (SELECT, EXPLAIN, etc.) — the Floot-managed database, or an external Postgres the user connected to the project. Writes are rejected — use execute_sql for those. Returns JSON: `{rows, rowCount, command, truncated?}` (or `{results: [...]}` for multi-statement queries). Pass `database` only if the project has more than one.
    ConnectorOAuth
  • Run a WRITE SQL statement against the project's Postgres database (the Floot-managed one, or an external Postgres the user connected) — CREATE/ALTER TABLE, INSERT, UPDATE, DELETE, DROP, migrations. Destructive statements are allowed but your MCP client will show the user the SQL and ask them to approve it (they can allow once or for the session). Schema-changing statements (CREATE/ALTER/DROP of tables, types, …) automatically re-pull the typed schema helper and return the updated schema — no separate pull_database_schema call needed. Pass `database` only if the project has more than one. By default the whole query (every statement in it) runs on one connection in one transaction that Floot opens and commits: if any statement fails, or the query times out before its COMMIT, nothing is applied. Leave BEGIN/COMMIT/ROLLBACK out of the query — a COMMIT or ROLLBACK inside it ends that transaction early, so a later failure no longer undoes what came before. Set no_transaction for statements that cannot run inside a transaction block (VACUUM, CREATE INDEX CONCURRENTLY, …); each statement then applies as it finishes. Queries are stopped after 75 seconds either way; split a longer migration into several calls. A disconnect does not stop a call that has started: if you got no result, check the schema before running it again.
    Connector
    Destructive
    OAuth
  • PHP + MySQL plans: runs one read-only SQL statement (SELECT, SHOW, DESCRIBE, EXPLAIN or WITH … SELECT) against the site's database and returns the rows. Runs in a read-only transaction; use execute_sql to change data. Use ? placeholders with params for values.
    ConnectorOAuth

Matching MCP Servers

  • A
    license
    Not graded
    quality
    C
    maintenance
    MCP server that connects to SQL databases (SQLite, PostgreSQL, MSSQL, MySQL) and provides tools to run read-only queries, list schemas/tables, and manage connections via stdio transport.
    Apache 2.0
  • A
    license
    A
    quality
    D
    maintenance
    Enables AI agents to execute SQL queries and explore Snowflake databases using natural language, with schema discovery, table inspection, and readonly mode.
    11
    446 npm
    MIT

Matching MCP Connectors

  • Review Supabase migration changes for missing RLS or policies, unrestricted read/write policies, exposed security definer functions and Data API grant gaps. Pass file contents: sql contains one migration's SQL text; files contains path and content for each file. Runs the VibeRaven 1.7.2 SQL rules and returns finding id, severity, file, line, a suggested fix and a guide link. For missing Data API grants, include the migration revoking default privileges or supabase/config.toml, plus browser files using supabase.from(...) (a "use client" file, or src files with package.json for Vite). Limits: supplied text only, up to 200 KB/50 files; cannot access your repository or database, does not execute SQL, and does not store or log file contents.
    ConnectorNo auth
  • Translates natural language questions into dialect-accurate, optimized SQL SELECT queries with schema awareness and safety checks. Use when generating reporting queries or automated data analytics pipelines; for analyzing SQL execution performance and EXPLAIN plans, use analyze_query_plan instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'natural_language_request' and 'schema_ddl' ('sql_dialect' defaults to 'postgresql_dialect'), supports '?demo=true' or L402 (15 sats), and returns HTTP 400 if invalid.
    ConnectorNo auth
  • Introspect the full database structure for a connection: every table, column, type, primary key, and index (MySQL connections do not report indexes yet; foreign keys are not reported) — the map to build queries against an unfamiliar database. Use analyze_table or data_profile instead when you need column VALUES (stats, nulls, PII) rather than structure. Read-only against your database. Results are cached 1 hour per connection; pass refresh=true to force a live re-introspection and bypass that cache, e.g. right after altering the schema. Does not consume daily quota. Returns tables with their columns, types, primary keys, and indexes.
    ConnectorOAuth
  • Restore the original tenant context set at session start. ALWAYS call this after cross-tenant queries (nevent_switch_tenant) to avoid leaving your SUPERADMIN account pointing to another tenant. For SUPERADMIN users, tenant switches PERSIST in the user record in the database — this tool reverses that. For OWNER/ADMIN/STAFF users, this resets to the session's home tenant. No parameters needed.
    Connector
    Destructive
    No auth
  • WHEN: developer needs correct X++ select or T-SQL for D365 tables with proper joins. Triggers: 'X++ select', 'generate a query', 'SQL for', 'join with', 'how to query', 'générer une requête', 'write a select statement', 'select from', 'X++ query for', 'requête X++', 'écrire une select'. Generate both X++ select statements and equivalent T-SQL queries for D365 F&O tables. Uses real field names, relations, and indexes from the knowledge base to produce correct joins. Supports: field selection, multi-table joins (auto-detects relations), WHERE filters, ORDER BY, TOP/firstonly, cross-company. Also accepts natural language descriptions like 'find all open sales orders for customer 1001 with CustTable join'. [!] For multi-table joins, call find_related_objects (or get_relation_graph if the relation index is loaded) FIRST to get the correct FK relations -- this tool will then produce accurate join conditions. [!] The generated X++ is a template -- adapt it to your custom code context before using in production. Returns side-by-side X++ and SQL with explanations.
    ConnectorNo auth
  • TABLES of one per-chain transfer database (list the tables of eth, bsc, polygon, tron, solana, bitcoin …) — the SHOW TABLES equivalent for eth_api, bsc_api, matic_api (Polygon), arbitrum_api, base_api, optimism_api, robinhood_api, arc_api, tron_api, solana, bitcoin, bitcoin_flow, ripple / ripple_flow (XRP Ledger), cardano / cardano_flow, altcoin / altcoin_flow (Litecoin, Dogecoin and Dash in one database), bitcash / bitcash_flow (Bitcoin Cash) and stellar — with each table's engine, sort key, partition key and approximate row count (Total_Rows; empty for most solana, bitcoin, ripple, cardano, altcoin and stellar tables, where no quick count exists). Only the tables you should query are listed, under the name to use in SQL. The sort key is what makes raw SQL fast: filter on its LEADING columns first (e.g. the address of transfers_sender / transfers_receiver, the transaction hash of the *_tx tables); a query that skips them scans far more data and may time out. Next steps: chain_describe_table for one table's columns, chain_search_columns to find which table has a column, then that chain's <chain>_transfers_raw_sql to run the SQL (bitcoin and bitcoin_flow → btc_transfers_raw_sql, matic_api → matic_transfers_raw_sql, ripple* → xrp_transfers_raw_sql, cardano* → ada_transfers_raw_sql, altcoin* → ltc_ / doge_ / dash_transfers_raw_sql with the chain's blockchain_id filter, bitcash* → bch_transfers_raw_sql, stellar → xlm_transfers_raw_sql). Prefer a specialized per-chain tool whenever one answers the question — chain_capabilities lists them. For trading_rt (DEX trades, prices, OHLC bars) use list_tables; list_databases describes every database.
    ConnectorOAuth
  • Run read-only SQL (DuckDB dialect) directly against any research database. The deep-access tool: anything the prebuilt tools do not cover, compute it yourself here. SELECT/WITH/DESCRIBE/SHOW only, 5000-row cap, 45s timeout, 3GB of memory per query (aggregate in the SQL and filter by date rather than pulling raw rows). A 'truncated' field appears only when the query had more rows than came back; a full page without it is complete. Call list_warehouse first for the schema map. Column names that are easy to guess wrong: prices_daily has adj_close and raw_close (no plain close), raw_volume and dollar_volume; a table in another database is read as <db>.<table> (FRED is fred.fred_obs: series_id, date, value).
    ConnectorOAuth
  • Load a .sql or .sql.gz dump into a site's database, with the site's own credentials: the undo for a bad change, or a restore from a backup. Pass file as list_dumps shows it, or any .sql / .sql.gz file on the server (a backup the user keeps). The database as it is now is dumped first (before-restore-...), so the restore itself can be undone with the same tool. Tables in the file replace the tables of the same name; tables the file does not mention stay. A dump from another database or another site version can break the site: check what the file holds first (read_file the first lines, or list_dumps). Runs in the background: follow with job_output. Say beforehand what will be lost (everything in those tables since the dump). For a few rows or one table, load the dump into a scratch database instead (playbook restore).
    Connector
    Destructive
    OAuth
  • REQUIRED before stock_data_query, 23 SQL patterns prevent timeouts/wrong results Must be called once per session immediately after get_database_schema. Contains query patterns for time-series selection, return calculations, screening joins, window functions, backtesting, and performance optimization. Time-series queries will timeout or return wrong results without these patterns. After this tool returns, call stock_data_query to execute SQL.
    ConnectorNo auth
  • REQUIRED before stock_data_query, 23 SQL patterns prevent timeouts/wrong results Must be called once per session immediately after get_database_schema. Contains query patterns for time-series selection, return calculations, screening joins, window functions, backtesting, and performance optimization. Time-series queries will timeout or return wrong results without these patterns. After this tool returns, call stock_data_query to execute SQL.
    ConnectorNo auth
  • Any question the other tools do not cover, as one read-only SQL statement over the archive database. SELECT or WITH only; a LIMIT is imposed if you omit one. Call `read_first` before computing anything and `list_datasets` to find table names. A query estimated to read more than 250,000 rows is refused — narrow it with a WHERE, or ask for one table at a time.
    ConnectorNo auth
  • Translate a natural-language request into a SQL statement. Returns JSON { sql } containing the query text and nothing else — no validation report, no complexity score, and the query is never executed or checked against a real database. It has no knowledge of your schema beyond what the request states, so table and column names are guesses unless you supply them. Review before running, especially anything that writes. Paid model call. Anonymous callers get 3 per hour per IP and are then refused with 401; signed-in callers get 15 per minute per IP. Capped at roughly 500 tokens. Answers are cached, so the same request returns the same query.
    ConnectorNo auth
  • Translate a natural-language request into a SQL statement. Returns JSON { sql } containing the query text and nothing else — no validation report, no complexity score, and the query is never executed or checked against a real database. It has no knowledge of your schema beyond what the request states, so table and column names are guesses unless you supply them. Review before running, especially anything that writes. Paid model call. Anonymous callers get 3 per hour per IP and are then refused with 401; signed-in callers get 15 per minute per IP. Capped at roughly 500 tokens. Answers are cached, so the same request returns the same query.
    ConnectorNo auth
  • Read the next ordered window of SQL deltas and canonical payloads for a database sync. claim=false is replayable; claim=true leases the window for 120 seconds. Apply a claimed window transactionally, including schema deltas, before ack_database_deltas. limit is also bounded by the registration's page_limit. snapshot_required pauses delivery until the replica reapplies its snapshot. No LLM call. Leasing, cursors, quarantine and snapshot handling: enricher://docs/database-sync.
    ConnectorOAuth
  • Run SQL on the app's database (owner-level, needs database:write), values as $1, $2 in params. Rows capped at 500 / 5 MB. A table left without row-level security is rolled back (RLS_REQUIRED). To just read rows, prefer query_database_rows.
    Connector
    Destructive
    OAuth