Debian Codegraph @

third_party/qdjango/tests/db/qdjangometamodel/tst_qdjangometamodel.cpp

raw
1 /*
2 * Copyright (C) 2010-2015 Jeremy Lainé
3 * Contact: https://github.com/jlaine/qdjango
4 *
5 * This file is part of the QDjango Library.
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 */
17
18 #include "QDjango.h"
19 #include "QDjango_p.h"
20 #include "QDjangoModel.h"
21 #include "QDjangoQuerySet.h"
22 #include "QDjangoWhere.h"
23
24 #include "tst_qdjangometamodel.h"
25 #include "util.h"
26
27 #define Q QDjangoWhere
28
29 template<class T>
30 void init(const QStringList &sql)
31 {
32 const QDjangoMetaModel metaModel = QDjango::registerModel<T>();
33 QCOMPARE(metaModel.createTableSql(), sql);
34 QCOMPARE(metaModel.createTable(), true);
35 }
36
37 template<class T, class K>
38 void setAndGet(const K &value)
39 {
40 // save object
41 T v1;
42 v1.setValue(value);
43 QCOMPARE(v1.save(), true);
44 QVERIFY(!v1.pk().isNull());
45
46 // save again
47 QCOMPARE(v1.save(), true);
48
49 // get object
50 T v2;
51 QVERIFY(QDjangoQuerySet<T>().get(Q(QLatin1String("pk"), Q::Equals, v1.pk()), &v2) != 0);
52 QCOMPARE(v2.value(), value);
53 }
54
55 template<class T>
56 void cleanup()
57 {
58 const QDjangoMetaModel metaModel = QDjango::registerModel<T>();
59 QCOMPARE(metaModel.dropTable(), true);
60 }
61
62 tst_FkConstraint::tst_FkConstraint(QObject *parent)
63 : QDjangoModel(parent)
64 {
65 setForeignKey("noConstraint", new User(this));
66 setForeignKey("cascadeConstraint", new User(this));
67 setForeignKey("nullConstraint", new Group(this));
68 }
69
70 User *tst_FkConstraint::noConstraint() const
71 {
72 return qobject_cast<User*>(foreignKey("noConstraint"));
73 }
74
75 void tst_FkConstraint::setNoConstraint(User *user)
76 {
77 setForeignKey("noConstraint", user);
78 }
79
80 User *tst_FkConstraint::cascadeConstraint() const
81 {
82 return qobject_cast<User*>(foreignKey("cascadeConstraint"));
83 }
84
85 void tst_FkConstraint::setCascadeConstraint(User *user)
86 {
87 setForeignKey("cascadeConstraint", user);
88 }
89
90 Group *tst_FkConstraint::nullConstraint() const
91 {
92 return qobject_cast<Group*>(foreignKey("nullConstraint"));
93 }
94
95 void tst_FkConstraint::setNullConstraint(Group *group)
96 {
97 setForeignKey("nullConstraint", group);
98 }
99
100 tst_FkConstraintWithRestrict::tst_FkConstraintWithRestrict(QObject *parent)
101 : tst_FkConstraint(parent)
102 {
103 setForeignKey("restrictConstraint", new User(this));
104 }
105
106 User *tst_FkConstraintWithRestrict::restrictConstraint() const
107 {
108 return qobject_cast<User*>(foreignKey("restrictConstraint"));
109 }
110
111 void tst_FkConstraintWithRestrict::setRestrictConstraint(User *user)
112 {
113 setForeignKey("restrictConstraint", user);
114 }
115
116 void tst_QDjangoMetaModel::initTestCase()
117 {
118 QVERIFY(initialiseDatabase());
119 }
120
121 void tst_QDjangoMetaModel::testBool()
122 {
123 QStringList sql;
124 QDjangoDatabase::DatabaseType databaseType = QDjangoDatabase::databaseType(QDjango::database());
125 if (databaseType == QDjangoDatabase::PostgreSQL)
126 sql << QLatin1String("CREATE TABLE \"tst_bool\" (\"id\" serial PRIMARY KEY, \"value\" boolean NOT NULL)");
127 else if (databaseType == QDjangoDatabase::MySqlServer)
128 sql << QLatin1String("CREATE TABLE `tst_bool` (`id` integer NOT NULL PRIMARY KEY AUTO_INCREMENT, `value` bool NOT NULL)");
129 else if (databaseType == QDjangoDatabase::MSSqlServer)
130 sql << QLatin1String("CREATE TABLE \"tst_bool\" (\"id\" int NOT NULL PRIMARY KEY IDENTITY(1,1), \"value\" bit NOT NULL)");
131 else
132 sql << QLatin1String("CREATE TABLE \"tst_bool\" (\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, \"value\" bool NOT NULL)");
133
134 init<tst_Bool>(sql);
135 setAndGet<tst_Bool>(true);
136 setAndGet<tst_Bool>(false);
137 cleanup<tst_Bool>();
138 }
139
140 void tst_QDjangoMetaModel::testByteArray()
141 {
142 QStringList sql;
143 QDjangoDatabase::DatabaseType databaseType = QDjangoDatabase::databaseType(QDjango::database());
144 if (databaseType == QDjangoDatabase::PostgreSQL)
145 sql << QLatin1String("CREATE TABLE \"tst_bytearray\" (\"id\" serial PRIMARY KEY, \"value\" bytea NOT NULL)");
146 else if (databaseType == QDjangoDatabase::MySqlServer)
147 sql << QLatin1String("CREATE TABLE `tst_bytearray` (`id` integer NOT NULL PRIMARY KEY AUTO_INCREMENT, `value` blob NOT NULL)");
148 else if (databaseType == QDjangoDatabase::MSSqlServer)
149 sql << QLatin1String("CREATE TABLE \"tst_bytearray\" (\"id\" int NOT NULL PRIMARY KEY IDENTITY(1,1), \"value\" varbinary(max) NOT NULL)");
150 else
151 sql << QLatin1String("CREATE TABLE \"tst_bytearray\" (\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, \"value\" blob NOT NULL)");
152
153 init<tst_ByteArray>(sql);
154 setAndGet<tst_ByteArray>(QByteArray("01234567", 8));
155 setAndGet<tst_ByteArray>(QByteArray("\x00\x01\x02\x03\x04\x05\x06\x07", 8));
156 cleanup<tst_ByteArray>();
157 }
158
159 void tst_QDjangoMetaModel::testDate()
160 {
161 QStringList sql;
162 QDjangoDatabase::DatabaseType databaseType = QDjangoDatabase::databaseType(QDjango::database());
163 if (databaseType == QDjangoDatabase::PostgreSQL)
164 sql << QLatin1String("CREATE TABLE \"tst_date\" (\"id\" serial PRIMARY KEY, \"value\" date NOT NULL)");
165 else if (databaseType == QDjangoDatabase::MySqlServer)
166 sql << QLatin1String("CREATE TABLE `tst_date` (`id` integer NOT NULL PRIMARY KEY AUTO_INCREMENT, `value` date NOT NULL)");
167 else if (databaseType == QDjangoDatabase::MSSqlServer)
168 sql << QLatin1String("CREATE TABLE \"tst_date\" (\"id\" int NOT NULL PRIMARY KEY IDENTITY(1,1), \"value\" date NOT NULL)");
169 else
170 sql << QLatin1String("CREATE TABLE \"tst_date\" (\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, \"value\" date NOT NULL)");
171
172 init<tst_Date>(sql);
173 setAndGet<tst_Date>(QDate(2012, 1, 8));
174 cleanup<tst_Date>();
175 }
176
177 void tst_QDjangoMetaModel::testDateTime()
178 {
179 QStringList sql;
180 QDjangoDatabase::DatabaseType databaseType = QDjangoDatabase::databaseType(QDjango::database());
181 if (databaseType == QDjangoDatabase::PostgreSQL)
182 sql << QLatin1String("CREATE TABLE \"tst_datetime\" (\"id\" serial PRIMARY KEY, \"value\" timestamp NOT NULL)");
183 else if (databaseType == QDjangoDatabase::MySqlServer)
184 sql << QLatin1String("CREATE TABLE `tst_datetime` (`id` integer NOT NULL PRIMARY KEY AUTO_INCREMENT, `value` datetime NOT NULL)");
185 else if (databaseType == QDjangoDatabase::MSSqlServer)
186 sql << QLatin1String("CREATE TABLE \"tst_datetime\" (\"id\" int NOT NULL PRIMARY KEY IDENTITY(1,1), \"value\" datetime NOT NULL)");
187 else
188 sql << QLatin1String("CREATE TABLE \"tst_datetime\" (\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, \"value\" datetime NOT NULL)");
189
190 init<tst_DateTime>(sql);
191 setAndGet<tst_DateTime>(QDateTime(QDate(2012, 1, 8), QTime(3, 4, 5)));
192 cleanup<tst_DateTime>();
193 }
194
195 void tst_QDjangoMetaModel::testDouble()
196 {
197 QStringList sql;
198 QDjangoDatabase::DatabaseType databaseType = QDjangoDatabase::databaseType(QDjango::database());
199 if (databaseType == QDjangoDatabase::PostgreSQL)
200 sql << QLatin1String("CREATE TABLE \"tst_double\" (\"id\" serial PRIMARY KEY, \"value\" real NOT NULL)");
201 else if (databaseType == QDjangoDatabase::MySqlServer)
202 sql << QLatin1String("CREATE TABLE `tst_double` (`id` integer NOT NULL PRIMARY KEY AUTO_INCREMENT, `value` real NOT NULL)");
203 else if (databaseType == QDjangoDatabase::MSSqlServer)
204 sql << QLatin1String("CREATE TABLE \"tst_double\" (\"id\" int NOT NULL PRIMARY KEY IDENTITY(1,1), \"value\" real NOT NULL)");
205 else
206 sql << QLatin1String("CREATE TABLE \"tst_double\" (\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, \"value\" real NOT NULL)");
207
208 init<tst_Double>(sql);
209
210 if (databaseType == QDjangoDatabase::MSSqlServer) {
211 double value = 3.14159;
212 // save object
213 tst_Double v1;
214 v1.setValue(value);
215 QCOMPARE(v1.save(), true);
216 QVERIFY(!v1.pk().isNull());
217
218 // save again
219 QCOMPARE(v1.save(), true);
220
221 // get object
222 tst_Double v2;
223 QVERIFY(QDjangoQuerySet<tst_Double>().get(Q(QLatin1String("pk"), Q::Equals, v1.pk()), &v2) != 0);
224
225 double p1 = v2.value();
226 double p2 = value;
227 QVERIFY(qAbs(p1 - p2) * 10000000. <= qMin(qAbs(p1), qAbs(p2)));
228 } else {
229 setAndGet<tst_Double>(double(3.14159));
230 }
231
232 cleanup<tst_Double>();
233 }
234
235 void tst_QDjangoMetaModel::testInteger()
236 {
237 QStringList sql;
238 QDjangoDatabase::DatabaseType databaseType = QDjangoDatabase::databaseType(QDjango::database());
239 if (databaseType == QDjangoDatabase::PostgreSQL)
240 sql << QLatin1String("CREATE TABLE \"tst_integer\" (\"id\" serial PRIMARY KEY, \"value\" integer NOT NULL)");
241 else if (databaseType == QDjangoDatabase::MySqlServer)
242 sql << QLatin1String("CREATE TABLE `tst_integer` (`id` integer NOT NULL PRIMARY KEY AUTO_INCREMENT, `value` integer NOT NULL)");
243 else if (databaseType == QDjangoDatabase::MSSqlServer)
244 sql << QLatin1String("CREATE TABLE \"tst_integer\" (\"id\" int NOT NULL PRIMARY KEY IDENTITY(1,1), \"value\" int NOT NULL)");
245 else
246 sql << QLatin1String("CREATE TABLE \"tst_integer\" (\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, \"value\" integer NOT NULL)");
247
248 init<tst_Integer>(sql);
249 setAndGet<tst_Integer>(0);
250 setAndGet<tst_Integer>(-2147483647);
251 setAndGet<tst_Integer>(2147483647);
252 cleanup<tst_Integer>();
253 }
254
255 void tst_QDjangoMetaModel::testLongLong()
256 {
257 QStringList sql;
258 QDjangoDatabase::DatabaseType databaseType = QDjangoDatabase::databaseType(QDjango::database());
259 if (databaseType == QDjangoDatabase::PostgreSQL)
260 sql << QLatin1String("CREATE TABLE \"tst_longlong\" (\"id\" serial PRIMARY KEY, \"value\" bigint NOT NULL)");
261 else if (databaseType == QDjangoDatabase::MySqlServer)
262 sql << QLatin1String("CREATE TABLE `tst_longlong` (`id` integer NOT NULL PRIMARY KEY AUTO_INCREMENT, `value` bigint NOT NULL)");
263 else if (databaseType == QDjangoDatabase::MSSqlServer)
264 sql << QLatin1String("CREATE TABLE \"tst_longlong\" (\"id\" int NOT NULL PRIMARY KEY IDENTITY(1,1), \"value\" bigint NOT NULL)");
265 else
266 sql << QLatin1String("CREATE TABLE \"tst_longlong\" (\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, \"value\" bigint NOT NULL)");
267
268 init<tst_LongLong>(sql);
269 setAndGet<tst_LongLong>(qlonglong(0));
270 setAndGet<tst_LongLong>(qlonglong(-9223372036854775807ll));
271 setAndGet<tst_LongLong>(qlonglong(9223372036854775807ll));
272 cleanup<tst_LongLong>();
273 }
274
275 void tst_QDjangoMetaModel::testString()
276 {
277 QStringList sql;
278 QDjangoDatabase::DatabaseType databaseType = QDjangoDatabase::databaseType(QDjango::database());
279 if (databaseType == QDjangoDatabase::PostgreSQL)
280 sql << QLatin1String("CREATE TABLE \"tst_string\" (\"id\" serial PRIMARY KEY, \"value\" varchar(255) NOT NULL)");
281 else if (databaseType == QDjangoDatabase::MySqlServer)
282 sql << QLatin1String("CREATE TABLE `tst_string` (`id` integer NOT NULL PRIMARY KEY AUTO_INCREMENT, `value` varchar(255) NOT NULL)");
283 else if (databaseType == QDjangoDatabase::MSSqlServer)
284 sql << QLatin1String("CREATE TABLE \"tst_string\" (\"id\" int NOT NULL PRIMARY KEY IDENTITY(1,1), \"value\" nvarchar(255) NOT NULL)");
285 else
286 sql << QLatin1String("CREATE TABLE \"tst_string\" (\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, \"value\" varchar(255) NOT NULL)");
287
288 init<tst_String>(sql);
289 setAndGet<tst_String>(QLatin1String("foo bar"));
290 cleanup<tst_String>();
291 }
292
293 void tst_QDjangoMetaModel::testTime()
294 {
295 QStringList sql;
296 QDjangoDatabase::DatabaseType databaseType = QDjangoDatabase::databaseType(QDjango::database());
297
298 if (databaseType == QDjangoDatabase::MSSqlServer)
299 #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
300 QSKIP("Currently broken in QODBC driver");
301 #else
302 QSKIP("Currently broken in QODBC driver", SkipAll);
303 #endif
304
305 if (databaseType == QDjangoDatabase::PostgreSQL)
306 sql << QLatin1String("CREATE TABLE \"tst_time\" (\"id\" serial PRIMARY KEY, \"value\" time NOT NULL)");
307 else if (databaseType == QDjangoDatabase::MySqlServer)
308 sql << QLatin1String("CREATE TABLE `tst_time` (`id` integer NOT NULL PRIMARY KEY AUTO_INCREMENT, `value` time NOT NULL)");
309 else if (databaseType == QDjangoDatabase::MSSqlServer)
310 sql << QLatin1String("CREATE TABLE \"tst_time\" (\"id\" int NOT NULL PRIMARY KEY IDENTITY(1,1), \"value\" time NOT NULL)");
311 else
312 sql << QLatin1String("CREATE TABLE \"tst_time\" (\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, \"value\" time NOT NULL)");
313
314 init<tst_Time>(sql);
315 setAndGet<tst_Time>(QTime(3, 4, 5));
316 cleanup<tst_Time>();
317 }
318
319 void tst_QDjangoMetaModel::testOptions()
320 {
321 QStringList sql;
322 QDjangoDatabase::DatabaseType databaseType = QDjangoDatabase::databaseType(QDjango::database());
323 if (databaseType == QDjangoDatabase::PostgreSQL) {
324 sql << QLatin1String(
325 "CREATE TABLE \"some_table\" ("
326 "\"id\" serial PRIMARY KEY, "
327 "\"aField\" integer NOT NULL, "
328 "\"b_field\" integer NOT NULL, "
329 "\"blankField\" integer NOT NULL, "
330 "\"indexField\" integer NOT NULL, "
331 "\"nullField\" integer, "
332 "\"uniqueField\" integer NOT NULL UNIQUE, "
333 "UNIQUE (\"aField\", \"b_field\")"
334 ")");
335 sql << QLatin1String("CREATE INDEX \"some_table_ac243651\" ON \"some_table\" (\"indexField\")");
336 } else if (databaseType == QDjangoDatabase::MySqlServer) {
337 sql << QLatin1String(
338 "CREATE TABLE `some_table` ("
339 "`id` integer NOT NULL PRIMARY KEY AUTO_INCREMENT, "
340 "`aField` integer NOT NULL, "
341 "`b_field` integer NOT NULL, "
342 "`blankField` integer NOT NULL, "
343 "`indexField` integer NOT NULL, "
344 "`nullField` integer, "
345 "`uniqueField` integer NOT NULL UNIQUE, "
346 "UNIQUE (`aField`, `b_field`)"
347 ")");
348 sql << QLatin1String("CREATE INDEX `some_table_ac243651` ON `some_table` (`indexField`)");
349 } else if (databaseType == QDjangoDatabase::MSSqlServer) {
350 sql << QLatin1String(
351 "CREATE TABLE \"some_table\" ("
352 "\"id\" int NOT NULL PRIMARY KEY IDENTITY(1,1), "
353 "\"aField\" int NOT NULL, "
354 "\"b_field\" int NOT NULL, "
355 "\"blankField\" int NOT NULL, "
356 "\"indexField\" int NOT NULL, "
357 "\"nullField\" int, "
358 "\"uniqueField\" int NOT NULL UNIQUE, "
359 "UNIQUE (\"aField\", \"b_field\")"
360 ")");
361 sql << QLatin1String("CREATE INDEX \"some_table_ac243651\" ON \"some_table\" (\"indexField\")");
362 } else {
363 sql << QLatin1String(
364 "CREATE TABLE \"some_table\" ("
365 "\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "
366 "\"aField\" integer NOT NULL, "
367 "\"b_field\" integer NOT NULL, "
368 "\"blankField\" integer NOT NULL, "
369 "\"indexField\" integer NOT NULL, "
370 "\"nullField\" integer, "
371 "\"uniqueField\" integer NOT NULL UNIQUE, "
372 "UNIQUE (\"aField\", \"b_field\")"
373 ")");
374 sql << QLatin1String("CREATE INDEX \"some_table_ac243651\" ON \"some_table\" (\"indexField\")");
375 }
376
377 init<tst_Options>(sql);
378
379 QDjangoMetaField metaField;
380 const QDjangoMetaModel metaModel = QDjango::registerModel<tst_Options>();
381
382 metaField = metaModel.localField("aField");
383 QCOMPARE(metaField.isAutoIncrement(), false);
384 QCOMPARE(metaField.isBlank(), false);
385 QCOMPARE(metaField.isNullable(), false);
386 QCOMPARE(metaField.isUnique(), false);
387 QCOMPARE(metaField.isValid(), true);
388
389 metaField = metaModel.localField("bField");
390 QCOMPARE(metaField.isAutoIncrement(), false);
391 QCOMPARE(metaField.isBlank(), false);
392 QCOMPARE(metaField.isNullable(), false);
393 QCOMPARE(metaField.isUnique(), false);
394 QCOMPARE(metaField.isValid(), true);
395
396 metaField = metaModel.localField("blankField");
397 QCOMPARE(metaField.isAutoIncrement(), false);
398 QCOMPARE(metaField.isBlank(), true);
399 QCOMPARE(metaField.isNullable(), false);
400 QCOMPARE(metaField.isUnique(), false);
401 QCOMPARE(metaField.isValid(), true);
402
403 metaField = metaModel.localField("nullField");
404 QCOMPARE(metaField.isAutoIncrement(), false);
405 QCOMPARE(metaField.isBlank(), false);
406 QCOMPARE(metaField.isNullable(), true);
407 QCOMPARE(metaField.isUnique(), false);
408 QCOMPARE(metaField.isValid(), true);
409
410 metaField = metaModel.localField("uniqueField");
411 QCOMPARE(metaField.isAutoIncrement(), false);
412 QCOMPARE(metaField.isBlank(), false);
413 QCOMPARE(metaField.isNullable(), false);
414 QCOMPARE(metaField.isUnique(), true);
415 QCOMPARE(metaField.isValid(), true);
416
417 cleanup<tst_Options>();
418 }
419
420 /** Test foreign key constraint sql generation
421 */
422 void tst_QDjangoMetaModel::testConstraints()
423 {
424 QStringList sql;
425 QDjangoDatabase::DatabaseType databaseType = QDjangoDatabase::databaseType(QDjango::database());
426 if (databaseType == QDjangoDatabase::PostgreSQL) {
427 sql << QLatin1String("CREATE TABLE \"tst_fkconstraint\" ("
428 "\"id\" serial PRIMARY KEY, "
429 "\"noConstraint_id\" integer NOT NULL REFERENCES \"user\" (\"id\") DEFERRABLE INITIALLY DEFERRED, "
430 "\"cascadeConstraint_id\" integer NOT NULL REFERENCES \"user\" (\"id\") ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, "
431 "\"nullConstraint_id\" integer REFERENCES \"group\" (\"id\") ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED, "
432 "\"restrictConstraint_id\" integer NOT NULL REFERENCES \"user\" (\"id\") ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED"
433 ")");
434 sql << QLatin1String("CREATE INDEX \"tst_fkconstraint_f388fc3c\" ON \"tst_fkconstraint\" (\"noConstraint_id\")");
435 sql << QLatin1String("CREATE INDEX \"tst_fkconstraint_4634d592\" ON \"tst_fkconstraint\" (\"cascadeConstraint_id\")");
436 sql << QLatin1String("CREATE INDEX \"tst_fkconstraint_44c71620\" ON \"tst_fkconstraint\" (\"nullConstraint_id\")");
437 sql << QLatin1String("CREATE INDEX \"tst_fkconstraint_728cefe1\" ON \"tst_fkconstraint\" (\"restrictConstraint_id\")");
438 } else if (databaseType == QDjangoDatabase::MySqlServer) {
439 sql << QLatin1String("CREATE TABLE `tst_fkconstraint` ("
440 "`id` integer NOT NULL PRIMARY KEY AUTO_INCREMENT, "
441 "`noConstraint_id` integer NOT NULL, "
442 "`cascadeConstraint_id` integer NOT NULL, "
443 "`nullConstraint_id` integer, "
444 "`restrictConstraint_id` integer NOT NULL, "
445 "CONSTRAINT `FK_noConstraint_id_8049d4ec` FOREIGN KEY (`noConstraint_id`) REFERENCES `user` (`id`), "
446 "CONSTRAINT `FK_cascadeConstraint_id_d2686b82` FOREIGN KEY (`cascadeConstraint_id`) REFERENCES `user` (`id`) ON DELETE CASCADE, "
447 "CONSTRAINT `FK_nullConstraint_id_b4eac280` FOREIGN KEY (`nullConstraint_id`) REFERENCES `group` (`id`) ON DELETE SET NULL, "
448 "CONSTRAINT `FK_restrictConstraint_id_99b64be3` FOREIGN KEY (`restrictConstraint_id`) REFERENCES `user` (`id`) ON DELETE RESTRICT"
449 ")");
450 sql << QLatin1String("CREATE INDEX `tst_fkconstraint_f388fc3c` ON `tst_fkconstraint` (`noConstraint_id`)");
451 sql << QLatin1String("CREATE INDEX `tst_fkconstraint_4634d592` ON `tst_fkconstraint` (`cascadeConstraint_id`)");
452 sql << QLatin1String("CREATE INDEX `tst_fkconstraint_44c71620` ON `tst_fkconstraint` (`nullConstraint_id`)");
453 sql << QLatin1String("CREATE INDEX `tst_fkconstraint_728cefe1` ON `tst_fkconstraint` (`restrictConstraint_id`)");
454 } else if (databaseType == QDjangoDatabase::MSSqlServer) {
455 sql << QLatin1String("CREATE TABLE \"tst_fkconstraint\" ("
456 "\"id\" int NOT NULL PRIMARY KEY IDENTITY(1,1), "
457 "\"noConstraint_id\" int NOT NULL REFERENCES \"user\" (\"id\"), "
458 "\"cascadeConstraint_id\" int NOT NULL REFERENCES \"user\" (\"id\") ON DELETE CASCADE, "
459 "\"nullConstraint_id\" int REFERENCES \"group\" (\"id\") ON DELETE SET NULL"
460 ")");
461 sql << QLatin1String("CREATE INDEX \"tst_fkconstraint_f388fc3c\" ON \"tst_fkconstraint\" (\"noConstraint_id\")");
462 sql << QLatin1String("CREATE INDEX \"tst_fkconstraint_4634d592\" ON \"tst_fkconstraint\" (\"cascadeConstraint_id\")");
463 sql << QLatin1String("CREATE INDEX \"tst_fkconstraint_44c71620\" ON \"tst_fkconstraint\" (\"nullConstraint_id\")");
464 } else {
465 sql << QLatin1String("CREATE TABLE \"tst_fkconstraint\" ("
466 "\"id\" integer NOT NULL PRIMARY KEY AUTOINCREMENT, "
467 "\"noConstraint_id\" integer NOT NULL REFERENCES \"user\" (\"id\"), "
468 "\"cascadeConstraint_id\" integer NOT NULL REFERENCES \"user\" (\"id\") ON DELETE CASCADE, "
469 "\"nullConstraint_id\" integer REFERENCES \"group\" (\"id\") ON DELETE SET NULL, "
470 "\"restrictConstraint_id\" integer NOT NULL REFERENCES \"user\" (\"id\") ON DELETE RESTRICT"
471 ")");
472 sql << QLatin1String("CREATE INDEX \"tst_fkconstraint_f388fc3c\" ON \"tst_fkconstraint\" (\"noConstraint_id\")");
473 sql << QLatin1String("CREATE INDEX \"tst_fkconstraint_4634d592\" ON \"tst_fkconstraint\" (\"cascadeConstraint_id\")");
474 sql << QLatin1String("CREATE INDEX \"tst_fkconstraint_44c71620\" ON \"tst_fkconstraint\" (\"nullConstraint_id\")");
475 sql << QLatin1String("CREATE INDEX \"tst_fkconstraint_728cefe1\" ON \"tst_fkconstraint\" (\"restrictConstraint_id\")");
476 }
477
478 // create tables
479 QDjangoMetaModel userModel = QDjango::registerModel<User>();
480 QCOMPARE(userModel.createTable(), true);
481
482 QDjangoMetaModel groupModel = QDjango::registerModel<Group>();
483 QCOMPARE(groupModel.createTable(), true);
484
485 QDjangoMetaModel metaModel = (databaseType == QDjangoDatabase::MSSqlServer) ?
486 QDjango::registerModel<tst_FkConstraint>() : QDjango::registerModel<tst_FkConstraintWithRestrict>();
487 QCOMPARE(metaModel.createTableSql(), sql);
488 QCOMPARE(metaModel.createTable(), true);
489
490 // drop tables
491 QCOMPARE(metaModel.dropTable(), true);
492 QCOMPARE(userModel.dropTable(), true);
493 QCOMPARE(groupModel.dropTable(), true);
494 }
495
496 void tst_QDjangoMetaModel::testIsValid()
497 {
498 QDjangoMetaModel metaModel;
499 QVERIFY(!metaModel.isValid());
500
501 metaModel = QDjango::registerModel<User>();
502 QVERIFY(metaModel.isValid());
503 }
504
505 QTEST_MAIN(tst_QDjangoMetaModel)