API tools faq
paste
Guest User

Untitled

a guest
Jan 22nd, 2018
64
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PHP 20.09 KB | None | 0 0
raw download clone embed print report
  1. <?php
  2.  
  3. class MyPDO {
  4.  
  5.     /**
  6.      * Instance de la classe PDO
  7.      *
  8.      * @var PDO
  9.      * @access private
  10.      */
  11.     private $PDOInstance = null;
  12.  
  13.     /**
  14.      * Instance de la classe myPDO
  15.      *
  16.      * @var myPDO
  17.      * @access private
  18.      * @static
  19.      */
  20.     private static $instance = null;
  21.  
  22.     /**
  23.      * Constantes destinées au constructeur de la classe PDO
  24.      *
  25.      * @var string
  26.      */
  27.     private $default_sql_user;
  28.     private $default_sql_host;
  29.     private $default_sql_pass;
  30.     private $default_sql_dtb;
  31.     private $default_sql_prefix;
  32.     private $default_encryption_key;
  33.     const SIMPLE_SELECT = 1;
  34.     const SIMPLE_UPDATE = 2;
  35.     const PREPARED_UPDATE = 3;
  36.     const SIMPLE_INSERT = 4;
  37.     const PREPARED_INSERT = 5;
  38.     const PREPARED_SELECT = 6;
  39.     const INCREMENTAL_UPDATE = 7;
  40.     const UNLOCK = 8;
  41.     const SIMPLE_DELETE = 9;
  42.     const COMPLEX_SELECT = 10;
  43.  
  44.     /**
  45.      * Constructeur
  46.      *
  47.      * @param void
  48.      * @return void
  49.      * @see PDO::__construct()
  50.      * @access private
  51.      */
  52.     private function __construct() {
  53.  
  54.         if (ServerUtilities::GAME_STATE == ServerUtilities::GAME_STATE_PRODUCTION) {
  55.             $this->default_sql_user = '';
  56.             $this->default_sql_host = '';
  57.             $this->default_sql_pass = '';
  58.             $this->default_sql_dtb = '';
  59.             $this->default_sql_prefix = 'xgp_';
  60.             $this->default_encryption_key = '';
  61.         } else if (ServerUtilities::GAME_STATE == ServerUtilities::GAME_STATE_LOCAL) {
  62.             $this->default_sql_user = 'root';
  63.             $this->default_sql_host = 'localhost';
  64.             $this->default_sql_pass = '';
  65.             $this->default_sql_dtb = 'orbitronio';
  66.             $this->default_sql_prefix = 'xgp_';
  67.             $this->default_encryption_key = '';
  68.         }
  69.  
  70.         try {
  71.             $this->PDOInstance = new PDO('mysql:dbname=' . $this->default_sql_dtb . ';host=' . $this->default_sql_host, $this->default_sql_user, $this->default_sql_pass);
  72.             $this->PDOInstance->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  73.         } catch (PDOException $err) {
  74.             message('Fatal error : ' . $err->getMessage());
  75.         }
  76.     }
  77.  
  78.     /**
  79.      * Crée et retourne l'objet myPDO
  80.      *
  81.      * @access public
  82.      * @static
  83.      * @param void
  84.      * @return myPDO $instance
  85.      */
  86.     public static function getInstance() {
  87.         if (is_null(self::$instance)) {
  88.             self::$instance = new myPDO();
  89.         }
  90.         return self::$instance;
  91.     }
  92.  
  93.     /*
  94.      * Mapping des méthodes PDO
  95.      *
  96.      * @access public
  97.      * @param string $sMethod
  98.      * @param array $aArguments
  99.      * @return mixed|boolean
  100.      */
  101.  
  102.     public function __call($sMethod, $aArguments) {
  103.         if (method_exists(get_class($this->PDOInstance), $sMethod)) {
  104.             return call_user_func_array(array($this->PDOInstance, $sMethod), $aArguments);
  105.         }
  106.         return false;
  107.     }
  108.  
  109.     /**
  110.      * Exécute une requête SQL avec PDO
  111.      *
  112.      * @return PDOStatement Retourne l'objet PDOStatement
  113.      */
  114.     public function query($type, $table, $Values = array(), $Where = array(), $OrderBy = array(), $ASC = true) {
  115.  
  116.         global $debug;
  117.  
  118.         $Result = null;
  119.         $Table = $this->default_sql_prefix . $table;
  120.         try {
  121.             switch ($type) {
  122.                 case self::SIMPLE_SELECT:
  123.                     $Query = self::buildSelectQuery($Table, $Values, $Where, $OrderBy, $ASC);
  124.                     $Result = $this->PDOInstance->query($Query);
  125.                     break;
  126.                 case self::PREPARED_SELECT:
  127.                     $Query = self::buildSelectPreparedQuery($Table, $Values, $Where, $OrderBy, $ASC);
  128.                     $PreparedQuery = $this->PDOInstance->prepare($Query);
  129.                     $Temp = array();
  130.                     foreach ($Where as $Clause) {
  131.                         $Temp[$Clause['field']] = $Clause['value'];
  132.                     }
  133.                     $Values = array_merge($Values, $Temp);
  134.                     $PreparedQuery->execute($Values);
  135.                     $Result = $PreparedQuery;
  136.                     break;
  137.                 case self::SIMPLE_UPDATE:
  138.                     $Query = self::buildUpdateQuery($Values, $Table, $Where);
  139.                     $this->PDOInstance->query($Query);
  140.                     break;
  141.                 case self::PREPARED_UPDATE:
  142.                     $Query = self::buildUpdatePreparedQuery($Values, $Table, $Where);
  143.                     $PreparedQuery = $this->PDOInstance->prepare($Query);
  144.                     $Values = array_merge($Values, $Where);
  145.                     $PreparedQuery->execute($Values);
  146.                     break;
  147.                 case self::SIMPLE_INSERT:
  148.                     $Query = self::buildInsertQuery($Values, $Table);
  149.                     $this->PDOInstance->query($Query);
  150.                     break;
  151.                 case self::PREPARED_INSERT:
  152.                     $Query = self::buildInsertPreparedQuery($Values, $Table);
  153.                     $PreparedQuery = $this->PDOInstance->prepare($Query);
  154.                     $Values = array_merge($Values, $Where);
  155.                     $PreparedQuery->execute($Values);
  156.                     break;
  157.                 case self::SIMPLE_DELETE:
  158.                     $Query = self::buildDeleteQuery($Where, $Table);
  159.                     $this->PDOInstance->query($Query);
  160.                     break;
  161.                 case self::COMPLEX_SELECT:
  162.                     $Query = self::buildComplexSelectQuery($Table, $Values, $Where, $OrderBy, $ASC);
  163.                     $Result = $this->PDOInstance->query($Query);
  164.                     break;
  165.                 case self::INCREMENTAL_UPDATE:
  166.                     $Query = self::buildIncrementalUpdateQuery($Values, $Table, $Where);
  167.                     $this->PDOInstance->query($Query);
  168.                     break;
  169.             }
  170.         } catch (PDOException $err) {
  171.             $debug->error($err->getLine() . ' : ' . $err->getMessage() . "<br />$Query<br />", "SQL Error");
  172.         }
  173.         //Libération mémoire
  174.         unset($Query, $Temp, $Clause, $Values, $Where, $type, $table);
  175.         return $Result;
  176.     }
  177.  
  178.     public function buildSelectQuery($Table, $Fields = null, $Where = null, $OrderBy = null, $ASC = true) {
  179.  
  180.         $QryString = 'SELECT ';
  181.  
  182.         if ($Fields) {
  183.  
  184.             $TotalFields = sizeof($Fields);
  185.             $CurrentField = 0;
  186.  
  187.             foreach ($Fields as $field) {
  188.                 $CurrentField++;
  189.                 if ($CurrentField == $TotalFields) {
  190.                     $QryString .= ' ' . $field . ' FROM ' . $Table . ' ';
  191.                 } else {
  192.                     $QryString .= ' ' . $field . ', ';
  193.                 }
  194.             }
  195.         } else {
  196.             $QryString .= '* FROM ' . $Table . ' ';
  197.         }
  198.  
  199.         if ($Where) {
  200.  
  201.             $TotalFields = sizeof($Where);
  202.             $CurrentField = 0;
  203.  
  204.             $QryString .= 'WHERE';
  205.  
  206.             foreach ($Where as $Clause) {
  207.                 $CurrentField++;
  208.                 if ($CurrentField == $TotalFields) {
  209.                     $QryString .= " `" . $Clause['field'] . "` " . $Clause['type'] . " '" . $Clause['value'] . "' ";
  210.                 } else {
  211.                     $QryString .= " `" . $Clause['field'] . "` " . $Clause['type'] . " '" . $Clause['value'] . "' AND ";
  212.                 }
  213.             }
  214.         }
  215.  
  216.         if ($OrderBy) {
  217.  
  218.             $TotalFields = sizeof($OrderBy);
  219.             $CurrentField = 0;
  220.  
  221.             $QryString .= 'ORDER BY';
  222.             foreach ($OrderBy as $field) {
  223.                 $CurrentField++;
  224.                 if ($CurrentField == $TotalFields) {
  225.                     $QryString .= ' ' . $field;
  226.                 } else {
  227.                     $QryString .= ' ' . $field . ',';
  228.                 }
  229.             }
  230.             if ($ASC) {
  231.                 $QryString .= ' ASC;';
  232.             } else {
  233.                 $QryString .= ' DESC;';
  234.             }
  235.         }
  236.         return $QryString;
  237.     }
  238.  
  239.     public function buildSelectPreparedQuery($Table, $Fields = null, $Where = null, $OrderBy = null, $ASC = true) {
  240.  
  241.         $QryString = 'SELECT ';
  242.  
  243.         if ($Fields) {
  244.  
  245.             $TotalFields = sizeof($Fields);
  246.             $CurrentField = 0;
  247.  
  248.             foreach ($Fields as $field) {
  249.                 $CurrentField++;
  250.                 if ($CurrentField == $TotalFields) {
  251.                     $QryString .= '`' . $field . '` FROM ' . $Table . ' ';
  252.                 } else {
  253.                     $QryString .= '`' . $field . '`, ';
  254.                 }
  255.             }
  256.         } else {
  257.             $QryString .= '* FROM ' . $Table . ' ';
  258.         }
  259.  
  260.         if ($Where) {
  261.  
  262.             $TotalFields = sizeof($Where);
  263.             $CurrentField = 0;
  264.  
  265.             $QryString .= 'WHERE';
  266.  
  267.             foreach ($Where as $Clause) {
  268.                 $CurrentField++;
  269.                 if ($CurrentField == $TotalFields) {
  270.                     $QryString .= " `" . $Clause['field'] . "` " . $Clause['type'] . " :" . $Clause['field'] . " ";
  271.                 } else {
  272.                     $QryString .= " `" . $Clause['field'] . "` " . $Clause['type'] . " :" . $Clause['field'] . " AND ";
  273.                 }
  274.             }
  275.         }
  276.  
  277.         if ($OrderBy) {
  278.  
  279.             $TotalFields = sizeof($OrderBy);
  280.             $CurrentField = 0;
  281.  
  282.             $QryString .= 'ORDER BY';
  283.             foreach ($OrderBy as $field) {
  284.                 $CurrentField++;
  285.                 if ($CurrentField == $TotalFields) {
  286.                     $QryString .= ' ' . $field;
  287.                 } else {
  288.                     $QryString .= ' ' . $field . ',';
  289.                 }
  290.             }
  291.             if ($ASC) {
  292.                 $QryString .= ' ASC;';
  293.             } else {
  294.                 $QryString .= ' DESC;';
  295.             }
  296.         }
  297.  
  298.         return $QryString;
  299.     }
  300.  
  301.     public function buildComplexSelectQuery($Table, $Fields = null, $Where = null, $OrderBy = null, $ASC = true) {
  302.  
  303.         $QryString = 'SELECT ';
  304.         $Specials = array('(', ')', 'OR', 'AND');
  305.  
  306.         if ($Fields) {
  307.  
  308.             $TotalFields = sizeof($Fields);
  309.             $CurrentField = 0;
  310.  
  311.             foreach ($Fields as $field) {
  312.                 $CurrentField++;
  313.                 if ($CurrentField == $TotalFields) {
  314.                     $QryString .= '`' . $field . '` FROM ' . $Table . ' ';
  315.                 } else {
  316.                     $QryString .= '`' . $field . '`, ';
  317.                 }
  318.             }
  319.         } else {
  320.             $QryString .= '* FROM ' . $Table . ' ';
  321.         }
  322.  
  323.         if ($Where) {
  324.  
  325.             $TotalFields = sizeof($Where);
  326.             $CurrentField = 0;
  327.  
  328.             $QryString .= 'WHERE';
  329.  
  330.             foreach ($Where as $Clause) {
  331.                 $CurrentField++;
  332.                 if (in_array($Clause['field'], $Specials)) {
  333.                     $QryString .= ' ' . $Clause['field'] . ' ';
  334.                 } else {
  335.                     if ($CurrentField == $TotalFields) {
  336.                         $QryString .= " `" . $Clause['field'] . "` " . $Clause['type'] . " '" . $Clause['value'] . "' ";
  337.                     } else {
  338.                         $QryString .= " `" . $Clause['field'] . "` " . $Clause['type'] . " '" . $Clause['value'] . "' " . $Clause['next_op'] . " ";
  339.                     }
  340.                 }
  341.             }
  342.         }
  343.  
  344.         if ($OrderBy) {
  345.  
  346.             $TotalFields = sizeof($OrderBy);
  347.             $CurrentField = 0;
  348.  
  349.             $QryString .= 'ORDER BY';
  350.             foreach ($OrderBy as $field) {
  351.                 $CurrentField++;
  352.                 if ($CurrentField == $TotalFields) {
  353.                     $QryString .= ' ' . $field;
  354.                 } else {
  355.                     $QryString .= ' ' . $field . ',';
  356.                 }
  357.             }
  358.             if ($ASC) {
  359.                 $QryString .= ' ASC;';
  360.             } else {
  361.                 $QryString .= ' DESC;';
  362.             }
  363.         }
  364.         return $QryString;
  365.     }
  366.  
  367.     /**
  368.      * Fonction buildInsertQuery qui retourne une requête SQL INSERT INTO
  369.      * @param array $Values le tableau contenant la liste des champs et valeurs à insérer
  370.      * @param string $Table la table cible
  371.      * @return string $QryString la requête INSERT INTO
  372.      */
  373.     public function buildInsertQuery($Values, $Table) {
  374.  
  375.         $TotalFields = sizeof($Values);
  376.         $CurrentField = 0;
  377.  
  378.         $QryString = 'INSERT INTO `' . $Table . '` (';
  379.  
  380.         foreach ($Values as $field => $value) {
  381.             $CurrentField++;
  382.             if ($CurrentField == $TotalFields) {
  383.                 $QryString .= '`' . $field . '` ) VALUES ( ';
  384.             } else {
  385.                 $QryString .= '`' . $field . '`, ';
  386.             }
  387.         }
  388.  
  389.         $CurrentField = 0;
  390.  
  391.         foreach ($Values as $field => $value) {
  392.             $CurrentField++;
  393.             if ($CurrentField == $TotalFields) {
  394.                 $QryString .= '\'' . $value . '\' );';
  395.             } else {
  396.                 $QryString .= '\'' . $value . '\', ';
  397.             }
  398.         }
  399.         //On libère un peu la mémoire occupée par ce script...
  400.         unset($TotalFields, $CurrentField, $field, $value); //Zou!
  401.         return $QryString;
  402.     }
  403.  
  404.     /**
  405.      * Fonction buildUpdateQuery qui retourne une requête SQL UPDATE
  406.      * @param array $Values le tableau contenant la liste des champs et valeurs à mettre à jour
  407.      * @param string $Table la table cible
  408.      * @param array $Where le tableau contenant la liste des clauses where à la requête
  409.      * @return string $QryString la requête UPDATE
  410.      */
  411.     public function buildUpdateQuery($Values, $Table, $Where) {
  412.  
  413.         $TotalFields = sizeof($Values);
  414.         $CurrentField = 0;
  415.  
  416.         $QryString = "UPDATE `" . $Table . "` SET";
  417.  
  418.         foreach ($Values as $field => $value) {
  419.             $CurrentField++;
  420.             if ($CurrentField == $TotalFields) {
  421.                 $QryString .= " `" . $field . "` = '" . $value . "' ";
  422.             } else {
  423.                 $QryString .= " `" . $field . "` = '" . $value . "',";
  424.             }
  425.         }
  426.         $TotalFields = sizeof($Where);
  427.         $CurrentField = 0;
  428.  
  429.         $QryString .= 'WHERE';
  430.  
  431.         foreach ($Where as $field => $value) {
  432.             $CurrentField++;
  433.             if ($CurrentField == $TotalFields) {
  434.                 $QryString .= " `" . $field . "` = '" . $value . "';";
  435.             } else {
  436.                 $QryString .= " `" . $field . "` = '" . $value . "' AND ";
  437.             }
  438.         }
  439.  
  440.         //On libère un peu la mémoire occupée par ce script...
  441.         unset($TotalFields, $CurrentField, $field, $value); //Zou!
  442.         return $QryString;
  443.     }
  444.  
  445.     public function buildIncrementalUpdateQuery($Values, $Table, $Where) {
  446.  
  447.         $TotalFields = sizeof($Values);
  448.         $CurrentField = 0;
  449.  
  450.         $QryString = "UPDATE `" . $Table . "` SET";
  451.  
  452.         foreach ($Values as $Clause) {
  453.             $CurrentField++;
  454.             if ($CurrentField == $TotalFields) {
  455.                 $QryString .= " `" . $Clause['field'] . "` = `" . $Clause['field'] . "` " . $Clause['type'] . " '" . $Clause['value'] . "' ";
  456.             } else {
  457.                 $QryString .= " `" . $Clause['field'] . "` = `" . $Clause['field'] . "` " . $Clause['type'] . " '" . $Clause['value'] . "',";
  458.             }
  459.         }
  460.         $TotalFields = sizeof($Where);
  461.         $CurrentField = 0;
  462.  
  463.         $QryString .= 'WHERE';
  464.  
  465.         foreach ($Where as $field => $value) {
  466.             $CurrentField++;
  467.             if ($CurrentField == $TotalFields) {
  468.                 $QryString .= " `" . $field . "` = '" . $value . "';";
  469.             } else {
  470.                 $QryString .= " `" . $field . "` = '" . $value . "' AND ";
  471.             }
  472.         }
  473.  
  474.         //On libère un peu la mémoire occupée par ce script...
  475.         unset($TotalFields, $CurrentField, $field, $value); //Zou!
  476.  
  477.         return $QryString;
  478.     }
  479.  
  480.     /**
  481.      * Fonction buildInsertPreparedQuery qui retourne une requête SQL INSERT INTO préparée
  482.      * @param array $Values le tableau contenant la liste des champs et valeurs à insérer
  483.      * @param string $Table la table cible
  484.      * @return string $QryString la requête INSERT INTO préparée
  485.      */
  486.     public function buildInsertPreparedQuery($Values, $Table) {
  487.  
  488.         $TotalFields = sizeof($Values);
  489.         $CurrentField = 0;
  490.  
  491.         $QryString = 'INSERT INTO `' . $Table . '` (';
  492.  
  493.         foreach ($Values as $field => $value) {
  494.             $CurrentField++;
  495.             if ($CurrentField == $TotalFields) {
  496.                 $QryString .= '`' . $field . '` ) VALUES ( ';
  497.             } else {
  498.                 $QryString .= '`' . $field . '`, ';
  499.             }
  500.         }
  501.  
  502.         $CurrentField = 0;
  503.  
  504.         foreach ($Values as $field => $value) {
  505.             $CurrentField++;
  506.             if ($CurrentField == $TotalFields) {
  507.                 $QryString .= ':' . $field . ' );';
  508.             } else {
  509.                 $QryString .= ':' . $field . ', ';
  510.             }
  511.         }
  512.         //On libère un peu la mémoire occupée par ce script...
  513.         unset($TotalFields, $CurrentField, $field, $value); //Zou!
  514.         return $QryString;
  515.     }
  516.  
  517.     /**
  518.      * Fonction buildUpdatePreparedQuery qui retourne une requête SQL UPDATE préparée
  519.      * @param array $Values le tableau contenant la liste des champs et valeurs à mettre à jour
  520.      * @param string $Table la table cible
  521.      * @param array $Where le tableau contenant la liste des clauses where à la requête préparée
  522.      * @return string $QryString la requête UPDATE préparée
  523.      */
  524.     public function buildUpdatePreparedQuery($Values, $Table, $Where) {
  525.  
  526.         $TotalFields = sizeof($Values);
  527.         $CurrentField = 0;
  528.  
  529.         $QryString = "UPDATE `" . $Table . "` SET";
  530.  
  531.         foreach ($Values as $field => $value) {
  532.             $CurrentField++;
  533.             if ($CurrentField == $TotalFields) {
  534.                 $QryString .= " `" . $field . "` = :" . $field . " ";
  535.             } else {
  536.                 $QryString .= " `" . $field . "` = :" . $field . ",";
  537.             }
  538.         }
  539.         $TotalFields = sizeof($Where);
  540.         $CurrentField = 0;
  541.  
  542.         $QryString .= 'WHERE';
  543.  
  544.         foreach ($Where as $field => $value) {
  545.             $CurrentField++;
  546.             if ($CurrentField == $TotalFields) {
  547.                 $QryString .= " `" . $field . "` = :" . $field . ";";
  548.             } else {
  549.                 $QryString .= " `" . $field . "` = :" . $field . " AND ";
  550.             }
  551.         }
  552.  
  553.         //On libère un peu la mémoire occupée par ce script...
  554.         unset($TotalFields, $CurrentField, $field, $value); //Zou!
  555.         return $QryString;
  556.     }
  557.  
  558.     public function buildLockQuery($Values) {
  559.  
  560.         $TotalFields = sizeof($Values);
  561.         $CurrentField = 0;
  562.         $QryString = 'LOCK TABLE';
  563.         foreach ($Values as $Table) {
  564.             $CurrentField++;
  565.             $Table = self::DEFAULT_SQL_PREFIX . $Table;
  566.             if ($CurrentField == $TotalFields) {
  567.                 $QryString .= ' ' . $Table . ' WRITE';
  568.             } else {
  569.                 $QryString .= ' ' . $Table . ' WRITE,';
  570.             }
  571.         }
  572.  
  573.         return $QryString;
  574.     }
  575.  
  576.     public function buildDeleteQuery($Where, $Table) {
  577.  
  578.         $QryString = 'DELETE FROM ' . $Table . ' ';
  579.  
  580.         if ($Where) {
  581.  
  582.             $TotalFields = sizeof($Where);
  583.             $CurrentField = 0;
  584.  
  585.             $QryString .= 'WHERE';
  586.  
  587.             foreach ($Where as $Clause) {
  588.                 $CurrentField++;
  589.                 if ($CurrentField == $TotalFields) {
  590.                     $QryString .= " `" . $Clause['field'] . "` " . $Clause['type'] . " '" . $Clause['value'] . "' ";
  591.                 } else {
  592.                     $QryString .= " `" . $Clause['field'] . "` " . $Clause['type'] . " '" . $Clause['value'] . "' AND ";
  593.                 }
  594.             }
  595.         }
  596.  
  597.         //On libère un peu la mémoire occupée par ce script...
  598.         unset($TotalFields, $CurrentField, $field, $value); //Zou!
  599.         return $QryString;
  600.     }
  601.  
  602.     public function __get($name) {
  603.         return $this->{$name};
  604.     }
  605.  
  606. }
  607.  
  608. ?>
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!