Cache: normalize mimetypes

diff --git a/db_structure.xml b/db_structure.xml
index e47cf3c629214cfc6c665f9a5c93a779a47b8963..3022983473b8656d71376be85192c3272551ba6b 100644 (file)
--- a/db_structure.xml
+++ b/db_structure.xml
@@ -94,6 +94,42 @@
 
        </table>
 
+       <table>
+
+               <name>*dbprefix*mimetypes</name>
+
+               <declaration>
+
+                       <field>
+                               <name>id</name>
+                               <type>integer</type>
+                               <default>0</default>
+                               <notnull>true</notnull>
+                               <autoincrement>1</autoincrement>
+                               <length>4</length>
+                       </field>
+
+                       <field>
+                               <name>mimetype</name>
+                               <type>text</type>
+                               <default></default>
+                               <notnull>true</notnull>
+                               <length>64</length>
+                       </field>
+
+                       <index>
+                               <name>mimetype_id_index</name>
+                               <unique>true</unique>
+                               <field>
+                                       <name>mimetype</name>
+                                       <sorting>ascending</sorting>
+                               </field>
+                       </index>
+
+               </declaration>
+
+       </table>
+
        <table>
 
                <name>*dbprefix*filecache</name>
@@ -151,18 +187,18 @@
 
                        <field>
                                <name>mimetype</name>
-                               <type>text</type>
+                               <type>integer</type>
                                <default></default>
                                <notnull>true</notnull>
-                               <length>64</length>
+                               <length>4</length>
                        </field>
 
                        <field>
                                <name>mimepart</name>
-                               <type>text</type>
+                               <type>integer</type>
                                <default></default>
                                <notnull>true</notnull>
-                               <length>32</length>
+                               <length>4</length>
                        </field>
 
                        <field>

diff --git a/lib/files/cache/cache.php b/lib/files/cache/cache.php
index 3ebae9baa5d210b06206bccc39abc69937979088..0001c2752da1b848dbd1b3c7711529d8b45845a8 100644 (file)
--- a/lib/files/cache/cache.php
+++ b/lib/files/cache/cache.php
@@ -36,6 +36,9 @@ class Cache {
         */
        private $numericId;
 
+       private $mimetypeIds = array();
+       private $mimetypes = array();
+
        /**
         * @param \OC\Files\Storage\Storage|string $storage
         */
@@ -61,6 +64,41 @@ class Cache {
                return $this->numericId;
        }
 
+       /**
+        * normalize mimetypes
+        *
+        * @param string $mime
+        * @return int
+        */
+       public function getMimetypeId($mime) {
+               if (!isset($this->mimetypeIds[$mime])) {
+                       $query = \OC_DB::prepare('SELECT `id` FROM `*PREFIX*mimetypes` WHERE `mimetype` = ?');
+                       $result = $query->execute(array($mime));
+                       if ($row = $result->fetchRow()) {
+                               $this->mimetypeIds[$mime] = $row['id'];
+                       } else {
+                               $query = \OC_DB::prepare('INSERT INTO `*PREFIX*mimetypes`(`mimetype`) VALUES(?)');
+                               $query->execute(array($mime));
+                               $this->mimetypeIds[$mime] = \OC_DB::insertid('*PREFIX*mimetypes');
+                       }
+                       $this->mimetypes[$this->mimetypeIds[$mime]] = $mime;
+               }
+               return $this->mimetypeIds[$mime];
+       }
+
+       public function getMimetype($id) {
+               if (!isset($this->mimetypes[$id])) {
+                       $query = \OC_DB::prepare('SELECT `mimetype` FROM `*PREFIX*mimetypes` WHERE `id` = ?');
+                       $result = $query->execute(array($id));
+                       if ($row = $result->fetchRow()) {
+                               $this->mimetypes[$id] = $row['mimetype'];
+                       } else {
+                               return null;
+                       }
+               }
+               return $this->mimetypes[$id];
+       }
+
        /**
         * get the stored metadata of a file or folder
         *
@@ -92,6 +130,8 @@ class Cache {
                        $data['size'] = (int)$data['size'];
                        $data['mtime'] = (int)$data['mtime'];
                        $data['encrypted'] = (bool)$data['encrypted'];
+                       $data['mimetype'] = $this->getMimetype($data['mimetype']);
+                       $data['mimepart'] = $this->getMimetype($data['mimepart']);
                }
 
                return $data;
@@ -110,7 +150,12 @@ class Cache {
                                'SELECT `fileid`, `storage`, `path`, `parent`, `name`, `mimetype`, `mimepart`, `size`, `mtime`, `encrypted`
                                 FROM `*PREFIX*filecache` WHERE parent = ? ORDER BY `name` ASC');
                        $result = $query->execute(array($fileId));
-                       return $result->fetchAll();
+                       $files = $result->fetchAll();
+                       foreach ($files as &$file) {
+                               $file['mimetype'] = $this->getMimetype($file['mimetype']);
+                               $file['mimepart'] = $this->getMimetype($file['mimepart']);
+                       }
+                       return $files;
                } else {
                        return array();
                }
@@ -179,22 +224,23 @@ class Cache {
         * @param array $data
         * @return array
         */
-       static function buildParts(array $data) {
+       function buildParts(array $data) {
                $fields = array('path', 'parent', 'name', 'mimetype', 'size', 'mtime', 'encrypted');
 
                $params = array();
                $queryParts = array();
                foreach ($data as $name => $value) {
                        if (array_search($name, $fields) !== false) {
-                               $params[] = $value;
-                               $queryParts[] = '`' . $name . '`';
                                if ($name === 'path') {
                                        $params[] = md5($value);
                                        $queryParts[] = '`path_hash`';
                                } elseif ($name === 'mimetype') {
-                                       $params[] = substr($value, 0, strpos($value, '/'));
+                                       $params[] = $this->getMimetypeId(substr($value, 0, strpos($value, '/')));
                                        $queryParts[] = '`mimepart`';
+                                       $value = $this->getMimetypeId($value);
                                }
+                               $params[] = $value;
+                               $queryParts[] = '`' . $name . '`';
                        }
                }
                return array($queryParts, $params);
@@ -339,6 +385,8 @@ class Cache {
                $result = $query->execute(array($pattern, $this->numericId));
                $files = array();
                while ($row = $result->fetchRow()) {
+                       $row['mimetype'] = $this->getMimetype($row['mimetype']);
+                       $row['mimepart'] = $this->getMimetype($row['mimepart']);
                        $files[] = $row;
                }
                return $files;
@@ -360,6 +408,7 @@ class Cache {
                        SELECT `fileid`, `storage`, `path`, `parent`, `name`, `mimetype`, `mimepart`, `size`, `mtime`, `encrypted`
                        FROM `*PREFIX*filecache` WHERE ' . $where . ' AND `storage` = ?'
                );
+               $mimetype = $this->getMimetypeId($mimetype);
                $result = $query->execute(array($mimetype, $this->numericId));
                return $result->fetchAll();
        }

diff --git a/lib/files/view.php b/lib/files/view.php
index 124345f3c6f7cbbe72acbec5f576be95b274fbf1..8303a080bd8f66fee8fbf52f439c94a5b9095058 100644 (file)
--- a/lib/files/view.php
+++ b/lib/files/view.php
@@ -693,7 +693,7 @@ class View {
 
                        $data = $cache->get($internalPath);
 
-                       if ($data) {
+                       if ($data and $data['fileid']) {
                                if ($data['mimetype'] === 'httpd/unix-directory') {
                                        //add the sizes of other mountpoints to the folder
                                        $mountPoints = Filesystem::getMountPoints($path);

diff --git a/lib/util.php b/lib/util.php
index 805ef6f18b043b335b306ec53a1fc200edef1e08..93c0d0f26d887304d4484317b3e095a2adb06a04 100755 (executable)
--- a/lib/util.php
+++ b/lib/util.php
@@ -74,7 +74,7 @@ class OC_Util {
         */
        public static function getVersion() {
                // hint: We only can count up. So the internal version number of ownCloud 4.5 will be 4.90.0. This is not visible to the user
-               return array(4,91,04);
+               return array(4,91,05);
        }
 
        /**