Visual dBASE 7.01 Tutorial

Fase IV  Creare i Moduli Dati

Ultima Modifica: 5  Febbraio 1999
Ken Mayer, TeamB


Traduzione in Italiano di: Antonio Campagna - Agosto 2000

Mete ed Obiettivi

Prima di cominciare questa fase...

È molto importante prima di cominciare a lavorare su questa fase, che il combobox "Cerca in": stia puntando alla directory "TUTORIAL e non alla directory "TUTORIAL\TABLES

Che cosa è un Modulo Dati?

Lettura Suggerita: BEGDATA.ZIP discute gli Oggetti Dati ed i Moduli Dati in modo approfondito.

Un Modulo Dati è un contenitore per Oggetti Dati. Se hai familiarità con le prime versioni di Visual dBASE, possiamo rudemente paragonare un Modulo Dati ai files QBE (Query By Example). Lo scopo di un Modulo Dati è impostare i tuoi Oggetti Dati nel modo più opportuno e coerente per l'applicazione che stai progettando, cosicché, se hai bisogno di riutilizzare le stesse impostazioni (per esempio, potresti avere un insieme di tabelle che fanno riferimento ad una scheda, ed hai bisogno delle esatte impostazioni per un report, o per un'altra scheda) puoi farlo senza ulteriore sforzo.

Nota: Per questo progetto non useremo il modulo "impostazione SQL". È mia opinione che il codice SQL generato da "impostazione SQL" è ingombrante, e generalmente non necessario per l'uso con gli Oggetti Dati in Visual dBASE 7. La maggior parte delle istruzioni SQL che avrai bisogno nella maggioranza delle applicazioni sviluppate con Visual dBASE sono abbastanza semplici, e non è necessario creare "joins" e cose simili (a dire il vero sia le "joins" sia altre istruzioni SQL select su tabelle locali, generano delle queries a sola lettura per lo più  inutili a parte i report!). 

Nota: La scelta di non usare un Modulo Dati "Shared" (condiviso) per questa applicazione è dovuta a diversi bugs in Visual dBASE quando si usano Moduli Dati condivisi... 

Un'altra utile caratteristica di Visual dBase 7 consiste nella possibilità di realizzare Moduli Dati Custom, nei quali  possiamo inserire alcune "impostazioni di base". Successivamente, possiamo creare altri Moduli Dati  derivati dal Modulo Dati Custom,  con questa operazione di derivazione, (subclassed)  faremo ereditare le  "impostazione di base" precedentemente inserite nel Modulo Dati Custom. Nell'applicazione che stiamo creando, ci avvarremo di un Modulo Dati Custom, che conterrà un Oggetto Database. Tutti gli altri Moduli Dati, di cui avremo bisogno per questa applicazione, saranno derivati da esso.  

Un Modulo Dati Custom 

Per la nostra applicazione useremo un Alias BDE, questo significa che avremo bisogno di un oggetto database. Piuttosto che creare questo Oggetto Database su ciascun Modulo Dati, possiamo mettere la definizione in un Modulo Dati Custom,  in modo tale che i successivi Moduli Dati saranno basati su quello custom, da cui erediteranno le proprietà in esso contenute.

Il metodo più facile per creare un Modulo Dati Custom, è andare nel Centro di Controllo, e selezionare il separatore "Moduli dati". Adesso dovresti vedere due icone, entrambe chiamate "(Senza nome)". La prima icona  è per i Moduli Dati "standard", la seconda  e per i Moduli Dati Custom. (nota: facendo clic con il tasto destro sulle suddette icone, vedrai apparire un menu "contestuale" che ti "dirà", a cosa si riferisce l'icona).

Doppio clic sull'icona e vedrai comparire la "superficie" di progettazione del Modulo Dati Custom.

Nota: Se si verificano errori circa l'impossibilità a caricare "Schede Custom" o altri errori, dovresti rivedere la sezione di setup (I parte) di questo tutorial, e precisamente il paragrafo "Cancellare i riferimenti ai file custom". E' possibile, che ci sia un riferimento nel tuo VDB.INI ad una scheda custom oppure ad un Modulo Dati Custom, che potrebbe generare problemi...

Nota: Se non vedi la finestra "Tavolozza Componenti", tramite un clic del tasto destro del mouse, sulla superficie di progettazione, dal menu che apparirà, seleziona "Tavolozza Componenti". Stesso discorso vale per la finestra "Ispezione". Per questo progetto avremo bisogno che le precedenti finestre (Tavolozza Componenti e Ispezione) siano entrambe visibili...

Se uno di questi strumenti (Tavolozza Componenti e/o Ispezione) non è semplicemente visibile (per es., la superficie di progettazione o un altro strumento lo ricopre,), puoi usare l'opzione "Finestra" nel menu del Visual dBASE in cima allo schermo, e selezionare la vista che ti serve.

Problema di preferenza: Ci sono molte opzioni nell'ambiente di sviluppo di Visual dBASE, una delle quali ha che fare col modo in cui i componenti sono visualizzati sulla Tavolozza Componenti. Se fai clic destro sulla Tavolozza Componenti, apparirà un menu nel quale c'e l'opzione "Personalizza Finestre Strumenti". Selezionando questa opzione, puoi modificare la visualizzazione degli oggetti all'interno della tavolozza. Prova a sperimentare... Comunque, questo è tutta una questione di preferenze, e personalmente preferisco vedere solo l'immagine e usare lo speedTip per capire di che controllo si tratta. Dipende da te! Puoi sempre cambiarlo successivamente...

Sulla Tavolozza Componenti, vedrai quattro icone. Al momento ne useremo solo una.

Abbiamo bisogno di trascinare un Oggetto Database, sulla superficie di progettazione del Modulo Dati. Se tieni il mouse sugli oggetti della tavolozza, vedrai uno speedTip, che ti indica di quale oggetto si tratta... clic sull'oggetto database, e trascinalo sulla superficie del Modulo Dati.

Abbiamo bisogno di impostare la proprietà databaseName, che dovrebbe essere "TUTORIAL". In Ispezione se clicchi sul combobox  associato a questa proprietà, dovresti vedere elencato tra gli altri il database "TUTORIAL". Selezionalo! C'è ancora una cosa da fare, dobbiamo rendere "attivo" questo database. Se non è attivo, quando tentiamo di accedere ai dati, di questo database,  non troveremo le tabelle... quindi sempre in Ispezione imposta a true la proprietà active.

Questo è tutto quello che abbiamo bisogno, per il nostro Modulo Dati Custom. Per i restanti Moduli Dati, necessari per la nostra applicazione, li erediteremo dall'oggetto database che abbiamo qui impostato.

Salva il Modulo Dati (Ctrl+W) e chiamalo: TUTORIAL.

Se  apri questo Modulo Dati Custom nell'editor di sorgenti, vedrai codice simile al seguente:  

   class TUTORIALCDataModule of DATAMODULE custom

      this.DATABASE1 = new DATABASE()
      this.DATABASE1.parent = this
      with (this.DATABASE1)
         left = 5.5714
         top = 2.3636
         databaseName = "TUTORIAL"
         active = true
      endwith

   endclass

Se stai esaminando questo Modulo Dati nell'editor di Sorgenti,chiudilo! ('usa il pulsante ' x' nella barra del titolo, o premi Ctrl+W...).

Un Modulo Dati per una "Scheda di immissione dati relativi al Cliente" 

Una delle molte cose che avremo necessità di fare nella nostra applicazione, è creare schede per interagire con i dati. A tal scopo, per fare questo, avremo bisogno di impostare alcuni Moduli Dati, che dovranno gestire  molti dettagli, (piuttosto che ricrearli ogni volta che ne abbiamo bisogno)...

Una delle schede che creeremo, dovrà interagire con la tabella Customer (Clienti). Questa tabella avrà bisogno di fare dei lookups sulla tabella State e sulla tabella Country. Invece di creare il codice, che gestisca questo genere di operazioni nella scheda, lo faremo in un Modulo Dati, così,  se abbiamo bisogno di generare, una vista,un report che elenca i clienti, non avremo bisogno di ricreare i lookups.

Nel Centro di Controllo, relativamente ai Moduli Dati, ora dovresti vedere tre icone, (due "(Senza nome)" ed una chiamata "Tutorial.cdm"). Adesso dobbiamo creare un Modulo Dati "standard". Per fare ciò fai doppio clic sull'icona (se appare la finestra che ti chiede di scegliere tra "Wizard" ed "Imposta" seleziona quest'ultima).

Apparirà la superficie di progettazione del Modulo Dati, che sembra identica a quella usata precedentemente per il Modulo Dati custom. Comunque, prima di continuare, abbiamo bisogno di "dire" al modulo "impostazione Modulo Dati" che questo nuovo Modulo Dati, dovrà ereditare le informazioni dal Modulo Dati Custom che abbiamo creato prima. Per fare questo:

Adesso, stai creando un Modulo Dati che è derivato (sotto classe) da quello custom. Dovresti vedere l'Oggetto Database. Non modificheremo nessuna proprietà di questo oggetto, anche se potremmo farlo (queste modifiche sarebbero relative solamente a questo Modulo Dati, e non a tutti i Moduli Dati dell'applicazione).Se volessi che le modifiche si riflettessero su tutti i Moduli Dati di un'applicazione, dovresti effettuarle nel Modulo Dati Custom.

Abbiamo bisogno invece, di mettere la tabella Customer in questo Modulo Dati, ciò ci consentirà di utilizzarlo per la scheda di immissione dati che creeremo successivamente.

Salva il tuo lavoro premendo <Ctrl + S>. Ti verrà chiesto di inserire un nome, Immetti "CUSTOMER" e clicca sul pulsante salva.

Clicca sulla superficie di progettazione del Modulo Dati, e seleziona la proprietà  rowset in  "Ispezione". Questo è quello che definiamo come il rowset principale del Modulo Dati  (questo è utile, perché quando questo Modulo Dati è messo su una scheda, se c'erano due oggetti query, il rowset che è specificato nella proprietà del rowset del Modulo Dati  sarà assegnato alla proprietà  rowset della scheda). Nel combobox seleziona "customer1".

Accertati che la query customer  ("customer1") è quella che è mostrata in Ispezione (clicca sull'icona sul Modulo Dati, o usa il combobox in cima al modulo "Ispezione" per selezionarla), e clicca sulla proprietà rowset. Dovresti vedere il pulsante  - questo significa che se ci clicchi su, vuoi ispezionare l'oggetto a cui fa riferimento. Cliccaci su. Ora dovresti vedere l'Oggetto rowset in Ispezione.

 

Nota: In tutto il tutorial uso il termine "drill down" quando parlo dell'uso del modulo "Ispezione". Questo vuol dire cliccare prima, su un riferimento oggetto nel modulo ispezione (coma abbiamo fatto sopra per l'Oggetto Rowset) e poi cliccare sul pulsante "Ispeziona" (il pulsante  ). Questo ci permetterà di muoverci attraverso la gerarchia di un oggetto per capire se un oggetto e contenuto in un altro oggetto. (L'oggetto query contiene l'oggetto rowset...)

Quando uso il termine "drill down" mi riferisco a questo processo. Così se ti indico un "drill down all' array fields" , significa prima cliccare sull'oggetto fields in Ispezione, e poi cliccare sul pulsante ("ispeziona") ...

Vogliamo che uno specifico indice sia attivo, che sarà l' indice "Names". Per usare questo indice clicca sulla proprietà indexName e usare il combobox che appare sulla destra. Seleziona "NAMES". Ciò è tutto quello che è necessario per inserire un indice.

Successivamente abbiamo bisogno di impostare un paio di lookups con i campi  "State ID" e "Country ID" per i clienti, i quali ci permetteranno tramite dBASE di visualizzare automaticamente gli Stati (Americani)  e le Nazioni associati al codice di due caratteri che sono memorizzati nella tabella Customer. Sembrerebbe difficile, ma non lo è (nelle prime versioni di dBASE fare questo era più complesso...).

Letture Suggerite: MISCCODE.ZIP e BEGDATA.ZIP discutono l'argomento lookupSQL in modo abbastanza approfondito, così come l'array fields e gli oggetti field... in più la guida in linea fornisce delle buone informazioni. 

Clicca su "fields" e poi sul pulsante . Questo ti permetterà di ispezionare l'array fields.

Seleziona il campo "State ID", e clicca sul pulsante . Stiamo adesso esaminando le proprietà del campo "State ID". Clicca sulla proprietà lookupSQL e digita:

   select * from state order by state

e assicurati di premere il tasto  <Invio> . 

Se imposti correttamente questa proprietà, il valore della proprietà del campo "State ID" mostrerà sulla scheda qualche cosa molto più grande di due caratteri (questo è chiamato "morphing dei dati"  usa la guida in linea e guarda le informazioni relative ai termini "morphing" e "lookupSQL"). In più, ci stiamo assicurando, tramite la clausola "order by", che la visualizzazione dei dati sarà in ordine alfabetico sul campo "state". (Normalmente, non useremo la clausola "order by", in alcuni casi con le tabelle locali questa clausola crea query di tipo "read only". Nel caso di un'operazione di lookup, questo non è un problema in quanto un'operazione di lookup, è, per natura a sola lettura...)

Abbiamo bisogno di fare le stesse cose per il campo "Country ID". Come avrai notato, abbiamo "ispezionato" gli Oggetti andando in "avanti", nella gerarchia degli oggetti. Come ci muoviamo all'indietro? Trova la proprietà "parent" la quale indica  "oggetto" - clicca sul pulsante , e come vedi, ritorniamo sull'oggetto fields ( puoi usare anche il pulsante ("Freccia Sinistra") in cima al modulo Ispezione - questo ti porta all'Oggetto  precedente ispezionato...)

Seleziona il campo "Country ID", clicca sul pulsante "Ispeziona", e seleziona lookupSQL ed immetti: 

    select * from country order by country

e premi <Invio>.

Crederesti che abbiamo finito con questo Modulo Dati? Salva quello che hai fatto finora ed esci (Ctrl+W).

Come puoi vedere, creare Moduli Dati non è così difficile, ovviamente aiuta, avere un'idea, di quello che hai bisogno di fare. Per esempio, potresti non avere usato la proprietà lookupSQL dell'oggetto campo discusso prima. Non ti preoccupare - puoi sempre aggiungere modifiche ad un Modulo Dati dopo che è stato creato.

Creare il Modulo Dati Inventory

Il Modulo Dati "Inventory" sarà simile al Modulo Dati "Customer" eccetto che l'unico lookup necessario sarà sulla tabella Supplier (Fornitori).

Nel Centro di Controllo seleziona il separatore "Modulo Dati" quindi fai doppio clic sulla prima icona .

Come facemmo con il Modulo Dati Customer, una volta che la superficie di progettazione del Modulo Dati è visualizzata, tramite il Centro di Controllo seleziona il separatore "tabelle", quindi seleziona la tabella "Inventory". Trascinala sulla superficie del Modulo Dati. Come fatto prima, controlla che la proprietà database della query punti a "form.database1", e che la proprietà active sia impostata a true.

Clicca sul Modulo Dati e poi in Ispezione sulla proprietà rowset. Nel combobox, seleziona "inventory1"

Clicca sull'Oggetto Query , e:  

       select supplier.'supplier id', company from supplier order by company

e premi <Invio>.

Questo particolare lookup, seleziona dei campi specifici al fine di evitare che venga mostrato il campo sbagliato. Abbiamo bisogno, infatti che appaia sulla scheda Inventory, il nome della società (campo company), e non il Contatto nella compagnia (Campo Contact), ed è ciò che si verificherebbe se non usassimo l'istruzione select vista sopra. (la proprietà lookupSQL, se non specifichi altrimenti, usa i campi nella sequenza di immissione nella tabella. Nel nostro caso il primo campo nella tabella Supplier è il "Supplier id", ma il successivo è "Contact" - e come detto sopra vogliamo visualizzare invece il campo "company" ...). In più stiamo specificando "supplier.'supplier id'" perché il nome del campo contiene degli spazi. Appare questo l'unico modo per ottenere il corretto nome del campo usando l'istruzione SQL select. 

Salva il Modulo Dati e chiamalo "Inventory" ed esci... 

Crea il Modulo Dati Supplier

Il Modulo Dati Supplier, sarà impostato quasi esattamente come la tabella Customer. Come fatto prima crea un Modulo Dati tramite il Centro di Controllo e trascina la tabella "Supplier" sulla superficie del Modulo Dati. 

Sempre come fatto prima, verifica che la proprietà database della query punti a "form.database1", e che la proprietà active sia true. 

Imposta la proprietà rowset del Modulo Dati affinché punti al rowset "supplier1". 

Salva il Modulo Dati e chiamalo "Supplier". 

Crea il Modulo Dati Invoice

Il Modulo Dati Invoice, che stiamo per realizzare, sarà un poco più complicato e richiederà di seguire i passi successivi attentamente. Per questo Modulo Dati useremo tre tabelle. La tabella Customer sarà la tabella principale, e la useremo come tabella "genitore" per la tabella Invoice, la quale, a sua volta, sarà la tabella "genitore" per la tabella LineItems (questi sono singoli articoli ordinati dal cliente), creando un tipo di relazione genitore ==> figlio ==> nipote. 

Così, per cominciare, crea un nuovo Modulo Dati, e trascina la tabella Customer sulla superficie del Modulo stesso. 

Anche per questo, come fatto prima verifica che la proprietà database della query punti a "form.database1", e che la proprietà active sia a true.  

Clicca sul Modulo Dati ed in Ispezione seleziona la proprietà rowset. Nel combobox, seleziona "customer1".  

Clicca sull'oggetto query customer , e vai all'oggetto rowset, ed imposta indexName a "Names". Imposta infine la proprietà autoEdit a false. 

Salva il Modulo Dati (Ctrl+S) e chiamalo "Invoice". 

Successivamente trascina la tabella Invoice sulla superficie di progettazione, e controlla il riferimento al database come visto sopra. 

Va' all'oggetto rowset (in Ispezione) ed imposta la proprietà indexName a "Customer ID". E' molto importante che questo sia l'indice, perché ti permetterà di risalire al Cliente. Non dimenticare di mettere autoEdit a false. 

La prossima parte è piuttosto importante, infatti riguarda l'impostazione di una  relazione tra due tabelle. Questa relazione è di tipo "padre/figlio", Ad ogni cliente corrispondono una o più fatture, ma ad ogni fattura corrisponde un solo cliente. 

Questo è fatto (con tabelle locali) usando le proprietà dell'oggetto rowset. Clicca sulla proprietà masterRowset, e seleziona nel combobox "customer1". Successivamente seleziona masterFields e nel combobox seleziona "Customer ID". Ci crederesti che questo e tutto quello che devi fare per impostare una relazione padre/figlio? 

Nota: Se usi tabelle che non sono locali (.DBF o .DB) avrai bisogno di usare la proprietà dell'oggetto query masterSource invece delle proprietà masterRowset e masterFields dell'oggetto rowset. Questo è discusso approfonditamente in vari documenti How To. 

Continuiamo. Trascina la tabella LineItem sulla superficie di progettazione, e controlla il riferimento al database come fatto sopra.La tabella lineItem sarà impostata in modo tale che possiamo avere uno o più articoli per fattura. Alcuni dei quali dovranno essere gestiti in codice nelle schede di immissione che useremo per aggiungere dati. 

Seleziona l'oggetto rowset, e metti la proprietà indexName a "Invoice ID". non dimenticare di mettere autoEdit a false. 

Clicca sulla proprietà masterRowset, e seleziona nel combobox "invoice1". Successivamente seleziona masterFields e nel combobox seleziona "Invoice ID." 

Un'ultima cosa dovrebbe essere fatta qui,  inserire un lookup sul campo "Item ID" che "guardi" nella tabella Inventory così che noi possiamo visualizzare il campo descrizione. Vai nell'array fields, e seleziona il campo "Item ID" premi il tasto e seleziona la proprietà lookupSQL ed immetti: 

select inventory.'item id', inventory.'description' from inventory 

e premi <Invio> 

Salva il modulo Dati ed esci (Ctrl+W), chiamalo "INVOICE" 

Dopo Tutto questo, Che si fa? 

Ok, progettare Moduli Dati non è affascinante o eccitante, e non puoi vedere i risultati del tuo lavoro finché non progetti le schede...  Comunque, quello che hai appena fatto è impostare moduli dati riutilizzabili che possono lavorare sia con le schede sia con i report, ed hai, in alcuni casi definito dei lookups, (nelle precedenti versioni di dBASE ci voleva molto codice). In un caso hai un insieme di tre tabelle relazionate... con pochissimo sforzo. La migliore cosa è la parte "riutilizzabile". La maggior parte di questi Moduli Dati lavorerà per schede e report (ed etichette), e potremmo usare lo stesso Modulo Dati su diverse schede... 

L'altra caratteristica importante è la capacità di creare un Modulo Dati (o una scheda o un report) dal quale se ne possono derivare(ereditare) altri,  vera OOP.  

Per Evitare Più tardi Problemi... 

C'è un bug nel modo in cui i "disegnatori visuali" per i Moduli Dati e per le Schede leggono e scrivono le informazioni nel file VDB.INI riguardo le schede/Moduli Dati custom. 

Per evitare problemi segui questi semplici passi: 

Ciò eviterà questo particolare difetto quando inizieremo a creare ed usare le schede custom.  

Inserisci i Moduli Dati nel Progetto 


Nel Centro di Controllo seleziona il separatore "Progetti", quindi doppio clic sul file progetto "Visual dBASE 7 Tutorial". 

Clic tasto destro del mouse sul pannello sinistro, e seleziona "Aggiungi file al progetto..." 

Nel combobox in fondo alla finestra di dialogo seleziona "Tipo File" e seleziona "Moduli Dati". verranno visualizzati i moduli dati che abbiamo creato. Selezionali e clicca su "Apri". (Nota: seleziona solamente i files con estensione .DMD e .CDM). 

Ripeti i passi fatti prima per inserire il Modulo Dati Custom 

Chiudi il progetto e salvalo  

Fase V - Creare il Menu

tutorial menu

Fine del File: DATAMODULE.HTM  5 - Febbraio -1999 KJM

Avvertimento Legale: Questo documento è parte del Visual dBASE 7 Tutorial creato da Ken Mayer. Questo materiale è © proprietà letteraria riservata 1999, da Ken Mayer. Visual dBASE 7 e Visual dBASE 7.01, il BDE (Borland Database Engine) e BDE Administrator sono tutelati in base ai diritti d'autore e marchio di fabbrica da Inprise, International. Questo documento non può essere esposto altrove senza il permesso esplicito dell'autore, il quale si riserva tutti diritti sul documento.