some corrections in sqlite3 storage
[tiramisu.git] / tiramisu / storage / sqlite3 / storage.py
1 # -*- coding: utf-8 -*-
2 "default plugin for cache: set it in a simple dictionary"
3 # Copyright (C) 2013 Team tiramisu (see AUTHORS for all contributors)
4 #
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 2 of the License, or
8 # (at your option) any later version.
9 #
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with this program; if not, write to the Free Software
17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 #
19 # ____________________________________________________________
20
21 from pickle import dumps, loads
22 from os import unlink
23 import sqlite3
24
25
26 class Storage(object):
27     __slots__ = ('_conn', '_cursor', 'is_persistent', 'db_file')
28
29     def __init__(self, config_id, is_persistent):
30         self.is_persistent = is_persistent
31         self.db_file = config_id + '.db'
32         self._conn = sqlite3.connect(self.db_file)
33         self._conn.text_factory = str
34         self._cursor = self._conn.cursor()
35
36     def execute(self, sql, params=None, commit=True):
37         if params is None:
38             params = tuple()
39         self._cursor.execute(sql, params)
40         if commit:
41             self._conn.commit()
42
43     def select(self, sql, params=None, only_one=True):
44         self.execute(sql, params=params, commit=False)
45         if only_one:
46             return self._cursor.fetchone()
47         else:
48             return self._cursor.fetchall()
49
50     def __del__(self):
51         self._cursor.close()
52         self._conn.close()
53         if not self.is_persistent:
54             unlink(self.db_file)
55
56
57 class Cache(object):
58     __slots__ = ('storage',)
59     key_is_path = True
60
61     def __init__(self, cache_type, storage):
62         self.storage = storage
63         cache_table = 'CREATE TABLE IF NOT EXISTS cache_{0}(path '.format(
64             cache_type)
65         cache_table += 'text primary key, value text, time real)'
66         self.storage.execute(cache_table)
67
68     # value
69     def _sqlite_decode_path(self, path):
70         if path == '_none':
71             return None
72         else:
73             return path
74
75     def _sqlite_encode_path(self, path):
76         if path is None:
77             return '_none'
78         else:
79             return path
80
81     def _sqlite_decode(self, value):
82         return loads(value)
83
84     def _sqlite_encode(self, value):
85         if isinstance(value, list):
86             value = list(value)
87         return dumps(value)
88
89     def setcache(self, cache_type, path, val, time):
90         convert_value = self._sqlite_encode(val)
91         path = self._sqlite_encode_path(path)
92         self.storage.execute("DELETE FROM cache_{0} WHERE path = ?".format(
93             cache_type), (path,), False)
94         self.storage.execute("INSERT INTO cache_{0}(path, value, time) "
95                              "VALUES (?, ?, ?)".format(cache_type),
96                              (path, convert_value, time))
97
98     def getcache(self, cache_type, path, exp):
99         path = self._sqlite_encode_path(path)
100         cached = self.storage.select("SELECT value FROM cache_{0} WHERE "
101                                      "path = ? AND time >= ?".format(
102                                          cache_type), (path, exp))
103         if cached is None:
104             return False, None
105         else:
106             return True, self._sqlite_decode(cached[0])
107
108     def hascache(self, cache_type, path):
109         path = self._sqlite_encode_path(path)
110         return self.storage.select("SELECT value FROM cache_{0} WHERE "
111                                    "path = ?".format(cache_type),
112                                    (path,)) is not None
113
114     def reset_expired_cache(self, cache_type, exp):
115         self.storage.execute("DELETE FROM cache_{0} WHERE time < ?".format(
116             cache_type), (exp,))
117
118     def reset_all_cache(self, cache_type):
119         self.storage.execute("DELETE FROM cache_{0}".format(cache_type))
120
121     def get_cached(self, cache_type, context):
122         """return all values in a dictionary
123         example: {'path1': ('value1', 'time1'), 'path2': ('value2', 'time2')}
124         """
125         ret = {}
126         for path, value, time in self.storage.select("SELECT * FROM cache_{0}"
127                                                      "".format(cache_type),
128                                                      only_one=False):
129             path = self._sqlite_decode_path(path)
130             value = self._sqlite_decode(value)
131             ret[path] = (value, time)
132         return ret