Jak tworzyć aplikacje, która będzie mogła działać na kilku bazach danych (niekoniecznie jednocześnie)? Korzystając z PDO. Tworzę zapytania SQL np. dla mysql, jednak te mogą się różnić w wypadku posgresql, więc jak to rozdzielić? Przecież nie będę tworzył osobnych paczek/plików dla konkretnej bazy. Zrobić to na klasach? Tylko że tworzenie klasy, do obsługi PDO jest chybione... Jak rozwiązujecie te kwestie u siebie?

http://nl3.php.net/manual/en/intro.pdo.php - drugi akapit już Cię informuje, że PDO nie ingeruje w żaden sposób w treść Twoich zapytań.

Możesz:
1. Skorzystać z jakiejś warstwy abstrakcji nad samą bazą danych - co i tak pewnie robisz korzystając z ORM-a (np. Doctrine).
2. Stworzyć osobną implementację dla każdego silnika bazy danych, tj.: a) Utworzyć paczkę z interfejsami (MyProject\DAO) oraz paczkę z implemetacją dla każdej z bazy danych (MyProject\DAO\Impl\MySQL, MyProject\DAO\Impl\PostgreSQL), W całym projekcie oczywiście nie powinno być absolutnie żadnego nawiązania do którejkolwiek z paczek implementacji (poza konfiguracją).

PS. I oczywiście żadna z klas nie będzie tutaj obsługiwać PDO samego w sobie - będzie natomiast z niego korzystać.

[PHP] pobierz, plaintext 
 
$db = new dbconnect('mysql'); // ustalam jaki typ bazy (wartosc odczytana np. z CFG), choć domyślnie może być to posgresql
$db->pdo-> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); // wysyłam dodatkowe atrybuty
 
if($db-> is_db('posgresql')) // sprawdzam czy baza to posgresql
{
   $getCokolwiek = $db->pdo-> prepare('SELECT cos FROM `gdzies` WHERE tu_lag =:lang LIMIT 1');
}
elseif($db-> is_db('mssql)') // czy mssql
{
   $getCokolwiek = $db->pdo-> prepare('SELECT cos FROM `gdzies` WHERE tu_lag =:lang LIMIT 1');
}
else // ewentualnie wszytko inne
{
   $getCokolwiek = $db->pdo-> prepare('SELECT cos FROM `gdzies` WHERE tu_lag =:lang LIMIT 1');
}
 
$getCokolwiek -> bindValue(':lang', 'pl_pl', PDO::PARAM_STR)
$getCokolwiek -> execute();
[PHP] pobierz, plaintext 

Czy takie podejście byłoby dobre, biorąc pod uwagę że byłoby wykonywane w modelu (MVC)?

Nawet nie próbuj tego robić w taki sposób jak zaproponowałeś bo się umęczysz z tym.

Aha, czyli to powinno wyglądać mniej więcej tak:

[PHP] pobierz, plaintext 
$db = new dbconnect(); // tu zostaje wczytany z cfg jaka ma być baza
$db-> select('cos', 'gdzies', 'tu_lang') // odpowiednik 'SELECT cos FROM `gdzies` WHERE tu_lag =:lang LIMIT 1'
[PHP] pobierz, plaintext 

O to Ci chodzi?

Za zwracanie danych (obiektów) ze źródła danych (np. bazy danych) odpowiedzialne są obiekty DAO. Dla każdego typu danych i każdego źródła danych powinieneś mieć osobny obiekt. Każde źródło danych może pobierać dane w sobie tylko znany sposób, ale powinno zapewniać wspólny dla wszystkich źródeł interfejs - dzięki temu w aplikacji będziesz mógł transparentnie korzystać z dowolnego źródła.

[PHP] pobierz, plaintext 
interface SomethingDao {
  public function findByLanguage($language);
}
 
class MysqlSomethingDao {
  public function findByLanguage(...) {
    // ... zwraca dane w sposób specyficzny dla MySQL-a
  }
}
 
class PostgresSomethingDao {
  public function findByLanguage(...) {
    // ... zwraca dane w sposób specyficzny dla Postgresa
  }
}
 
class FacebookSomethingDao {
  public function findByLanguage(...) {
    // ... zwraca dane w sposób specyficzny dla Facebookowego webservice'a
  }
}
 
// A w samej aplikacji masz co najwyżej:
 
public function doSomething(SomethingDao $sthDao) {
  $sth = $sthDao->findByLanguage('en');
  $sth->doSthElse();
}
[PHP] pobierz, plaintext 

Czytam właśnie o tym, przegląda różne bazy i sposoby... i rozumiem samą ideę, jednak... To jest tylko nadbudówka, co nie wydaje mi się zbyt korzystne, bo muszę sam pisać interfejs, to tak jakbym chciał zrobić obsługę połączeń z bazami, gdy nie było PDO. Chociaż jakby się nad tym zastanowić, to coś w tym może być, a są jakieś spójne interfejsy lub nazewnictwo? Albo coś 'natywnego' w php? I jak nazywa się to:



Chodzi mi o wywołanie klasy w metodzie, bo chce o tym poczytać.

Interfejsy DAO deklarują metody wykonujące operacje odczytu/zapisu danych biznesowych ze/do źródła danych, zaś samo PDO deklaruje metody pozwalające na połączenie aplikacji ze źródłem danych (w dodatu bardzo konkretnym), tak więc to nie do końca to samo.
Nie ma jakiś konkretnych wytycznych co do nazewnictwa. Z reguły interfejsy będą kończyły się przyrostkiem Dao/DAO (na sposób zapisu akronimów też nie ma jednoznacznej konwencji), a implementacje będą znajdować się w osobnej paczce (np. interfejsy w My\Project\Dao, a implementacje w My\Project\Dao\Impl\[Mysql|Postgres|Oracle|Mssql]).

Ale tu jest tylko zadeklarowana metoda doSomething() z jednym argumentem, który musi być obiektem implementującym interfejs SomethingDao. Jeżeli o to Ci chodzi to nazywa się to type hinting.

Swoją drogą, z racji na to, że w większości SQL-owskich baz danych zapytania są niemal identyczne (mowa oczywiście o prostych operacjach), będziesz mógł utworzyć sobie jeden obiekt (dla każdego rodzaju danych), po którym mogłyby dziedziczyć implementacje specyficznych baz danych:

[PHP] pobierz, plaintext 
namepsace My\Project\Dao;
 
interface UserAccountDao {
  public function findInactive();
  public function activate(Account $account);
}
 
namespace My\Project\Dao\Impl;
 
abstract class AbstractUserAccountDao {
  protected $conn;
 
  public function __construct(\PDO $conn) {
    $this->conn = $conn;
  }
 
  public function findInactive() {
    $sql = $this->getFindInactiveQuery();
 
    $stmt = $this->conn->prepare($sql);
    $stmt->execute();
 
    return $stmt->findAll();
  }
 
  public function activate(Account $account) {
    $sql = $this->getActivateQuery();
 
    $stmt = $this->conn->prepare($sql);
    $stmt->bindValue('id', $account->getId(), \PDO::PARAM_INT);
    $stmt->execute();
  }
 
  protected function getFindInactiveQuery() {
    return 'SELECT ... FROM ... WHERE is_active = 0 ...;';
  }
 
  protected function getActivateQuery() {
    return 'UPDATE ... SET is_active = 1 WHERE id = :id;';
  }
}
 
namespace My\Project\Dao\Impl\Mysql;
 
class UserAccountDao extends AbstractUserAccountDao { }
 
namespace My\Project\Dao\Impl\Postgres;
 
class UserAccountDao extends AbstractUserAccountDao {
  protected function getFindInactiveQuery() {
    return 'jakieś tam specyficzne dla postgresa zapytanie - tutaj notabene nie potrzebne';
  }
}
[PHP] pobierz, plaintext