witam,
Problem jest tego typu, że w projekci, który teraz piszę muszę współpracować z kilkoma bazami danych, spróbuję opisać to na przykładzie.
Mam główną bazę danych w niej znajduję się pewna liczba sklepów (poprzez odpowiedni formularz, użytkownik może w każdej chwili dodać kolejny sklep)
Teraz na podstawie zapytania pobieramy sklepy i wyświetlamy je w postaci checkboxów użytkownikowi, który dodając produkt ma możliwość wybrania do
których sklepów ma zostać dodany dany produkt.
Problem, który nie wiem jak rozwiązać polega na tym jak w klasie produkt rozpoznać, które sklepy zostały wybrane i połączyć się z bazą danych odzielną dla
każdego sklepu by do wybranych sklepów dodać produkt?

Obecny kod klasy Product:

[PHP] pobierz, plaintext 
<?php
    define('DIR_MAIN', '../../');
    require_once(DIR_MAIN.'common.php');
    
    require_once('interfaces/itemOperations.php');
 
    class Product extends Item implements itemOperations {
        
        public static function addItem(){
            
            global $dsn, $user, $passwd;
            
            if($_SERVER['REQUEST_METHOD'] == 'POST'){
            try
    {    
                $db = new PDO($dsn,$user,$passwd);
                
                $db -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
                
                $query = $db->prepare('INSERT into `produkt` (`idjezyka`, `idkategorii`, `idprod`, `nazwap`, `kopisp`,
                                        `dopisp`, `plikp`, `cena`, `popis`, `pkluczowe`, `popisid`) 
                                VALUES (:idjezyka, :idkategorii, :idprod, :nazwap, :kopisp, :dopisp, :plikp, :cena, :popis, 
                                    :pkluczowe, :popisid)');
                
                $query->bindValue(':idjezyka', $_POST['idjezyka'], PDO::PARAM_INT);
                $query->bindValue(':idkategorii', $_POST['idkategorii'], PDO::PARAM_INT);
                $query->bindValue(':idprod', $_POST['idprod'], PDO::PARAM_INT);
                $query->bindValue(':nazwap', $_POST['nazwap'], PDO::PARAM_STR);
                $query->bindValue(':kopisp', $_POST['kopisp'], PDO::PARAM_STR);
                $query->bindValue(':dopisp', $_POST['dopisp'], PDO::PARAM_STR);
                $query->bindValue(':plikp', $_POST['plikp'], PDO::PARAM_STR);
                $query->bindValue(':cena', $_POST['cena'], PDO::PARAM_INT);
                $query->bindValue(':popis', $_POST['popis'], PDO::PARAM_STR);
                $query->bindValue(':pkluczowe', $_POST['pkluczowe'], PDO::PARAM_STR);
                $query->bindValue(':popisid', $_POST['popisid'], PDO::PARAM_INT);
                
                $count = $query->execute();
                
                $idp = $db->lastInsertId();
                
                foreach($_POST['sklep'] as $ids){
                    $ids = (int) $ids;
                    
                    if($ids){                
                        $q = $db->prepare('INSERT into `asortyment` (`idproduktu`, `idsklepu`) VALUES ('.$idp.','.$ids.') ');
                        $c = $q->execute();
                    }
                }
                
                }
    catch(PDOException $e)
    {
        echo 'Wystąpił błąd biblioteki PDO: ' . $e->getMessage();
    }
                
                }
            else {
                addProduct();
            }
            
        }
        
        public static function deleteItem($idItem){
            
            global $dsn, $user, $passwd;
            
            $db = new PDO($dsn,$user,$passwd);
                $db -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
                
                $brand = $db -> exec('DELETE FROM produkt where idproduktu = '.$idItem.' ');
                
                header('Location: ../../www/secure/index.php');
            
        }
        
        
    }
    
?>
[PHP] pobierz, plaintext 

przy dodawaniu widoczna jest jeszcze tabela asortyment, która pełni rolę magazynu.
Skąd wiedzieć ile i z którymi bazami przyporządkowanymi do poszczególnych sklepów, nawiązać połączenie i dodać produkt?
pzdr

Hmm, czy to nie jest czasem średnio bezpieczne ?

[PHP] pobierz, plaintext 
<?php
global $dsn, $user, $passwd;
        
$db = new PDO($dsn,$user,$passwd);
?>
[PHP] pobierz, plaintext 

Hmm, napisałem własną klasę do obsługi bazy danych itp.
Może ten kodzik Cię naprowadzi.

[PHP] pobierz, plaintext 
<?php
$Config->Load('DB.ini');
 
$DB = $Loader->loadClass('dfDB', true, false);
 
$DB->createConnection('First_Connection', $Config->getProperty('DB_HOST'), $Config->getProperty('DB_PORT'), $Config->getProperty('DB_USER'), $Config->getProperty('DB_PASSWD'));
 
$DB->createConnection('Second_Connection', $Config->getProperty('DB_HOST'), $Config->getProperty('DB_PORT'), $Config->getProperty('DB_USER'), $Config->getProperty('DB_PASSWD'));
 
$DB->setActiveConnection('First_Connection');
 
{ ...Jakies operacje... }
 
$DB->setActiveConnection('Second_Connection');
 
{ ...Operacje na innej bazie... }
?>
[PHP] pobierz, plaintext 

Wrzucić to w pętle i laczysz sie pokolei z bazami.

Pozdrawiam.

prosiłbym jeszcze o parę wskazówek co do w/w problemu, problem jak skorzystaszłeś z kilku konfiguracji do połączenia z bazą,
mój kod, którego używam do łączenia:

[PHP] pobierz, plaintext 
<?php
class Connect {
        
        public static $dbType = null;
        public static $dbHost = null;
        public static $dbPort = null;
        public static $dbName = null;
        public static $dbUser = null;
        public static $dbPasswd = null;
 
        public static function getDbType(){
               if(self::$dbType === null){
                 self::$dbType = Config::getInstance()->getProperty("dbType");
           }
           return self::$dbType;
     }
     
         public static function getDbHost(){
             if(self::$dbHost === null){
                 self::$dbHost = Config::getInstance()->getProperty("dbHost");
             }
         return self::$dbHost;
         }
         
         public static function getDbPort(){
             if(self::$dbPort === null){
                 self::$dbPort = Config::getInstance()->getProperty("dbPort");
             }
         return self::$dbPort;
         }
         
         public static function getDbName(){
             if(self::$dbName === null){
                 self::$dbName = Config::getInstance()->getProperty("dbName");
             }
         return self::$dbName;
         }
         
         public static function getDbUser(){
             if(self::$dbUser === null){
                 self::$dbUser = Config::getInstance()->getProperty("dbUser");
             }
         return self::$dbUser;
         }
         
         public static function getDbPasswd(){
             if(self::$dbPasswd === null){
                 self::$dbPasswd = Config::getInstance()->getProperty("dbPasswd");
             }
         return self::$dbPasswd;
         }
    }
?>
[PHP] pobierz, plaintext 

klasa Config to singleton, który parsuję podobnie jak u Ciebie pliki .ini?
pzdr

Nie korzystam z singleton'u. Wykorzystuje coś na ten wzór.

[PHP] pobierz, plaintext 
<?php
/*
*
* Loader to obiekt, który laduje pliki/klasy/widoki/controllery/modele.
* Ulatwia pracę, aczkolwiek nie jestem pewien czy to najlepsze rozwiazanie.
*
*/
 
$Context = $Loader->loadClass('dfContext');
$Loader->setContext($Context);
 
$Config = $Loader->loadClass('dfConfig');
$Context->setConfig($Config);
 
/*
*
* Loader ladując klase automatycznie tworzy jej instancję i constructorem przekazuje jej Context.
* Metoda loadClass posiada dwa argumenty, jeden sprawdza czy ma zostac utworzona instancja, a drugi czy przekazac Context.
* Wszystkie klasy poza Context, dziedzicza po klasie Component, która posiada metody setContext() i getContext().
*
*/
?>
[PHP] pobierz, plaintext 

Przykład użycia...

[PHP] pobierz, plaintext 
<?php
...
 
public function Dispatch() {
 
   ...
 
   $Loader = $this->getContext()->getLoader();
 
   ...
 
}
 
...
?>
[PHP] pobierz, plaintext 

A co to ładowania configuracji.
Klasa Config ma metody, które ładuja pliki .ini, .php oraz dynamiczną konfigurację z bazy danych.
Ładując plik .ini automatycznie nadpisuje wartości, którę już sie pojawiły.
Może to wada, ale na razie mi nie przeszkadza.

Kiedyś korzystałem z klasy Registry, która była singleton'em, ale zrezygnowałem z tego, ponieważ burzy to szczelność całego programu.
Rejestr był dostępny w wielu miejscach, w których nie powinien.

Pozdrawiam.

ok wymyśliłem sobie coś takiego tylko mi nie chce działać nie wiedzieć czemu?

[PHP] pobierz, plaintext 
<?php
 
    define('DIR_MAIN', '../../');
    define('DIR_SETTINGS', DIR_MAIN.'data/');
    
    require_once(DIR_MAIN.'common.php');
    
    class ChooseDB {
        
        private $dbConfigFile;
        private $data = array();
        
        public __construct($dbConfigFile){
            $this->dbConfigFile = $dbConfigFile;
        }
        
        public function getProperty($name){
            
            $this->data = parse_ini_file(DIR_SETTINGS.'DB.sklep'.$this->dbConfigFile.'.php');
            
            if(!isset($this->data[$name])){
                echo 'błąd!';
            }
            
            return $this->data[$name];
        }
                
    }
    
?>
[PHP] pobierz, plaintext 

następnie sprawdzam, tablicę pochodzącą z checkboxów i na jej podstawie wywołuje ChooseDB, tworzę obiekt PDO i wrzucam,
tyle tylko, że nie pojawia się nic w tej drugiej bazie

[PHP] pobierz, plaintext 
<?php
foreach($_POST['sklep'] as $ids){
                    $ids = (int) $ids;
                    
                    if($ids){                
                        $q = $db->prepare('INSERT into `asortyment` (`idproduktu`, `idsklepu`) VALUES ('.$idp.','.$ids.') ');
                        $c = $q->execute();
                        
                        $db = new ChooseDB($ids);
                        $dbType = $db->getProperty("dbType");
                        $dbHost = $db->getProperty("dbHost");
                        $dbPort = $db->getProperty("dbPort");
                        $dbName = $db->getProperty("dbName");
                        $dbUser = $db->getProperty("dbUser");
                        $dbPasswd = $db->getProperty("dbPasswd");
                        
                        $dbDsn = $dbType.':'.'host='.$dbHost.';'.'dbname='.$dbName.';'.$dbPort;
                                                
                        $pdo = new PDO($dbDsn,$dbUser,$dbPasswd);
                        
                        $pdo -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
                
                $q = $pdo->prepare('INSERT into `produkt` (`idjezyka`, `idkategorii`, `idprod`, `nazwap`, `kopisp`,
                                        `dopisp`, `plikp`, `cena`, `popis`, `pkluczowe`, `popisid`) 
                                VALUES (:idjezyka, :idkategorii, :idprod, :nazwap, :kopisp, :dopisp, :plikp, :cena, :popis, 
                                    :pkluczowe, :popisid)');
                
                $q->bindValue(':idjezyka', $_POST['idjezyka'], PDO::PARAM_INT);
.....
?>
[PHP] pobierz, plaintext 

Pierwsze co się rzuca w oczy to, że za każdym wywołaniem metody getPorperty() parsujesz na nowo plik.
Po drugie Twoj pliki .ini musi mieć opowiednie rozszerzenie.

tak wiem jak parsować pliki *.ini i jaką one powinny mieć budowę, już działa ta moja klasa, może nie najlepsza ale na chwilę obecną
na tyle mnie stać, może jakieś sugestie jak ją poprowadzić?
mam jeszcze tylko jeden problem ponieważ tablica POST['sklep'] jest wypełniona ale produkt i tak dodaje się tylko do pierwszej bazi tylko raz do tabeli asortyment?
pzdr

Na pewno jest wypełniona ?

Spróbuj tak...

[PHP] pobierz, plaintext 
<?php
var_dump($_POST['sklep']);
?>
[PHP] pobierz, plaintext 

I zobacz co zwraca.