ordinamento lista oggetti

Salve

Ecco cosa mi piacerebbe sapere.

Una proprietà di una classe X contiene una lista di oggetti Y e tre proprietà Y sono dei numeri float.

Vorrei poter ordinare la lista di oggetti secondo il valore di ognuna di queste tre proprietà in modo decrescente.

Per altre esigenze, ho creato per queste classi un metodo toStdClass, che non fa altro un cast ad oggetto stdClass, quindi potrebbe essere utile castare ogni oggetto della lista prima a stdClass poi dopo anche in array.

Io pensavo di creare un metodo in X da richiamare nel costruttore e nel set della lista, in modo da ordinarla appena come si deve fin da subito.

Dopo tutto questo giro di supposizioni, qualcuno potrebbe suggerirmi in che modo potrei riordinare questa lista di oggetti secondo tre proprietà di ogni oggetto?

In fase di output questa lista diventerà una tabella opportunamente trattata e ordinata.

inviato 6 anni fa
larchitetto
X 0 X

Scusa...non ho capito molto...

Per oggetto intendi un oggetto php?

Puoi portare un esempio degli oggetti in gioco?

risposto 6 anni fa
Mario Santagiuliana
X 0 X

Ok.

Questa classe

class Torneo {
  protected static $has_title = true;
  protected static $has_body = false;
  protected $inizio = 0;
  protected $fine = 0;
  protected $con_turni = false;
  protected $turni_durata = "";
  protected $turni = array(); //array di oggetti Turno
  protected $classifica = array(); //array di oggetti Torneo_Giocatore
  protected $term;
  protected $ordine;
  private static $type = "torneo";
// ...
}

Ha una proprietà Torneo::turni altro non è che una lista di oggetti. Ogni oggetto è definito così:

class Turno {
  protected static $has_title = true;
  protected static $has_body = false;
  protected $data;
  protected $ordine;
  protected $partite = array();
  protected static $type = "turno";
// ...
}

Torneo::classifica è un'altra lista di oggetti. Ogni oggetto è definito così:

class Torneo_Giocatore {
  const PUNTI = -1;
  private $vid;
  private $nid;
  private $user;
  private $punti = self::PUNTI;
  private $buk = (float)0;
  private $bs = (float)0;
// ...
}

Vorrei poter ordinare la lista di oggetti contenute in Torneo, rispettivamente per Turno::ordine (ASC) e per Torneo_Giocatore::punti (DESC), Torneo_Giocatore::buk (DESC), Torneo_Giocatore::bs (DESC).

Faccio qualche esempio.

Creo un torneo:

$torneo = new Torneo();
var_dump($torneo);

L'output sarà simile a (ho eliminato le parti del dump inutili):

object(Torneo)#33 (12) {
  ["inizio:protected"]=>
  string(10) "1270072800"
  ["fine:protected"]=>
  string(10) "1272578400"
  ["con_turni:protected"]=>
  bool(true)
  ["turni_durata:protected"]=>
  string(9) "15 minuti"
  ["turni:protected"]=>
  array(3) {
    [0]=>
    object(Turno)#30 (8) {
      ["torneo:protected"]=>
      int(1)
      ["data:protected"]=>
      string(10) "1270076400"
      ["ordine:protected"]=>
      int(2)
      ["partite:protected"]=>
      array(1) {}
      ["nid:protected"]=>
      int(3)
      ["vid:protected"]=>
      int(23)
    }
    [1]=>
    object(Turno)#31 (8) {
      ["torneo:protected"]=>
      int(1)
      ["data:protected"]=>
      string(10) "1270076400"
      ["ordine:protected"]=>
      int(1)
      ["partite:protected"]=>
      array(1) {}
      ["nid:protected"]=>
      int(2)
      ["vid:protected"]=>
      int(24)
    }
    [2]=>
    object(Turno)#9 (8) {
      ["torneo:protected"]=>
      int(1)
      ["data:protected"]=>
      string(10) "1272027900"
      ["ordine:protected"]=>
      int(3)
      ["partite:protected"]=>
      array(1) {}
      ["nid:protected"]=>
      int(4)
      ["vid:protected"]=>
      int(25)
    }
  }
  ["classifica:protected"]=>
  array(2) {
    [3]=>
    object(Torneo_Giocatore)#26 (6) {
      ["vid:private"]=>
      string(2) "22"
      ["nid:private"]=>
      string(1) "1"
      ["user:private"]=>
      object(stdClass)#27 (22) {}
      ["punti:private"]=>
      float(0.5)
      ["buk:private"]=>
      float(2)
      ["bs:private"]=>
      float(2)
    }
    [4]=>
    object(Torneo_Giocatore)#28 (6) {
      ["vid:private"]=>
      string(2) "22"
      ["nid:private"]=>
      string(1) "1"
      ["user:private"]=>
      object(stdClass)#29 (22) {}
      ["punti:private"]=>
      float(2.5)
      ["buk:private"]=>
      float(3)
      ["bs:private"]=>
      float(3)
    }
  }
  ["term:protected"]=>
  NULL
  ["ordine:protected"]=>
  int(1)
  ["nid:protected"]=>
  int(1)
  ["vid:protected"]=>
  int(22)
  ["title:protected"]=>
  NULL
  ["body:protected"]=>
  string(0) ""
}

Eseguendo l'algoritmo di ordinamento sulle proprietà di quest'oggetto, dovremmo avere:

* ordinando per Torneo::turni::ordine, Torneo::turni sarà:array(object(Turno)#31, object(Turno)#30, object(Turno)#9)

* ordinando per punti, buk e bs (tutti DESC) in Torneo::Torneo_Giocatore, dovremmo avere per Torneo::classifica:array(object(Torneo_Giocatore)#28, object(Torneo_Giocatore)#26)

Magari conservando gli indici degli array in questione.

Se ci son altre domande esplicherò meglio il problema.

Grazie.

risposto 6 anni fa
larchitetto
modificato 6 anni fa
X 0 X

Non riesco a capire come hai così tanti oggetti...sembra che li utilizzi per immagazzinare i dati, sbaglio?

Ora ultima cosa: hai già creato un metodo all'interno del tuo oggetto Torneo che faccia l'ordinamento?

risposto 6 anni fa
Mario Santagiuliana
X 0 X
Non riesco a capire come hai così tanti oggetti...sembra che li utilizzi per immagazzinare i dati, sbaglio?

Eh già, Torneo raccoglie tutti i dati che lo riguardano, così poi da poter mettere su pagina i turni con le varie partite disputate, la classifica e una anagrafica dello stesso torneo...

Ora ultima cosa: hai già creato un metodo all'interno del tuo oggetto Torneo che faccia l'ordinamento?

Non ancora poiché mi son fermato pensando a come potrei implementare un metodo simile.

Per essere precisi ho fatto solamente:

public function ordina() {}

Per poi poterlo utilizzare così:

$torneo = new Torneo();
$torneo->ordina();
risposto 6 anni fa
larchitetto
X 0 X

Sono convinto che il metodo che stai utilizzando per la gestione della cosa non sia il metodo migliore.

A me personalmente sembra molto complicato.

Conosci il modello MVC di programmazione? Credo che tu in questo caso puoi seguire un modello simile.

I dati dei vari tornei li salvi dove? In un database?

Al momento mi sembra quasi che tu stia tentando di ricreare tramite classi e oggetti php un modello di database relazionale. Non ne vedo la ragione di ciò. Esistono i database SQL per questo.

So che non ti ho dato una risposta alla tua domanda ma vorrei invitarti a riflettere sulla logica di ciò che stai e che vuoi creare.

risposto 6 anni fa
Mario Santagiuliana
X 0 X

mmm vedo di rispondere senza dilungarmi... Premetto che per node si intende contenuto.

Dunque i dati memorizzati si trovano su db, sparsi in diverse tabelle, in parte organizzate dal CMS e in parte organizzate da me per... completare le informazioni - in questo caso sul torneo -.

Conosco l'MVC, in effetti sto utilizzando quel pattern, o meglio il CMS lo organizza più o meno per me; forse visto così non sembra.

L'oggetto torneo che vedi tu viene istanziato da una funzione che ha il compito di essere il controller, mi arriva un oggetto stdClass basilare per il trasporto dati e, all'interno di questa funzione, io passo quest'oggetto ad una classe che, eseguite le query, mi restituisce un oggetto torneo completo - e qui sto utilizzando il pattern DAO -.

// funzione controller che chiede di completare le informazioni di node
function gs_content_type_load($node) {
  if (Content_type::is_content_type($node, Torneo::get_type())) {
    return TorneoDAO::load_torneo_by_node($node);  
  }
  // ...
}

Il data transfer object data è delegato alla stdClass, poiché il CMS si aspetta un oggetto di quella classe da dare al view; infatti la DAO richiamata prima istanzia un oggetto Torneo, poi lo casta a stdClass e lo rende, pronto per il view.

class TorneoDAO extends NodeGSDAO {
  public static function load_torneo_by_node(&$node) {
    $torneo = self::select_torneo_by_nid_vid($node->nid, $node->vid);
    if (is_null($torneo)) {
      return null;
    }
    return $torneo->toStdClass();
  }
  public static function select_torneo_by_nid_vid($nid, $vid = null) {
    // ...altre istruzioni con query...
    $classifica = Torneo_GiocatoreDAO::select_classifica_by_nid_vid($nid, $vid, $partial_node->con_turni);
    if ($partial_node->con_turni) {
      $turni = TurnoDAO::select_turni_by_tnid($partial_node->nid);
      return new Torneo($partial_node, $classifica, $turni);
    }
    return new Torneo($partial_node, $classifica);
  }
}

Allora perché creare una classe che contiene queste liste di oggetti? In questo caso specifico, oltre al problema dell'ordinamento, una classe del genere non serve a molto, e la DAO potrebbe rendere benissimo un oggetto stdClass. In altri contesti però è utile in quanto invocando i suoi metodi, ad esempio, ottengo il link del contenuto via __toString, la data formattata, alcune informazioni sul node type, etc.

class Torneo {
  // ...
  public function __toString() {
    return $this->theme_node_link();
  }
  public function theme_node_link($text = "", $edit = false, $new_window = false) {
    if ($text == "" && !is_null($this->title)) {
      $text = $this->title;
    } elseif ($text == "") {
      $text = 'contenuto #'. $this->nid;
    }
    if ($edit) {
      $edit = '/edit';
      $init = "Modifica ";
    } else {
      $edit = "";
      $init = "Visualizza ";
    }
    $options = array(
      'attributes' => array('title' => $init. $text)
    );
    if ($new_window) {
      $options['attributes']['target'] = '_blank';
    }
    return l($text, 'node/'. $this->nid. $edit, $options);
  }
  // ...
}

Ho provato a ordinare la lista via query ma, purtroppo, non sono molto bravo e l'ho vista dura; poi magari dovrei togliere i set delle liste altrimenti con un set di una lista non ordinata e non ordinabile non ho risolto il mio problema.

Quindi dopo tutti questi passaggi ne esce fuori un oggetto bello grosso - purtroppo la specifica del torneo prevede tanti dati - ma, una volta castato a stdClass da inviare per il view si ha una prima riduzione dei dati, trasformati per un primo output e poi lo stesso oggetto infine, viene incorporato ed elaborato per la pagina da inviare a video.

Che ne pensi? O c'è qualcosa che non ti convince?

Infine, volendo, potrei ordinare la lista dei turni via query, però resta il problema spinoso della classifica, visto che i punti non sono organizzati dal punto di vista della partita, a meno di rivoluzionare il db...

risposto 6 anni fa
larchitetto
X 0 X
Che ne pensi? O c'è qualcosa che non ti convince?
Quindi dopo tutti questi passaggi ne esce fuori un oggetto bello grosso

Mi sembra il tutto troppo macchinoso e con un grande dispendio di memoria per il php.

Tu fai salvare i vari dati estratti dal database in più oggetti.

Non è questo quello che devi fare secondo me.

Credo che ti basti un oggetto che con vari metodi implementati al suo interno ti restituisca in array (più o meno ordinati) i dati che va a prelevare tramite un model (o anche direttamente) dal tuo database. Delega al dbms l'ordinamento degli stessi.

Non mi sembra affatto il caso di istanziare tutti questi oggetti...metti che hai 1000 tornei (o partite...o quello che è) istanzi 1000 oggetti? Non è una scelta normale e logica...sbaglio?

P.S. so che non ti sto dando una risposta al quesito iniziale, sono convinto che stai sbagliando approccio nella soluzione del tuo problema.

risposto 6 anni fa
Mario Santagiuliana
X 0 X

Beh sia che risolvo con oggetti o array, la base di dati quella resta e le query da fare quelle restano.

Ho studiato il problema, e non vedo altre soluzioni che rispondano alle diverse esigenze per organizzare i dati - per quelle che possono essere le mie conoscenze in materia -.

Altri siti anche importanti utilizzano questo CMS e contengono migliaia di articoli instanziando un oggetto per contenuto che solitamente viene visto su pagina.

A questo bisogna aggiungere la cache del CMS e le relative ottimizzazioni operate.

Ho pensato alla tua soluzione, quella di avere in una classe degli array e dei metodi che rendono ciò che mi serve... Secondo me viene tutto troppo disordinato: questa classe avrebbe troppe responsabilità...

Inoltre resterei volentieri in ambito OOP.

Con il DBMS non sono in grado di ordinare la classifica punti se il torneo prevede dei turni (di n partite in cui un giocatore disputa una partita per turno), poiché il torneo tiene traccia della classifica, ma i punti sono ricavati esaminando i vari turni per un dato giocatore... Ma, eseguite le dovute operazioni, mi ritrovo poi nel modello la classifica punti completa.

risposto 6 anni fa
larchitetto
X 0 X

Non è necessario esista una sola classe per fare tutto. Non sarebbe corretto.

La mia sensazione è che tu voglia rappresentare i tuoi dati all'interno di oggetti. Questa struttura/rappresentazione dovrebbe essere demandata al solo database. Con i vari oggetti che poi ti andrai a creare estrai i dati.

Io non andrei mai ad estrarre i dati per poi salvarli in oggetti e poi fare tutte le operazioni...prima farei le varie operazioni e poi estraggo e rappresento i miei dati sulle pagine html. E' un processo diverso.

risposto 6 anni fa
Mario Santagiuliana
X 0 X

Ok. Ma fare l'inverso significa metter su delle query troppo complesse ed onerose per comprendere l'ordinamento... No troppo lavoro, dovrei rifare tutto il progetto e purtroppo non ne ho il tempo - e poi comunque non troverei una soluzione migliore -, e in ogni caso tutte le operazioni sono eseguite dal DBMS, manca solamente un ordinamento di una lista di oggetti - e quest'ordinamento potrebbe esser richiesto dall'utente cliccando uno stupidissimo link -.

Poi non mi sembra tanto errato avere negli oggetti una rappresentazione dei dati contenuti nella base dati, no? A me hanno insegnato questo metodo, secondo il quale per ogni entità esisterebbe una classe che ne contiene i dati e ne applica i metodi previsti. Se poi tra due o più entità esiste una relazione, allora anziché memorizzare solamente la chiave esterna, si memorizza l'intero oggetto di quell'entità, con opportuni accorgimenti. O erro?

Così magari gli oggetti possono eseguire delle operazioni durante la navigazione dell'utente, come ad esempio creare un link al contenuto con un semplice $torneo->get_node_link(), o ancora alterare il proprio stato e memorizzarlo poi su DB.

risposto 6 anni fa
larchitetto
X 0 X

Io continuo a vedere gli oggetti come strumenti per estrarre in modo corretto ed eventualmente elaborare i dati presenti in un database. Non estrarre i dati ed immagazzinarli in essi per poi eseguire delle operazioni. La cosa a me sembra occupi molta più memoria del dovuto e del necessario.

risposto 6 anni fa
Mario Santagiuliana
X 0 X

Non mi sembra un approccio sbagliato quello di larchitetto.

Gli ORM (vedi Propel e Doctrine) fanno proprio così: una riga del database è mappata su un oggetto, ogni colonna su una proprietà dell'oggetto stesso.

Un elenco di oggetti/righe può essere ottenuto con un altro oggetto che implementi le interfacce standard di SPL, ad esempio ArrayIterator e Countable.

Io comunque eviterei di reimplementare tutto ciò, visto che i due ORM citati sopra lo fanno già egregiamente (e non solo questo, ovviamente)

risposto 6 anni fa
Massimiliano Arione
X 0 X

Ma la mappatura e il contenimento dei dati sono due cose differenti giusto?

Io ho capito che larchitetto vuole salvare all'interno di oggetti i dati presenti nel database. Il traffico del database è ridotto al minimo ma il consumo di memoria è al massimo in quanto con una query (o quello che è) estraggo tutti i dati e lo copio in più oggetti. Ho capito male?

Gli ORM lavorano in questo modo?

risposto 6 anni fa
Mario Santagiuliana
X 0 X

Ma la mappatura e il contenimento dei dati sono due cose differenti giusto?

Io ho capito che larchitetto vuole salvare all'interno di oggetti i dati presenti nel database. Il traffico del database è ridotto al minimo ma il consumo di memoria è al massimo in quanto con una query (o quello che è) estraggo tutti i dati e lo copio in più oggetti. Ho capito male?

Gli ORM lavorano in questo modo?

Gli ORM fanno esattamente questo (ma non solo questo), come ho detto prima.

Ovviamente c'è più overhead ad avere tutti oggetti, ma è una differenza trascurabile: le applicazioni che usano ORM non hanno problemi di prestazioni e, se ne hanno, il collo di bottiglia al 99% è nel database (una mancata ottimizzazione). D'altro canto c'è il vantaggio dell'astrazione dal db e la possibilità di fare tutto in OOP. Se poi usi pure lo scaffolding, la vita di sviluppatore diventa molto molto più semplice  ;)

risposto 6 anni fa
Massimiliano Arione
X 0 X

Dato che per me è un argomento nuovo e ho un'ottica di programmazione "all'antica" in merito, anche se amo l'OOP, queste applicazioni, per non avere problemi di prestazioni, su che genere di server corrono?

Una tecnica così non la posso usare su un provider che mi offre un servizio con delle limitazioni (ad esempio se sto su un server condiviso). Sbaglio a capire qualche cosa?

risposto 6 anni fa
Mario Santagiuliana
X 0 X

Dato che per me è un argomento nuovo e ho un'ottica di programmazione "all'antica" in merito, anche se amo l'OOP, queste applicazioni, per non avere problemi di prestazioni, su che genere di server corrono?

Una tecnica così non la posso usare su un provider che mi offre un servizio con delle limitazioni (ad esempio se sto su un server condiviso). Sbaglio a capire qualche cosa?

Io ho visto girare symfony (con Propel o con Doctrine) su un po' di tutto. Per lo sviluppo, anche sul netbook. Per i server, anche su dreamhost e perfino su altervista (con sqlite).

risposto 6 anni fa
Massimiliano Arione
X 0 X

Ok.

Ipotesi: ho un database da circa 100 Mb di dati o anche più, la cosa come funziona? Estrarre 100 Mb dal database e inserirli in oggetti (anche se poi uso cache and co.) pesa di molto sul sistema, se ho delle limitazioni sono con le mani legate, sbaglio?

risposto 6 anni fa
Mario Santagiuliana
X 0 X

Ok.

Ipotesi: ho un database da circa 100 Mb di dati o anche più, la cosa come funziona? Estrarre 100 Mb dal database e inserirli in oggetti (anche se poi uso cache and co.) pesa di molto sul sistema, se ho delle limitazioni sono con le mani legate, sbaglio?

Ma l'idratazione (il processo di inserimento di dati da db in oggetti) avviene solo a richiesta.

Ora, non credo che tu abbia esigenza di estrarre i dati dal tuo intero database (a meno che tu non stia facendo un'esportazione, ma in questo caso sono io il primo a dirti di non farla tramite ORM).

Di solito, anche quando si estraggono dati da una singola tabella, si fa una paginazione, per cui al massimo si tirano fuori 20 o 30 righe per volta. Anche se fossero 100 righe non è un problema, se invece diventano 1000 forse sì.

risposto 6 anni fa
Massimiliano Arione
X 0 X

Ecco, è proprio qui che nasce la mia perplessità sull'approccio che sta usando larchitetto per costruire la sua applicazione.

Lui ha chiesto appunto di fare un ordinamento di dati. L'ordinamento credo che bisogna farlo in relazione a tutti i record presenti nel database o sbaglio?

Se invece come dici te garak, i dati si estraggono a "gruppi" con una paginazione non ho nulla da ridire  :)

Grazie per le delucidazioni  :bye:

risposto 6 anni fa
Mario Santagiuliana
X 0 X

Ecco, è proprio qui che nasce la mia perplessità sull'approccio che sta usando larchitetto per costruire la sua applicazione.

Lui ha chiesto appunto di fare un ordinamento di dati. L'ordinamento credo che bisogna farlo in relazione a tutti i record presenti nel database o sbaglio?

Se invece come dici te garak, i dati si estraggono a "gruppi" con una paginazione non ho nulla da ridire  :)

Grazie per le delucidazioni  :bye:

Be' no: l'ordinamento non richiede l'estrazione di tutti i dati. L'ordinamento viene eseguito sempre dal database, che poi restituisce un certo numero di righe, che vengono idratate.

Certo che se di dovessero idratare tutte le righe per poi ordinare in base ai valori di un campo, sarebbe un bella mazzata. Ma, ripeto, non è il modo per fare un ordinamento.

risposto 6 anni fa
Massimiliano Arione
X 0 X
Certo che se di dovessero idratare tutte le righe per poi ordinare in base ai valori di un campo, sarebbe un bella mazzata. Ma, ripeto, non è il modo per fare un ordinamento.

Ed è quello che stavo contestando a larchitetto  :(

 :bye:

risposto 6 anni fa
Mario Santagiuliana
X 0 X

Beh nel mio caso si tratta di pochi oggetti relativamente piccoli che vengon caricati su richiesta - una volta inseriti in cache il problema è maggiormente ridotto -.

L'hosting di destinazione è condiviso, ma si tratta di un bacino di utenza relativamente basso (si parla di circa 20 iscritti), e con contenuti non troppo onerosi - forse toccheremo quota 10MB in un anno -.

Dove ho potuto, ho ordinato via DBMS ma, nel caso proposto, nel DB non ho i dati da ordinare secondo un campo ben preciso. I dati, in fase di estrazione, vengono elaborati e settati in una proprietà di Torneo. Se dovessi fare quest'operazione via DBMS, la vedo molto più dispendiosa e complessa a livello di query.

Esplico meglio, magari si trova una soluzione migliore.

L'ordinamento via class l'ho risolto così:

  /*
  * quando mi serve ordinare, richiamo questo metodo:
  */
  public function classifica_sort() {
    /*
     * http://stackoverflow.com/questions/124266/sort-object-in-php
     */
    usort($this->classifica, 'Torneo::cmp_classifica_punti');
  }
  /*
   * 
 * The comparison function must return an integer less than, equal to, or
 * greater than zero if the first argument is considered to be
 * respectively less than, equal to, or greater than the second.
   */
  private static function cmp_classifica_punti(&$tg1, &$tg2) {
    if ($tg1->get_punti() > $tg2->get_punti()) {
      return -1;
    } elseif ($tg1->get_punti() < $tg2->get_punti()) {
      return +1;
    }
    if ($tg1->get_buk() > $tg2->get_buk()) {
      return -1;
    } elseif ($tg1->get_buk() < $tg2->get_buk()) {
      return +1;
    }
    if ($tg1->get_bs() > $tg2->get_bs()) {
      return -1;
    } elseif ($tg1->get_bs() < $tg2->get_bs()) {
      return +1;
    }
    return 0;
  }

In una situazione simile, su DB, punti si trova settato a -1, poiché il punteggio finale viene calcolato in base ai risultati dei turni del torneo.

Mi spiego meglio.

Un torneo può esser non diviso in turni, e l'utente inserirà la classifica punti manualmente - e qui è possibile ordinare via DBMS -, può anch'esser diviso in turni, ogni turno è diviso in partite, dove un giocatore gioca una partita solamente.

Per poter ricostruire quindi il torneo, ho nel DB una tabella per le partite, che ha i seguenti campi: sfidante uno, sfidante due, risultato (0 vince sfidante 1, 1 vince sfidante 2 o > 1 pareggio). Attraverso Partita posso assegnare i punti ad entrambi i giocatori, assegnando 0, 1 o 0.5.

Un turno ha una lista di Partite, quindi è possibile stilare una classifica punti di tutti i giocatori per una partita giocata in quel turno.

Un torneo ha una lista di turni, quindi è possibile interrogare via via i vari oggetti per chiedere per ogni giocatore il totale punti - è più semplice scriverlo che farlo, si tratta di due righe di codice stupido per tre classi -.

Il risultato viene poi settato per ogni giocatore elencato in Torneo::classifica in fase di estrazione dei dati dal DB, per semplicità.

Ho proceduto così per non rappresentare il medesimo dato in diverse forme su diverse tabelle... Ho tentato di ipotizzare un ordinamento via DBMS in una situazione simile, ma ho visto troppe query, troppi count...

Mi piacerebbe sapere di più su alcuni termini apparsi in questo thread, e cioè "idratare", "ORM (vedi Propel e Doctrine)", "SPL"... Così mi potrei documentare meglio.

Non mi sembra stia reimplementando quanto già fatto - a meno che non esiste un framework che faccia questo lavoro ma io non sto utilizzando alcun framework, bensì un CMS -.

Aggiungo un appunto. Dal DB mi arrivano i dati che istanzio su oggetto per poter eseguire delle probabili operazioni. Non mi sembra sia errato, ad esempio, estrarre dal DB i valori per instanziare un oggetto Auto, e chiedere poi via metodo di accendersi, accelerare, frenare e spegnersi, no?

Per il view della stessa auto, utilizzo la stdClass passando i dati richiesti per quella pagina - e quindi l'oggetto e i dati inviati al browser peseranno molto meno.

A voi, e grazie per le risposte.

risposto 6 anni fa
larchitetto
X 0 X
Effettua l'accesso o registrati per rispondere a questa domanda