Source for file OnpubDatabase.php

Documentation is available at OnpubDatabase.php

  1. <?php
  2.  
  3. /**
  4.  * Manage an Onpub database.
  5.  *
  6.  * @author {@link mailto:corey@onpub.com Corey H.M. Taylor}
  7.  * @copyright Onpub (TM). Copyright 2012, Onpub.com.
  8.  *  {@link http://onpub.com/}
  9.  * @license http://www.gnu.org/copyleft/gpl.html GNU General Public License
  10.  *  Version 2
  11.  * @package OnpubAPI
  12.  */
  13. class OnpubDatabase
  14. {
  15.   private $pdo;
  16.  
  17.   /**
  18.    * Connect to a database.
  19.    *
  20.    * All the methods in this class which query the database use the database
  21.    * connection provided by the PDO object required by this constructor.
  22.    * Currently, Onpub only supports MySQL as a database for storing content.
  23.    * Therefore, when constructing the PDO object, only the
  24.    * {@link PHP_MANUAL#ref.pdo-mysql PDO_MYSQL} driver is supported
  25.    * as a PDO {@link PHP_MANUAL#ref.pdo-mysql.connection data source}.
  26.    *
  27.    * @param PDO $pdo A {@link PHP_MANUAL#function.pdo-construct PHP Data Object}.
  28.    */
  29.   function __construct(PDO $pdo)
  30.   {
  31.     $this->pdo = $pdo;
  32.     $this->pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, TRUE);
  33.   }
  34.  
  35.   /**
  36.    * Get the name of the currently connected-to MySQL database.
  37.    *
  38.    * @return mixed NULL if no database is currently selected. Otherwise, the
  39.    *  name of the MySQL that's currently being used.
  40.    */
  41.   public function current()
  42.   {
  43.     $result = $this->pdo->query('SELECT DATABASE() AS current');
  44.     OnpubDatabase::verifyQuery($this->pdo, $result, FALSE);
  45.  
  46.     if (!($row = $result->fetch(PDO::FETCH_ASSOC))) {
  47.       return 0;
  48.     }
  49.  
  50.     $result->closeCursor();
  51.  
  52.     return $row["current"];
  53.   }
  54.  
  55.   /**
  56.    * Delete the Onpub schema.
  57.    *
  58.    * Calling this method will delete all Onpub content and schema in the
  59.    * PDO-connected database! Use with caution.
  60.    *
  61.    * @return mixed TRUE if the schema was successfully deleted. An array
  62.    *  of PDOException objects will be returned if any errors occured.
  63.    */
  64.   public function delete()
  65.   {
  66.     $sqlfile = array();
  67.     $line = 0;
  68.     $exceptions = array();
  69.  
  70.     $sqlfile = file('../api/sql/deleteonpubtables.sql');
  71.  
  72.     // advance past all comments
  73.     while (strpos($sqlfile[$line], '--') !== FALSE) {
  74.       $line++;
  75.  
  76.       while ($sqlfile[$line] == "\n") {
  77.         $line++;
  78.       }
  79.     }
  80.  
  81.     for ($i = $line; $i < sizeof($sqlfile); $i++) {
  82.       $query = '';
  83.  
  84.       while (strpos($sqlfile[$i], ';') === FALSE) {
  85.         $query .= $sqlfile[$i];
  86.         $i++;
  87.       }
  88.  
  89.       $query .= $sqlfile[$i];
  90.  
  91.       if (($i + 1) < sizeof($sqlfile)) {
  92.         while ($sqlfile[$i + 1] == "\n") {
  93.           $i++;
  94.         }
  95.       }
  96.  
  97.       $result = NULL;
  98.       $result = $this->pdo->exec($query);
  99.  
  100.       try {
  101.         OnpubDatabase::verifyExec($this->pdo, $result, FALSE);
  102.       }
  103.       catch (PDOException $e) {
  104.         $exceptions[] = $e;
  105.       }
  106.     }
  107.  
  108.     if (sizeof($exceptions)) {
  109.       return $exceptions;
  110.     }
  111.  
  112.     return TRUE;
  113.   }
  114.  
  115.   /**
  116.    * Install the {@link http://onpub.com/pdfs/onpub_schema.pdf Onpub schema}.
  117.    *
  118.    * Calling this method will install the Onpub tables in the PDO-connected
  119.    * database.
  120.    *
  121.    * @param int $version Optional argument to specify what version of the Onpub
  122.    *  schema to install. If NULL (the default), the latest version of the schema
  123.    *  will be added to the database.
  124.    * @return mixed TRUE if the schema was successfully installed. An array
  125.    *  of PDOException objects will be returned if any errors occured.
  126.    */
  127.   public function install($version = NULL)
  128.   {
  129.     $sqlfile = array();
  130.     $line = 0;
  131.     $exceptions = array();
  132.  
  133.     $sqlfile = file('../api/sql/createonpubtables-rev0.sql');
  134.  
  135.     // advance past all comments
  136.     while (strpos($sqlfile[$line], '--') !== FALSE) {
  137.       $line++;
  138.  
  139.       while ($sqlfile[$line] == "\n") {
  140.         $line++;
  141.       }
  142.     }
  143.  
  144.     for ($i = $line; $i < sizeof($sqlfile); $i++) {
  145.       $query = '';
  146.  
  147.       while (strpos($sqlfile[$i], ';') === FALSE) {
  148.         $query .= $sqlfile[$i];
  149.         $i++;
  150.       }
  151.  
  152.       $query .= $sqlfile[$i];
  153.  
  154.       if (($i + 1) < sizeof($sqlfile)) {
  155.         while ($sqlfile[$i + 1] == "\n") {
  156.           $i++;
  157.         }
  158.       }
  159.  
  160.       $result = NULL;
  161.       $result = $this->pdo->exec($query);
  162.  
  163.       try {
  164.         OnpubDatabase::verifyExec($this->pdo, $result, FALSE);
  165.       }
  166.       catch (PDOException $e) {
  167.         $exceptions[] = $e;
  168.       }
  169.     }
  170.  
  171.     if (sizeof($exceptions)) {
  172.       return $exceptions;
  173.     }
  174.  
  175.     return TRUE;
  176.   }
  177.  
  178.   /**
  179.    * Gets a list of MySQL databases that the logged-in user has access to.
  180.    * System database names are excluded from the list.
  181.    *
  182.    * @return array Array will be empty if user has no database access.
  183.    *  Otherwise array will contain the names of the MySQL databases she has
  184.    *  access to.
  185.    */
  186.   public function listDBs()
  187.   {
  188.     $result = $this->pdo->query('SHOW DATABASES');
  189.     OnpubDatabase::verifyQuery($this->pdo, $result, FALSE);
  190.     $rows = $result->fetchAll(PDO::FETCH_ASSOC);
  191.  
  192.     $excludes = array('mysql', 'performance_schema', 'information_schema');
  193.     $dbs = array();
  194.  
  195.     if ($rows) {
  196.       foreach ($rows as $row) {
  197.         if (!in_array($row['Database'], $excludes))
  198.         {
  199.           $dbs[] = $row['Database'];
  200.         }
  201.       }
  202.     }
  203.  
  204.     $result->closeCursor();
  205.     return $dbs;
  206.   }
  207.  
  208.   /**
  209.    * Check the status of the Onpub schema.
  210.    *
  211.    * @return mixed The version of the schema in the database as an int. An array
  212.    *  of PDOException objects will be returned if the schema is incomplete or
  213.    *  not installed.
  214.    */
  215.   public function status()
  216.   {
  217.     $oaamaps = new OnpubAAMaps($this->pdo);
  218.     $oarticles = new OnpubArticles($this->pdo);
  219.     $oauthors = new OnpubAuthors($this->pdo);
  220.     $oimages = new OnpubImages($this->pdo);
  221.     $osamaps = new OnpubSAMaps($this->pdo);
  222.     $osections = new OnpubSections($this->pdo);
  223.     $owebsites = new OnpubWebsites($this->pdo);
  224.     $owsmaps = new OnpubWSMaps($this->pdo);
  225.     $queryOptions = new OnpubQueryOptions($this->pdo);
  226.     $queryOptions->setPage(1, 1);
  227.     $exceptions = array();
  228.     $version = 0;
  229.  
  230.     try {
  231.       $oaamaps->select($queryOptions);
  232.     }
  233.     catch (PDOException $e) {
  234.       $exceptions[] = $e;
  235.     }
  236.  
  237.     try {
  238.       $oarticles->select($queryOptions);
  239.     }
  240.     catch (PDOException $e) {
  241.       $exceptions[] = $e;
  242.     }
  243.  
  244.     try {
  245.       $oauthors->select($queryOptions);
  246.     }
  247.     catch (PDOException $e) {
  248.       $exceptions[] = $e;
  249.     }
  250.  
  251.     try {
  252.       $oimages->select($queryOptions);
  253.     }
  254.     catch (PDOException $e) {
  255.       $exceptions[] = $e;
  256.     }
  257.  
  258.     try {
  259.       $osamaps->select($queryOptions);
  260.     }
  261.     catch (PDOException $e) {
  262.       $exceptions[] = $e;
  263.     }
  264.  
  265.     try {
  266.       $osections->select($queryOptions);
  267.     }
  268.     catch (PDOException $e) {
  269.       $exceptions[] = $e;
  270.     }
  271.  
  272.     try {
  273.       $owebsites->select($queryOptions);
  274.     }
  275.     catch (PDOException $e) {
  276.       $exceptions[] = $e;
  277.     }
  278.  
  279.     try {
  280.       $owsmaps->select($queryOptions);
  281.     }
  282.     catch (PDOException $e) {
  283.       $exceptions[] = $e;
  284.     }
  285.  
  286.     if (sizeof($exceptions)) {
  287.       return $exceptions;
  288.     }
  289.  
  290.     $version = 1;
  291.  
  292.     return $version;
  293.   }
  294.  
  295.   /**
  296.    * Verify the results of a call to {@link PHP_MANUAL#function.pdostatement-execute PDOStatement->execute()}.
  297.    *
  298.    * Used internally to verify whether or not a PDOStatement->execute() call was
  299.    * successful or not. If the call returned FALSE then an exception is
  300.    * thrown with an error message and error code, explaining what went wrong.
  301.    * If the execute() call fails during a running database transaction,
  302.    * {@link PHP_MANUAL#function.pdo-rollback PDOStatement->rollback()} is called to
  303.    * roll back the transaction to put the database back in the state it was
  304.    * before the error occured; then the appropriate exception is thrown.
  305.    *
  306.    * @param PDO $pdo The PDO object which called {@link PHP_MANUAL#function.pdo-prepare prepare()}.
  307.    * @param mixed $result The value execute() returned when it was called.
  308.    * @param bool $isTransaction TRUE if execute() was called during a running
  309.    *                             database transaction, FALSE otherwise.
  310.    * @param array $errorInfo The array returned by {@link PHP_MANUAL#function.pdostatement-errorinfo PDOStatement->errorInfo()}.
  311.    * @return void 
  312.    * @throws PDOException if the execute() call failed.
  313.    */
  314.   public static function verifyExecute(PDO $pdo, $result, $isTransaction, $errorInfo)
  315.   {
  316.     if ($isTransaction) {
  317.       if (!$result) {
  318.         $status = $pdo->rollBack();
  319.  
  320.         if (!$status) {
  321.           $errorInfo = $pdo->errorInfo();
  322.           $e = new PDOException($errorInfo[2], $errorInfo[1]);
  323.           $e->errorInfo = $errorInfo;
  324.  
  325.           throw $e;
  326.         }
  327.  
  328.         $e = new PDOException($errorInfo[2], $errorInfo[1]);
  329.         $e->errorInfo = $errorInfo;
  330.  
  331.         throw $e;
  332.       }
  333.     }
  334.     else {
  335.       if (!$result) {
  336.         $e = new PDOException($errorInfo[2], $errorInfo[1]);
  337.         $e->errorInfo = $errorInfo;
  338.  
  339.         throw $e;
  340.       }
  341.     }
  342.   }
  343.  
  344.   /**
  345.    * Verify the results of a call to {@link PHP_MANUAL#function.pdo-exec PDO->exec()}.
  346.    *
  347.    * Used internally to verify whether or not a PDO->exec() call was
  348.    * successful or not. If the call returned FALSE then an exception is
  349.    * thrown with an error message and error code, explaining what went wrong.
  350.    * If the exec() call fails during a running database transaction,
  351.    * {@link PHP_MANUAL#function.pdo-rollback PDO->rollback()} is called to
  352.    * roll back the transaction to put the database back in the state it was
  353.    * before the error occured; then the appropriate exception is thrown.
  354.    *
  355.    * @param PDO $pdo The PDO object which called exec().
  356.    * @param mixed $result The value exec() returned when it was called.
  357.    * @param bool $isTransaction TRUE if exec() was called during a running
  358.    *                             database transaction, FALSE otherwise.
  359.    * @return void 
  360.    * @throws PDOException if the exec() call failed.
  361.    */
  362.   public static function verifyExec(PDO $pdo, $result, $isTransaction)
  363.   {
  364.     if ($isTransaction) {
  365.       if ($result === FALSE) {
  366.         $errorInfo = $pdo->errorInfo();
  367.         $status = $pdo->rollBack();
  368.  
  369.         if (!$status) {
  370.           $errorInfo = $pdo->errorInfo();
  371.           $e = new PDOException($errorInfo[2], $errorInfo[1]);
  372.           $e->errorInfo = $errorInfo;
  373.  
  374.           throw $e;
  375.         }
  376.  
  377.         $e = new PDOException($errorInfo[2], $errorInfo[1]);
  378.         $e->errorInfo = $errorInfo;
  379.  
  380.         throw $e;
  381.       }
  382.     }
  383.     else {
  384.       if ($result === FALSE) {
  385.         $errorInfo = $pdo->errorInfo();
  386.         $e = new PDOException($errorInfo[2], $errorInfo[1]);
  387.         $e->errorInfo = $errorInfo;
  388.  
  389.         throw $e;
  390.       }
  391.     }
  392.   }
  393.  
  394.   /**
  395.    * Verify the results of a call to {@link PHP_MANUAL#function.pdo-query PDO->query()}.
  396.    *
  397.    * Used internally to verify whether or not a PDO->query() call was
  398.    * successful or not. If the call returned FALSE then an exception is
  399.    * thrown with an error message and error code, explaining what went wrong.
  400.    * If the query() call fails during a running database transaction,
  401.    * {@link PHP_MANUAL#function.pdo-rollback PDO->rollback()} is called to
  402.    * roll back the transaction to put the database back in the state it was
  403.    * before the error occured; then the appropriate exception is thrown.
  404.    *
  405.    * @param PDO $pdo The PDO object which called query().
  406.    * @param mixed $result The value query() returned when it was called.
  407.    * @param bool $isTransaction TRUE if query() was called during a running
  408.    *                             database transaction, FALSE otherwise.
  409.    * @return void 
  410.    * @throws PDOException if the query() call failed.
  411.    */
  412.   public static function verifyQuery(PDO $pdo, $result, $isTransaction)
  413.   {
  414.     if ($isTransaction) {
  415.       if (!$result) {
  416.         $errorInfo = $pdo->errorInfo();
  417.         $status = $pdo->rollBack();
  418.  
  419.         if (!$status) {
  420.           $errorInfo = $pdo->errorInfo();
  421.           $e = new PDOException($errorInfo[2], $errorInfo[1]);
  422.           $e->errorInfo = $errorInfo;
  423.  
  424.           throw $e;
  425.         }
  426.  
  427.         $e = new PDOException($errorInfo[2], $errorInfo[1]);
  428.         $e->errorInfo = $errorInfo;
  429.  
  430.         throw $e;
  431.       }
  432.     }
  433.     else {
  434.       if (!$result) {
  435.         $errorInfo = $pdo->errorInfo();
  436.         $e = new PDOException($errorInfo[2], $errorInfo[1]);
  437.         $e->errorInfo = $errorInfo;
  438.  
  439.         throw $e;
  440.       }
  441.     }
  442.   }
  443.  
  444.   /**
  445.    * Verify the results of a call to {@link PHP_MANUAL#function.pdo-beginTransaction PDO->beginTransaction()} or {@link PHP_MANUAL#function.pdo-commit PDO->commit()}.
  446.    *
  447.    * Used internally to verify whether or not a PDO->beginTransaction() or a
  448.    * PDO->rollback() call was successful or not. If the call returned FALSE
  449.    * then an exception is thrown with an error message and error code,
  450.    * explaining what went wrong.
  451.    *
  452.    * @param PDO $pdo The PDO object which called beginTransaction() or rollback().
  453.    * @param mixed $result The value beginTransaction() or rollback() returned when it was called.
  454.    * @return void 
  455.    * @throws PDOException if the beginTransaction() or rollback() call failed.
  456.    */
  457.   public static function verifyTransaction(PDO $pdo, $result)
  458.   {
  459.     if (!$result) {
  460.       $errorInfo = $pdo->errorInfo();
  461.       $e = new PDOException($errorInfo[2], $errorInfo[1]);
  462.       $e->errorInfo = $errorInfo;
  463.  
  464.       throw $e;
  465.     }
  466.   }
  467.  
  468.   /**
  469.    * Verify the results of a call to {@link PHP_MANUAL#function.pdo-prepare PDO->prepare()}.
  470.    *
  471.    * Used internally to verify whether or not a PDO->prepare() call was
  472.    * successful or not. If the call returned FALSE then an exception is
  473.    * thrown with an error message and error code, explaining what went wrong.
  474.    * If the prepare() call fails during a running database transaction,
  475.    * {@link PHP_MANUAL#function.pdo-rollback PDO->rollback()} is called to
  476.    * roll back the transaction to put the database back in the state it was
  477.    * before the error occured; then the appropriate exception is thrown.
  478.    *
  479.    * @param PDO $pdo The PDO object which called prepare().
  480.    * @param mixed $result The value prepare() returned when it was called.
  481.    * @param bool $isTransaction TRUE if prepare() was called during a running
  482.    *                             database transaction, FALSE otherwise.
  483.    * @return void 
  484.    * @throws PDOException if the prepare() call failed.
  485.    */
  486.   public static function verifyPrepare(PDO $pdo, $result, $isTransaction)
  487.   {
  488.     if ($isTransaction) {
  489.       if ($result === FALSE) {
  490.         $errorInfo = $pdo->errorInfo();
  491.         $status = $pdo->rollBack();
  492.  
  493.         if (!$status) {
  494.           $errorInfo = $pdo->errorInfo();
  495.           $e = new PDOException($errorInfo[2], $errorInfo[1]);
  496.           $e->errorInfo = $errorInfo;
  497.  
  498.           throw $e;
  499.         }
  500.  
  501.         $e = new PDOException($errorInfo[2], $errorInfo[1]);
  502.         $e->errorInfo = $errorInfo;
  503.  
  504.         throw $e;
  505.       }
  506.     }
  507.     else {
  508.       if ($result === FALSE) {
  509.         $errorInfo = $pdo->errorInfo();
  510.         $e = new PDOException($errorInfo[2], $errorInfo[1]);
  511.         $e->errorInfo = $errorInfo;
  512.  
  513.         throw $e;
  514.       }
  515.     }
  516.   }
  517.  
  518.   /**
  519.    * Decode a UTF8-encoded string to a latin1-encoded string.
  520.    *
  521.    * @param string $in_str UTF8-encoded string.
  522.    * @return string latin1-encoded string.
  523.    */
  524.   public static function utf8Decode($in_str)
  525.   {
  526.     // utf8Decode is courtesy nospam@jra.nu and was found
  527.     // at: http://us4.php.net/utf8-decode in the comments section
  528.     // Replace ? with a unique string
  529.     $new_str = str_replace("?", "q0u0e0s0t0i0o0n", $in_str);
  530.  
  531.     // Try the utf8_decode
  532.     $new_str = utf8_decode($new_str);
  533.  
  534.     // if it contains ? marks
  535.     if (strpos($new_str, "?") !== FALSE) {
  536.       // Something went wrong, set new_str to the original string.
  537.       $new_str = $in_str;
  538.     }
  539.     else {
  540.       // If not then all is well, put the ?-marks back where is belongs
  541.       $new_str = str_replace("q0u0e0s0t0i0o0n", "?", $new_str);
  542.     }
  543.  
  544.     return $new_str;
  545.   }
  546. }
  547. ?>

Documentation generated on Fri, 08 Feb 2013 04:02:20 -0500 by phpDocumentor 1.4.4