pdo.php

PhpWiki是sourceforge的一个开源项目

                $sth->execute();
                $id = $sth->fetchSingle();
                $sth = $dbh->prepare("INSERT INTO $page_tbl"
                                     . " (id,pagename,hits)"
                                     . " VALUES (?,?,0)");
                $id++;
                $sth->bindParam(1, $id, PDO_PARAM_INT);
                $sth->bindParam(2, $pagename, PDO_PARAM_STR, 100);
                if ($sth->execute())
                    $this->commit();
                else 
                    $this->rollBack();
            }
        }
        assert($id);
        return $id;
    }

    function get_latest_version($pagename) {
        $dbh = &$this->_dbh;
        extract($this->_table_names);
        $sth = $dbh->prepare("SELECT latestversion"
                             . " FROM $page_tbl, $recent_tbl"
                             . " WHERE $page_tbl.id=$recent_tbl.id"
                             . "  AND pagename=?");
        $sth->bindParam(1, $pagename, PDO_PARAM_STR, 100);
        $sth->execute();
        return $sth->fetchSingle();
    }

    function get_previous_version($pagename, $version) {
        $dbh = &$this->_dbh;
        extract($this->_table_names);
        $sth = $dbh->prepare("SELECT version"
                             . " FROM $version_tbl, $page_tbl"
                             . " WHERE $version_tbl.id=$page_tbl.id"
                             . "  AND pagename=?"
                             . "  AND version < ?"
                             . " ORDER BY version DESC");
        $sth->bindParam(1, $pagename, PDO_PARAM_STR, 100);
        $sth->bindParam(2, $version, PDO_PARAM_INT);
        $sth->execute();
        return $sth->fetchSingle();
    }
    
    /**
     * Get version data.
     *
     * @param $version int Which version to get.
     *
     * @return hash The version data, or false if specified version does not
     *              exist.
     */
    function get_versiondata($pagename, $version, $want_content = false) {
        $dbh = &$this->_dbh;
        extract($this->_table_names);
        extract($this->_expressions);
                
        assert(is_string($pagename) and $pagename != '');
        assert($version > 0);
        
        // FIXME: optimization: sometimes don't get page data?
        if ($want_content) {
            $fields = $this->page_tbl_fields . ", $page_tbl.pagedata AS pagedata"
                . ', ' . $this->version_tbl_fields;
        } else {
            $fields = $this->page_tbl_fields . ", '' AS pagedata"
                . ", $version_tbl.version AS version, $version_tbl.mtime AS mtime, "
                . "$version_tbl.minor_edit AS minor_edit, $iscontent AS have_content, "
                . "$version_tbl.versiondata as versiondata";
        }
        $sth = $dbh->prepare("SELECT $fields"
                             . " FROM $page_tbl, $version_tbl"
                             . " WHERE $page_tbl.id=$version_tbl.id"
                             . "  AND pagename=?"
                             . "  AND version=?");
        $sth->bindParam(1, $pagename, PDO_PARAM_STR, 100);
        $sth->bindParam(2, $version, PDO_PARAM_INT);
        $sth->execute();
        $row = $sth->fetch(PDO_FETCH_NUM);
        return $row ? $this->_extract_version_data_num($row, $want_content) : false;
    }

    function _extract_version_data_num($row, $want_content) {
        if (!$row)
            return false;

        //$id       &= $row[0];
        //$pagename &= $row[1];
        $data = empty($row[8]) ? array() : $this->_unserialize($row[8]);
        $data['mtime']         = $row[5];
        $data['is_minor_edit'] = !empty($row[6]);
        if ($want_content) {
            $data['%content'] = $row[7];
        } else {
            $data['%content'] = !empty($row[7]);
        }
        if (!empty($row[3])) {
            $data['%pagedata'] = $this->_extract_page_data($row[3], $row[2]);
        }
        return $data;
    }

    function _extract_version_data_assoc($row) {
        if (!$row)
            return false;

        extract($row);
        $data = empty($versiondata) ? array() : $this->_unserialize($versiondata);
        $data['mtime'] = $mtime;
        $data['is_minor_edit'] = !empty($minor_edit);
        if (isset($content))
            $data['%content'] = $content;
        elseif ($have_content)
            $data['%content'] = true;
        else
            $data['%content'] = '';
        if (!empty($pagedata)) {
            $data['%pagedata'] = $this->_extract_page_data($pagedata, $hits);
        }
        return $data;
    }

    /**
     * Create a new revision of a page.
     */
    function set_versiondata($pagename, $version, $data) {
        $dbh = &$this->_dbh;
        $version_tbl = $this->_table_names['version_tbl'];
        
        $minor_edit = (int) !empty($data['is_minor_edit']);
        unset($data['is_minor_edit']);
        
        $mtime = (int)$data['mtime'];
        unset($data['mtime']);
        assert(!empty($mtime));

        @$content = (string) $data['%content'];
        unset($data['%content']);
        unset($data['%pagedata']);
        
        $this->lock(array('page','recent','version','nonempty'));
        $this->beginTransaction();
        $id = $this->_get_pageid($pagename, true);
        $backend_type = $this->backendType();
        // optimize: mysql can do this with one REPLACE INTO.
        if (substr($backend_type,0,5) == 'mysql') {
            $sth = $dbh->prepare("REPLACE INTO $version_tbl"
                                 . " (id,version,mtime,minor_edit,content,versiondata)"
                                 . " VALUES(?,?,?,?,?,?)");
            $sth->bindParam(1, $id, PDO_PARAM_INT);
            $sth->bindParam(2, $version, PDO_PARAM_INT);
            $sth->bindParam(3, $mtime, PDO_PARAM_INT);
            $sth->bindParam(4, $minor_edit, PDO_PARAM_INT);
            $sth->bindParam(5, $content, PDO_PARAM_STR, 100);
            $sth->bindParam(6, $this->_serialize($data), PDO_PARAM_STR, 100);
            $rs = $sth->execute();
        } else {
            $sth = $dbh->prepare("DELETE FROM $version_tbl"
                                 . " WHERE id=? AND version=?");
            $sth->bindParam(1, $id, PDO_PARAM_INT);
            $sth->bindParam(2, $version, PDO_PARAM_INT);
            $sth->execute();
            $sth = $dbh->prepare("INSERT INTO $version_tbl"
                                . " (id,version,mtime,minor_edit,content,versiondata)"
                                 . " VALUES(?,?,?,?,?,?)");
            $sth->bindParam(1, $id, PDO_PARAM_INT);
            $sth->bindParam(2, $version, PDO_PARAM_INT);
            $sth->bindParam(3, $mtime, PDO_PARAM_INT);
            $sth->bindParam(4, $minor_edit, PDO_PARAM_INT);
            $sth->bindParam(5, $content, PDO_PARAM_STR, 100);
            $sth->bindParam(6, $this->_serialize($data), PDO_PARAM_STR, 100);
            $rs = $sth->execute();
        }
        $this->_update_recent_table($id);
        $this->_update_nonempty_table($id);
        if ($rs) $this->commit( );
        else $this->rollBack( );
        $this->unlock(array('page','recent','version','nonempty'));
    }
    
    /**
     * Delete an old revision of a page.
     */
    function delete_versiondata($pagename, $version) {
        $dbh = &$this->_dbh;
        extract($this->_table_names);

        $this->lock(array('version'));
        if ( ($id = $this->_get_pageid($pagename)) ) {
            $dbh->query("DELETE FROM $version_tbl"
                        . " WHERE id=$id AND version=$version");
            $this->_update_recent_table($id);
            // This shouldn't be needed (as long as the latestversion
            // never gets deleted.)  But, let's be safe.
            $this->_update_nonempty_table($id);
        }
        $this->unlock(array('version'));
    }

    /**
     * Delete page from the database with backup possibility.
     * i.e save_page('') and DELETE nonempty id
     * 
     * deletePage increments latestversion in recent to a non-existent version, 
     * and removes the nonempty row,
     * so that get_latest_version returns id+1 and get_previous_version returns prev id 
     * and page->exists returns false.
     */
    function delete_page($pagename) {
        $dbh = &$this->_dbh;
        extract($this->_table_names);

        $this->beginTransaction();
        //$dbh->CommitLock($recent_tbl);
        if (($id = $this->_get_pageid($pagename, false)) === false) {
            $this->rollback( );
            return false;
        }
        $mtime = time();
        $user =& $GLOBALS['request']->_user;
        $meta = array('author' => $user->getId(),
                      'author_id' => $user->getAuthenticatedId(),
                      'mtime' => $mtime);
        $this->lock(array('version','recent','nonempty','page','link'));
        $version = $this->get_latest_version($pagename);
        if ($dbh->query("UPDATE $recent_tbl SET latestversion=latestversion+1,"
                        . "latestmajor=latestversion+1,latestminor=NULL WHERE id=$id")) 
        {
            $insert = $dbh->prepare("INSERT INTO $version_tbl"
                                    . " (id,version,mtime,minor_edit,content,versiondata)"
                                    . " VALUES(?,?,?,?,?,?)");
            $insert->bindParam(1, $id, PDO_PARAM_INT);
            $insert->bindParam(2, $version + 1, PDO_PARAM_INT);
            $insert->bindParam(3, $mtime, PDO_PARAM_INT);
            $insert->bindParam(4, 0, PDO_PARAM_INT);
            $insert->bindParam(5, '', PDO_PARAM_STR, 100);
            $insert->bindParam(6, $this->_serialize($meta), PDO_PARAM_STR, 100);
            if ($insert->execute()
                and $dbh->query("DELETE FROM $nonempty_tbl WHERE id=$id")
                and $this->set_links($pagename, false)) {
                    // need to keep perms and LOCKED, otherwise you can reset the perm 
                    // by action=remove and re-create it with default perms
                    // keep hits but delete meta-data 
                    //and $dbh->Execute("UPDATE $page_tbl SET pagedata='' WHERE id=$id") 
                $this->unlock(array('version','recent','nonempty','page','link'));
                $this->commit();
                return true;
            }
        } else {
            $this->unlock(array('version','recent','nonempty','page','link'));	
            $this->rollBack();
            return false;
        }
    }

    function purge_page($pagename) {
        $dbh = &$this->_dbh;
        extract($this->_table_names);
        
        $this->lock(array('version','recent','nonempty','page','link'));
        if ( ($id = $this->_get_pageid($pagename, false)) ) {
            $dbh->query("DELETE FROM $version_tbl  WHERE id=$id");
            $dbh->query("DELETE FROM $recent_tbl   WHERE id=$id");
            $dbh->query("DELETE FROM $nonempty_tbl WHERE id=$id");
            $this->set_links($pagename, false);
            $sth = $dbh->prepare("SELECT COUNT(*) FROM $link_tbl WHERE linkto=$id");
            $sth->execute();
            if ($sth->fetchSingle()) {
                // We're still in the link table (dangling link) so we can't delete this
                // altogether.
                $dbh->query("UPDATE $page_tbl SET hits=0, pagedata='' WHERE id=$id");
                $result = 0;
            }
            else {
                $dbh->query("DELETE FROM $page_tbl WHERE id=$id");
                $result = 1;
            }
        } else {
            $result = -1; // already purged or not existing
        }
        $this->unlock(array('version','recent','nonempty','page','link'));
        return $result;
    }


    // The only thing we might be interested in updating which we can
    // do fast in the flags (minor_edit).   I think the default
    // update_versiondata will work fine...
    //function update_versiondata($pagename, $version, $data) {
    //}

    function set_links($pagename, $links) {
        // Update link table.
        // FIXME: optimize: mysql can do this all in one big INSERT/REPLACE.

        $dbh = &$this->_dbh;
        extract($this->_table_names);

        $this->lock(array('link'));
        $pageid = $this->_get_pageid($pagename, true);

        if ($links) {
            $dbh->query("DELETE FROM $link_tbl WHERE linkfrom=$pageid");
            foreach ($links as $link) {
                if (isset($linkseen[$link]))
                    continue;
                $linkseen[$link] = true;
                $linkid = $this->_get_pageid($link, true);
                assert($linkid);
                $dbh->query("INSERT INTO $link_tbl (linkfrom, linkto)"
                            . " VALUES ($pageid, $linkid)");
            }
        } elseif (DEBUG) {
            // purge page table: delete all non-referenced pages
            // for all previously linked pages...
            $sth = $dbh->prepare("SELECT $link_tbl.linkto as id FROM $link_tbl".
                                 " WHERE linkfrom=$pageid");
            $sth->execute();
            foreach ($sth->fetchAll(PDO_FETCH_NUM) as $id) {
            	// ...check if the page is empty and has no version
                $sth1 = $dbh->prepare("SELECT $page_tbl.id FROM $page_tbl"
                                      . " LEFT JOIN $nonempty_tbl USING (id) "
                                      . " LEFT JOIN $version_tbl USING (id)"
                                      . " WHERE ISNULL($nonempty_tbl.id) AND"
                                      . " ISNULL($version_tbl.id) AND $page_tbl.id=$id");
                $sth1->execute();
                if ($sth1->fetchSingle()) {
                    $dbh->query("DELETE FROM $page_tbl WHERE id=$id");   // this purges the link
                    $dbh->query("DELETE FROM $recent_tbl WHERE id=$id"); // may fail
                }
            }
            $dbh->query("DELETE FROM $link_tbl WHERE linkfrom=$pageid");
        }
        $this->unlock(array('link'));
        return true;
    }
    
    /**
     * Find pages which link to or are linked from a page.
     *
     * Optimization: save request->_dbi->_iwpcache[] to avoid further iswikipage checks
     * (linkExistingWikiWord or linkUnknownWikiWord)
     * This is called on every page header GleanDescription, so we can store all the existing links.
     */
    function get_links($pagename, $reversed=true, $include_empty=false,
                       $sortby=false, $limit=false, $exclude='') {
        $dbh = &$this->_dbh;
        extract($this->_table_names);

        if ($reversed)
            list($have,$want) = array('linkee', 'linker');
        else
            list($have,$want) = array('linker', 'linkee');
        $orderby = $this->sortby($sortby, 'db', array('pagename'));
        if ($orderby) $orderby = ' ORDER BY $want.' . $orderby;
        if ($exclude) // array of pagenames
            $exclude = " AND $want.pagename NOT IN ".$this->_sql_set($exclude);
        else 
            $exclude='';
        if ($limit) {
            list($offset, $count) = $this->limit($limit);
            $limit = " LIMIT $offset, $count";
        } else 
            $limit = '';

        $sth = $dbh->prepare("SELECT $want.id AS id, $want.pagename AS pagename,"