add persistent option for db
[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(self, value):
70         return loads(value)
71
72     def _sqlite_encode(self, value):
73         if isinstance(value, list):
74             value = list(value)
75         return dumps(value)
76
77     def setcache(self, cache_type, path, val, time):
78         convert_value = self._sqlite_encode(val)
79         self.storage.execute("DELETE FROM cache_{0} WHERE path = ?".format(
80             cache_type), (path,), False)
81         self.storage.execute("INSERT INTO cache_{0}(path, value, time) "
82                              "VALUES (?, ?, ?)".format(cache_type),
83                              (path, convert_value, time))
84
85     def getcache(self, cache_type, path, exp):
86         cached = self.storage.select("SELECT value FROM cache_{0} WHERE "
87                                      "path = ? AND time >= ?".format(
88                                          cache_type), (path, exp))
89         if cached is None:
90             return False, None
91         else:
92             return True, self._sqlite_decode(cached[0])
93
94     def hascache(self, cache_type, path):
95         return self.storage.select("SELECT value FROM cache_{0} WHERE "
96                                    "path = ?".format(cache_type),
97                                    (path,)) is not None
98
99     def reset_expired_cache(self, cache_type, exp):
100         self.storage.execute("DELETE FROM cache_{0} WHERE time < ?".format(
101             cache_type), (exp,))
102
103     def reset_all_cache(self, cache_type):
104         self.storage.execute("DELETE FROM cache_{0}".format(cache_type))
105
106     def get_cached(self, cache_type, context):
107         """return all values in a dictionary
108         example: {option1: ('value1', 'time1'), option2: ('value2', 'time2')}
109         """
110         ret = {}
111         for path, value, time in self.storage.select("SELECT * FROM cache_{0}"
112                                                      "".format(cache_type),
113                                                      only_one=False):
114             opt = context.cfgimpl_get_description().impl_get_opt_by_path(path)
115             value = self._sqlite_decode(value)
116             ret[opt] = (value, time)
117         return ret