ForHosting KIT · Lettura e monitoraggio di siti web

Formatti SQL e renda leggibili le query online

Trasformi una query SQL compatta o dallo stile incoerente in una versione leggibile, con parole chiave maiuscole, spazi prevedibili e rientri strutturati.

● BetaGratis · nel tuo browser

Esegui gratis nel browser Vedi l'API

Usalo da WebAPIEmailTelegramApp presto

Il formattatore esegue un’analisi lessicale deterministica: conserva stringhe e identificatori delimitati, rendendo più semplici da esaminare clausole ed espressioni annidate. Prima di produrre l’output controlla anche la struttura. Parentesi senza corrispondenza, valori tra virgolette incompleti e identificatori delimitati non chiusi vengono rifiutati. Lei può usare lo strumento nel browser oppure automatizzare lo stesso comportamento tramite API al costo di $0.002 per richiesta.

Che cosa modifica e conserva il formattatore

Il formattatore converte in maiuscolo le parole chiave SQL riconosciute e dispone su righe leggibili le clausole principali, tra cui SELECT, FROM, WHERE, GROUP BY, ORDER BY, HAVING, LIMIT e i join più comuni. Le virgole separano gli elementi degli elenchi, mentre le parentesi aggiungono un livello di rientro alle espressioni annidate e alle sottoquery. Gli operatori ricevono spazi uniformi. Contemporaneamente, il contenuto delimitato viene trattato come protetto. Il testo tra apici singoli, gli identificatori tra virgolette doppie o accenti gravi e quelli tra parentesi quadre mantengono caratteri e maiuscole originali. Anche i commenti di riga e di blocco restano nell’output. In questo modo la query diventa più facile da controllare senza fare ipotesi sullo schema del database. La formattazione è volutamente deterministica: lo stesso input genera sempre lo stesso output, senza rete, interpretazioni di modelli, scelte casuali o dipendenze dall’ambiente. Il risultato viene restituito nel campo formatted_sql come testo semplice, che Lei può copiare in un editor, una migrazione, un rapporto o una revisione del codice.

Come la convalida strutturale tutela il risultato

Un output gradevole non è utile se nasconde una query incompleta; per questo la convalida avviene durante la tokenizzazione, prima dell’impaginazione. Ogni parentesi aperta deve avere la relativa chiusura e nessuna parentesi chiusa può precedere quella aperta. Stringhe tra apici singoli e identificatori tra virgolette doppie, accenti gravi o parentesi quadre devono terminare correttamente. I caratteri di citazione raddoppiati all’interno di un valore sono riconosciuti come escape, consentendo la comune rappresentazione SQL di un apostrofo mediante due apici singoli. Anche gli escape con barra inversa rimangono uniti dove compaiono. Un commento di blocco non terminato viene rifiutato, perché non è possibile formattare in sicurezza la parte restante. Questi controlli sono strutturali e non semantici: lo strumento non si collega al database, non verifica tabelle o colonne, non sceglie un dialetto e non stabilisce se l’istruzione verrà eseguita. Una query bilanciata può ancora contenere sintassi specifica errata. Il messaggio segnala quindi parentesi o virgolette non bilanciate come input non valido, senza dichiarare una compilazione SQL completa.

Usare SQL formattato in un flusso affidabile

Incolli la query completa nel campo query e la invii come stringa. Nell’uso interattivo, confronti il risultato formattato con l’originale prima di sostituire codice di produzione, soprattutto quando l’istruzione impiega operatori specifici di un fornitore o regole di delimitazione insolite. Nelle automazioni, esegua il formattatore prima di archiviare migrazioni generate, allegare SQL a richieste di revisione o confrontare modifiche alle query. Un layout uniforme riduce il rumore nelle differenze: chi revisiona può concentrarsi su join, condizioni, colonne selezionate e ordinamento invece che su spazi e maiuscole. Poiché commenti e valori delimitati vengono conservati, il risultato è adatto sia alla documentazione sia all’esecuzione, ma non sostituisce mai la convalida o i test del database. Lo strumento nel browser usa la stessa funzione pura dell’API, mantenendo i risultati coerenti. L’API costa $0.002 per richiesta. L’input viene elaborato senza servizi esterni e non deve essere conservato dopo la risposta. Se la convalida fallisce, corregga il delimitatore senza corrispondenza e invii nuovamente l’intera istruzione.

Casi d'uso

Riordinare SQL generato

Converta una query su una sola riga proveniente da un ORM, un log o uno strumento di report in un formato più facile da esaminare.

Uniformare le revisioni delle migrazioni

Applichi maiuscole e rientri prevedibili prima della revisione per ridurre le differenze che riguardano soltanto lo stile.

Rilevare query incollate incomplete

Rifiuti SQL copiato senza una parentesi o una virgoletta prima di pubblicarlo o passarlo a un altro sistema.

Domande frequenti

Il formattatore esegue il codice SQL?

No. Esegue soltanto una formattazione lessicale locale e controlli strutturali. Non si collega a database e non consulta schemi.

Come gestisce maiuscole e minuscole?

Le parole chiave SQL riconosciute diventano maiuscole. Testo e identificatori delimitati conservano la capitalizzazione originale.

Quali elementi vengono convalidati?

Rifiuta parentesi senza corrispondenza, apici o virgolette non chiusi, identificatori incompleti tra accenti gravi o parentesi quadre e commenti di blocco non terminati.

Supporta tutti i dialetti SQL?

Formatta la sintassi SQL comune senza scegliere un dialetto. Le costruzioni specifiche dei fornitori vengono conservate, ma non ne certifica la semantica.

Quanto costa l’API?

L’API costa $0.002 per richiesta. La versione per browser esegue la stessa logica di formattazione deterministica.

Per sviluppatori — accesso via API

Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.

Endpoint

POSThttps://api.kit.forhosting.com/web/sql-format

Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.

Chiamala dal tuo stack

curl -X POST https://api.kit.forhosting.com/web/sql-format \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"select u.id,u.name,count(o.id) as orders from users u left join orders o on o.user_id=u.id where u.active=true group by u.id,u.name order by orders desc;"}'

const res = await fetch("https://api.kit.forhosting.com/web/sql-format", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "query": "select u.id,u.name,count(o.id) as orders from users u left join orders o on o.user_id=u.id where u.active=true group by u.id,u.name order by orders desc;"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/web/sql-format",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "query": "select u.id,u.name,count(o.id) as orders from users u left join orders o on o.user_id=u.id where u.active=true group by u.id,u.name order by orders desc;"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/sql-format", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"query":"select u.id,u.name,count(o.id) as orders from users u left join orders o on o.user_id=u.id where u.active=true group by u.id,u.name order by orders desc;"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"query":"select u.id,u.name,count(o.id) as orders from users u left join orders o on o.user_id=u.id where u.active=true group by u.id,u.name order by orders desc;"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/sql-format", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Esempio di richiesta

{
  "query": "select u.id,u.name,count(o.id) as orders from users u left join orders o on o.user_id=u.id where u.active=true group by u.id,u.name order by orders desc;"
}

Esempio di risposta

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "web.sql_format",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.

Prezzi

per richiesta$0.002

Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.

Limiti

`timeout_sec`	30
`max_crawl_pages`	25

Errori

HTTP	Codice	Significato
`401`	`unauthorized`	Chiave API mancante o non valida: controlla l'header Authorization.
`402`	`insufficient_balance`	Credito esaurito: ricarica per continuare a eseguire attività.
`404`	`unknown_type`	Tipo di attività sconosciuto: controlla il campo type della richiesta.
`429`	`rate_limited`	Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo.

Leggi la documentazione completa del KIT →