.. _orm_genropy/approfondimenti/srcobj: Structure e Object ================== Partendo dalla definizione della struttura e delle caratteristiche che il :ref:`model dell'applicativo Genropy` deve avere, e che fa lo sviluppatore definendo classi e metodi all'interno di file Python, al momento dell'avvio dell'applicativo vengono istanziati dall'ORM di Genropy tutta una serie di oggetti che verranno utilizzati per operare con il database. Viene quindi innanzitutto istanziato l' :ref:`oggetto db` , che contiene a sua volta l'oggetto :ref:`model di Genropy` , e che a sua volta contiene due istruzioni: ``src`` e ``obj``. ``src`` è un oggetto di tipo *descrittivo* che si occupa di compilare una `Bag `_ con la struttura degli oggetti, mentre ``obj`` è un oggetto di tipo *operativo*, ovvero l'oggetto su cui concretamente andremo ad effettuare le :ref:`operazioni sul database` . È quindi possibile, ad esempio, osservare uno stesso :ref:`package` da due diverse prospettive:: model.src.package('adm') e:: model.obj['adm'] Lo stesso vale per la `SqlTable`_, per la quale rimandiamo alla successiva sezione considerata la sua centralità nell'ORM di Genropy. La parte "descrittiva" interviene nella primissima fase della costruzione, mentre la seconda, quella operativa, continuerà ad essere utilizzata dall'applicativo in tutte le operazioni. .. image:: /_static/images/structure-e-object.jpg :width: 777px :align: center Questo parallelismo tra una suddivisione tra un livello puramente *descrittivo* e uno *operativo* è quella che permette a Genropy di sfruttare a pieno le potenzialità in termini di **customizzazione di un applicativo**. Rispetto ad altri framework, in cui a essere definiti sono direttamente gli oggetti Python (*package*, *table*, *columns*, ecc) che verranno poi utilizzati, piuttosto che la loro descrizione, questa dicotomia consente a un :ref:`package` di Genropy, tramite un mix-in degli oggetti, di ridefinire in tutto o in parte un altro package, così elevando enormemente le possibilità di personalizzazione di un applicativo. SqlTable ******** L’oggetto **SqlTable** è l’elemento centrale dell’ORM di Genropy, ma data la sua natura particolare è bene approfondire come esso venga definito ed istanziato. Tramite la definizione della classe di mixin ``Table`` noi :ref:`definiamo la table` , descrivendone le sue proprietà SQL (nome, primary key), le :ref:`colonne` di cui si compone, le :ref:`relazioni` , i vincoli e gli indici. L’istanza di applicazione in memoria carica l’intera struttura del *database* sotto forma di un oggetto gerarchico che contiene a sua volta gli :ref:`oggetti descrittivi DbTableObj` . L’oggetto ``SqlTable``, che viene istanziato dal metodo *table*, è quello che implementa tutte le funzioni di :ref:`lettura` e di :ref:`scrittura` da e sul database:: app = GnrApp('sandboxpg') db = app.db clienti_tbl = db.table('fatt.cliente') :: All'interno dell'oggetto *SqlTable* sarà possibile individuare tutta una serie di attributi, tra i quali ``pkey``, ``caption_field``, ``name_long``, ``name_plural``, ovvero tutte le proprietà della table che abbiamo specificato nel modulo di *model* e tutti i metodi che abbiamo definito: oltre quindi a una serie di **metodi built-in (API)** comuni a tutte le tabelle (es: :ref:`insert, update` , :ref:`query` , e così via), conterrà anche tutti i **metodi di mixin**, ovvero tutti quei metodi che abbiamo definito all'interno della classe *Table*. .. hint:: È infatti prassi comune (e fortemente consigliata) dello sviluppo in Genropy la definizione di metodi all'interno della classe *Table*: in questo modo tali metodi saranno ampiamente disponibili all'interno dell'applicativo e facilmente individuabili all'interno dell'oggetto *SqlTable*. L'altra faccia della medaglia dell'oggetto SqlTable è la sua parte "descrittiva", che ritroviamo nell'oggetto ``src``:: db.model.src.table('cliente') *DbTableObj* rappresenta la struttura della Table, che definisce cioè come la tabella è costruita in termini di :ref:`colonne, colonne virtuali` , :ref:`relazioni` e così via: è quindi la `Bag `_ contenente tutto ciò che è stato definito da noi nel metodo ``config_db``. *DbTableObj* è però solo un oggetto descrittivo in termini di struttura della nostra tabella. L'oggetto "attivo" che andremo ad utilizzare per le nostre :ref:`Operazioni di lettura` e :ref:`scrittura` è invece **SqlTable**, il "mapper" della *table* del database. Lo schema seguente riassume la composizione della *SqlTable*: .. image:: /_static/images/schemino-table.png :width: 800px :align: center Qui in fondo è presente un file di ulteriore approfondimento degli oggetti trattati in formato Jupyter (eseguibile in modo attivo) o HTML. .. raw:: html

**Allegati:** - `ORM: L'oggetto db.model (Jupyter) `_ - `ORM: L'oggetto db.model (HTML) `_ .. sectionauthor:: Davide Paci