Problema con classi ed ereditarietà delle costanti

[tasso85]

Salve a tutti =)

Vado subito al sodo: usando l'ultima versione di PHP 5.2.x (per essere allineato con la versione usata su altervista, che usa PHP 5.2.17), ho realizzato la seguente struttura di classi:

abstract class DAO {
  const TABLE = "";

  [...]

  function select($where = "", $order = "", $limit = "") {
    $sql = "SELECT * FROM " . self::TABLE;
    [...]
  }

  [...]
}

class UsersDAO extends DAO {
  const TABLE = "users";

  [...]
} 

il problema è che se io eseguo il sequente codice:

$dao = new UsersDAO;
$utenti = $dao->select(); 

Mi genera un errore un quanto la query base nella variabile $sql viene creata usando la costante TABLE del padre e non della classe figlia!

Ora, personalmente sono nuovo alla programmazione in PHP ad oggetti (ho sempre usato procedurale, anche se conosco abbastanza bene il paradigma OO da Java), però a costo di sbagliare dico: non dovrebbe prendermi correttamente il valore della costante per la classe che sto effettivamente utilizzando?
Come si può eventualmente aggirare il problema sempre restando nel range delle feature di PHP 5.2.x?

Grazie in anticipo per i vostri suggerimenti =)

EDIT: ho notato che lo stesso problema si presenta anche con le variabili dichiarate "static", mentre per le variabili di classe "normali" tutto funziona correttamente...

[satifal]

Perchè non fai una cosa del genere:

<?php
abstract class DAO {

  protected $TABLE = "";

  function select($where = "", $order = "", $limit = "") {
    $sql = "SELECT * FROM " . $this->TABLE;
    echo $sql;
  }

}

class UsersDAO extends DAO {

  protected $TABLE = "users";

}

$dao = new UsersDAO;
$utenti = $dao->select();
?>

[tasso85]

Ho effettivamente provato la tua soluzione, e funziona, ma ciò che mi "urta" è che, per principio, la mia TABLE dovrebbe essere una costante globale, non una variabile di classe.

Poi, è vero che il mio sistema di DAO che sto scrivendo tiene una cache delle istanze, quindi ciascuna classe DAO può avere una sola istanza attiva per volta, quindi alla fine non cambia molto, è solo per correttezza formale diciamo...

Ma è solo PHP a comportarsi seguendo questa strana logica? Non mi pareva Java funzionasse così...

[tasso85]

Uhm, leggendo sul sito di PHP, proprio alla sezione "costanti" relativamente alla parte sulla programmazione ad oggetti, vi è un commento di qualcuno che indica il mio stesso identico problema e la soluzione, per PHP 5.2.x, pare sia usare le Reflection Classes per estrapolare i dati effettivi dalla reference $this dove necessario...

class A {
  const A = "A";
  static $C = "A";

  function testReflection() {
    $ref = new ReflectionObject($this);
    $refA = $ref->getConstant('A');
    $refC = $ref->getStaticPropertyValue('C');
    return 'self::A = ' . $refA . ', self::$C = ' . $refC;
  }

  function testDirect() {
    return 'self::A = ' . self::A . ', self::$C = ' . self::$C;
  }
}

class B extends A {
  const A = "B const";
  static $C = "B static";
}

$b = new B;
$tests = 100000;

$start = microtime(true);
for ($i = 0; $i < $tests; $i++) {
  $b->testDirect();
}
var_dump(microtime(true) - $start);


$start = microtime(true);
for ($i = 0; $i < $tests; $i++) {
  $b->testReflection();
}
var_dump(microtime(true) - $start); 

ho messo in piedi questo breve test, ed in effetti tutto funziona come mi aspetterei (usando le Reflection Classes), però vi è un po' di degrado delle prestazioni: sulla mia macchina, il primo ciclo viene eseguito circa in un secondo, mentre il secondo ciclo in circa tre secondi...