Gestionale con MySql e OpenOffice – 6 prima macro

L’utilità di avere un front-end come openoffice è che offre una sequenza di oggetti grafici che si relazionano al server mysql in maniera efficiente. Insomma viene evitato lo smazzo non da poco di creare un’interfaccia grafica per il server mysql.
L’efficienza è aumentata dal fatto questi oggetti grafici e le loro funzioni possono essere manipolati da riga di codice con l’uso delle macro.
Per un excursus sulle macro di openoffice e il modo con cui si scrive codice guardare qui.

Siamo arrivati ad avere una pagina-formulario con una tabella che si collega alla tabella fatture di mysql, e una sotto-tabella che per ogni fattura mostra quali scadenze ci sono e con che data.

Tuttavia dal momento che nella tabella fatture si fa uso di un menu a tendina per inserire le ragioni sociali, nel momento in cui dovessimo registrare una fattura che riporta una ragione sociale nuova, mai registrata, saremmo impossibilitati a inserire il nome.

Allora dovremmo andare nella sezione tabelle del file base, aprire la tabella elenco_nominativi, inserire il nominativo, tornare alla nostra pagina-formulario, chiuderla e riaprirla e così troveremmo nel menu a tendina la ragione sociale appena inserita.

Una procedura assolutamente non professionale e comunque molto onerosa dal punto di vista del tempo perso.

Si può risolvere andando ad aggiungere un oggetto-formulario con cui si disegna una griglia collegata alla tabella elenco_nominativi, si aggiunge un campo di testo dove poter scrivere e si applica una macro che va a visualizzare nella griglia appena disegnata solo i nominativi che contengono il testo che viene scritto nel campo di testo. Per fare questo:

Si apre in modo bozza la nostra pagina-formulaio (tasto destro – modifica).
Si clicca su navigatore formulario si clicca sul capostitpite Moduli, tasto destro → NuovoFormulario. (Da solo dovrebbe chiamarsi Formulario 1).
Tasto destro su Formulario 1proprietà
Nella scheda dati si seleziona Tipo di contenuto: Comando SQL
Nel campo Contenuto si clicca sui tre puntini … → (finestra aggiungi tabella o query) → si seleziona la tabella elenco_nominativi → clicca Aggiungi → clicca Chiudi.
Fare doppio clic su *, cliccare su salva e chiudere la finestra.

Si ha quindi:

Per creare una griglia si clicca su Formulario 1 dentro il navigatore formulario. Poi si clicca su campo di controllo tabella come si è fatto qua.

Si crea una griglia con una sola colonna contente il campo nominativi_en.

Dal momento che ho solo la colonna nominativi_en, quando inserisco una riga il campo attivo_en verrà riempito per difetto col numero 1 (attivo), come impostato da mysql, invece il campo tipo_en non ha un valore per difetto e quindi verrebbe riempiro da null. Per evitare questo si fa così nella pagina-formulario:

Si crea un campo Campo numerico (Campo di testo o Campo formattato) che appartenga a Formulario 1. Quindi tasto destro → Campo di controllo → nella scheda generale Visibile: no, Valore predefinito: 1 (fornitore, dal momento che siamo sulle fatture di acquisto); nella scheda Dati → Campo di dati: Tipo_en.

Ora se avviamo il formulario si vede che è ora possibile inserire nella griglia appena creata nuove ragioni sociali, senza quindi dover andare ad aprire la tabella elenco_nominativi dentro la sezione tabelle.
Però restano 2 problemi.

1) per vedere se una ragione sociale è presente devo scorrere l’intera colonna coi nominativi (e può essere molto lunga e quindi il procedimento rischia di diventare laborioso)
2) quando inserisco un nuovo nominativo questo non appare nel menu a tendina della griglia fatture.
Aggiungo quindi un campo di testo dove poter inserire il nominativo che si cerca.
Per fare questo io utilizzo una campo di testo:
Dal navigatore formulario si clicca su Formulario (non su Formulario 1) e poi sul tasto Campo di testo:

,

lo si disegna nella pagina-formulario. Non si associa nessun campo a questa casella. Infine dal navigatore formulario si cambia il nome (tasto dx → proprietà → scheda generale → Nome) della campo di testo in Nominativo
.
Siccome mentre scrivo dentro il campo di testo andrò ad aggiornare ad ogni tasto che digito il contenuto del Form elenco_nominativi è importante che il campo di testo non sia un oggetto appartenente al Form elenco_nominativi, altrimenti ad ogni tasto premuto si crea un cortocircuito per cui si aggiorna – cancellandosi – anche il testo che sto scrivendo.

Serve quindi fare una macro.

Si fa:
StrumentiMacroOrganizza macro …office Basic → nella sezione Macro da è preferibile selezionare il file primodatabase → Si clicca su nuovo → si dà il nome al modulo (Modulo 1) e si clicca OK → si clicca su modifica.

Serve poi ricordarsi di andare su strumentiopzioni → sezione openoffice → Sicurezza → Sicurezza delle macro e impostare Medio. Chiudere primodatabase e aprire cliccando su abilita macro per attivare l’uso delle macro.

Si accede quindi alla pagina delle macro. Di solito contiene una funzione vuota Main.

Si scrive in fondo al foglio (in questo caso sotto la funzione Main, dopo end sub):

sub trova_clienti(oEv)

oEv cattura l’evento che attiva la procedura: nel nostro caso il rilascio di un tasto della tastiera

Questo comando ottiene nella variabile Form il controllo dell’oggetto Formulario, che relaziona la tabella mysql fatturecon il file di base
Form = ThisComponent.Drawpage.Forms.getByname(“Formulario”)
Poi prendiamo anche il Formulario 1, quello che gestisce la relazione con la tabella elenco_nominativi
fb = ThisComponent.Drawpage.Forms.getByName(“Formulario 1”)
Prendiamo controllo anche della casella da cui stiamo scrivendo il nome della ragione sociale, che è un oggetto di Form (il primo formulario)
testo=Form.getbyname(“Nominativo”)
Infine recuperiamo il codice del tasto che è stato premuto e che ha generato questo evento. L’evento “tasto” è illustrato qui L’elenco dei codici tasto è presente qui
tasto = oEv.keyCode

se il tasto è un numero o una lettera oppure uno spazio, un cancella, un backspace, una virgola un punto sottrazione moltiplicazione divisione maggiore minore uguale (e poco altro) azioniamo la procedura

if (tasto > 255 and tasto < 266) or (tasto > 511 and tasto < 538) or (tasto > 1282 and tasto < 1296) or (tasto = 0) then
‘MIGLIORIA: BISOGNEREBBE METTERE CHE SE SI SCRIVE \ APPARE UN MESSAGGIO CHE TE LA RIFIUTA
contenuto= “”
acquisiamo il contenuto del campo di testo da cui stiamo scrivendo
contenuto = testo.text
n serve per analizzare di carattere in carattere il testo scritto nel campo, u invece memorizza l’ultimo apice ( ‘ ) incontrato
n = 1
u = 1
Salviamo la lunghezza della stringa contenuta nel campo di testo
lun_str = len(contenuto)
Dal momento che l’apice ( ‘ ) nei comandi SQL delimitano i valori serve che quando il nome contiene
‘un apice questo venga raddoppiato di modo da rendere il comando SQL leggibile dal server

while n < lun_str+1
Mid(contenuto,n,1) estrae dalla stringa contenuto una sottostringa che comincia dal carattere n di contenuto e prosegue per un carattere (ossia: estrae il carattere n)
if Mid(contenuto,n,1) = “‘” then
‘ Se il carattere n è un apice si spezza in due la stringa (la parte prima dell’ultimo apice trovato e la parte che segue) e si aggiunge un altro apice in mezzo
contenuto = Mid(contenuto, 1, n) + “‘” + Mid(contenuto, n+1, lun_str-u)
Si memorizza in u la posizione del carattere successivo all’ultimo apice trovato
u=n+2
Siccome abbiamo aggiunto un carattere (l’apice) ora la stringa è più lunga di 1, quindi aumento lun_str e serve che il
‘ciclo while non analizzi il prossimo carattere perché sarebbe un apice e questo genererebbe un ciclo infinito quindi faccio n=n+1

n=n+1
lun_str=lun_str+1
end if
passo al carattere successivo
n=n+1
wend

Scrivo il comando SQL: prendo tutte le colonne dalla tabella elenco_fornitori, solo le righe in cui il campo `tipo_en` è 1 (fornitore) e `nominativi_en` contiene la stringa memorizzata in contenuto.
‘INSTR infatti è una funzione SQL che restituisce l’indice che una sottostringa ha all’interno di una stringa.
‘Se al posto di imporre >0 si fosse impostato INTRS(…) = 1 si sarebbero trovate tutte le stringhe che cominciano con la sottostringa
contenuto
‘Infine si ordinano le righe della query in ordine di nominativo crescente
‘Per fare l’apice diagonale `, nei sistemi operativi linux si preme AltGr ‘

comando= “SELECT `elenco_nominativi`.* FROM `elenco_nominativi` WHERE `tipo_en` = ‘1’ AND INSTR(`elenco_nominativi`.`nominativi_en`,'”+contenuto+”‘) > 0 ORDER BY `nominativi_en` ASC”

‘Si imposta il comando SQL del formulario fb e si ricarica il formulario per far appartire il risultato della nuova query
fb.command = comando
fb.reload
‘tasto giu

elseif tasto=1024 then
Se si preme il tasto “freccia giù” il formulario fb va giù di una riga (a meno che non sia già all’ultima riga o alla riga “afterlast”).
‘(nel mio caso non prende Last ma prende afterLast anche quando è l’ultima riga).

if fb.isLast or fb.isafterLast then
else
fb.next
end if

‘tasto su
elseif tasto=1025 then
Se si preme il tasto “freccia su” il formulario fb va su di una riga (a meno che non sia già alla prima riga o alla riga “beforefirst”.
if fb.isfirst or fb.isbeforeFirst then
else
fb.previous
end if
end if

end sub

Poi serve aggiornare le caselle di riepilogo per permettere che un nuovo nominativo appaia subito nel menu a tendina del campo ragione sociale della griglia fatture. Per questo serve un’altra macro:

sub aggiornacombo
Form = ThisComponent.Drawpage.Forms.getByName(“Formulario”)
a = Form.getbyname(“Campo di controllo tabella 1”)
Per trovare il nome di del campo ragionesociale_fat clicco tasto dx sulla intestazione della colonna ragionesociale_fat → proprietà → scheda Generale → vedo il campo Nome
b=a.getbyname(“NumericField2”)
b.refresh()
end sub

In questa macro si ottiene l’oggetto-formulario delle fatture e da questo si ottiene la griglia e da questa si ottiene la colonna con la casella di riepilogo (ragionesociale_rag). Infine si fa il refresh della casella di riepilogo.

In alcuni casi è capitato che openoffice chiedesse che ogni variabile venisse dichiarata prima di essere usata. Non so da cosa dipenda, comunque se succede è sufficiente dichiarare all’inizio della procedura tutte le variabili che si usano, ad es:

Dim Form as Object

Ora serve associare gli eventi alle macro.

Per quel che riguarda la casella combinata appena aggiunta: si fa doppio clic sul campo di testo (o tasto destro proprietà) → scheda Eventi → si va sul campo Dopo aver premuto il tasto → si clicca i tre puntini → Si clicca su Macro… → si sceglie la macro trova_clienti.

Per quel che riguarda l’aggiornamento della casella di riepilogo serve far si che la lista si riaggiorni ogni volta che si esegue un’azione sulla tabella elenco_nominativi.

Da navigatore formulario si clicca su Formulario 1, tasto destro → proprietà → scheda eventi
Scegliamo il campo Dopo l’azione sul record → tre puntini → andiamo a prendere la macro aggiornacombo.

Ora è preferibile aggiungere un’etichetta con scritto “Cerca” affianco al campo di testo, per rendere chiaro all’utente che da quel campo non può inserire dati ma solo ricercare i nominativi.

Si clicca su Testo fisso: , lo si disegna nella pagina-formulario e si fa tasto destro → proprietà → Scheda GeneraleDidascalia: “Cerca:”

Annunci

Excursus su macro di OpenOffice o LibreOffice

La prima parte in rosso contiene indicazioni basilari sulle macro da come registrare una macro a come eseguirla associata a un tasto o a un menu a tendina e infine un codice di “hello world”, la seconda parte in verde contiene informazioni più specifiche su come consultare le api di openoffice per scrivere codice.

Le macro di openoffice sono dei comandi scritti a computer che permettono di fare potenzialmente qualsiasi cosa coi documenti di openoffice.

La prima macro la si può realizzare senza scrivere codice: si clicca su strumenti → macro → registra macro
Si fa qualcosa come ad esempio cambiare il colore di un testo
Si clicca su termina registrazione
Si nomina la macro, scegliendo dove salvarla
La si esegue con strumentimacroEsegui macro → si cerca la macro che si è appena registrata e si clicca su esegui. Il programma rifarà le stesse azioni che si sono registrate (ad esempio l’atto di cliccare sul bottone che cambia il colore di un testo)
Si può guardare il codice corrispondente alla macro andando su strumentimacroOrganizza macro → …office basic → si sceglie la macro e si clicca modifica.

Infine si può agevolare l’uso di una macro associandola a un tasto. Per fare questo:
Strumenti → personalizza → tastiera → si seleziona il tasto o i tasti da associare nella sezione tasti di scelta rapida → nella sezione “Funzioni” “Categoria”, si va in fondo su “Macro di openoffice”, si cerca il modulo dove si è salvata la macro e quindi si clicca sulla macro (nella sezione funzione).
Ci si assicura di nuovo che sia selezionato il tasto che si vuole assegnare e si clicca su cambia.

Prima di associare un tasto è opportuno verificare se quel tasto farebbe già qualcosa di per sé.
In base infatti se si associa una macro a un tasto (o più tasti) non vengono sovrascritte le funzionalità originarie del tasto.
Si ha quindi una situazione instabile dove il tasto fa: o solo la funzione originaria per cui era stato progettato, o sia la funzione originaria che la macro associata, o solo la macro associata.

In openoffice si può anche associare una macro a un menu a tendina:

strumentipersonalizza → scheda menu → sezione menu di openoffice → nuovo → si da il nome → Si va sulla sezione contenuto menuimporta… → in fondo su Macro di openoffice → si sceglie la macro → si clicca su aggiungi → si clicca su OK.

Anche se si possono usare anche altri 1 o 2 linguaggi nella maggior parte dei casi le macro di openoffice sono scritte usando il linguaggio basic o visual basic.

In questo linguaggio le procedure ad esempio si dichiarano con

sub nomeprocedura (a as String, b as integer)
end sub

Le istruzioni if sono:

if a = 0 then

elseif a >0 then

else

end if

I cicli for sono

for i=0 to 10
next

E via così, tutta la sintassi come anche i comandi per manipolare le stringhe e le tipologie base si trovano facilmente in internet cercando ad esempio visual basic manipolare stringhe.

Per fare una macro di esempio:
strumentimacroorganizza macro → …office Basic → si seleziona il posto dove si vuole salvare la macro e si clicca su modifica.

Attenzione: se si salva una macro dentro il file di openoffice e non dentro la sezione “macro personali”, al momento dell’apertura di quel file openoffice disattiverà le macro.
Per poterle usare serivrà modificare le impostazioni di sicurezza:
Strumentiopzionisezione generale openofficesicurezza → sicurezza delle macrosi imposta su medio o su basso

Si va in fondo al testo e si scrive

sub procedurainutile
msgbox(“Ciao”)
end sub

Dopodichè si potrà invocare questa procedura, che apre una finestra con scritto Ciao, coi metodi che si sono detti prima.

Le macro di openoffice vengono invocate singolarmente nel momento in cui sono richieste dall’utente, quindi non mi pare che si possano avere delle variabili che permangono al di fuori della procedura che si invoca, in luogo di queste però esistono ad esempio i comandi nascosti, che sono oggetti che possono essere creati nel formulario.

Gli oggetti e relative funzioni di openoffice sono ideati con l’architettura object oriented.
Ogni oggetto implementa una sequenza di interfacce.
Una certa interfaccia può essere implementata da più oggetti.
Ogni oggetto implementa una data interfaccia a modo suo.
Quindi una funzione di un’interfaccia che restituisce object (che è l’oggetto base su cui si basano tutti gli oggetti: si può dire che tutti gli oggetti di openoffice sono anche degli object) potrà restituire oggetti differenti a seconda dell’oggetto che l’ha implementata.

Infine le macro di openoffice gestiscono i documenti di openoffice tramite degli oggetti detti service: si tratta di oggetti che si relazionano con le funzionalità grafiche e interne di openoffice.
I service sono in grado di manipolare i documenti di openoffice.

Tutte le interfacce con tutte le rispettive funzioni e tutti i service costituiscono le api di openoffice.

Le api di openoffice si trovano elencate alfabeticamente qui.

Siccome nella documentazione vengono indicate le funzioni astratte, così come definite dalle interfacce.
Quando scrivo una macro però voglio sapere esattamente quali oggetti restituisce una funzione e quante funzioni implementa un certo oggetto.

La maggior parte degli oggetti di openoffice implementano il comando dbg_methods, dbg_properties e Dbg_SupportedInterfaces.
Quindi quando si sta scrivendo del codice e per esempio si usa una funzione che le api definiscono astrattamente come

object elementi_presenti(integer)

di cui non so quale sia l’oggetto restituito, quando la invoco da macro:

etichetta = formulario.elementi_presenti(0)

potrò utilizzare:

etichetta.dbg_methods()

Per avere un elenco delle procedure implementate.
La stessa cosa vale quando in generale ho un oggetto di cui non ho informazioni precise.


Gestionale con MySql e OpenOffice – 5 primo sottoform

Costruita l’interfaccia grafica usando il formulario di base per accedere alla tabella fatture di mysql, andiamo a sviluppare l’idea.

Di norma ogni fattura va anche pagata e di solito il pagamento ha una scadenza, in altri casi il pagamento e diviso in 2 o 3 parti e viene pagato con 2 o 3 scadenze differenti.
Quindi ad ogni fattura è associata nessuna, una o più scadenze di pagamento.

Per organizzare queste scadenze ci servirà una tabella in mysql che contengo almeno l’importo, la data della scadenza e l’id di riferimento della fattura.
Poi serve di poter inserire queste scadenze nella tabella mysql.
Questo verrà fatto dal formulario (inteso come la pagina) delle fatture attraverso un sotto-formulario. Che è un formulario (inteso come oggetto di raccordo tra mysql e base) che appartiene ad un “formulario-padre” ed è a questo collegato da un campo.
Nel nostro caso quando scegliamo una fattura vedremo nel sottoformulario tutte le scadenze di quella fattura, e quando scriviamo le scadenze le stiamo associando alla fattura che in quel momento è selezionata nel formulario padre. Si collega quindi il campo id della tabella fatture, con il campo della tabella scadenze che è dedicato agli id delle fatture.

Si costruisce una tabella in mysql, dentro nuovoschema, di nome scadenze con i seguenti campi:

idscadenze (PK, NN, AI), tipo INT
data_sca (NN), tipo DATE
idfatture_sca, tipo INT
importo_sca, tipo DOUBLE, default: 0
pagare_sca, tipo BINARY, default: false
tipo_pagam_sca, tipo INT, default: 1

Una scadenza senza data non può essere rintracciata quindi si vincola con Not Null il campo data_sca;
poi serve autorizzare il pagamento mediante il campo pagare_sca: al momento dell’inserimento dovrà essere non autorizzato per poi ricevere autorizzazione nell’imminenza del pagamento;
infine siccome il pagamento può svolgersi con riba, bonifico, contanti, assegno, carta di credito o quant’altro, il tipo di pagamento viene indicato nel campo tipo_pagam_sca. Con valore prestabilito pari a 1 (vd dopo: RiBa)

Per associare a un numero una parola che indichi la modalità di pagamento, creiamo un’altra tabella
nome:
tipi_pagamento
Campi:
idtipi_pagamento (PK, NN, AI), tipo INT
tipo_pagam_tip
(NN, UQ), tipo VARCHAR(45)

Il tipo di pagamento ha la clausola UQ: unique, perché non avrebbe senso avere due tipi di pagamento uguali con 2 id differenti.

In questa tabella inseriamo, o facendo doppio click sulla tabella dalla workbench di mysql o dalla sezione tabelle di base:

RiBa
Bon
Ass
CaCr
Cont

Che stanno per “ricevuta bancaria”, “bonifico”, “assegno”, “carta di credito” o “contanti”. Volendo uno può scriverli anche per esteso.

Ora andiamo su base e modifichiamo il formulario che finora gestisce le fatture.
Se avevamo base aperto mentre abbiamo fatto queste modifiche da mysql può essere necessario chiuderlo e riaprirlo perchè si riescano a vedere le tabelle appena create.

Quindi tasto destro → modifica sul formulario Formulario1, poi si clicca sul tasto navigatore formulario e si clicca col tasto destro su Formulario → nuovo → Formulario


Abbiamo creato un sotto-formulario: un oggetto che appartiene agli oggetti di Formulario, infatti nella rappresentazione del navigatore, questo è allineato all’oggetto griglia.

Ora si clicca su tasto destro proprietà del nuovo formulario, e lo si imposta.

Nella scheda Dati nel campo Tipo di contenuto possiamo lasciare Tabella e andiamo ad inserire nel campo Contenuto, dalla tendina, nuovoschema.scadenze.

Poi clicchiamo sui tre puntini (…) affianco al campo Collega da o Collega per, e nella finestra che appare, selezioniamo id_fatture_sca e id_fatture_sca:

Quindi abbiamo queste impostazioni:

Clicchiamo anche sui tre puntini affianco al campo ordina e scegliamo come Nome campo data_sca e sequenza crescente.
In questo modo facciamo che il formulario appaia ordinato per data crescente.

Ora possiamo chiudere o ignorare la finestra “proprietà modulo” e andiamo a creare nella nostra pagina una griglia collegata al sotto-formulario appena impostato.
Per far sì che la griglia appartenga al sottoformulario questo deve essere selezionato nel navigatore formulario mentre si crea la griglia.
Possiamo creare la griglia con la procedura guidata oppure colonna per colonna. L’importante è che non appaia il campo idscadenze ma nemmeno il campo idfatture_sca. Anche il campo pagare_sca non è necessario appaia in questa pagina.

In generale tutti i campi superflui è preferibile evitare di inserirli perchè l’utente sarà obbligato a battere invio su questi prima di poter arrivare alla riga successiva.

Abbiamo questa situazione. Se clicchiamo su modo bozza on/off possiamo cominciare a inserire le scadenze fattura per fattura.


Gestionale con MySql e OpenOffice – 4 primo Formulario


Una volta installato mysql e libre/open office, creato la prima tabella in sql, modificata per renderla più funzionale usando una seconda tabella “elenco”, si passa a creare un Form in libreoffice o openoffice.

Da questo momento in poi mi riferirò specificamente a openoffice, dal momento che in alcuni dettagli mi è parso più stabile rispetto a libreoffice, ad esempio le left join andavano in crash, Anche se in effetti mi è parso che in alcuni casi anche openoffice avesse alcune difficoltà con le left join: in particolare non riusciva a gestire elenchi lunghi generati da left join. Inoltre i report – anche se noi non li utilizziamo – sono più agevoli in openoffice. Tuttavia libreoffice sembra in qualche caso avere delle funzioni in più.

In ogni caso di qui in poi mi riferisco a openoffice, anche se i due programmi sono intercambiabili e utilizzano gli stessi file, con la stessa estensione .odb.

Va poi specificato che openoffice e libreoffice non hanno la stabilità dei programmi proprietari ad esempio della microsoft, quindi ci possono essere piccoli o grandi bug a seconda del computer dove sono installati: quello che viene detto qui, funziona sul mio computer e in linea di massima funziona in tutti gli altri ma può anche capitare che alcune funzionalità si inceppino semplicemente passando da un pc all’altro (per esempio le left join facevano esplodere libreoffice ma non davano particolari problemi in openoffice.
Tuttavia oltre a essere programmi liberi, permettono molta più possibilità di inventiva per il programmatore rispetto ai programmi proprietari.

Quindi si apre openoffice base.

Si seleziona
collega ad un database esistentescegliendo “mysql, poi
connetti con ODBC”
poi si clicca su sfoglia e si seleziona la sorgente dati, da noi si chiamava banalmente
odbcname.
Poi si inserisce l’utente, da noi root,
Infine si selezionea “
no, non registrare il database” e si dà il nome al file. Noi lo chiameremo “primodatabase

nella prima schermata è anche possibile scegliere “collega ad un database esistente” → “odbc”. Tuttavia questa scelta a me ha creato qualche problema di comunicazione tra base e mysql.

Un file ODF è suddiviso in quattro parti: Tabelle, Query, Formulari, Report.

Nel nostro caso quando il file si apre sono già presenti le tabelle create su MySql. Dal momento che le tabelle le creiamo e modifichiamo direttamente da mysql non useremo la sezione tabelle di openoffice base, anche se a volte torna utile aprire una tabella da openoffice, mentre magari si sta impostando una query o un altro comando in MySql.

Anche la sezione query ha un interesse marginale per i nostri scopi (ma anche in generale impostare query ha una utilità ridotta). Le nostre query verranno eseguite direttamente all’interno dei forulari. Una volta che si sanno fare quelle si possono fare quante query si vogliono.

La sezione report è più interessante ma ha il limite di poter usare – per quel che ne so – una sola tabella o query alla volta

Si va nella sezione Formulari, e si clicca su “Crea formulario in vista struttura”.

Appare il formulario vuoto.
Un formulario è composto da alcuni oggetti, alcuni visuali altri non visuali, che interagiscono col database oltre ad altri oggetti fissi che non interagiscono col database.
Soprattutto i formulari sono composti da degli oggetti non visuali “Forms”, ossia proprio “Formulari”.
Nonostante il nome sia lo stesso il formulario inteso come la pagina bianca appena apparsa è un foglio su cui si possono disegnare tabelle o inserire campi di testo, mentre i Forms, ossia sempre i Formulari, che sono contenuti dentro al foglio, sono degli oggetti invisibili che hanno il compito di comunicare con il database.
Ogni form può connettersi al massimo a una tabella o una query proveniente dal database mysql.

La prima cosa da fare in un formulario, in un foglio vuoto è quella di andare ad inserire ed impostare il primo Form.

Si clicca sull’icona “navigatore formulario” in basso a sinistra (da non confondersi col navigatore del documento di openoffice):

Si clicca col tasto destro su Moduli → Nuovo → Formulario

Qualora non fosse visibile il tasto del navigatore, serve attivare il gruppo “Struttura del formulario” andando a selezionarlo in Visualizza → Barra degli strumenti.
Stessa cosa per i controlli del formulario che devono essere visibili. Si gestiscono da Visualizza → Barra degli strumenti → Controlli per formulario

Si ottiene la seguente finestra

Si clicca tasto destro su “Moduli” poi → Nuovo → Formulario e si ottiene:

Una volta giunti qui suggerisco di salvare il formulario, inteso come pagina, prima di procedere. Si clicca File → Salva.

Salvare il formulario permette di evitare di dover inserire nelle proprietà la sorgente dati. In ogni caso se venisse richiesta vi andrebbe inserito il file di base stesso a cui il formulario appartiene (“primodatabase”).

Da questa schermata si fa tasto destro sul formulario → modifica e si entra nel formulario in modalità di modifica.

Ora si clicca di nuovo sul navigatore

Tasto destro su Formulario, sotto la scritta Moduli → proprietà.

Nella tab “Dati” nel campo “Tipo di contenuto” si seleziona “Comando SQL” e si scrive nel campo “Contenuto”:

SELECT * FROM fatture;

Che vuol dire: tieni in memoria tutte le colonne della tabella fatture.

Nella tab “Dati” è in generale opportuno selezionare come “Tipo di contenuto”Comando SQL”. Questo perchè permette poi di manipolare meglio il form attraverso le macro che possono cambiare quel comando SQL che introduciamo ma che non potrebbero agire a riguardo se scegliessimo una Tabella o una Query.

Ora, si clicca la freccia in basso a sinistra o comunque si deve arrivare a cliccare “Altri campi di controllo”.

E si seleziona l’icona griglia:

Con il mouse si indica l’area che si vuole ricoprire con la griglia (è conveniente all’inizio farla piuttosto grande), e si segue il wizard per la composizione delle colonne della griglia. Inizialmente si può anche selezionare il tasto =>> che aggiunge alla griglia tutte le colonne presenti nella tabella del formulario (che nel nostro caso è SELECT * FROM fatture; ossia è la tabella fatture).

Per capire che cosa fa il wizard della griglia si può allargare la griglia a sufficienza così che sia possibile cliccare tasto sulla barra dell’intestazione della griglia destro, fuori dalle colonne già esistenti. Si seleziona “Nuova colonna” e quindi Campo di testo, che è una modalità che va bene un po’ per tutto.

Oppure se si ha a che fare con un numero si può scegliere campo numerico, campo data o campo formattato se si ha a che fare con una data o con un campo che si preferisce formattare come si fa con writer o calc (i corrispettivi open di word e excel). Se si ha un campo binario si può scegliere l’opzione Casella di controllo. Campo maschera serve per vincolare la digitazione di quel campo: se voglio che in quel campo si inseriscano tre lettere e sue numeri, col campo a maschera riesco a imporre all’utente questo formato.
Invece Casella combinata e soprattutto Casella di riepilogo presentano funzioni più avanzate che useremo per unire i campi numerici come ragionesociale_fat ai nominativi corrispondenti negli elenchi,

Ora di può cliccare su Modo bozza on/off:

E “eseguiamo” il nostro formulario.

In griglia non appare niente ancora perchè non abbiamo inserito dati in tabella. Si può provare a inserire dati in tabella (ricordandosi che il campo ragionesociale_fat è per ora ancora un campo numerico dove si possono inserire solo numeri interi).

E’ il caso di ricordare che i dati che scriviamo in griglia verranno trascritti nella tabella collegata del database (nel nostro caso la tabella fatture) solo quando andiamo a capo di una riga. Quando ci sono dati scritti in griglia ma non ancora passati alla tabella del database vengono segnalati con una matita nella barra laterale sinistra della grigli che sostituisce il triangolino verde che è invece presente quando tutte le cose scritte in griglia sono state anche memorizzate nella tabella del database.

Dopo aver provato a inserire righe nella tabella, si possono cancellare le righe che si sono scritte cliccando col tasto destro sulla barra laterale sinistra della griglia, a livello della riga che si vuole eliminare e selezionando Elimina righe.

Ora per prima cosa serve che nel campo ragionesociale_fat appaia il nominativo in lettere della ditta che si intende indicare.

Per fare questo creiamo in mysql una tabella in cui ogni nominativo sia associato a un numero.

Apriamo la workbench, entriamo in nuovoschema, e creiamo una nuova tabella (vedi qui su come creare tabelle) che chiamiamo elenco_nominativi, con due colonne, la colonna idelenco_nominativi,(con PK, NN, AI) e la colonna nominativi_en di tipo VARCHAR(127) con NN.

Ora, quando si creano nuove tabelle o le si modifica o si agisce in qualche modo sulla struttra dello schema tramite workbench, può capitare che base (libreoffice base) non recepisca le modifiche. E’ per questo opportuno andare nella sezione tabelle e cliccare da menu Visualizzaaggiorna tabelle. Oppure serve salvare i formulari aperti, chiuderli, salvare il file di base, e chiudere il file. Una volta che tutte le finestre relative al file primodatabase.odb siano state chiude si può riaprire il file, e lo si ritrova aggiornato.

Ora andiamo sulla sezione “tabelle”, e apriamo la tabella elenco_nominativi (se non appare probabilmente l’avete creata nello schema sbagliato) e inseriamo sotto la colonna nominativi_en un po’ di “nomi”.

Inseriamo:

Mario srl
Verdi spa
Arch. Bianchi
Ing Rossi
Mario Rossi

Si ricorda che nella prima colonna idelenco_nominativi non si deve scrivere niente perchè è una colonna che aggiorna automaticamente il database.

Ora ritorniamo nella sezione Formulari e riapriamo il formulario creato in precedenza con tasto destro → modifica.

Clicchiamo con tasto destro sopra la colonna ragionesociale_fat e scegliamo Sostituisci con → Casella di riepilogo.

Ora si clicca di nuovo con tasto destro sopra ragionesociale_fat e stavolta però si sceglie Colonna… che permette di entrare nelle proprietà della colonna.

Si va nella sezione Dati e sul campo Tipo del contenuto della lista si seleziona Sql.

Si clicca quindi sui puntini a lato del campo Contenuto elenco

Si entra in una finestra apposita dove già dovrebbe comparire la finestra Aggiungi tabella o query. Se non apparisse è sufficiente cliccare su inserisci → Aggiungi tabella o query.

Si fa doppio click sulla tabella elenco nominativi, e si può cliccare Chiudi.

Sulla tabellina che appare nella sezione alta si fa doppio click prima su nominativi_en e poi su idelenco_nominativi. Si può cliccare quindi su salva e si può uscire da questa finestra.

Ora nella sezione Dati della colonna ragionesociale_fat, nel campo Contenuto elenco dovrebbe apparire questo comando:

SELECT `nominativi_en`, `idelenco_nominativi` FROM `nuovoschema`.`elenco_nominativi` AS `elenco_nominativi`

Che andiamo a modificare aggiungendo la clausola finale ORDER BY, clausola sql che permette di ordinare una query a seconda del campo è composta da ODER BY nomecampo ASC (oppure DESC a seconda se si vuole ordinare in maniera crescente o descrescente):

SELECT `nominativi_en`, `idelenco_nominativi` FROM `nuovoschema`.`elenco_nominativi` AS `elenco_nominativi` ORDER BY `nominativi_en` ASC

Possiamo ora eseguire il nostro formulario cliccando sul tasto Modo bozza on/off.

Se prima avevamo lasciato una riga con un numero intero da 1 a 4 nel campo ragionesociale_fat ora ci appare un nome. Il nome associato a quel numero nella tabella elenco_nominativi

Si noti che se ci si posiziona nel campo ragionesociale_fat, anche se non è possibile vedre il cursore, si può scrivere con la tastiera “mario ” apparirà la scritta “Mario Rossi” ma appena si procede e si arriva a scrivere “mario s” apparirà il nominativo di “Mario srl”.
Mi accorgo ora che questa funzione presente in openoffice, non è ancora stata implementate in libreoffice.

Per ora abbiamo sistemato la parte che riguarda il campo ragionesociale_fat.

Per quanto riguarda il campo idfatture, si tratta di un campo eccezionale, come lo sono tutti i campi id.
Si incrementa da solo e soprattutto ogni volta che una futura tabella vorrà fare riferimento a una certa fattura indicherà proprio il numero del campo id.
E’ quindi importante che questo numero non venga modificato perché scombinerebbe le eventuali associazioni.
Inoltre, nella tabella del nostro formulario, la colonna id costringe l’utente ogni volta a battere invio per uscire da un campo che non utilizza e che non deve utilizzare.
Eliminiamo quindi la colonna idfatture.

Ri-clicchiamo sul tasto Modo bozza on/off e andiamo a cliccare col tasto destro sulla colonna idfatture e selezioniamo Elimina Colonna.

Dopodichè clicchiamo e manteniamo premuto sul campo data_dat e trasciniamo col mouse senza mollare a sinistra arrivando all’inizio della colonna ragionesociale_fat, qui molliamo la presa.
La data dovrebbe così apparire nella griglia come il primo campo, e la ragione sociale come il secondo.

Clicchiamo su salva per salvare il formulario.


Gestionale con MySql e OpenOffice – 3 prima tabella con join

Installati MySql e openoffice (o libreoffice), andiamo a modificare la tabella fatture, rendendo così la sua forma definitiva.

Accedendo alla workbench di MySql, cliccando sulla connessione e
poi sul nostro schema “nuovoschema”, possiamo cliccare sulla
tabella fatture col tasto destro del mouse.

Se per caso si erano inseriti dati nella tabelle è meglio cancellarli,
cliccando sull’icona con la riga rossa (o con il meno) e poi su apply.

Dal menu che appare clicchiamo su Alter table”

Clicchiamo sulla colonna ragionesociale_fate cambiamo il tipo di dati: da Varchar(45) impostiamo INT.
In questa colonna infatti verranno inseriti solo dei numeri interi.
Ogni numero intero indicherà una e una sola ragione sociale.

Servirà quindi creare un elenco di ragioni sociali e associare ogni riga ad un numero.

Quindi il codice SQL per la tabella fattura (per crearla da zero) è:
CREATE TABLE
`nuovoschema`.`fatture` (
`idfatture` INT NOT NULL AUTO_INCREMENT,
`ragionesociale_fat` INT NOT NULL ,
`data_fat` DATE NULL ,

`imponibile_fat` DOUBLE NULL DEFAULT 0 ,
`IVA_fat` DOUBLE
NULL DEFAULT 0 ,
`totale_fat` DOUBLE NULL DEFAULT 0 ,

`fatturecol` VARCHAR(45) NULL ,
PRIMARY KEY (`idfatture`) )

ENGINE = MyISAM
DEFAULT CHARACTER SET = latin1;

Su nuovoschemacreiamo una nuova tabella con quattro colonne:

Nome: elenco_nominativi
Collation:
latin1 default collation
Engine:
MyISAM

Tutte le tabelle verrano create con collation = latin1 default collatione engine = MyIASM per cui questo non verrà più ripetuto. Stessa cosa vale per le impostazioni della chiave primaria id.

La prima colonna mantiene il nome automatico (idelenco_nominativi) e si clicca su PK, NN e AI
2^: nome:
nominativi_en, con tipo di dato VARCHARma questa volta si fa doppio clic sulla scritta varchar(45) e si modifica il numero dentro le parentesi impostandolo pari a 120, ottendo così VARCHAR(120):
ossia ogni ragione sociale può avere al massimo 120 caratteri, che – per avere un’idea – sono ¾ di un sms.

Poi si clicca su NN e UQ(unique), dal momento che una riga senza ragione sociale non ha senso e che è importante che non ci siano due  righe con la stessa ragione sociale.
3^: tipo_en, SMALLINT, NN
4^: attivo_en, SMALLIN, NN, default: 1

La prima colonna(la chiave primaria) dà il numero associato alla  ragione sociale
La
seconda colonna dà la ragione sociale
La
terza colonna serve a specificare se si tratta di un fornitore, di un cliente o altre tipologie (subappaltatori, professionisti etc a seconda della precisione che serve)
Noi qui si usa solo due tipologie: fornitore: con valore 1, e cliente con valore 2.
La
quarta colonna serve ad indicare se il nominativo è ancora attivo o se è da considerarsi archiviato. Anche qui noi usiamo solo due valori: 1 attivo, 2 archiviato.

Impostate le colonne si può cliccare su apply
(appaiono i comandi sql corrispondenti, di nuovo applye infine close).

Se si clicca su edit table data si può inserire nella colonna “nominativi_en” i primi nominativi che servono da esempio.

Li imposteremo tutti di tipo 1 (fornitori) e con valore “attivo” 1,
ossia attivo. Non si imposta la prima colonna
idelenco_rag_soc
in quanto si riempirà automaticamente.

Primofornitore, 1, 1
Secondofornitore, 1, 1
Terzofornitore, 1, 1
Quartofornitore, 1, 1
Quintofornitore, 1, 1
Sestofornitore, 1, 1
Settimofornitore, 1, 1
Ottavofornitore, 1, 1

Si clicca su Apply – Apply – Close

Si può osservare la prima colonna, con gli id, che conterrà in una sequenza di numeri da 1 a 8. Quei numeri sono i numeri associati ad
una data ragione sociale. Ossia se ad esempio nella tabella
fatture alla colonna ragionesociale_fat si vuole “scrivere” ‘Sestofornitore’ basterà scrivere il numero 6 e sarà poi il server sql ad associare il numero 6 al nome ‘sestofornitore’

Ho detto “scrivere” ma in realtà l’utente non vede mai i numeri, scrive e legge sempre solo i nomi associati, tuttavia impostare le tabelle con campi interi al posto di campi stringa permette di risparmiare spazio e soprattutto di essere più rigorosi: nessuno potrà mai inserire ad esempio Ingegner D. Rovelli nell’elenco delle fatture e Ing. Diego nell’elenco del telefono. La codifica permette di mantenere una leggibilità generale. Inoltre se un giorno L’Ing. D. Rovelli cambia la ragione sociale in ‘Rovelli associati sas’ si potrà scegliere (quando sia sensato  farlo) di andare a modificare il nome nella tabella elenco_rag_soc, modificare la ragione sociale e tutti i documenti con quel riferimento saranno aggiornati con la nuova ragione sociale.

Ora modifichiamo la tabella fatture inserendo queste tre righe (si esclude sempre il campo id che si aggiorna da solo e si inseriscono numero  fattura – ragionesociale – data (sempre e solo con forma AAAA-MM-GG) – imponibile – iva – totale:

1, ‘4’, ‘2009-01-02’, 100, 10, 110
2, ‘3’, ‘2009-01-28’, 1, 0, 1
3, ‘4’, ‘2011-09-25’, 10000, 2000, 12000

Abbiamo tre fatture, che per essere lette. Tuttavia nel campo ragionesociale_fat
ci sono solo dei numeri, per vederli decodificati (senza necessità di tenere a mente le associazioni) serve fare una JOIN.
Una JOIN è un comando sql che permette di associare a un numero, una riga di una tabella. Nel caso vogliamo associare a ogni numero presente nel campo
ragionesociale_fat la riga corrispondente in  elenco_rag_soc.

Per fare questo si cancella quello che c’è scritto nella parte bianca della workbench e si scrive:

USE nuovoschema;
SELECT fatture.*, elenco_nominativi.nominativi_en FROM fatture  JOIN elenco_nominativi ON ragionesociale_fat =  idelenco_nominativi;

Di cui la parte

FROM fatture JOIN elenco_nominativi ON ragionesociale_fat =
idelenco_nominativi

vuol dire: prendi la tabella fatture, per ogni riga della tabella fatture guarda nel ragionesociale_fat, prendi il numero che c’è in quel  campo e associami la riga di elenco_nominativi che ha l’id uguale a  quel numero.

Invece la parte SELECT fatture.*, elenco_nominativi.nominativi_en

vuol dire: del risultato che hai ottenuto prima mostrami tutte le colonne della tabella fatture e solo la colonna nominativi_en della tabella   elenco_nominativi.

Per fare una JOIN è importante che uno dei due campi che si collegano (in questo caso elenco_nominativi.idelenco_nominativi e fatture.ragionesociale_fat)
sia un campo univoco, ossia che appaia una volta solo nella tabella di appartenenza. Tutti i campi primary key sono campi univoci.
Supponiamo di usare un campo non univoco.
Mettiamo che un dato valore appaia due volte nella stessa tabella, come se ci fosse, in elenco_rag_soc:

1 Dott. Lo Bianco
2 Arch. Rossi
3 On. Vittori
2 Ing Verdi

Ogni volta che nella tabella fatture, nel campo ragionesociale_fat
appare il numero 2, il comando JOIN produrrà 2 righe distinte: la prima associando Arch Rossi e la seconda associando Ing Verdi.
Si può  notare come una join non sia modificabile da sql. Questo perchè la  join non sa se si creerà una tabella con un campo univoco. Nel caso in cui ad esempio non ci fosse un valore univoco e si modifica una riga della join, mysql non sarebbe in  grado di scegliere quale tabella andare a modificare. Tuttavia impostando come indici univoci le chiavi primarie di ciascuna tabella coinvolta sembra possibile modificare la join.

Una join collega un campo1 di una tabella1 con un campo2 di una tabella2 se campo1 o campo2 sono vuoti, la join non ti mostra quella riga:
ad esempio se una riga di fatture è fatta così
6,NULL, ‘2009-01-02’, 100, 10, 110
Essendo nullo il campo da collegare questa riga non apparirà nel risultato della JOIN.
Per questo è importante che i campi che si vogliono collegare a righe di altre tabelle non siano nulli, soprattutto a questo serve la clausola NN (not null) che si imposta quando si crea una tabella.

Per ovviare a questo esistono i comandi LEFT JOIN o RIGHT JOIN. Il primo vuol  dire mostra tutte le righe della colonna sinistra e, se si possono collegare,  collegale alla tabella destra, la seconda è uguale ma a tabelle invertite.

Ora che abbiamo fatto la prima tabella con corrispettivo elenco, possiamo passare a impostare un Form da openoffice o libreoffice. Un Form è una pagina che permette di inserire e modificare in maniera agevole e “umana” i dati presenti nel server sql.


Gestionale con MySql e Openoffice – 2 prima tabella mysql

Una volta che abbiamo installato libreoffice e mysql (con workbench e  connettore ODBC) e che abbiamo creato in mysql il nostro schema  (“nuovoschema”), procediamo a creare la prima tabella.

Questa prima tabella non sarà quella definitiva.

Differisce dalla definitiva per la colonna ragione sociale che qui contiene una stringa (cioè un testo) mentre nella definitiva conterrà un numero.
Questo permette anche a chi non è esperto di database relazionali di capire il mecanismo.

Accediamo quindi alla workbench di mysql e di lì clicchiamo sopra la connessione che abbiamo creato in precedenza.

Vogliamo creare una tabella fatture che contenga i seguenti campi:

1) numero interno, 2) ragione sociale, 3) data fattura, 4)
imponibile, 5) iva, 6) totale fattura, 7) note.

Una tabella di un database non è come una tabella in excel. In particolare si  distingue per due cose: le colonne possono contenere solo la tipologia di dato  che si imposta all’inizio: se si sceglie che una colonna contenga dei numeri interi  non potrà avere nessuna riga con numeri con la virgola o con parole. Se si prova  a farlo il server dà errore.
La seconda cosa è che ogni riga è contraddistinta da un indice univoco: un  numero che nessun’altra riga ha, quindi se sai quel numero puoi chiedere al  database: dammi la riga corrispondente a questo numero, e il database può  risponderti coi dati che ti servono.
Di solito si imposta questo indice in modo che si incrementi da solo, senza  bisogno che l’utente digiti niente.
Questo indice di solito non appare mai nelle tabelle di libre/open office, le tabelle  su cui effettivamente si lavora perchè ha solo una funzione interna

Nella workbench si selezionata il nostro schema nuovoschema.
Per creare la tabella si clicca sull’iconcina della tabella poi si inserisce

nome: “fatture”,
collation: latin1 – default collation
Engine: MyIsam

MyIsam è l’unico database che permette di impostare in ciacuna tabella una  cartella di salvataggio diversa da quella generale di mysql.
Invece innodb è l’unico che permette di utilizzare le foreign key.

Poi si procede a creare le colonne:
Di norma il nome della prima colonna lo si lascia come è impostato,  quindi “idfatture”, con tipo di dati: “int”. si spunta su “PK”(primary key) su “NN” (not null) e su “AI”(auto-increment).
In questo modo si è impostato la prima colonna come chiave primaria che si auto imposta incrementandosi ad ogni nuova riga

Poi si clicca sulla seconda riga e mettiamo il nome: num_fat, si imposta come datatype: “INT” e si clicca su NN [ossia: tutte le fatture devono avere un numero interno]
3^ riga: nome: “ragionesociale_fat” Datatype: “varchar(45)” e si clicca su
NN
4^ riga: nome: data_fat, tipo: “date”
5: nome: imponibile_fat, tipo: “double”
6: IVA_fat, double
7: totale_fat, double

Per finire impostiamo i valori per difetto dei campi

`imponibile_fat`
`IVA_fat`
`totale_fat`

Si va sulla colonna “default” e si inserisce 0 (zero) per ciascuno di questi  campi. Questo farà sì che se l’utente non digita niente, mysql  riempie quei campi col valore zero.
Se non viene impostato un valore di default, non si impone la clausola  NN (not-null) e quando l’utente non digita niente, verrà inserito il valore NULL, che non è un valore. E’ un non-valore, può essere un problema in  alcuni casi, ad esempio quando si devono sommare i valori di una  colonna, non è detto che NULL venga inteso come uno zero.

Dato che se due tabelle hanno campi con lo stesso nome possono crearsi  problemi (ad es tabella fatture ha il campo “data” e la tabella ddt ha il suo campo  “data”), è sempre meglio quando si danno i nomi, di qualificare con un suffisso o  in altro modo il campo in modo da rendere improbabile l’esistenza di due
campi con lo stesso nome.
E’ sempre preferibile, se si devono usare numeri con la virgola usare il tipo  double: il tipo float è molto casareccio e può creare problemi anche se risparmia qualche byte di spazio.

Una volta impostato tutto, clicchiamo su apply.
Appare una schermata con la traduzione in comandi sql di tutto quello che abbiamo impostato per via grafica.
Se clicchiamo di nuovo su Apply, il server esegue i comandi e crea la  nostra tabella, con i campi che abbiamo chiesto.
Deve apparire la scritta che dice che i comandi sono stati eseguiti  correttamente e si può cliccare close.

Al posto di procedere per via grafica si può inserire nella zona testo della  workbench i comandi sql corrispondenti e cliccare sull’icona con il lampo. Il risultato è lo stesso.
Addirittura si potrebbe teoricamente fare a meno della workbench e digitare i comandi dalla riga di comando sql. Tuttavia la workbench consente una maggiore intuitività e  rapidità anche nel modificare le tabelle.

Se tornando alla schermata del nostro schema non vediamo la tabella appena creata, serve cliccare il tasto “aggiorna schema” (per chi ce l’ha).

Adesso se si fa doppio clic sulla tabella creata (o se no tasto destro-> edit table data) appare una schermata con i dati della tabella (ancora nessuno: li si possono inserire facendo doppio clic sui campi con scritto NULL, scrivendoci quello che si vuole e infine cliccando su “apply” o  l’iconcina con la spunta verde)
La data deve essere inserita con il formato AAAA-MM-GG, tipo 2009-08-31.

Lo stesso succede se sulla parte bianca della schermata cancello
tutte le scritte e scrivo:

USE nuovoschema;
SELECT * FROM fatture;

e clicco sull’icona con il lampo (quello senza barrette o lenti)

SELECT * – indica che nel risultato dovranno apparire tutte le colonne
FROM fatture – indica che i dati vanno presi dalla tabella fatture

SELECT * FROM table; E’ il più elementare comando SQL

Ogni comando sql che permette di vedere i dati di una o più tabelle si chiama query. SELECT * FROM table; è la query più semplice.


Fare un gestionale con MySql e Openoffice – 1 introduzione e installazione

Se si vuole creare un programma – anche abbastanza complesso – come un gestionale, lo si può architettare da soli anche partendo da zero, purché si abbia un po’ di pazienza (in quantità proporzionale alla complessità del programma).

Servono principalmente due cose:

MySql
Openoffice o libreoffice

Si utilizzerà MySql come database: il motore;
e openoffice o libreoffice come front-end, ossia: l’interfaccia, lo  strumento che permette di visualizzare le operazioni che chiediamo a MySql.
Se si vuole fare qualcosa di leggermente più complesso è molto consigliabile usare libre/open office come front-end perchè mysql è molto più veloce – per  quello che è la mia esperienza – del motore integrato in l/o office. Inoltre se si usa  mysql si può attingere alla mostruosa documentazione, forum, chat, articoli,  blog che parlano dei comandi SQL, mentre se si usa il motore integrato,  un qualsiasi dubbio sulla modalità d’uso può anche diventare irrisolvibile.
Senza  contare che il “cuore” del nostro programma:le tabelle del server mysql  può essere serenamente esportato a qualsiasi altro front-end che sia in grado di  relazionarsi con gli odbc.

Serve quindi installare Openoffice o libreoffice.

Se ci si trova in Windows basta scaricare il programma dal sito Openoffice o libreoffice, ed eseguirlo seguendo le istruzioni

Se ci si trova in ubuntu (linux) mi pare che ormai funzionino anche i comandi da terminale:

sudo apt-get instal openoffice.org

oppure

sudo apt-get instal libreoffice

altrimenti la precedente procedura era:

wget (nome file OO per linux-deb italiano – si trova nel sito openoffice.org, idem per libreoffice)
tar xovfz file_scaricato

cd cartella_dove_si_è_decompresso_il_file
sudo dpkg -iR DEBS/
cd DEBS/
sudo dpkg -iR desktop-integration/

Per installare MySql invece

Innanzitutto serve installare: il server che è la macchina vera e propria, la workbench, che è uno strumento di mysql che ti permette di usare il server (altrimenti devi usarlo da riga di comando, e non  è un bell’approccio: rischia che ti passa la voglia) e il connettore ODBC che è lo strumento che permetterà a openoffice/libreoffice di  dialogare con mysql.

In windows:

Si va nel sito MySql, si clicca su “Download GA” e ci si scarica e  installa:
MySQL community server
MySQL workbench (GUI tool)
MySQL connector/ODBC

In ubuntu (o debian-like linux):

Da terminale digito:

sudo apt-get install mysql-server

La procedura è qui.

Per la workbench la procedura è a questo sito.
La procedura varia ad ogni versione di ubuntu. Per ubuntu 10.04 LTS
(long termi support) serve:
Andare nel sito di MySql,
scaricarsi la versione per ubuntu 10.04 (file deb) quindi fare:

sudo apt-get install libctemplate0 libzip1 python-pysqlite2 mysql-client python-crypto python-paramiko
sudo dpkg -i mysql-workbench-gpl-5.2.27-1ubu1004-i386.deb

al posto dell’ultimo comando si può anche avviare (dopo aver digitato la prima riga) il programma di autoinstallazione che si apre quando il file  viene scaricato.

Infine installo l’odbc:

La guida è a questa pagina
sudo apt-get install libmyodbc

Ora conviene avviare la workbench e fare le procedure iniziali: “open
connection to start quering”.
Qui si usa (per compatibilità con l’esempio che stiamo facendo)  l’indirizzo 127.0.0.1, poi si imposta l’utente come root e la password di  root, port:3306 (dovrebbe apparire da solo) poi si clicca ok.



Si entra nella connessione e si può creare uno schema con il bottone composto da tre dischetti.

Uno schema è un contenitore di tabelle. Un file di libreoffice o openoffice si può connettere solo ad uno schema. Quindi lo schema che andiamo a  creare è la parte di database che ci interessa.
Una volta cliccato sui tre dischetti basta dare il nome allo schema, eventualmente selezionare come “Default collection” la “latin1 default collection”.
Questo schema lo chiameremo “nuovoschema”

Ora serve di Impostare l’odbc

L’odbc è un protocollo che permette ai programmi come openoffice/libreoffice, ma anche moltissimi altri programmi che vogliono usare un database di avere un linguaggio comune per interfacciarsi al database.

Qui supponiamo di utilizzare un database che va solo da un  computer: utilizzando infatti l’indirizzo 127.0.0.1 il database risulta  inaccessibile, ma per fare che sia un database raggiunto anche da  altri computer in rete è sufficiente impostare l’odbc con l’indirizzo corretto e fornire i necessari privilegi all’utente mySql.
Inoltre si usa come utente root.
Ma per molti motivi qualcuno può necessitare che l’utente che si  collega non sia root.

In windows:

[procedura da verificare] Andare su Amministratore ODBC (fare: trova “odbs”) di windows e
aggiungere un DSN (database source name o in DSN di sistema o in DSN di utente)
si clicca “aggiungi” e si sceglie il driver mySql ODBC.
mettere 127.0.0.1 come indirizzo,
utente: root
password: (la password di root)
come database va messo il database che si vuole scegliere, quello che nella workbench si chiama “schema”.
Serve quindi scegliere lo schema che si è creato in precedenza: nuovoschema.

In ubuntu (o debian-like linux):

sudo gedit /etc/odbc.ini

e aggiungere questo:

[odbcname]
Driver = /usr/lib/i386-linux-gnu/odbc/libmyodbc.so
Description = MyODBC 3.51 Driver DSN
SERVER = 127.0.0.1
PORT = 3306
USER = root
Password = (password di root)
Database = nuovoschema
OPTION = 3
SOCKET =

(nelle versioni precedenti di ubuntu, ad es la 10.04 il driver era in
/usr/lib/odbc/libmyodbc.so)
Io poi ho dovuto, fuori dalle guide integrare con i seguenti comandi (ma forse il bug è già stato risolto)

sudo apt-get install libiodbc2-dev
sudo apt-get install iodbc