Chodzi o model, który pobiera newsy.
Mam na przykład takie coś:

[PHP] pobierz, plaintext 
class News extends Model {
    public function getAll() {
        return $this->db->query('SELECT * FROM `news`')->fetchAll();
    }
}
[PHP] pobierz, plaintext 

Muszę również pobierać newsy:
a) tylko 5 najnowszych
b) tylko usunięte (delete = 1)
c) tylko te, które mają datę publikacji mniejszą niż aktualna (publish < time())
d) tylko widoczne (visible = 1)

e) połączenie a + b, a + c, b + c, a + b + c + d i tak dalej, i tak dalej.

I pytanie, jak rozwiązać to aby nie tworzyć wielu metod, a najlepiej żeby była jedna czy dwie?

Klasa bazy danych

[PHP] pobierz, plaintext 
class Database {
 
    protected $pdo;
    protected $stmt;
 
    public function __construct($type, $host, $name, $user, $pass) {
        $this->pdo = new PDO($type . ':host=' . $host . ';dbname=' . $name, $user, $pass, array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"));
    }
 
    public function query($sql, $data = array()) {
		$this->stmt = $this->pdo->prepare($sql);
		$this->stmt->setFetchMode(PDO::FETCH_ASSOC);
		foreach($data as $key=>$value) {
            if(is_int($value))
                $this->stmt->bindValue(':' . $key, $value, PDO::PARAM_INT);
            else
                $this->stmt->bindValue(':' . $key, $value);
		}
         $this->stmt->execute();
		return $this;
	}
 
	public function fetch() {
		return $this->stmt->fetch();
	}
 
	public function fetchAll() {
		return $this->stmt->fetchAll();
	}
 
	public function rowCount() {
		return $this->stmt->rowCount();
	}
 
	public function lastId() {
		return $this->pdo->lastInsertId();
	}
 
        public function pdo() {
            return $this->pdo;
        }
}
[PHP] pobierz, plaintext 

Najprostsze rozwiązanie jakie mi teraz przychodzi do głowy to przekazywanie warunku w parametrze

[PHP] pobierz, plaintext 
$model->getData("WHERE delete=1");
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
public function getData($query=null){
	return $this->db->query('SELECT * FROM `news` '.$query)->fetchAll();
}
[PHP] pobierz, plaintext 

ale czy rozsądne, wątpię...

Może coś w tym stylu:

[PHP] pobierz, plaintext 
    public function getMany($fields = null, $cond = null, $limit = null, $orderBy = null)
    {
        $query = "SELECT ";
        if(!is_null($fields)) {
            $query .= ... // doklejasz listę pól do zapytania
        } else {
            $query .= "* ";
        }
 
        $query .= "FROM " . $this->tableName . ' ';
 
        if(!is_null($cond)) {
            $query .= ... // doklejasz $cond
        }
 
        // ...sprawdzasz resztę zmiennych i ewentualnie doklejasz
 
        return $this->db->query($query);
    }
[PHP] pobierz, plaintext 

Użycie:

[PHP] pobierz, plaintext 
 
    getMany('*', null, 5, "date DESC");
    getMany('*', "delete = 1");
    getMany('*', "publish < " . time());
    getMany('*', 'visible = 1');
[PHP] pobierz, plaintext 

Do prostych zastosowań wystarczy, do bardziej zaawansowanych zainteresowałbym się Doctrine 2, zamiast pisał coś swojego

Zrób sobie metodę np. whereBuilder z parametrami który buduje WHERE, potem w get... doklejasz to co zostało wygenerowane

A czy nie napisałem tego samego?

Czyli ogólnie nic nowego czego bym nie wiedział. Myślałem nad tym, ale jakoś źle mi to wygląda. Nie wiem czy ktoś zauważył, ale używam bindowania więc wasze przykłady mi się nie przydadzą.
A kod w stylu:

[PHP] pobierz, plaintext 
$where = array('delete = :delete', 'visible = :visible', 'publish > :publish');
$data = array('delete' => $_POST['delete'], 'visible' => $_POST['visible'], 'publish' => time());
$model->getMany($where, $data, 5); // $model->getMany(where, dane_do_bindowania, limit);
[PHP] pobierz, plaintext 

wydaje mi się zbyt mocno przesadzony.
Miałem i nadal mam nadzieje na inny sposób na to.

To może napisz chociaż jak byś chciał żeby to wyglądało. Bo "innych sposobów na to" istnieje mnóstwo, tylko ciężko wyczuć jaki Tobie się będzie podobał. Możesz np. napisać klasę, powiedzmy Query i użyć jej mniej więcej w ten sposób:

[PHP] pobierz, plaintext 
$query = new Query('news');
$query->fields('title, created_at')
	->where('delete', array('eq' => '1'))
        ->where('visible', array('eq' => '1'), 'and')
        ->where('publish', array('eq' > time()), 'and')
	->limit(10)
	->orderBy('title');
$query->build();
[PHP] pobierz, plaintext 

I powiedzmy, że build() zbuduje takie zapytanie: "SELECT title, created_at FROM news WHERE delete = :delete AND visible = :visible AND publish > :publish ORDER BY title ASC LIMIT 10".
Możesz potem ten obiekt $query przekazać do metody query() z Twojej klasy Database i niech już ona sobie z nim radzi - wszystkie informacje - czyli samo zapytanie jak i parametry do zbindowania - tam siedzą.
To jest jeden z wielu sposobów.. ale też może Ci się wydać mocno przesadzony... Możesz też użyć już wspomnianego Doctrine - integruje się szalenie łatwo, za pomocą composera

chyba za bardzo chcesz dobrze

chyba nie rozumiem

pisałem do Evinek