Mercurial > hg > orthanc

comparison OrthancFramework/UnitTestsSources/SQLiteTests.cpp @ 4044:d25f4c0fa160 framework

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
splitting code into OrthancFramework and OrthancServer
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 10 Jun 2020 20:30:34 +0200
parents UnitTestsSources/SQLiteTests.cpp@27628b0f6ada
children 05b8fd21089c
comparison
equal deleted inserted replaced
4043:6c6239aec462 4044:d25f4c0fa160
1 /**
2 * Orthanc - A Lightweight, RESTful DICOM Store
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
4 * Department, University Hospital of Liege, Belgium
5 * Copyright (C) 2017-2020 Osimis S.A., Belgium
6 *
7 * This program is free software: you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License as
9 * published by the Free Software Foundation, either version 3 of the
10 * License, or (at your option) any later version.
11 *
12 * In addition, as a special exception, the copyright holders of this
13 * program give permission to link the code of its release with the
14 * OpenSSL project's "OpenSSL" library (or with modified versions of it
15 * that use the same license as the "OpenSSL" library), and distribute
16 * the linked executables. You must obey the GNU General Public License
17 * in all respects for all of the code used other than "OpenSSL". If you
18 * modify file(s) with this exception, you may extend this exception to
19 * your version of the file(s), but you are not obligated to do so. If
20 * you do not wish to do so, delete this exception statement from your
21 * version. If you delete this exception statement from all source files
22 * in the program, then also delete it here.
23 *
24 * This program is distributed in the hope that it will be useful, but
25 * WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
27 * General Public License for more details.
28 *
29 * You should have received a copy of the GNU General Public License
30 * along with this program. If not, see <http://www.gnu.org/licenses/>.
31 **/
32
33
34 #if ORTHANC_UNIT_TESTS_LINK_FRAMEWORK == 1
35 # include <OrthancFramework.h>
36 #endif
37
38 #include "PrecompiledHeadersUnitTests.h"
39 #include "gtest/gtest.h"
40
41 #include "../Core/SystemToolbox.h"
42 #include "../Core/SQLite/Connection.h"
43 #include "../Core/SQLite/Statement.h"
44 #include "../Core/SQLite/Transaction.h"
45
46 #include <sqlite3.h>
47
48 using namespace Orthanc;
49
50
51 TEST(SQLite, Configuration)
52 {
53 /**
54 * The system-wide version of SQLite under OS X uses
55 * SQLITE_THREADSAFE==2 (SQLITE_CONFIG_SERIALIZED), whereas the
56 * static builds of Orthanc use SQLITE_THREADSAFE==1
57 * (SQLITE_CONFIG_MULTITHREAD). In any case, we wish to ensure that
58 * SQLITE_THREADSAFE!=0 (SQLITE_CONFIG_SINGLETHREAD).
59 **/
60 ASSERT_NE(0, sqlite3_threadsafe());
61 }
62
63
64 TEST(SQLite, Connection)
65 {
66 SystemToolbox::RemoveFile("UnitTestsResults/coucou");
67 SQLite::Connection c;
68 c.Open("UnitTestsResults/coucou");
69 c.Execute("CREATE TABLE c(k INTEGER PRIMARY KEY AUTOINCREMENT, v INTEGER)");
70 c.Execute("INSERT INTO c VALUES(NULL, 42);");
71 }
72
73
74 TEST(SQLite, StatementReferenceBasic)
75 {
76 sqlite3* db;
77 sqlite3_open(":memory:", &db);
78
79 {
80 SQLite::StatementReference r(db, "SELECT * FROM sqlite_master");
81 ASSERT_EQ(0u, r.GetReferenceCount());
82
83 {
84 SQLite::StatementReference r1(r);
85 ASSERT_EQ(1u, r.GetReferenceCount());
86 ASSERT_EQ(0u, r1.GetReferenceCount());
87
88 {
89 SQLite::StatementReference r2(r);
90 ASSERT_EQ(2u, r.GetReferenceCount());
91 ASSERT_EQ(0u, r1.GetReferenceCount());
92 ASSERT_EQ(0u, r2.GetReferenceCount());
93
94 SQLite::StatementReference r3(r2);
95 ASSERT_EQ(3u, r.GetReferenceCount());
96 ASSERT_EQ(0u, r1.GetReferenceCount());
97 ASSERT_EQ(0u, r2.GetReferenceCount());
98 ASSERT_EQ(0u, r3.GetReferenceCount());
99 }
100
101 ASSERT_EQ(1u, r.GetReferenceCount());
102 ASSERT_EQ(0u, r1.GetReferenceCount());
103
104 {
105 SQLite::StatementReference r2(r);
106 ASSERT_EQ(2u, r.GetReferenceCount());
107 ASSERT_EQ(0u, r1.GetReferenceCount());
108 ASSERT_EQ(0u, r2.GetReferenceCount());
109 }
110
111 ASSERT_EQ(1u, r.GetReferenceCount());
112 ASSERT_EQ(0u, r1.GetReferenceCount());
113 }
114
115 ASSERT_EQ(0u, r.GetReferenceCount());
116 }
117
118 sqlite3_close(db);
119 }
120
121 TEST(SQLite, StatementBasic)
122 {
123 SQLite::Connection c;
124 c.OpenInMemory();
125
126 SQLite::Statement s(c, "SELECT * from sqlite_master");
127 s.Run();
128
129 for (unsigned int i = 0; i < 5; i++)
130 {
131 SQLite::Statement cs(c, SQLITE_FROM_HERE, "SELECT * from sqlite_master");
132 cs.Step();
133 }
134 }
135
136
137 namespace
138 {
139 static bool destroyed;
140
141 class MyFunc : public SQLite::IScalarFunction
142 {
143 public:
144 MyFunc()
145 {
146 destroyed = false;
147 }
148
149 virtual ~MyFunc() ORTHANC_OVERRIDE
150 {
151 destroyed = true;
152 }
153
154 virtual const char* GetName() const ORTHANC_OVERRIDE
155 {
156 return "MYFUNC";
157 }
158
159 virtual unsigned int GetCardinality() const ORTHANC_OVERRIDE
160 {
161 return 2;
162 }
163
164 virtual void Compute(SQLite::FunctionContext& context) ORTHANC_OVERRIDE
165 {
166 context.SetIntResult(1000 + context.GetIntValue(0) * context.GetIntValue(1));
167 }
168 };
169
170 class MyDelete : public SQLite::IScalarFunction
171 {
172 public:
173 std::set<int> deleted_;
174
175 virtual const char* GetName() const ORTHANC_OVERRIDE
176 {
177 return "MYDELETE";
178 }
179
180 virtual unsigned int GetCardinality() const ORTHANC_OVERRIDE
181 {
182 return 1;
183 }
184
185 virtual void Compute(SQLite::FunctionContext& context) ORTHANC_OVERRIDE
186 {
187 deleted_.insert(context.GetIntValue(0));
188 context.SetNullResult();
189 }
190 };
191 }
192
193 TEST(SQLite, ScalarFunction)
194 {
195 {
196 SQLite::Connection c;
197 c.OpenInMemory();
198 c.Register(new MyFunc());
199 c.Execute("CREATE TABLE t(id INTEGER PRIMARY KEY, v1 INTEGER, v2 INTEGER);");
200 c.Execute("INSERT INTO t VALUES(NULL, 2, 3);");
201 c.Execute("INSERT INTO t VALUES(NULL, 4, 4);");
202 c.Execute("INSERT INTO t VALUES(NULL, 6, 5);");
203 SQLite::Statement t(c, "SELECT MYFUNC(v1, v2), v1, v2 FROM t");
204 int i = 0;
205 while (t.Step())
206 {
207 ASSERT_EQ(t.ColumnInt(0), 1000 + t.ColumnInt(1) * t.ColumnInt(2));
208 i++;
209 }
210 ASSERT_EQ(3, i);
211 ASSERT_FALSE(destroyed);
212 }
213 ASSERT_TRUE(destroyed);
214 }
215
216 TEST(SQLite, CascadedDeleteCallback)
217 {
218 SQLite::Connection c;
219 c.OpenInMemory();
220 MyDelete *func = new MyDelete();
221 c.Register(func);
222 c.Execute("CREATE TABLE parent(id INTEGER PRIMARY KEY, dummy INTEGER);");
223 c.Execute("CREATE TABLE child("
224 " id INTEGER PRIMARY KEY, "
225 " parent INTEGER REFERENCES parent(id) ON DELETE CASCADE, "
226 " value INTEGER);");
227 c.Execute("CREATE TRIGGER childRemoved "
228 "AFTER DELETE ON child "
229 "FOR EACH ROW BEGIN "
230 " SELECT MYDELETE(old.value); "
231 "END;");
232
233 c.Execute("INSERT INTO parent VALUES(42, 100);");
234 c.Execute("INSERT INTO parent VALUES(43, 101);");
235
236 c.Execute("INSERT INTO child VALUES(NULL, 42, 4200);");
237 c.Execute("INSERT INTO child VALUES(NULL, 42, 4201);");
238
239 c.Execute("INSERT INTO child VALUES(NULL, 43, 4300);");
240 c.Execute("INSERT INTO child VALUES(NULL, 43, 4301);");
241
242 // The following command deletes "parent(43, 101)", then in turns
243 // "child(NULL, 43, 4300/4301)", then calls the MyDelete on 4300 and
244 // 4301
245 c.Execute("DELETE FROM parent WHERE dummy=101");
246
247 ASSERT_EQ(2u, func->deleted_.size());
248 ASSERT_TRUE(func->deleted_.find(4300) != func->deleted_.end());
249 ASSERT_TRUE(func->deleted_.find(4301) != func->deleted_.end());
250 }
251
252
253 TEST(SQLite, EmptyTransactions)
254 {
255 try
256 {
257 SQLite::Connection c;
258 c.OpenInMemory();
259
260 c.Execute("CREATE TABLE a(id INTEGER PRIMARY KEY);");
261 c.Execute("INSERT INTO a VALUES(NULL)");
262
263 {
264 SQLite::Transaction t(c);
265 t.Begin();
266 {
267 SQLite::Statement s(c, SQLITE_FROM_HERE, "SELECT * FROM a");
268 s.Step();
269 }
270 //t.Commit();
271 }
272
273 {
274 SQLite::Statement s(c, SQLITE_FROM_HERE, "SELECT * FROM a");
275 s.Step();
276 }
277 }
278 catch (OrthancException& e)
279 {
280 fprintf(stderr, "Exception: [%s]\n", e.What());
281 throw e;
282 }
283 }
284
285
286 TEST(SQLite, Types)
287 {
288 SQLite::Connection c;
289 c.OpenInMemory();
290 c.Execute("CREATE TABLE a(id INTEGER PRIMARY KEY, value)");
291
292 {
293 SQLite::Statement s(c, std::string("SELECT * FROM a"));
294 ASSERT_EQ(2, s.ColumnCount());
295 ASSERT_FALSE(s.Step());
296 }
297
298 {
299 SQLite::Statement s(c, SQLITE_FROM_HERE, std::string("SELECT * FROM a"));
300 ASSERT_FALSE(s.Step());
301 ASSERT_EQ("SELECT * FROM a", s.GetOriginalSQLStatement());
302 }
303
304 {
305 SQLite::Statement s(c, SQLITE_FROM_HERE, "INSERT INTO a VALUES(NULL, ?);");
306 s.BindNull(0); ASSERT_TRUE(s.Run()); s.Reset();
307 s.BindBool(0, true); ASSERT_TRUE(s.Run()); s.Reset();
308 s.BindInt(0, 42); ASSERT_TRUE(s.Run()); s.Reset();
309 s.BindInt64(0, 42ll); ASSERT_TRUE(s.Run()); s.Reset();
310 s.BindDouble(0, 42.5); ASSERT_TRUE(s.Run()); s.Reset();
311 s.BindCString(0, "Hello"); ASSERT_TRUE(s.Run()); s.Reset();
312 s.BindBlob(0, "Hello", 5); ASSERT_TRUE(s.Run()); s.Reset();
313 }
314
315 {
316 SQLite::Statement s(c, SQLITE_FROM_HERE, std::string("SELECT * FROM a"));
317 ASSERT_TRUE(s.Step());
318 ASSERT_EQ(SQLite::COLUMN_TYPE_NULL, s.GetColumnType(1));
319 ASSERT_TRUE(s.ColumnIsNull(1));
320 ASSERT_TRUE(s.Step());
321 ASSERT_EQ(SQLite::COLUMN_TYPE_INTEGER, s.GetColumnType(1));
322 ASSERT_TRUE(s.ColumnBool(1));
323 ASSERT_TRUE(s.Step());
324 ASSERT_EQ(SQLite::COLUMN_TYPE_INTEGER, s.GetColumnType(1));
325 ASSERT_EQ(42, s.ColumnInt(1));
326 ASSERT_TRUE(s.Step());
327 ASSERT_EQ(SQLite::COLUMN_TYPE_INTEGER, s.GetColumnType(1));
328 ASSERT_EQ(42ll, s.ColumnInt64(1));
329 ASSERT_TRUE(s.Step());
330 ASSERT_EQ(SQLite::COLUMN_TYPE_FLOAT, s.GetColumnType(1));
331 ASSERT_DOUBLE_EQ(42.5, s.ColumnDouble(1));
332 ASSERT_TRUE(s.Step());
333 ASSERT_EQ(SQLite::COLUMN_TYPE_TEXT, s.GetColumnType(1));
334 ASSERT_EQ("Hello", s.ColumnString(1));
335 ASSERT_TRUE(s.Step());
336 ASSERT_EQ(SQLite::COLUMN_TYPE_BLOB, s.GetColumnType(1));
337 ASSERT_EQ(5, s.ColumnByteLength(1));
338 ASSERT_TRUE(!memcmp("Hello", s.ColumnBlob(1), 5));
339
340 std::string t;
341 ASSERT_TRUE(s.ColumnBlobAsString(1, &t));
342 ASSERT_EQ("Hello", t);
343
344 ASSERT_FALSE(s.Step());
345 }
346 }