Newsgroup: it.comp.lang.visual-basic
Titolo: [Consiglio] Aiutatemi a decidere come gestire un configuratore...

Rieccomi qua ragazzi....
ho concluso la prima parte del mio motore per le interfacce (vedi post "[?]
Domanda su Timer multipli" di ieri).
Ora il bimbo può essere configurato per ogni singola funzione (gli
intervalli intendo, tipo i wizard per i backup), scrive il suo bel log, si
collega a diversi db, si parcheggia nella traybar....... e adesso???
adesso devo trovare una politica di configurazione che mi permetta di
gestire diverse situazioni senza dover modificare e ricompilare il codice!
Fino ad ora ho pensato a:
1) Inserire direttamente le query da eseguire, ma purtroppo non posso avere
un'unica connessione, quindi non saprei come fare
2) Creare una struttura dove associare ad ogni campo di una mia tabella, il
corrispondente nella tabella del db esterno, specificando magari il criterio
di formattazione (ad esempio il formato della data...), ma poi non saprei
come gestire le esportazioni che necessitano ad esempio di raggruppamenti
3) chiedere consiglio su it.comp.lang.visual-basic :-P
idee?
ciaociao

 ciaociao

 3) chiedere consiglio su it.comp.lang.visual-basic :-P
Tempo fa ebbi ("ebbi"?) lo stesso problema: mi ero rotto di riscrivere 
per ogni nuovo programma la sua routine di importazione/esportazione dati.
Così mi sono fatto la mia bella classe che dato un file di formato in 
input (file ascii, quindi se un giorno il cliente voleva aggiungere un 
campo o modificare il formato di un campo lo poteva fare addirittura da 
solo).
'Sta classe si leggeva (e validava il formato) gli si passava la 
connessione e la query di partenza/destinazione e poi si formattava ogni 
campo.
Gestiva anche l'ordinamento nel caso non fosse specificato un order by, 
la possibilità di sovrascrivere i record già presenti (dichiarando nel 
file di formato quali campi formavano la chiave di un record) se 
aggiornarli, aggiornare solo i campi con NULL o se rifarere la tabella 
da zero.
Supportava addirittura la possibilità di definire alcune funzioni come 
formato (es. per un dato campo poteva essere importata una stringa 
fissa, un valore numerico, Time, Date, CR, LF, Substringhe del campo 
d'origine...)
Alla fine mi bastava definire nel file ascii cosa e come importare e il 
resto veniva fatto in automatico.
Unico problema è che ti passerei anche la classe, ma è scritta in Delphi :P
Ciao

 inviare il file di testo.
Perfetto, partiamo da qui allora. ;-)
Ora immagina di dover inserire il risultato di una di queste query in una
tabella che sta su un altro db.
Come faresti per gestire la configurazione di tale operazione?
ciaociao

[Marg = 
circa...@inwind.it
 in
c6oc6p$duq51$
1...@ID-193795.news.uni-berlin.de
] ha scritto:

Se la connessione è fissa da programma (quindi punta a un db specifico
diverso dal desiderao), non vedo altra soluzione che inserire nella query il
percorso+nome del db, magari sfruttando SQL che lo consente anche se la
connessione è su un db specifico (Select * from tabella,
c:\cartella\sottocartella\altro_db.altra_tabella ...), magari (io ne ho
inventate un tot) mettendo nel file di testo una sintassi tua (fra
delimitatori tuoi) da sostituire a runtime con il loro significato,
sfruttando variabili note al programma.

 Ciao
intanto grazie
ciaociao

 sfruttando variabili note al programma.
Questo andrebbe bene fra db di access, ma se il database di partenza fosse
SQL server e quello di destinazione un file di AS/400?
(tanto per citare la mia situazione attuale) ;-)
ciaociao

 già uno spunto per partire :-P
Quando arrivo a casa stassera lo cerco.
Ciao

 (tanto per citare la mia situazione attuale) ;-)
Marg:
*SEZIONE_SQL_ESP0DAMA+Alternativa=griglia estesa+*
Select pippo, @campo_libero1@ From @database_contabilità@.tabellai Order By
@mio_ordinamento@
Questo, per esempio, intendevo. Inventa tu quanto può essere variabile (e la
tua sintassi relativa), leggi il "Marg-comando" dal file di testo e prima di
eseguirlo, a runtime, fai gli adattamenti del caso, aggiungi le selezioni di
contesto (Where) e via...


Questo è chiarissimo,
io mi riferivo al fatto che non posso (leggasi "non so se si può fare e se
si può fare non so come") utilizzare un'unica query, salvata in qualunque
"marg-formato", per scrivere i dati in un database che non sia access.
Esempio (facciamo finta che le query siano già il risultato
dell'interpretazione del 'marg-comando'):
da access a access:
INSERT INTO db1.tabella1 (db1.campo1, db1.campo2
SELECT db2.campo1 IN c:\pippo.mdb, db2.campo2 IN c:\pippo.mdb
FROM db2.tabella1
da SQL server a ORACLE:
INSERT INTO ....??????
tè capì? ;-)
ciaociao

 da SQL server a ORACLE:
prova a cercare i post di giorgio prix e/o giorgio rancati (che mi par di
capire siano la stessa persona
-- 
Salutoni
Sergio
per rispondere... togli il group dall'indirizzo

 Ciao
ciaociao

 par di capire siano la stessa persona
ok, ora cerco, grazie
ciaociao

 par di capire siano la stessa persona
wow!
non avevo mai trovato nulla di simile! :)
Molto utile
grazie anche a Giorgio allora!
ciaociao

 non avevo mai trovato nulla di simile! :)
Lo diresti anche a noi? <eg>
PS: Ho cercato

 tè capì? ;-)
Sì (anche se non conosco Oracle).
Io ho nel file di testo le query valide per Access che prevedono delle tags
per le varianti per SQL Server (almeno quelle che non possono essere intese
al volo parserizzando la query).
Sostituisco le tags a runtime in funzione dell'ambiente (tipo di database
e/o accesso) in cui devono essere eseguite.


ops...scusate....
leggiti questo 3d:
ASP + ADO e un po di Vb...travasare dati da un archivio all'altro
ciaociao


Non hai afferrato il problema...
non mi preoccupa la sintassi delle varianti (tipo sostituire la Left con la
SubStr ecc..), ma il fatto di indicare nella query il "path" del db, nel
caso in cui esso non sia un db access!
Comunque se leggi il 3d di Giorgio che ho indicato nell'altro post capirai
cosa intendo :)
ciaociao

 capirai cosa intendo :)
L'ho afferrato, anche perchè con Access, ADO e SQL Server ADO l'ho dovuto
già risolvere...
Io ho, fra le tante, una tag che dice @SOLO_SE_ADO=bla-bla-bla@
Tè capì?


i go capì! ;-)
Io comunque uso solo ADO, dato che la maggior parte dei collegamenti non
saranno su access....
quindi tu conoscevi già il modo di passare alla query i parametri di
connessione per un db tipo SQLserver....
mannaggia.... e non potevi dirlo prima?!? :-D
ciaociao

 mannaggia.... e non potevi dirlo prima?!? :-D
Non ho detto questo. Ma di fatto lo faccio, devo farlo (non posso
permettermi di scrivere comandi diversi per un db o un altro, col rischio di
dimenticarne uno).
L'ambiente sa come connettersi, almeno su db di primo appoggio.
Se un comando SQL deve accedere (dalla connessione/database sulla quale in
comando stesso deve essere eseguito) a più database e di diversa natura, la
sintassi del comando deve adeguarsi a quanto l'ambiente prevede.
Quindi, fermo restando che occorre conosce la sintassi di un comando per un
ambiente o per l'altro (e mi pare ovvio), nel file di testo inserisco delle
tag che verranno considerate da un ambiente o dall'altro, altre, in ogni
caso, dal mio ambiente (per mie variabili).
Quel comando fornito da Giorgio è sicuramente comodo e forse può essere
esteso ad altre situazioni, ma non credo che basti per sempre e per ogni
cosa.
Insomma, se io scrivo (sto inventando):
Select * From @Quanto_segue_solo_per_SQL_Server=bla-bla-bla@ ... Where
@Quanto_segue_solo_per_Oracle=bla-bla-bla@
capisci che, una volta che la mia routine di adeguamento a runtime riconosce
le tags "@Quanto_segue_solo_per_SQL_Server=...@" e
"@Quanto_segue_solo_per_Oracle=...@" e, di conseguenza, sa se e come gestire
(includere/escludere) quanto segue = (... alias bla-bla-bla alias quello che
vuoi), io posso pistolare come e quando voglio sul file di testo, oltre che
fare quanti comandi voglio?
Se il comando è in programma ci sarà sempre una cazzatina da sistemare e
quindi ricompilare.


ok, ma continuo a sostenere che senza il comando di Giorgio, la soluzione
non sarebbe stata completa per le mie esigenze.
Mi spiego:
fermo restando che la soluzione del file di testo con le tags è quella che
utilizzerò, resta il fatto che, fino a 1 ora fa, non sarei stato in grado di
fare una query che prelevasse i dati da un db access e li mettesse in un db
SQL server (*in un'unica query!*).
Se si fosse trattato di fare solo una select o una delete no problem, ma
spostare in blocco un gruppo di records con una INSERT INTO...SELECT... non
lo credevo possibile.
Ora che conosco la sintassi, posso tranquillamente costruire il mio bel
parser, il quale, quando incontrerà nel file il tag:
@Quanto_segue_per_connettersi_a_Sql@, saprà che dovrà scrivere "[ODBC;
DRIVER=Sql server.......]".
Tutto qua, spero di essermi spiegato ;-)
ciaociao

 Tutto qua, spero di essermi spiegato ;-)
Io avevo inteso che tu volessi personalizzare/parametrizzare dei comandi con
sintassi nota.

Lupo wrote:

Non proprio, in pratica questo aggeggio serve per importare/esportare i 
dati dal mio programma a un qualunque altro software. Quindi se la 
softwarehouse del caso mi dice :<vorrei i dati di tutti gli scarichi del 
cliente Pippo ogni sera alle 23! Dovresti metterli su un db Oracle in 
una tabella che si chiama 'AHRTSS3' e i campi da riempire sono 'eewERW', 
'ewrwrwe' e 'ewefwefrgg22'> io mi configuro il motore in modo da 
reperire i dati dal mio db e scriverli in quell'altro, il tutto 
possibilmente senza dover ricompilare nulla.
Beh, ora stacco, domani mi ci tuffo e poi vi farò sapere
ciaociao

 tutto possibilmente senza dover ricompilare nulla.
Quindi la sintassi è nota... ovvero sai quale deve essere, devi solo
comporla (anche con le variabili del caso)
PS: Se i nomi dei campi sono quelli credo che non funzionerà mai, pur con
tutta la cura che ci puoi mettere. Digitarli correttamente sarà sempre
un'impresa molto improbabile. :-P

 Ciao
Ciao,
Andrea


La classe in questione più che altro era stata scritta per
importare/esportare da DB a file di testo e viceversa.
Poi l'ho usato anche "impropriamente" ad es. per la stampa di etichette
personalizzate: se esiste il formato relativo al cliente alcune informazioni
vengono prese da lì piuttosto che usare quelle standard.
Questo è la documentazione (scarsa) che mi ero fatto per non
dimenticarmi come scrivere il file di formato
// -------------------------------
//
// [*]FieldName[; o:<offset>; l:<length>; p:[precision]; f:<format>;
u:<update_options>;]
//
// * says that the field is a part of the primary key
//
// <format> = any valid format
//            'd' truncated integer
//            'f' float formattato sulla lunghezza senza separatore decimale
//            'p' float formattato sulla lunghezza con separatore decimale
da pannello
//                controllo
//            's' stringa allineata a destra su lunghezza se precisione > 0
//                        allineata a sinistra su lunghezza se precisione <
0
//                        non allineata se precisione = 0
//
//
// options to decide if update the field
// <update_options> = 'ALWAYS', 'ONLY_IF_NULL', 'ONLY_IF_NOT_NULL'
//
//
// [*]FieldName = <Funzione>
//
// <funzione> = 'DATE', 'TIME', 'NOW', 'TRUE', 'FALSE' 'CR', 'LF', 'CRLF',
'TAB'
//              'SSTR(string, from, length)', 'STR('string')'
//
// [*]FieldName = $<paramIndex> (zero based)
//
// <paramIndex> = index of the collection of parameters defined
// -------------------------------
Questo è un esempio di file.
Se letto per l'esportazione significa che esporta dalla query passata il
campo DataBollaCarico con formato "yymmdd", tutti i campi sono separati da
TAB (i campi tra "<" ">" sono interpretati come campi "fasulli") e il record
termina con CFLF.
Per l'importazione
disposizione e pezza formano la chiave univoca del record per poter decidere
se sovrascriverlo.
// Esempio di file di esportazione
// --------------------------------
DataBollaCarico; f:yymmdd
<separatore> = TAB
*disposizione
<separatore> = TAB
*pezza
<separatore> = TAB
<scelta> = SSTR(scelta, 1, 2)
<separatore> = TAB
Metri
<terminatore> = CRLF
// - Fine ------------------------
Se ti interessa la classe in Delphi la trovi qui:
www.neodatatype.net/dump/AsciiFi3.pas
Ciao


Grazie Zanna, sei stato veramente gentile
ciaociao