Nogle er PHP lidt af en hurdle...

At overskrive reserveret ord er vel ikke unikt for PHP. Kan faktisk ikke lige komme på noget sprog der vil lade dig gøre det.

Man kunne så mene at det ikke burde give et problem i klasse konstanter.

Alternativt kunne du jo bare sætte en _ foran dem eller efter dem.

En anden mulighed er at lave det til klasse variabler:

Restriction:: $OR er fuldt lovligt. (mellemrummet skyldes smily.)

<?php
class Restriction{
  public static $OR = 4;
}

print Restriction::$OR;
?>

Men det i princippet det samme som at skrive et $ foran alt bare muligvis en anelse mindre effektivt.



Ved ikke om det var noget i retning af det følgende du havde tænkt dig at kunne skrive. Personligt har jeg aldrig rigtig forstået pointen i at prøve at undgå at skrive SQL. Men kan da godt se at det nedenstående lettere kunne flyttes til andre database sprog og evt. lettere kunne testes for korrekthed.

$c = new MySqlCriteria();

$m = $c->_or(
       $c->_like('name','%Gnu%'),
       $c->_equal('age',220)
     );

print $m->to_sql();

Det bagved læggende:

abstract class MySqlBase{
  public function to_sql(){
    return 'WHERE '.$this->to_string();
  }
  public abstract function to_string();
}


class MySqlLike extends MySqlBase{
  private $f = "";
  private $v = "";
  public function __construct($field, $value){
    $this->f = $field;
    $this->v = $value;
  }

  public function to_string(){
    return '`'.$this->f.'` LIKE '.$this->v;
  }
}

class MySqlEqual extends MySqlBase{
  private $f = "";
  private $v = "";
  public function __construct($field, $value){
    $this->f = $field;
    $this->v = $value;
  }

  public function to_string(){
    return '`'.$this->f.'` = '.$this->v;
  }
}

class MySqlOr extends MySqlBase{
  private $crits = array();
  public function __construct($args){
    $this->crits = $args;
  }

  public function to_string(){
    $sep = '';
    $str = '';
    foreach($this->crits as $crit){
      $str.= $sep.$crit->to_string();
      $sep = ' OR ';
    }
    return $str;
  }
}


abstract class Criteria{
  public abstract function _like($field, $where);
  public abstract function _equal($field, $where);
  public abstract function _or();
}



class MySqlCriteria extends Criteria{
  public function _like($field, $where){
    return new MySqlLike($field, $where);
  }

  public function _equal($field, $where){
    return new MySqlEqual($field, $where);
  }

  public function _or(){
    return new MySqlOr(func_get_args());
  }
}

Lav statiske funktioner der eventuelt refererer til klassevariabler.

Så vil dit scenarie se således ud:

$c = new Criteria();
$c->add(new Restriction(Restriction::like(), 'name', 'Fritz%'))
  ->add(new Restriction(Restriction::or(),
		new Restriction(Restriction::equal(), 'age', 10),
		new Restriction(Restriction::isNull(), 'age')
  ));

Alternativt kan du lave hver funktion til et factory der returnerer et objekt.

$c = new Criteria();
$c->add(Restriction::like('name', 'Fritz%'))
  ->add(Restriction::or(
                Restriction::equal('age', 10),
		Restriction::isNull('age')
  ));

Det vil ikke virke. Du kan ikke navngive klasser, funktioner, konstanter efter et reserveret ord. Du kan navngive variabler efter reserveret ord.


I hvertfald ikke i min version af PHP.

Det er sandt, det var også primært et build-up til factory-fremgangsmåden. Man kan altid omdøbe funktionerne til at hedde noget andet.

hehe... ja man kan komme frem til nogle mystiske opstillinger...

person, dit forslag er udemærket. Desværre går det imod al logisk navngivning. Ved at sætte en underscore foran metode navnet, indikerer man at metoden kun kan kaldes internt i klassen.

Men jeg er kommet frem til noget der måske kan gå:

 $c = new Criteria('project');
 $c->add(new Restriction(Criteria::LIKE, 'name', 'Fritz%'))
   ->add(
         new Restriction(Criteria::GREATER_EQUAL, 'age', 10),
         // adds OR instead of AND, when adding multiple restrictions in one function call.
         new Restriction(Criteria::IS_NULL, 'age')
   )
   ->join(new Criteria('user'), new Restriction(Criteria::EQUAL, 'pk_user', 'fk_user'));

Hvis i kan være behjælpelige, med opstilling af mulige problemer - så bare giv gas. Jo mere jeg kan få afdækket des bedre.

jeg ville nok i hvertfald lave hjælpe funktioner så man undgår at skulle skrive new hele tiden.

Jeg antog da jeg læste den post at criteria omhandlede delen efter et 'WHERE ...' i for eksempel sql. Derfor virker en join på criteria lettere mystisk.

Endnu få at undgå at skrive super lang kode ville jeg nok også opretter special klasser, enten formen TypeRestriction eller RestrctionType:
OrRestriction eller RestrictionOr.

Umiddelbart kan jeg ikke lide at man selv skal huske at sætte % i din like erklæring. Og hvordan ser din restriction forskel på om jeg ønsker at sammenligne et felt med en tekst eller to felter?

new Restriction(Criteria::EQUAL, 'pk_user', 'fk_user'));
new Restriction(Criteria::EQUAL, 'pk_user', 'værdi'));

Med special klasser på typen LikeRestriction:

$c = new Criteria('project');
$c->add(new StartsWithRestriction('name', 'Fritz'))
  ->add(
      new GreaterEqualRestriction('age', 10),
      // adds OR instead of AND, when adding multiple restrictions in one function call.
      new IsNUllRestriction('age')
    )
    ->join(new Criteria('user'), new EqualRestriction('pk_user', 'fk_user'));

Med hjælpe funktioner på typen: type_restriction, criteria:

$c = criteria('project');
$c->add(starts_with_restriction('name', 'Fritz'))
  ->add(
      greater_equal_restriction('age', 10),
      // adds OR instead of AND, when adding multiple restrictions in one function call.
      is_null_restriction('age')
    )
    ->join(criteria('user'), equal_restriction('pk_user', 'fk_user'));

Angående _ i starten så er det rigtigt at de normalt bruges til at angive private/protected. Men skrev at du kunne sætte dem efter. Eneste anden mulighed er vel at rette i selve fortolkeren til PHP . Kan ikke se hvorfor det skulle være ulovligt at give en klasse konstant et beskyttet ord. Der komme altid :: foran dem når de bruges, og det giver ingen mening at sige $this:: or 4. Ved faktisk ikke om eller hvor man kan få koden til php.

En helt fjerde og lettere vanvittig ide er, at lave et DSL af en art, men så er du tilbage hvor du startede med noget der ligner SQL:

new Criteria(<<<S
table project

restrctions
  like name 'Fritz'
  greate equal age 10
  is null age

join
  user
  restiction
    equal pk_user fk_user
S;)