Free PlyxSQL© Beta - 1.0.0.79  - Text to SQL

POSTED BY GIULIANO PAGNINI, 20 LUG 2026

Free DOWNLOAD Clicca qui Info https://pgsoft.it/plyxhtml

Il Configuratore Semantico plyxSQL: dalla mappatura dei campi a una vera base di conoscenza

Il Configuratore Semantico di plyxSQL Schema Designer è nato come un ponte tra lo schema fisico di un database e un modello linguistico chiamato a generare SQL a partire da domande in linguaggio naturale. Nelle ultime settimane si è arricchito di una serie di funzionalità pensate per un solo obiettivo: dare all'AI più contesto, riducendo al minimo gli errori di interpretazione — join sbagliati, campi inventati, valori "congelati" nel tempo.

Ecco cosa è cambiato.

1. Relazioni esplicite tra le tabelle

Fino a poco tempo fa, un lookup diceva solo "questo campo punta a quest'altra tabella" — ma non diceva come. Un JOIN su una relazione uno-a-molti può duplicare righe silenziosamente se non gestito con un GROUP BY; scegliere INNER invece di LEFT può far sparire dai risultati proprio i record che l'utente voleva vedere.

Ogni lookup ora può portare con sé due informazioni in più:

• Cardinalità — 1:1, 1:N o N:1
• Tipo di JOIN — INNER, LEFT o RIGHT

Quando importi un lookup direttamente da una foreign key reale dello schema, il Designer propone già un valore sensato: N:1 come cardinalità tipica, e LEFT se il campo di riferimento è opzionale (nullable) — così un record senza quel collegamento non sparisce dai risultati per un dettaglio tecnico che l'utente non ha motivo di conoscere.

2. Chi rappresenta una riga? Il campo "identificatore umano"

Una domanda come "mostrami gli utenti" richiede all'AI di scegliere quale campo elencare — l'ID numerico non serve a nessuno. Ora un campo per tabella può essere marcato come identificatore umano (tipicamente una ragione sociale, un nome, una descrizione): quando la domanda non specifica quali colonne vuole, l'AI sa già cosa mostrare accanto alla chiave primaria, senza dover indovinare.

3. Cosa rappresenta davvero questa tabella?

I nomi fisici delle tabelle non sono sempre parlanti. SBEREGPERM non dice granché a un modello linguistico, per quanto bravo sia a indovinare gli acronimi. Ogni tabella può ora avere una descrizione libera — poche parole di contesto ("registrazioni permanenti") distinte dalle keyword di rilevamento, che restano espressioni booleane pensate per un altro scopo: decidere quando includere la tabella, non spiegarne il significato.

4. Una mappa per vedere lo schema semantico, non solo quello fisico

Configurare dieci, venti tabelle con keyword, lookup, filtri e campi calcolati produce, nel tempo, una configurazione che nessuno tiene più a mente per intero. Il Designer offre ora una vista dedicata — un grafico separato dallo schema fisico, raggiungibile con un bottone in sidebar — che mostra solo le tabelle effettivamente configurate, ciascuna con il proprio alias, la keyword principale e due contatori rapidi (filtri e campi calcolati configurati). Le relazioni tra tabelle appaiono come curve etichettate con cardinalità e tipo di join; passando il mouse su un nodo si vede il dettaglio completo — keyword intere, filtri con la loro espressione, lookup, tutto quello che il riquadro compatto non può mostrare senza affollare la vista.

Non è un doppione dello schema fisico: è la rappresentazione di quello che l'AI vede davvero quando genera una query.

5. Custom key che non invecchiano: le macro temporali

Molte configurazioni usano parametri come [[ANNO]] per puntare a tabelle organizzate per anno (SBEREGISTRO2026, e l'anno prossimo SBEREGISTRO2027). Fino a poco fa, il valore di quel parametro andava aggiornato a mano, una volta l'anno, da qualcuno che se lo ricordasse.

Ora il campo "Valore" di una custom key può contenere un'espressione dinamica — YEAR(TODAY()), CURRENT_DATE, YEAR(TODAY())-1 per l'anno precedente, e altre dodici — che viene risolta al valore vero nel momento in cui viene generata una domanda reale, non quando la configurazione viene salvata o esportata. Una combo dedicata, in fondo alla finestra di configurazione globale, elenca tutte le espressioni riconosciute: si seleziona la riga della tabella, si sceglie l'espressione dalla combo, ed è fatto.

Il punto tecnico interessante è quando avviene questa risoluzione — ed è anche il punto più facile da sbagliare, se non ci si pensa fin dall'inizio.

La scelta di risolvere l'espressione al momento della richiesta, e non prima, è quella che fa funzionare tutto il resto: il pacchetto configurato oggi resta corretto anche tra un anno, senza che nessuno debba ricordarsi di aggiornarlo — è il processore delle macro, non la configurazione, a occuparsi di restare aggiornato.

In sintesi

Nessuna di queste funzionalità, da sola, cambia radicalmente il configuratore. Messe insieme, spostano l'ago della bilancia da "un dizionario di mapping tra parole e colonne" verso qualcosa che si avvicina a una vera base di conoscenza: relazioni con un verso e una molteplicità precisi, tabelle che sanno spiegare cosa sono, valori che restano corretti senza manutenzione, e una mappa per vedere tutto questo a colpo d'occhio invece di ricostruirlo a memoria ogni volta.

#TextToSQL #AI #DatabaseLegacy #SQL #Firebird #CodeGeneration #SoftwareArchitecture #DataEngineering #LLM #PromptEngineering #DigitalTransformation #PubblicaAmministrazione #SoftwareDevelopment #TechInnovation #PlyxSQL

Free PlyxSQL© SQL Beta - 1.0.0.77 - Text to SQL

 Free PlyxSQL© Beta - 1.0.0.77  - Text to SQL

POSTED BY GIULIANO PAGNINI, 17 LUG 2026

Free DOWNLOAD Clicca qui Info https://pgsoft.it/plyxhtml

Configuratore semantico per il text to SQL

Perché un configuratore semantico è essenziale per il text-to-SQL su database legacy

Chi lavora con database gestionali storici — come quelli tipici della pubblica amministrazione o dei software verticali italiani — conosce bene il problema: campi chiamati IDUBICAZIONE, NGIURIDICA, STAG, tabelle con suffissi variabili come E_PUB[[ANNO]] o EREGTEMP[[ANNO]]. Nomi che hanno senso solo per chi ha scritto lo schema vent'anni fa, ma che diventano un ostacolo enorme quando si tenta di applicare un modello di linguaggio per generare SQL a partire da domande in linguaggio naturale.

Il problema dei nomi non convenzionali

Un LLM generico, senza contesto, non ha modo di sapere che NGIURIDICA = 1 significa "DITTA" o che IDCOMUNE va risolto tramite una tabella COMUNI con ref_field = ID. Senza un layer di mediazione, il modello può:

• Inventare join inesistenti o sbagliare la cardinalità (confondendo relazioni 1:N con 1:1)

• Interpretare male campi booleani mascherati da interi (CHIUSO, ESENTE, PAGATO)

• Non riconoscere pattern di naming variabili per anno o comune, tipici di database multi-tenant o multi-periodo

Cosa fa davvero un configuratore semantico

Un configuratore semantico agisce come un dizionario vivo tra il linguaggio umano e lo schema fisico del database. Definisce esplicitamente:

• Lookup e cardinalità: quali campi id vanno risolti in valori leggibili, e se il join è 1:1, 1:N o N:1 (fondamentale per evitare duplicazioni negli aggregati)

• Placeholder dinamici: gestione di parametri come comune o anno che si propagano nei nomi di tabella, non solo nei valori

• Campi calcolati: espressioni CASE o business logic che traducono codici interni in concetti di dominio (es. TIPO)

• Filtri pre-validati: pattern di query complessi (subquery, condizioni di stato) già testati e riutilizzabili, evitando che il modello li reinventi ogni volta con margine di errore

Il valore concreto

Con questo approccio, la generazione SQL diventa deterministica e verificabile, non un'interpretazione statistica del modello. Il configuratore trasforma un database "illeggibile" in un'interfaccia semantica coerente, permettendo a chi pone la domanda — anche un utente non tecnico — di ottenere risultati corretti senza conoscere la struttura fisica sottostante.

Per chi sviluppa strumenti di code generation e automazione su schemi legacy, questo livello di configurazione non è un'opzione: è la differenza tra un text-to-SQL affidabile in produzione e un generatore di query plausibili ma potenzialmente sbagliate.

Semantic scheme

Ecco la query SQL generata per "Utenti in mora", con i placeholder [[COMUNE]] e [[ANNO]] risolti secondo i valori di default (riccione → G911, anno → anno corrente 2026), rispettando tutti i vincoli indicati (nessun filtro su IDCOMUNE, nessuna esclusione per ESENTE, uso del filtro esatto fornito in matched_filters).

Note sulla generazione

• [[COMUNE]] è stato risolto in G911 (Riccione), essendo il comune marcato come defaultvalue: true in assenza di indicazioni diverse nella domanda.

• [[ANNO]] è stato risolto in 2026, corrispondente all'anno corrente (YEAR(TODAY)), marcato come default.

• Nessun filtro su ESENTE è stato applicato, coerentemente con il vincolo di non escludere questi record.

• Nessun filtro su IDCOMUNE è stato inserito, come richiesto.

• La condizione di mora è stata ripresa integralmente dal filtro fornito in matched_filters, senza modifiche, poiché non conteneva placeholder tra graffe da sostituire.

• Non sono stati inclusi JOIN verso le tabelle di lookups poiché la domanda "Utenti in mora" non richiede la risoluzione di alcun valore leggibile aggiuntivo (es. nome ubicazione, comune, ecc.) e nessun campo lookup è necessario per la logica di filtro.

SELECT

  G911UTENTI.IDUTENTE,

  G911UTENTI.RAGIONE_SOCIALE,

 .....

  G911UTENTI.NAZIONE,

  CASE

    WHEN G911UTENTI.NGIURIDICA = 0 THEN 'FISICA'

    WHEN G911UTENTI.NGIURIDICA = 1 THEN 'DITTA'

    ELSE NULL

  END AS TIPO

FROM G911UTENTI

WHERE (G911UTENTI.CHIUSO IS NULL OR G911UTENTI.CHIUSO = 0)

  AND G911UTENTI.IDUTENTE IN (

    SELECT IDUTENTE

    FROM G911E_PUB2026

    WHERE (Pagato IS NULL OR Pagato = 0)

      AND (ANNULLATO IS NULL OR ANNULLATO = 0)

      AND (DATA > :CURRENT_DATE)

  )

#TextToSQL #AI #DatabaseLegacy #SQL #Firebird #CodeGeneration #SoftwareArchitecture #DataEngineering #LLM #PromptEngineering #DigitalTransformation #PubblicaAmministrazione #SoftwareDevelopment #TechInnovation #PlyxSQL

Free PlyxSQL© SQL Beta - 1.0.0.75 - Text to SQL

Free PlyxSQL© Beta - 1.0.0.75  - Text to SQL

POSTED BY GIULIANO PAGNINI, 15 LUG 2026

Free DOWNLOAD Clicca qui Info https://pgsoft.it/plyxhtml

Configuratore semantico per il text to SQL

Dallo schema al prompt: il Configuratore Semantico di plyxSQL e le nuove Foreign Key

Se lavori con database di enti pubblici — tributi, affissioni, occupazioni di suolo — conosci bene il problema: schemi grandi, spesso non normalizzati, tabelle con nomi tag-based per comune e anno, e una crescente richiesta di "genera questa query con l'AI" da parte di chi in ufficio non scrive SQL tutti i giorni.

In questa versione dello Schema Designer di plyxSQL abbiamo aggiunto un pezzo intero dedicato esattamente a questo: il Configuratore Semantico. Non è un generatore di query — è lo strato che dice a un modello AI come leggere il tuo schema, prima ancora che scriva una riga di SQL. E già che c'eravamo, abbiamo sistemato e ampliato la gestione delle Foreign Key, che nel Designer era rimasta un po' indietro.

Vediamo cosa c'è di nuovo, con qualche esempio pratico.

Il problema di partenza

Immagina di dover chiedere a un'AI: "vorrei aggiornare le anagrafiche utenti con la PEC della tabella recapiti, solo se la PEC degli utenti è vuota". Per generare SQL corretto, l'AI ha bisogno di sapere:

• quali tabelle sono coinvolte, e con che nome reale nel DB (spesso con prefissi tipo [[COMUNE]] e suffissi anno)
• quali campi puoi davvero usare, e quali no (magari alcuni sono sensibili, o semplicemente irrilevanti)
• come si collegano due tabelle, se serve un JOIN
• quali regole di business valgono sempre ("non escludere mai i record ESENTE=1", "non filtrare per IDCOMUNE"...)

Passare tutto questo a mano, ogni volta, in un prompt scritto lì per lì, non è sostenibile. Il Configuratore Semantico lo fa una volta, dentro lo schema stesso, e da lì in poi genera il prompt corretto in automatico ad ogni domanda.

Configurare una tabella: le sei sezioni

Tasto destro su una tabella → ⚙ Configura semantica... apre un dialog con tutto quello che serve, organizzato in blocchi chiari:

1. Alias — il nome "vero" che la tabella deve avere nel prompt, placeholder inclusi: [[COMUNE]]UTENTI, [[COMUNE]]REGISTRO[[ANNO]].

2. Keyword di identificazione — le parole che, se presenti nella domanda, fanno capire all'AI (e al nostro motore di auto-detect) che questa tabella è rilevante. E qui la cosa si fa interessante: le keyword non sono semplici parole, sono espressioni booleane:

(utente+utenti+contribuente+matricola)-(insegne+occupazioni+cup)

Si legge: "se la domanda parla di utenti/contribuenti, MA non di insegne, occupazioni o CUP". Supportiamo + (OR), & (AND), - (NOT) e le parentesi, con la logica booleana standard — negare un gruppo tra parentesi nega il risultato complessivo, non termine per termine. Niente sorprese, tutto prevedibile.

3. Campi attivi, con alias di dominio — scegli quali campi finiscono nel prompt (perché no, non sempre vuoi esporre tutto), e per ognuno puoi aggiungere sinonimi: il campo fisico DESCRIZIONE nella tabella VIE può avere alias ubicazione, via, indirizzo — così se la domanda usa uno di questi termini, l'AI sa a cosa si riferisce davvero, anche senza nessun JOIN.

4. Lookup — qui si dice all'AI come risolvere un ID in un valore leggibile: UTENTI.IDCOMUNE punta a COMUNI.ID, e il campo da mostrare è COMUNI.DESCRIZIONE. Due modi per configurarlo:

• a mano, in una griglia editabile;
• trascinando direttamente nel canvas da un campo all'altro (con un mini-popup che chiede quale campo mostrare);
• oppure, se hai già delle Foreign Key reali nello schema, con un click su "Importa da FK" che le legge tutte e propone i Lookup corrispondenti in automatico.

5. Campi calcolati — espressioni SQL con nome logico, tipo TIPO = CASE WHEN NGIURIDICA=0 THEN 'FISICA' ELSE 'DITTA' END.

6. Keyword filter — condizioni WHERE che scattano solo se la domanda contiene certe parole (stessa sintassi booleana della sezione 2), utile per filtri di dominio che non vuoi sempre attivi.

Le regole che valgono sempre: constraint e custom key

Tasto destro sul canvas → ⚙ Configurazione semantica globale... apre le impostazioni valide per ogni prompt generato:

• Constraint generali: una per riga, es. "non filtrare mai per IDCOMUNE", "con UNION ALL non inserire GROUP BY".
• Custom key, ora a quattro colonne — Parametro / Key / Valore / Default. Qui risolvi i placeholder: [[COMUNE]] può avere più valori possibili (riccione → G911, gatteo → H231), e la colonna Default dice all'AI quale usare se la domanda non specifica il comune.

Genera prompt AI: dal Designer direttamente al provider

Con tutto configurato, il comando "Genera prompt AI..." (menu Query, o il pulsante dedicato in toolbar) apre una finestra dove scrivi la domanda, scegli dialetto e versione (stessa combo già nota da "Export DDL"), e ottieni il JSON pronto — o lo invii direttamente al provider AI già configurato (Anthropic, OpenAI, Ollama), senza passare da un editor esterno.

Il nostro motore di rilevamento automatico decide da solo quali tabelle includere, in base a nome e keyword — se non trova corrispondenze, include tutte le tabelle configurate e te lo segnala, non genera mai un prompt "a metà" in silenzio.

Un passo oltre: il pacchetto per il server

Il Configuratore Semantico non serve solo per generare un prompt al volo dal Designer. Con "Esporta pacchetto semantico (server)..." ottieni un JSON completo — tutte le tabelle configurate, i lookup, i campi calcolati, le constraint globali — pensato per un componente server che riceve domande a runtime e deve rigenerare da sé lo stesso tipo di prompt, senza il Designer in mezzo. Motore booleano incluso, con specifica precisa per chi deve reimplementarlo in un altro linguaggio.

Le Foreign Key, finalmente al completo

Mentre eravamo lì, abbiamo chiuso alcuni buchi storici sulle FK nel Designer:

• ON DELETE CASCADE evidenziato in rosso nel canvas — una CASCADE nascosta tra molte relazioni è un classico modo di perdere dati per errore, ora salta all'occhio anche solo scorrendo lo schema.
• Dialog "Regole FK", finalmente collegato per davvero: se hai una FK selezionata, ne modifichi ON DELETE/ON UPDATE con due semplici tendine; se parti da una tabella senza FK selezionata, si apre invece una creazione guidata — scegli il campo sorgente, la tabella di destinazione (con aggiornamento automatico dei campi disponibili) e le regole, in un colpo solo.
• Il disegno interattivo delle FK ora cattura correttamente il campo specifico da cui parti — prima, per un bug di vecchia data, finiva sempre per collegare la chiave primaria, anche se avevi trascinato da tutt'altro campo.

Produttività sul canvas

Un paio di comandi pensati per schemi grandi, dove scorrere/zoommare a mano per trovare una tabella diventa la parte più lenta del lavoro:

• Trova tabella — una combo di ricerca in alto a sinistra: scegli la tabella, e la vista si centra lì.
• Avvicina tabella — hai la tabella "attiva" selezionata e vuoi collegarci una FK verso una tabella che non è nemmeno visibile nello schema? Un click sposta quella tabella accanto a quella attiva (spostamento annullabile con Ctrl+Z, come un drag manuale), e centra la vista su entrambe.
• Le tabelle con centinaia di campi non occupano più altezze infinite di canvas: oltre una certa soglia, i campi scorrono con la rotellina — stesso comportamento già noto dal Query Builder.
• Zoom e posizione della vista vengono ora salvati con lo schema: riapri il progetto e sei esattamente dove avevi lasciato, non più tutto azzerato.

In breve

Il filo conduttore di questo giro di lavoro è uno solo: rendere lo schema autosufficiente per generare prompt AI corretti, senza che chi scrive la domanda debba conoscere i dettagli fisici del database — prefissi comune, suffissi anno, campi generici riusati con significati diversi in tabelle diverse. Tutto questo, configurato una volta nello Schema Designer, resta lì pronto per ogni nuova domanda — dal Designer stesso, o da un server che lo consulta a runtime.

Il prossimo passo naturale, su cui stiamo già ragionando, è la validazione lato server del SQL generato dall'AI prima di eseguirlo davvero — stesso principio di "non fidarsi ciecamente" applicato all'output, non solo all'input. Ne parliamo nel prossimo articolo.

#SQL #database #DataEngineering #plyxSQL #FireDAC #TextToSQL #Vuelityx #PGSOFT

Free PlyxSQL© SQL Beta - 1.0.0.71

Free PlyxSQL© SQL 

POSTED BY GIULIANO PAGNINI, 13 LUG 2026

Free DOWNLOAD Clicca qui Info https://pgsoft.it/plyxhtml

Profilare le query in PlyxSQL: un componente VCL con grafico in tempo reale

Il problema: "perché questa query è lenta?"

Chiunque lavori con FireDAC su più database (Oracle, SQL Server, PostgreSQL, MySQL, SQLite…) prima o poi si scontra con la stessa domanda: quanto ci mette davvero questa query, e perché? Il monitor integrato di FireDAC c'è e funziona, ma è pensato per il debug estemporaneo, non per restare agganciato all'applicazione e mostrare l'informazione a chi sta lavorando sulla query in quel momento.

Nell'ambito di plyxSQL, il mio tool di gestione SQL scritto in C++Builder, ho quindi costruito un componente dedicato. Due, in realtà: uno che misura, uno che disegna. Tenerli separati è stata la decisione architetturale più importante di tutto il lavoro.

Due componenti, due responsabilità

TFDQueryProfiler è il motore: un TComponent non visuale che esegue una TFDQuery o una TFDStoredProc cronometrando il tempo con TStopwatch, registra le righe coinvolte e, se richiesto, recupera il piano di esecuzione nativo del driver. Nessuna intercettazione automatica delle query esistenti — lo richiami esplicitamente quando vuoi profilare qualcosa:

auto res = FDQueryProfiler1->ProfileOnActiveConnection(
    L"SELECT * FROM Clienti WHERE Attivo=1");

ShowMessage(Format(L"%d ms, %d righe",
    ARRAYOFCONST((res.ElapsedMs, res.RowsAffected))));

La parte più interessante è il recupero del piano di esecuzione: non esiste una sintassi EXPLAIN universale, quindi il componente riconosce il dialetto della connessione e sceglie il comando giusto driver per driver:

Driver	Comando
SQL Server	SET SHOWPLAN_ALL ON
PostgreSQL	EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)
MySQL	EXPLAIN FORMAT=JSON
SQLite	EXPLAIN QUERY PLAN
Oracle	EXPLAIN PLAN FOR + DBMS_XPLAN.DISPLAY()

Per Firebird, InterBase, DB2, Informix e Access il componente ritorna semplicemente una stringa vuota invece di inventare una sintassi che potrebbe non esistere in quel dialetto. Meglio onesto che silenziosamente sbagliato.

Dal numero al disegno: TFDQueryProfilerChart

Il secondo componente, TFDQueryProfilerChart, è un TCustomControl che si aggancia all'evento OnProfileComplete del profiler e disegna tutto con GDI+: niente TeeChart, niente dipendenze esterne, solo Winapi.GDIPAPI e Winapi.GDIPOBJ, presenti in ogni edizione di RAD Studio.

Il collegamento tra i due componenti è una riga:

FDQueryProfilerChart1->Profiler = FDQueryProfiler1;

Da quel momento, ogni chiamata a Profile(), ProfileSQL() o ProfileStoredProc() fa comparire una nuova barra animata nel grafico, con:

• Fascia KPI in alto — ultima esecuzione, media, min/max, totale query profilate;
• Barre colorate per soglia — verde/ambra/rosso in base a due soglie configurabili (ThresholdWarningMs, ThresholdCriticalMs);
• Animazione di crescita ease-out a 60fps quando arriva un nuovo dato;
• Tooltip on-hover con SQL troncato, tempo, righe e dialetto;
• Pannello di dettaglio on-click che mostra l'anteprima del piano di esecuzione.

Un dettaglio che fa la differenza: il colore ereditato

plyxSQL gestisce già più connessioni contemporaneamente in un TFDTreeExplorer, e ogni connessione ha un proprio colore identificativo nell'albero. Invece di inventare una palette scollegata, il profiler risolve il colore dello slot attivo e lo propaga al grafico:

TColor TFDQueryProfiler::ResolveConnColor(TFDConnection* AConn) const
{
    if (!FTreeExplorer || !AConn) return clNone;
    if (FTreeExplorer->ActiveConn() != AConn) return clNone;
    TConnSlot* slot = FTreeExplorer->GetActiveSlot();
    return slot ? slot->ConnColor : clNone;
}

Risultato: bordo della barra selezionata, tooltip e pannello di dettaglio si intonano automaticamente al colore già assegnato a quella connessione nell'albero, con un fallback su un accento neutro quando il profiler non è collegato a nessun TFDTreeExplorer. Un piccolo dettaglio, ma è quello che fa sembrare un componente "parte dell'app" invece che un widget incollato sopra.

#SQL #database #DataEngineering #plyxSQL #FireDAC

Free PlyxSQL© SQL Beta - 1.0.0.70

 Free PlyxSQL© SQL 

POSTED BY GIULIANO PAGNINI, 11 LUG 2026

Free DOWNLOAD Clicca qui Info https://pgsoft.it/plyxhtml

Novità e fix della versione 1.0.0.70

Con la versione 1.0.0.70 arrivano diversi miglioramenti importanti sia sul fronte ETL sia su LocalSQL, con nuove funzioni per la creazione dei tracciati, l’importazione dati e la connessione a sorgenti REST. Il lavoro di questa sessione ha anche corretto diversi bug storici, migliorato le prestazioni di apertura dei progetti e reso più chiara l’interfaccia dei wizard.

ETL: import più potente e più chiaro

Nel dialog Nuova fase è stato aggiunto il pulsante “Genera campi da tabella”, che permette di collegare automaticamente i campi con lo stesso nome subito dopo la scelta di origine e destinazione, senza dover prima confermare la fase. Sempre nel flusso ETL è stata introdotta una nuova modalità di import con supporto a più strategie operative, tra cui inserimento, append, update, append/update e delete, con gestione delle chiavi multiple tramite un campo dedicato.

Un altro miglioramento importante riguarda l’evidenziazione dei campi con tipo diverso tra origine e destinazione: testo, numeri, date, booleani e binari vengono ora messi in risalto sia nel dialog di generazione campi sia nella modifica del singolo campo. Questo aiuta a individuare subito dove è opportuno usare una regola di tipo Espressione per la conversione.

Log e gestione fase

È stato aggiunto anche un nuovo evento di logging per l’import ETL, che mostra nella finestra di avanzamento un memo cronologico con inizio e fine importazione, inizio e fine di ogni fase, conteggio dei record e eventuali errori. In più, nel dialog Nuova fase è comparso il pulsante “Aggiungi fase”, utile per salvare rapidamente la fase corrente e aprirne subito una nuova con le stesse connessioni e modalità dell’ultima configurazione.

Durante l’implementazione sono stati corretti anche alcuni punti di compilazione e validazione, in particolare l’allineamento alla reale API FireDAC e il controllo obbligatorio di origine e destinazione, così da evitare la creazione accidentale di fasi vuote.

LocalSQL e tracciato

La sezione LocalSQL ha ricevuto un intervento molto ampio. Ora i parametri del tracciato vengono salvati in modo completo e affidabile: tipo record, encoding, salto righe iniziali e layout campi persistono correttamente sulla connessione. È stato introdotto anche il nuovo campo “Salta righe iniziali” nel wizard, utile per scartare le prime righe fisiche del file prima del parsing.

Inoltre, i campi con lunghezza nota fino a 255 caratteri vengono ora creati come VARCHAR(n) invece che come testo illimitato, migliorando l’introspezione FireDAC. Sono stati aggiunti i pulsanti per salvare e caricare il tracciato su file, così da esportare e riutilizzare facilmente l’intera configurazione tramite file dedicati.

Incolla tracciato e anteprima

Anche la funzione Incolla tracciato è stata resa più intelligente: ora riconosce correttamente nomi campo non necessariamente tutti maiuscoli, normalizzandoli in identificatori SQL puliti come CODICE_FISCALE invece di ricadere su nomi generici. L’estensione del file dati viene anche rilevata automaticamente, evitando che il wizard resti bloccato su un formato predefinito non corretto.

L’anteprima del tracciato è stata inoltre resa più leggibile grazie a un pannello più ampio e a una griglia meno schiacciata. Sono state anche migliorate le griglie editabili, rimuovendo il comportamento che bloccava l’editing diretto delle celle.

Fix sul tracciato

Uno dei bug più importanti corretto riguarda il caso in cui il file di configurazione venisse scambiato per un file dati. In precedenza il salvataggio del tracciato poteva finire nella stessa area usata per cercare i dati reali, generando anteprime illeggibili. Ora il formato dedicato .tracciato separa nettamente configurazione e dati, e una guardia aggiuntiva impedisce di aprire una configurazione come se fosse una sorgente dati.

Nuova connessione REST

Una novità rilevante è il nuovo tipo di connessione LocalSQL REST. Questo consente di collegare uno o più endpoint HTTP GET e mapparli come tabelle virtuali. La connessione supporta autenticazione configurabile tramite nessuna autenticazione, Bearer token, API Key su header personalizzato o Basic Auth.

È possibile anche specificare un JSON Path per individuare l’array dei record quando non è alla radice della risposta. Lo schema viene derivato in modo robusto dall’unione delle chiavi viste nei primi 200 record, così da gestire bene campi opzionali o distribuiti in modo sparso.

Prestazioni e apertura progetti

L’apertura dei progetti è stata resa più veloce grazie alla scansione lazy delle cartelle per le connessioni LocalSQL basate su file. Ora la scansione non avviene più subito all’apertura del progetto, ma solo quando l’utente espande il nodo Tabelle o quando viene richiesto esplicitamente da codice.

Per i casi in cui l’elenco tabelle serve subito, è stato introdotto un metodo dedicato per forzare la scansione della cache. È stata anche corretta una regressione legata al classico errore “no such table”, ripristinando il preload delle tabelle quando una connessione viene attivata.

Interfaccia e localizzazione

La finestra di progresso durante l’apertura progetto ora mostra due livelli di avanzamento: Connessione N di M e File N di M, così da rendere più chiaro il caricamento delle tabelle. La gestione dei messaggi di aggiornamento è stata anche limitata alla sola finestra di progresso, evitando effetti collaterali sul form principale.

Infine, sono state aggiunte numerose nuove chiavi di localizzazione per il testo introdotto in questa sessione, e il wizard è stato ripulito ulteriormente: quando si seleziona il tipo REST, cartella, estensione e pulsante Browse vengono nascosti del tutto perché non servono più.

Big data analisi

Super fast dataset map analisi 

Conclusione

La versione 1.0.0.70 porta quindi un insieme molto consistente di miglioramenti: più automazione nell’ETL, tracciati più affidabili, connessioni REST più flessibili, apertura progetti più veloce e una lunga serie di fix che migliorano solidità e usabilità generale. È un rilascio che punta sia sulla produttività quotidiana sia sulla robustezza del flusso di lavoro.

#SQL #database #MAPSENGINE #DataEngineering #plyxSQL #FireDAC

Free PlyxSQL© SQL Beta - 1.0.0.66 ETL Professional

Free PlyxSQL© SQL Beta - ETL Professional

POSTED BY GIULIANO PAGNINI, 07 LUG 2026

Free DOWNLOAD Clicca qui Info https://pgsoft.it/plyxhtml

ETL con BackMove: velocità e controllo nel cuore di PlyxSQL

                

Conclusione tecnica

BackMove in PlyxSQL si presta bene a una visione moderna dell’ETL: veloce, configurabile e orientato al dato, non al codice rigido. La possibilità di definire regole per singolo campo, con REGEXP, LOOKUP e trasformazioni dedicate, rende il flusso più solido e più adatto a contesti enterprise dove qualità, tracciabilità e manutenzione contano quanto le prestazioni

Free PlyxSQL© SQL Beta - 1.0.0.66 Map Engine

 Free PlyxSQL© SQL Beta - Map Engine

POSTED BY GIULIANO PAGNINI, 07 LUG 2026

Free DOWNLOAD Clicca qui Info https://pgsoft.it/plyxhtml

CSV samples

#SQL #database #MAPSENGINE #DataEngineering #plyxSQL #FireDAC

Free PlyxSQL© SQL Beta - 1.0.0.64 new ETL engine

 Free PlyxSQL© SQL Beta - new ETL engine

POSTED BY GIULIANO PAGNINI, 04 LUG 2026

Free DOWNLOAD Clicca qui Info https://pgsoft.it/plyxhtml

PlyxSQL cresce ancora: arriva l'ETL a fasi con motore BatchMove integrato

Chiunque lavori ogni giorno con i database conosce quel momento: i dati sono nel posto sbagliato. Un CSV da caricare in produzione. Un database legacy da travasare in quello nuovo. Due ambienti da tenere allineati senza scrivere ogni volta lo stesso script usa-e-getta.

Fino a ieri, per farlo dovevi uscire dal tuo client SQL. Aprire un tool ETL esterno, spesso sovradimensionato per il compito. Oppure scrivere codice.

Con l'ultimo aggiornamento, plyxSQL smette di essere solo il posto dove scrivi query — diventa anche il posto dove sposti i dati.

Fasi, non script

Il nuovo modulo ETL di plyxSQL ragiona per fasi: ogni fase è una coppia tabella origine → tabella destinazione, con le sue regole di campo, il suo filtro, le sue impostazioni. Costruisci il flusso a vista, direttamente nell'albero delle connessioni che già usi per esplorare i tuoi database — non serve un ambiente separato, non serve reimparare uno strumento nuovo.

Origine e destinazione si scelgono da un menu a discesa con filtro istantaneo: scrivi tre lettere, plyxSQL ti mostra solo le tabelle (o i campi) che contengono quel testo, tra centinaia di righe di schema.

Le regole di campo: più di un copia-incolla

Ogni campo mappato può seguire una regola diversa:

• Diretto — il valore passa così com'è
• Costante — scrivi sempre lo stesso valore, qualunque sia l'origine
• Espressione — trasforma il valore al volo: maiuscole, minuscole, sottostringhe, valori di default, e ora anche espressioni regolari (REGEXMATCH, REGEXEXTRACT, REGEXREPLACE) e conversione di formato per date e numeri (DATE(yyyy-mm-dd), NUMBER(,;.)) — pensate apposta per quando l'origine è un CSV che tratta tutto come testo
• Lookup — traduci un codice in un valore leggendolo da un'altra tabella, con tabella e campi scelti anch'essi da un elenco filtrabile, non digitati a memoria

E se non ricordi la sintassi esatta di una funzione, non serve: un Assistente dedicato elenca tutte le funzioni disponibili, con descrizione, campi guidati per i parametri e anteprima dal vivo dell'espressione che stai costruendo.

Il cuore delle prestazioni: il motore BatchMove di FireDAC

Qui sta la parte che conta davvero per chi sposta milioni di righe, non dieci. Il vecchio approccio — un comando di inserimento per ogni riga — è semplice ma è anche il modo più lento possibile di scrivere su un database: ogni riga è un'andata e ritorno di rete.

Il nuovo motore ETL di plyxSQL applica prima le trasformazioni riga per riga (dove serve davvero la CPU: espressioni, lookup, conversioni), poi affida la scrittura vera e propria al motore BatchMove di FireDAC, che scrive a blocchi usando l'Array DML nativo del driver — molte meno andate e ritorno di rete rispetto a un inserimento alla volta, con transazioni dimensionate a blocco per un buon equilibrio tra velocità e sicurezza dei dati.

Il risultato: importazioni pensate per l'uso reale, non per la demo.

Progetti multi-database, senza compromessi

Ogni fase può avere una connessione diversa da quella globale del progetto: puoi consolidare dati da più origini eterogenee in un'unica destinazione, o distribuire un'unica origine su più destinazioni, tutto nello stesso progetto. I progetti si salvano e si ricaricano in formato .fdmap, pronti per essere riusati.

Sempre sotto controllo

Una barra di avanzamento mostra fase corrente, riga per riga, con stima quando possibile. Un bottone Annulla ferma l'importazione al primo punto sicuro, senza lasciare la destinazione a metà di un blocco. Gli errori — una riga con un vincolo violato, una tabella non trovata — vengono tracciati e riportati a fine importazione, senza far fallire l'intero processo per un singolo record difettoso.

Per chi è pensato

Per chi amministra database e si ritrova periodicamente a spostare dati tra ambienti. Per chi sviluppa e ha bisogno di popolare un database di test da uno di produzione, ripulendo o mascherando i dati al volo con le regole di trasformazione. Per chi migra da un sistema legacy e non vuole scrivere ed eseguire uno script diverso per ogni tabella.

plyxSQL resta quello che era — un client SQL veloce, leggero, che non ti fa perdere tempo. Solo che adesso, quando i dati devono muoversi, non devi più uscire da lì per farlo.

#SQL #database #ETL #DataEngineering #plyxSQL #FireDAC

Free PlyxSQL© SQL Beta - 1.0.0.60 Test E2E backend e frontend

 Free PlyxSQL© SQL Beta - Test E2E backend e frontend

POSTED BY GIULIANO PAGNINI, 03 LUG 2026

Free DOWNLOAD Clicca qui Info https://pgsoft.it/plyxhtml

Test E2E "in un click": come TRestConfigDlg verifica backend e frontend generati

Quando un tool genera codice — API REST, backend, frontend — la vera domanda non è "il generatore ha prodotto dei file?" ma "quei file funzionano davvero?". Nel wizard API REST questa domanda trova risposta in una funzionalità integrata di test end-to-end, azionabile con un solo click direttamente dalla terza pagina del wizard, quella dedicata al log di generazione.

L'idea di fondo è semplice: dopo aver generato il progetto, l'utente può premere un pulsante e vedere, in tempo reale, l'esito di una suite di test che compila, avvia e interroga realmente il backend (e opzionalmente il frontend) appena creato — senza uscire dall'IDE del wizard.

Due pulsanti, due suite

Nella pagina 3 del dialog compaiono due pulsanti dedicati:

• ▶ Backend E2E — compila e avvia il backend Node.js/Express generato, quindi lo bombarda con richieste HTTP reali verso gli endpoint REST prodotti dal generatore.
• ▶ Frontend E2E — esegue il type-check Vue (vue-tsc), la build Vite del frontend e infine una suite Playwright headless che simula l'interazione di un utente reale con l'interfaccia generata.

Entrambi i pulsanti restano disabilitati finché non è stata completata con successo una generazione , e funzionano solo se il backend prodotto è di tipo Node.js + Express: gli altri backend non sono ancora coperti da questa infrastruttura di test.

Il flusso del test di backend

Il gestore orchestra l'intero processo:

1. Verifiche preliminari: la generazione dev'essere andata a buon fine, il backend dev'essere Node/Express, Node.js dev'essere reperibile nel PATH (o in una delle posizioni tipiche di installazione su Windows), e lo script run-e2e.mjs dev'essere individuabile — accanto all'eseguibile, in una cartella superiore, oppure tramite la variabile d'ambiente RESTGEN_E2E_DIR.
2. Costruzione della command line: il dialog traduce la configurazione scelta dall'utente (driver database, modalità di autenticazione) nel linguaggio atteso dallo script di test — ad esempio jwt/basic/none per l'autenticazione, oppure sqlite/pg/mssql/mysql/firebird per il dialetto SQL.
3. Una scelta pragmatica su Firebird: se il progetto usa Firebird, il test non si connette a un server Firebird reale, ma usa SQLite in locale (il modulo nativo node:sqlite, zero configurazione). Questo evita di trascinarsi dietro le note incompatibilità di wireCrypt/SRP della libreria node-firebird. Chi vuole davvero testare contro Firebird può comunque lanciare run-e2e.mjs a mano con --db firebird.
4. Avvio in background: il comando (node + script + parametri) parte su un thread Win32 separato, per non bloccare l'interfaccia.
5. Feedback in tempo reale: mentre il processo gira, l'output di npm install, compilazione TypeScript, avvio del server e chiamate HTTP scorre riga per riga nella memo di log del dialog.
6. Riepilogo finale: a processo concluso, viene letto un report JSON con il conteggio di test passati, falliti e con warning, mostrato come riga di riepilogo insieme al percorso del file.

Il thread worker: niente lambda, solo Win32 puro

Uno degli aspetti più interessanti dal punto di vista implementativo è la scelta di non usare TThread, TTask o lambda catturanti, ma un thread Win32 "grezzo" creato con CreateThread. Il commento nel codice è esplicito: bcc32c (il compilatore Clang-based di C++Builder) può confondersi con lambda annidate che catturano membri di classe all'interno di metodi. Per eliminare ogni ambiguità, i parametri necessari al thread vengono impacchettati in una struct semplice (TE2EParams) passata per puntatore:

cpp

struct TE2EParams {
    TButton*  btnRef;
    TLabel*   lbRef;
    TMemo*    memoRef;
    bool*     flagRef;
    wchar_t   rptPath[MAX_PATH];
    wchar_t   cmdLine[4096];
};

Il thread worker (E2EThreadProc) fa tre cose in sequenza:

1. Lancia il processo (node run-e2e.mjs ...) con CreateProcessW, reindirizzando stdout e stderr su una pipe anonima creata con CreatePipe.
2. Legge lo stream di output a blocchi da 4 KB, ricostruendo le righe complete (gestendo anche frammenti di riga a cavallo tra due letture) e le inoltra alla UI.
3. Al termine, tenta di leggere un report JSON dal percorso concordato, estraendo in modo leggero (senza un vero parser JSON, con una ricerca di sottostringa) i contatori pass/fail/warn.

Comunicare con la UI senza rischi di race condition

Aggiornare controlli VCL da un thread che non è quello principale è una delle fonti più comuni di crash nelle applicazioni Windows. Il dialog risolve il problema con due tecniche complementari, entrambe thread-safe per costruzione:

• SendMessageW con EM_REPLACESEL per appendere ogni riga di log alla memo: un trucco classico che sfrutta il fatto che i messaggi di finestra vengono comunque processati nel thread proprietario del controllo.
• PostMessageW con messaggi custom (WM_USER+100 per il riepilogo finale, WM_USER+101 per riabilitare il pulsante) per notificare in modo asincrono la conclusione del test, senza bloccare il thread di lavoro in attesa che la UI elabori l'evento.

Il flag booleano che segnala "test in corso" (E2ERunning / FERunning) viene riportato a false direttamente dal thread worker: trattandosi di una singola scrittura di un bool, l'operazione è atomica sia su x86 sia su x64, quindi non serve una sezione critica dedicata.

Un piccolo TTimer (tmrCursor) fa da watchdog: controlla ogni 300 ms se uno dei due flag è ancora attivo e, quando entrambi tornano a false, ripristina il cursore di sistema da clessidra a normale.

Il test del frontend: stessa infrastruttura, contenuto diverso

OnRunFEClick segue la stessa logica del test di backend ma orchestra una pipeline diversa: vue-tsc per il controllo dei tipi TypeScript/Vue, build di produzione con Vite, e infine una suite Playwright headless che simula interazioni utente reali contro il frontend appena costruito, collegato al backend Node generato in precedenza. Il riuso è quasi totale: la stessa struct TE2EParams e la stessa E2EThreadProc vengono impiegate per lanciare ed monitorare anche questo secondo processo, cambiando solo lo script (run-e2e-frontend.mjs) e i percorsi coinvolti (cartella frontend e backend_node).

Perché questo approccio ha senso

Al di là dei dettagli implementativi, la scelta progettuale merita una menzione: invece di limitarsi a generare codice e sperare che funzioni, il wizard chiude il cerchio offrendo una verifica automatica e visibile, integrata nello stesso strumento che ha generato il codice. L'utente non deve aprire un terminale, ricordarsi comandi npm, o installare Playwright a mano: preme un pulsante e osserva, riga dopo riga, se l'API generata risponde correttamente alle richieste reali — autenticazione inclusa, dialetto SQL incluso.

Dal punto di vista ingegneristico, la parte più istruttiva è probabilmente la gestione della concorrenza: un caso di scuola di come far convivere un processo esterno di lunga durata, uno streaming di output in tempo reale e un'interfaccia VCL reattiva, il tutto senza framework di threading di alto livello — solo primitive Win32 usate con disciplina.

#plyxSQL #SoftwareDevelopment #Sicurezza #CPlusPlusBuilder #Delphi #NodeJS #DPAPI #DevSecOps