Per prima cosa importiamo GnrApp
from gnr.app.gnrapp import GnrApp
app = GnrApp('sandboxpg')
mydb = app.db
tbl_prodotto = mydb.table('fatt.prodotto')
L'oggetto table implementa un metodo insert che riceve in modo polimorfico o un dizionario o una bag contenente i dati del nuovo record.
nuovo_prodotto = dict(codice='TTFFG', descrizione='Prodotto Simpatico')
tbl_prodotto.insert(nuovo_prodotto)
mydb.commit()
#l'insert sul database non avviene realmente fin quando non si esegue il comando commit sull'oggetto db
print (nuovo_prodotto)
Notiamo che noi non abbiamo passato un valore per la primary key eppure il adesso al dizionario (oggetto mutabile) che rappresentava il nostro record sono state aggiunte delle colonne alle quali è stato dato un valore.
Queste sono colonne di sistema che abbiamo definito nel model con la chiamata a sysFields. Se questi campi vengono aggiunti al model della table, vengono valorizzati automaticamente dall'ORM, qualora non fossero già valorizzati al momento della insert.
Merita un discorso particolare l'assegnazione automatica della primary key. L'assegnazione automatica avviene se al momento della insert nel record ricevuto non è presente un valore per la colonna primary key. In questo caso viene invocato il metodo di table pkeyValue.
Nel caso che abbiamo appena visto usiamo come primary key della table la colonna di sistema id e possiamo usare quindi la pkeyValue standard che rende un uuid di 22 caratteri.
tbl = pkg.table('prodotto', pkey='id',
name_long='Prodotto')
self.sysFields(tbl)new_pkey = tbl_prodotto.pkeyValue()
print (new_pkey)
from gnr.core.gnrlang import getUuid
new_uuid = getUuid()
print (new_uuid)
Ovviamente se il metodo insert ricevesse la colonna pkey già valorizzata il sistema utilizzerebbe il valore ricevuto e non farebbe quindi l'auto assegnazione.
new_pkey = '1234567891234567891234'
altro_prodotto = dict(id = new_pkey, codice='GNAM', descrizione='Prodotto buono')
tbl_prodotto.insert(altro_prodotto)
print (altro_prodotto)
Nessuno però mi obbliga ad usare la colonna id di sistema e posso invece voler usare come primary key una colonna normale con valori che vengono ad esempio compilati in form o ricevuti da un processo di importazione da sistemi esistenti.
Se vediamo ad esempio in sandbox la tabella cliente_tipo
tbl = pkg.table('cliente_tipo', pkey='codice', caption_field='descrizione',lookup=True)
self.sysFields(tbl,id=False)
tbl.column('codice' ,size=':5',name_long='!![it]Codice', unique=True)
Notiamo che usa come pkey la colonna codice.
tbl_cli_tipo = mydb.table('fatt.cliente_tipo')
###ATTENZIONE CAMBIARE CODICE ALTRIMENTI DUPLICATE PKEY ERROR####
nuovo_tipo = dict(codice='PR7G5', descrizione='THSDDSD')
tbl_cli_tipo.insert(nuovo_tipo)
mydb.commit()
print(nuovo_tipo)
Se volessi far fare l'autoassegnazione ad una colonna specifica secondo un criterio specifico posso ridefinire sulla mia tabella il metodo pkeyValue.
Ridefiniamo la table cliente_tipo come segue:
from random import randint
class Table(object):
def config_db(self, pkg):
tbl = pkg.table('cliente_tipo', pkey='codice', name_long='!![it]Cliente tipo',
name_plural='!![it]Cliente tipi',caption_field='descrizione',lookup=True)
self.sysFields(tbl,id=False)
tbl.column('codice' ,size=':5',name_long='!![it]Codice')
tbl.column('descrizione',name_long='!![it]Descrizione')
def pkeyValue(self, record):
iniziale = record['descrizione'][0]
numero_casuale = str(randint(100,1000))
return '{iniziale}{numero_casuale}'.format(iniziale=iniziale, numero_casuale=numero_casuale)nuovo_tipo_auto_code = dict(descrizione='Autoassegno')
tbl_cli_tipo.insert(nuovo_tipo_auto_code)
print (nuovo_tipo_auto_code)
Benché esista questa possibilità, suggeriamo di utilizzare se possibile l'id di sistema di Genropy così da potersi dimenticare del tutto di questa problematica e di averla gestita totalemtne dal framework.
In caso di pkey relative a colonne numeriche il comportamento di default della pkeyValue è di restituire il valore numerico incrementato rispetto all'ultimo presente.
class Table(object):
def config_db(self,pkg):
tbl = pkg.table('foo', pkey='serial_number', name_long='!![it]Foo')
self.sysFields(tbl,id=False)
tbl.column('serial_number',dtype='L',name_long='!![it]Serial Nr.', unique=True)foo_tbl = mydb.table('fatt.foo')
foo_tbl.pkeyValue()
new_foo = dict(description='Cicciobello')
foo_tbl.insert(new_foo)
mydb.commit()
print (new_foo)
Parlando di scrittura su database vogliamo anche accennare a dei metodi di hook che è possibile definire sulle table.
Questi metodi vengono eseguiti rispettivamente prima e dopo l'inserimento o modifica del record e ricevono come parametro il record. I metodi in ing vengono eseguiti prima della scrittura effettiva e tipicamente si usano per effuare controlli o calcolare il valore di colonne in modo automatico secondo la business logic di applicazione.
I metodi in ed vengono invece eseguiti dopo la scrittura e possono innescare operazioni su altre tabelle, ma non su quella dove è definito.
def trigger_onInserting(self, record):
record['description'] = record.get('description') or 'UNKNOWN'
record['iniziale'] = record['description'].upper()[0]foo_tbl = mydb.table('fatt.foo')
new_rec = dict(description='Kinom')
foo_tbl.insert(new_rec)
print (new_rec)
unknown_rec = dict()
foo_tbl.insert(unknown_rec)
print (unknown_rec)
mydict = dict()
mydict['descr'] = mydict.get('descr') or 'ciao'
print (mydict['descr'])
Per effettuare una scrittura di update di un singolo record, la table definisce il metodo update.
Questo metodo riceve due parametri di tipo dizionario (o Bag) che rappresentano rispettivamente il record con i dati nuovi da aggiornare e il record allo stato precedente, ovvero così come l'abbiamo letto.
#leggo il record che voglio aggiornare con parametro for_update = True
rec_trapano = tbl_prodotto.record(where='$codice=:cod_prod',
cod_prod='T1',
for_update=True).output('dict')
print (rec_trapano)
Se faccio la lettura con for_update = True mi sto riservando il record per modificarlo. Questo parametro riguarda tutti i metodi di lettura, non solo record, ma anche query.
Posso infatti fare una intera query in modalità for_update ed aggiornare tutti i record della selezione e fare alla fine un unico commit.
#faccio una copia del record originale prima di modificarlo
old_record = dict(rec_trapano)
#lo incremento del 10%
rec_trapano['prezzo_unitario'] = rec_trapano['prezzo_unitario'] * 3
tbl_prodotto.update(rec_trapano, old_record)
mydb.commit()
nuovo_prezzo = tbl_prodotto.readColumns(pkey = rec_trapano['id'], columns='$prezzo_unitario')
print (nuovo_prezzo)
Perché è buona norma passare old_record? Perché nei trigger onUpdating e onUpdated qualcuno potrebbe voler testare quali campi sono stati cambiati e come sono stati cambiati, per innescare eventi di business logic.
def trigger_onUpdating(self, record, old_record):
if record['prezzo_unitario'] < old_record['prezzo_unitario']:
self.notificaRibassoProdotto(record)
Se voglio verificare il cambiamento di un set di campi esiste anche il metodo di table fieldsChanged
def trigger_onUpdating(self, record, old_record):
if self.fieldsChanged('prezzo_unitario,prodotto_tipo', record, old_record):
self.faiQualcosa(record)Ne esistono ben 2!
Nel caso in cui io voglia aggiornare una selezione di record posso usare il metodo di table batchUpdate, nel caso in cui io voglia leggere e modificare un singolo record posso usare il metodo recordToUpdate. Adesso li vediamo nel dettaglio.
Questo metodo è per metà query e per metà update, infatti ha dei parametri comuni con il metodo query che servono a definire quali record voglio selezionare e dei parametri invece che servono a definire come i record devono essere modificati. Proprio come lo statement UPDATE di sql, questo metodo opera il cambiamento sui record che soddisfano le condizioni del parametro where.
Senza questo metodo e solo con update dovrei fare...
prodotti = tbl_prodotto.query(where='$descrizione ILIKE :desc' , desc='Tavolo%', for_update = True).fetch()
for p in prodotti:
old_rec = dict(p)
p['prezzo_unitario'] = 49
tbl_prodotto.update(p, old_rec)
#invece con batchUpdate posso fare
# con updater "statico" dizionario
tbl_prodotto.batchUpdate( dict(prezzo_unitario = 49),
where='$descrizione ILIKE :desc',
desc='Tavolo%')
def myupdater(rec):
if rec['prezzo_unitario'] < 100:
rec['prezzo_unitario'] = rec['prezzo_unitario'] + 11
else:
rec['prezzo_unitario'] = rec['prezzo_unitario'] - 5
rec['descrizione'] = 'PROMO {desc}'.format(desc = rec['descrizione'])
updated_pkeys = tbl_prodotto.batchUpdate(myupdater,
where='$descrizione ILIKE :desc',
desc='Tavolo%')
mydb.commit()
Questa modalità si avvale dell'apertura di un contesto: all'interno del contesto avviene la lettura del record for_update, fuori dal contesto il lock viene rilasciato ed avviene la commit
with tbl_prodotto.recordToUpdate(codice='T1') as rec_prodotto:
rec_prodotto['prezzo_unitario'] = rec_prodotto['prezzo_unitario'] + 1
mydb.commit()
prodotti = tbl_prodotto.query(where='$prezzo_unitario > :soglia' , soglia=100).fetch()
for prodotto in prodotti:
with tbl_prodotto.recordToUpdate(where='$id=:prod_id AND $prezzo_unitario>:soglia',
prod_id=prodotto['id'],
soglia=100,
ignoreMissing = True) as rec_prodotto:
if rec_prodotto:
rec_prodotto['prezzo_unitario'] = rec_prodotto['prezzo_unitario'] + 1
print(rec_prodotto['prezzo_unitario'])
mydb.commit()