w zasadzie 2 klasy bo connect jest oddzielnie

nie staram się wynaleźć koła na nowo tylko uprościć sobie robotę

ale pewnie jest tu parę błędów więc oceniajcie

btw. PDO do mnie nie przemawia jakoś a może przyzwyczaiłem się do starego?

pozdrawiam

[PHP] pobierz, plaintext 
<?php
 
class DBConnect {
 
    private static $_instance;
    public static $db;
    private static $host = 'localhost';
    private static $user = 'root';
    private static $pass = '';
    private static $database = 'ukcrm';
 
    private function __construct() {
        $this->connect();
    }
 
    public function setConnect() {
        if (!isset(self::$_instance)) {
            self::$_instance = new DBConnect();
        }
    }
 
    private static function connect() {
        self::$db = mysqli_connect(self::$host, self::$user, self::$pass, self::$database) or die('Connection fail');
    }
 
    public function changeConnect($host, $user, $pass, $db) {
        if (isset(self::$_instance)) {
            mysqli_close(self::$db);
            self::$host = $host;
            self::$user = $user;
            self::$pass = $pass;
            self::$database = $db;
            self::connect();
        } else {
            self::$_instance = new DBConnect();
            self::ChangeConnect($host, $user, $pass, $db);
        }
    }
 
}
 
class sql {
 
    private $table;
    private $params;
    private $where;
    private $columns;
    private $result;
    private $sql;
    private $order;
    private $orderMode = 'ASC';
    private $limit;
 
    function __construct() {
        DBConnect::setConnect();
        $this->resetSql();
    }
 
    public function resetSql() {
        $this->table = '';
        $this->params = array();
        $this->where = array();
        $this->result = array();
        $this->columns = array();
        $this->order = array();
        $this->sql = '';
        $this->limit = '';
    }
 
    public function setTable($table) {
        $this->table = $table;
    }
 
    public function setSqlString($string) {
        $this->sql = $string;
    }
 
    public function crearteSQL($mode) {
        if ($mode == 'insert') {
            $this->sql = 'INSERT INTO ' . $this->table . ' SET ' . implode(', ', $this->params);
        }
        if ($mode == 'update') {
            $this->sql = 'UPDATE ' . $this->table . ' SET ' . implode(', ', $this->params) . ' WHERE ' . implode(' ', $this->where);
        }
        if ($mode == 'delete') {
            $this->sql = 'DELETE FROM ' . $this->table . ' WHERE ' . implode(' ', $this->where);
        }
        if ($mode == 'select') {
            $this->sql = 'SELECT ' . implode(', ', $this->columns) . ' FROM ' . $this->table;
            if (!empty($this->where))
                $this->sql .= ' WHERE ' . implode(' ', $this->where);
            if (!empty($this->order)) {
                $this->sql .= ' ORDER BY ' . implode(', ', $this->order) . ' ' . $this->orderMode;
            }
            if ($this->limit) {
                $this->sql .= ' LIMIT ' . $this->limit;
            }
        }
    }
 
    public function setLimit($value) {
        $this->limit = $value;
    }
 
    public function setOrderMode($value) {
        $this->orderMode = $value;
    }
 
    public function addOrder($column) {
        $this->order[] = $column;
    }
 
    public function addParam($name, $value, $filter) {
        if ($value) {
            switch ($filter) {
                case 'int':
                    $value = $this->filterInt($value);
                    break;
                case 'double':
                    $value = $this->filterDouble($value);
                    break;
                case 'text':
                    $value = $this->filterText($value);
                    break;
                case 'like':
                    $value = $this->filterLike($value);
                    break;
            }
        } else {
            $value = "NULL";
            if ($filter == 'double')
                $value = '0';
        }
        $this->params[] = $name . '=' . $value;
    }
 
    public function addWhere($column, $value, $filter, $sign = '=') {
        if ($value) {
            switch ($filter) {
                case 'int':
                    $value = $this->filterInt($value);
                    break;
                case 'double':
                    $value = $this->filterDouble($value);
                    break;
                case 'text':
                    $value = $this->filterText($value);
                    break;
                case 'like':
                    $value = $this->filterLike($value);
                    $sign = ' LIKE ';
                    break;
            }
        } else {
            $value = "NULL";
        }
        $this->where[] = $column . $sign . $value;
    }
 
    public function addTextWhere($value) {
        $this->where[] = $value;
    }
 
    public function addColumn($value) {
        $this->columns[] = $value;
    }
 
    public function addColumns($val = array()) {
        if (!empty($val)) {
            foreach ($val as $value) {
                $this->addColumn($value);
            }
        }
    }
 
    public function sqlQuery() {
        $this->result = mysqli_query(DBConnect::$db, $this->sql) or die(mysqli_error());
    }
 
    public function getResult() {
        return $this->result;
    }
 
    public function getRow() {
        return mysqli_fetch_assoc($this->result);
    }
 
    public function numRows() {
        return mysqli_num_rows($this->result);
    }
 
    public function testSQL() {
        echo $this->sql . '<br />';
        exit();
    }
 
    private function filter($value, $type) {
        $value = mysqli_real_escape_string(DBConnect::$db, $value);
        switch ($type) {
            case "text":
                $value = ($value != "") ? "'" . $value . "'" : "NULL";
                break;
            case "int":
                $value = ($value != "") ? intval($value) : "NULL";
                break;
            case "double":
                $value = ($value != "") ? "'" . doubleval($value) . "'" : "NULL";
                break;
        }
        return $value;
    }
 
    public function filterInt($value) {
        return $this->filter($value, 'int');
    }
 
    public function filterText($value) {
        return $this->filter($value, 'text');
    }
 
    public function filterDouble($value) {
        $value = str_replace(',', '.', $value);
        return $this->filter($value, 'double');
    }
 
    public function filterLike($value) {
        return $this->filter('%' . $value . '%', 'text');
    }
 
}
 
//przykładowe wywołanie
 
$sql = new sql();
$sql->setTable('kkk k left join iii i on k.kkk_id = i.id');
$cols = array('k.id', 'k.number', 'k.name', 'k.preson');
$sql->addColumns($cols);
$cols = array('i.id as invid', 'i.number as inumber', 'i.name as iname', 'i.preson as iperson');
$sql->addColumns($cols);
$sql->addWhere('k.id', $_GET['id'], 'int');
$sql->crearteSQL('select');
$sql->sqlQuery();
if ($sql->numRows() == 1) {
    $row = $sql->getRow();
}
 
 
//inne wywolanie
 
if (isset($_POST['action'])) {
    $sql = new sql();
    $sql->setTable('anytable');
 
    $sql->addParam('flue_sizing', $_POST['flue_sizing'], 'text');
    $sql->addParam('flue_route', $_POST['flue_route'], 'text');
    $sql->addParam('based_on_client_info', $_POST['based_on_client_info'], 'text');
    $sql->addParam('instalation_time1', $_POST['instalation_time1'], 'text');
    $sql->addParam('instalation_time1_combo', $_POST['instalation_time1_combo'], 'text');
    $sql->addParam('instalation_time2', $_POST['instalation_time2'], 'text');
    $sql->addParam('instalation_time2_combo', $_POST['instalation_time2_combo'], 'text');
    $sql->addParam('lead_time', $_POST['lead_time'], 'text');
    $sql->addParam('lead_time_combo', $_POST['lead_time_combo'], 'text');
 
    $sql->addParam('zone', $_POST['zone'], 'text');
    $sql->addParam('terrain_category', $_POST['terrain_category'], 'text');
    $sql->addParam('basic_wind_speed', $_POST['basic_wind_speed'], 'text');
    $sql->addParam('reliability_level', $_POST['reliability_level'], 'text');
 
    $sql->addParam('lorry_length', $_POST['lorry_length'], 'text');
    $sql->addParam('crane_radius_of_loading', $_POST['crane_radius_of_loading'], 'text');
    $sql->addParam('building_height', $_POST['building_height'], 'text');
    $sql->addParam('crane_capacity', $_POST['crane_capacity'], 'text');
    $sql->addParam('crane_radius_for_lifting', $_POST['crane_radius_for_lifting'], 'text');
 
    $sql->addParam('nr_of_appliances', $_POST['nr_of_appliances'], 'text');
 
    if ($_POST['action'] == 'edit') {
                $sql->addWhere('id', $_POST['id'], 'int');
                $sql->addParam('data_mod', date('Y-m-d'), 'text');                                
                $sql->crearteSQL('update');
                //$sql->testSQL();
                $sql->sqlQuery();
            }
}
?>
[PHP] pobierz, plaintext 

Więcej staticów się nie dało?
Czemu setConnect()? getInstance() skoro to singleton.
I czemu singleton?
Masa private, blokujesz rozwój klasy poprzez dziedziczenie.

klasa powstała w związku z dużymi formularzami i pewnie dlatego singleton w connect bo zapytania w zasadzie dotyczą jednej bazy, jest ich najwyżej kilka ale kolumn duzo

co do private to cenna uwaga ale na dzień dzisiejszy nie bardzo widzę jej rozwój przez dziedziczenie

założenie było takie żeby ona wykonywała prawidłowe i przefiltrowane zapytanie i na tyle czytelne że w razie modyfikacji formularza/bazy/widoku (lub po prostu własnego błędu) można było szybko zmodyfikować duże zapytanie sql

crearteSQL? Powinno być raczej createSQL. Nie słyszałem o słowie "crearte". Może to i szczegół, ale warto to poprawić.

oczywista literówka, dzięki

Jako wartosc jakiego pola daj 0 a do bazy pojdzie NULL...

Jesli Tobie klasa pasuje to ok, w zasadzie nie nadaje sie do zadnego uzywania ot tak przez ludzi.
Ograniczona funkcjonalnosc,
definiowane danych polaczenia w samej klasie, o, przepraszam, jest changeConnect
stosowanie die, ktore zabije mi aplikacje nawet jak nie chce tego
brak obslugi zastrzezonych nazwa tabel i kolumn
jak wartosc jest pusta to dla double ustawiasz 0, dla INT NULL. hm.... a co jesli ja chce nawet dla DOUBLE dac NULL a nie 0? No i czemu double jest wyroznione a int nie?
$sql->setTable('kkk k left join iii i on k.kkk_id = i.id'); - no nie, tabela to tabela, a LEFT JOIN to LEFT JOIN, nie mieszaj tego

dzięki za sugestie, jeżeli chodzi o ograniczoną funkcjonalność to racja ale nie wiem czy kiedykolwiek da się stworzyć taką co przewidzi wszystkie opcje, dlatego porobiłem furtki typu setSqlString($string) lub addTextWhere($value)

wartośc 0 zamiast NULL dla double jest mi potrzebna do obecnej aplikacji i przeoczyłem to przy kopiowaniu kodu, oczywiście można wywalić tego ifa

Da się, spójrz chociażby na ZEND-a.

Nigdy nie zrozumiem po co ludzie tworzą takie potwory które robią nakładki, skoro jest PDO jako standard. Tylko po to, aby korzystać z metody "crearteSQL" która niewiele mówi i nie klepać ciągle SELECT/UPDATE itd? Absurd.

ps. ciekaw jestem jak skorzystasz z tej klasy na PHP 5.5 w której niema mysql_*

edycja:
źle przeczytałem mysqli_real_escape_string ... zdawało mi się, że mysqli ma być obiektowe...

Ale on ma mysqli_ a nie mysql_

!*!

mysqli_* jest zarówno obiektowe jak i strukturalne(pewnie dla tych baranów co nie potrafia obiektowości i zakończyli swoja edukacje na mysql, a teraz bd musieli pozmieniac na i przed )

Ta klasa ma sesns jeśli podpinamy rózne silniki bazodanowe, ale wtedy jest źle napisana bo ogranicza nas do jednego... Wiesz jak masz 50000 razy napisać SELECT... no to lepiej raz

O wersji strukturalnej nie wiedziałem... To już w ogóle jest głupotą.


1. "SELECT/UPDATE/INSERT" nie zmieniają się, są stałe, więc co za różnica czy będę je miał w kodzie, a modyfikacja zapytania i tak będzie wymagała interwencji w ten ciąg.

2. Czym podpinanie w klasach podobnych jak powyższa, różni się od tego z PDO?
Już nie mówiąc o tym, że w większych aplikacjach i tak nie stosuje się takich nadbudówek, bo o wiele wydajniej jest napisać na krótko zapytanie, niż zaprzęgać do tego kombajn, często wadliwy.

Rozumiem klasy które mają za zadanie łączenie się z SQL np. pobierając z cfg login i hasło z portem, ale takie coś? Bleee, ohyda.

ps. takie coś, ma niby mi zaoszczędzić czasu?

[PHP] pobierz, plaintext 
$sql->addWhere('k.id', $_GET['id'], 'int');
$sql->crearteSQL('select');
[PHP] pobierz, plaintext 

To mi przypomniało bzdurą historię sprzed kilku dni... empty() nie jest funkcją! I świat się zmienił...

!*! ok masz rację, przyznaje się rzuciłem tylko pobierznie na to okiem, faktycznie ta klasa nie ma sesnsu..


Widze ktoś dawno nie zagladał do manuala http://www.php.net/manual/en/mysqli.construct.php ,ale pewnie pracujesz na PDO Sam też twierdze, że jest bez sensu no ale jakoś musieli to pogodzić


Właśnie o to chodzi, że się nie zmieniają i to miałem na myśli, na ale faktycznie to co naskrobał za bardzo przypomina PDO i tym samym traci sens


No wiesz niektórym wydaje sie, że wiedzą lepiej od nas Jak już o tym mowa to ja usłyszałem, że isset albo empty to nie są metody podrecznikowe tylko pratyczne, albo widziałem kogoś kto sie obudził bo mu register globals przestało działać Są programiści i programiści

Pozwolę się wtrącić.
Bo jakoś dziwnym trafem każdy kto dodaje tu prace od razu dostaje fale krytyki a przecież nie każdy jest PRO i od czegoś trzeba zacząć.
Uważam, że takie klasy jak ta są bardzo ważne i potrzebne, ponieważ pomagają autorowi i klientom klasy ogarnąć podstawy obiektowości i podstawowe polecenia sqla.

Zgadzam się.

a hermatyzacja, polimorfizm i pierwszeństwo interfejsów nad implementacją?

Fasadą, możemy bez zmian w kodzie zmieniać implementację klasy na: inne silniki, PDO, pliki, nierelacyjne bazy danych.

Oczywiście, jednak nie wyobrażam sobie przepuszczania zapytań bezpośrednio przez klasy systemowe nawet przez PDO.

Czy ta klasa to kombajn?

Czy więcej kodu oznacza więcej straconego czasu? Czy w programowaniu obiektowym chodzi zawsze o mniejszą liczbę kodu(np metody typu: get, set)? Czy może o czytelność i łatwość rozbudowy?


To kim wy jesteście, że wiecie wszystko najlepiej?
W takim razie sprzedaję 28 tomów encyklopedii jak wy wszystko wiecie najlepiej.

To nie ta bajka.


Jak coś jest do wszystkiego, to jest do niczego. Z tego co pamiętam w OOP właśnie chodzi o rozbicie wszystkiego co możliwe, a nie budowę jednego kombajnu który ma w sobie wszytko.
W powyższej klasie nie ma rozbicia na inne silniki, odróżnienie bazy od SQL / pliki. Jest tylko nadbudówka która nie jest przydatna, ponieważ wszytko to jest dostępne natywnie z poziomu PDO.


Czytaj wyżej. Nie chodzi o ilość kodu do napisania, tylko o elastyczność której tu brakuje. Nie ma sensu pisać

[PHP] pobierz, plaintext 
$sql->addWhere('k.id', $_GET['id'], 'int');
$sql->crearteSQL('select');
[PHP] pobierz, plaintext 

skoro jest

[PHP] pobierz, plaintext 
$stmt = $pdo -> prepare('SELECT ...
[PHP] pobierz, plaintext 

A że nie muszę pisać polecenia SQL w całości z palca? Co z tego skoro muszę i tak zrobić odwołanie do metody.
Dlatego spór o to czy pisać główną konstrukcje czy nie, był dobry tak samo jak klasy które tworzyły jeden interfejs, dawno temu, przed PDO.

Sam sobie przeczysz.. bo jak ktoś skorzysta z takiej "klasy" nie majac duzego pojecia itak nie pozna np sql bo wszystko ma opakowane i wywołuje to np jak tu

[PHP] pobierz, plaintext 
    $sql->addWhere('k.id', $_GET['id'], 'int');
    $sql->crearteSQL('select');
[PHP] pobierz, plaintext 

co mu tak naprawde nic nie mówi... Ja w pierwszej swojej wypowiedzi przeoczyłem to, na co zwrócił mi uwage !*! i miał rację, ponadto wymyślanie koła na nowo tylko dla satysfakcji, że działa jest bez sensu, w tym przypadku ponieważ tak jak powiedziano ta klasa nie ma niczego wiecej niż dostarcza nam PDO, a nawet dało by się wymienić szereg ograniczen, chociażby wspomniane przez mnie czy prez Ciebie inne silniki bazodanowe...


Nikt nie wie wszystkiego tym bardziej najlepiej, źle zinterpretowałeś te słowa, chodziło o to że przychodzą tu osoby, które nie posiadają wiedzy, bo sie jescze uczą i próbują nam wmawiać, że cos nie działa albo działa zupełnie inaczej niż ma, a sami nawet czesto nie zajrzeli do manuala, tylko mówią bo im sie tak wydaje... i potem potrafia prowadzic dyskusje na jakis temat która itak kończy sie na tym że sie okazuje iż mieliśmy rację... Nie twierdze że nik nie ma prawa do pomyłek, ale jesli jest sie czegoś pewnym to trzeba miec na to niezbite dowody...

Najlepiej zakończmy te dyskusję bo powoli odbiega ona od tematu oceny..

Jedno jest pewne !*! masz napewno rację



Tutaj faktycznie to jest tak jak powiedziałeś, choć można by zaimplementować to troche inaczej z zachowaniem elastyczności i troche w kierunku tego co powiedziałem, ale to już nie w tym temacie, dlatego Twoje argumenty są jak nabardziej słuszne jesli chodzi o klase zaprezetowaną w tym wątku i też sie z Tobą zgadzam