]> git.datanom.net - lensdb.git/blob - src/sqlite-storage.c
before transition to proper ide
[lensdb.git] / src / sqlite-storage.c
1 /*
2 * sqlite-storage.c
3 *
4 * Copyright 2024 Michael Rasmussen <mir@datanom.net>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19 * MA 02110-1301, USA.
20 *
21 *
22 */
23
24 #include <stdio.h>
25 #include "sqlite-storage.h"
26 #include "gui.h"
27 #define DBNAME "lensdb.db"
28
29 static sqlite3* db = NULL;
30 static gchar* lensmaker = "create table lensmaker("
31 "id integer not null,"
32 "maker text not null UNIQUE,"
33 "page int DEFAULT -1,"
34 "PRIMARY KEY(id AUTOINCREMENT));";
35 static gchar* lens = "create table lens("
36 "id integer not null,"
37 "sn text not null,"
38 "maker integer not null,"
39 "description text not null,"
40 "notes text,"
41 "date_added datetime DEFAULT current_timestamp,"
42 "PRIMARY KEY(id AUTOINCREMENT),"
43 "constraint fk_maker foreign key (maker) references lensmaker (id)"
44 " on delete cascade);";
45 static gchar* search = "SELECT l.id, l.sn, l.description, l.notes, l.maker"
46 " FROM lens l JOIN lensmaker m on l.maker = m.id";
47 static gchar* all = "SELECT m.maker,l.sn,l.description,l.notes,l.date_added"
48 " FROM lensmaker m JOIN lens l on m.id = l.maker";
49
50 void close_storage() {
51 if (db != NULL)
52 sqlite3_close(db);
53 }
54
55 gint init_storage(const gchar* path) {
56 gboolean init_db = FALSE;
57 gint rc;
58 gchar* ErrMsg = NULL;
59
60 gchar* file = g_strconcat(path, "/", DBNAME, NULL);
61 if (!g_file_test(file, G_FILE_TEST_EXISTS)) {
62 init_db = TRUE;
63 }
64 rc = sqlite3_open(file, &db);
65 g_free(file);
66
67 if (rc) {
68 gchar* err = g_strdup_printf("Failed to open DB: %s\n", sqlite3_errmsg(db));
69 fprintf(stderr, err);
70 show_err_msg(GTK_MESSAGE_ERROR, err);
71 g_free(err);
72 return 1;
73 }
74
75 if (init_db) {
76 rc = sqlite3_exec(db, "PRAGMA foreign_keys = ON", 0, 0, &ErrMsg);
77 if (rc != SQLITE_OK) {
78 gchar* err = g_strdup_printf("SQL error: %s\n", ErrMsg);
79 fprintf(stderr, err);
80 show_err_msg(GTK_MESSAGE_ERROR, err);
81 g_free(err);
82 sqlite3_free(ErrMsg);
83 ErrMsg = NULL;
84 }
85 rc = sqlite3_exec(db, lensmaker, 0, 0, &ErrMsg);
86 if (rc != SQLITE_OK) {
87 gchar* err = g_strdup_printf("SQL error: %s\n", ErrMsg);
88 fprintf(stderr, err);
89 show_err_msg(GTK_MESSAGE_ERROR, err);
90 g_free(err);
91 sqlite3_free(ErrMsg);
92 ErrMsg = NULL;
93 }
94 rc = sqlite3_exec(db, lens, 0, 0, &ErrMsg);
95 if (rc != SQLITE_OK) {
96 gchar* err = g_strdup_printf("SQL error: %s\n", ErrMsg);
97 fprintf(stderr, err);
98 show_err_msg(GTK_MESSAGE_ERROR, err);
99 g_free(err);
100 sqlite3_free(ErrMsg);
101 }
102 }
103
104 return 0;
105 }
106
107 gint add_lens(Row* row) {
108 gint rc;
109 sqlite3_stmt* stmt;
110 gint status = 1;
111
112 rc = sqlite3_prepare_v2(db, "insert into lens (sn, maker, description, notes) values (?1, ?2, ?3, ?4) returning id", -1, &stmt, 0);
113 if (rc != SQLITE_OK) {
114 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
115 fprintf(stderr, err);
116 show_err_msg(GTK_MESSAGE_ERROR, err);
117 g_free(err);
118 sqlite3_finalize(stmt);
119 return status;
120 }
121
122 rc = sqlite3_bind_text(stmt, 1, row->sn, -1, NULL);
123 if (rc) {
124 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
125 fprintf(stderr, err);
126 show_err_msg(GTK_MESSAGE_ERROR, err);
127 g_free(err);
128 sqlite3_finalize(stmt);
129 return status;
130 }
131
132 rc = sqlite3_bind_int(stmt, 2, row->maker);
133 if (rc) {
134 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
135 fprintf(stderr, err);
136 show_err_msg(GTK_MESSAGE_ERROR, err);
137 g_free(err);
138 sqlite3_finalize(stmt);
139 return status;
140 }
141
142 rc = sqlite3_bind_text(stmt, 3, row->data, -1, NULL);
143 if (rc) {
144 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
145 fprintf(stderr, err);
146 show_err_msg(GTK_MESSAGE_ERROR, err);
147 g_free(err);
148 sqlite3_finalize(stmt);
149 return status;
150 }
151
152 rc = sqlite3_bind_text(stmt, 4, row->notes, -1, NULL);
153 if (rc) {
154 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
155 fprintf(stderr, err);
156 show_err_msg(GTK_MESSAGE_ERROR, err);
157 g_free(err);
158 sqlite3_finalize(stmt);
159 return status;
160 }
161
162 rc = sqlite3_step(stmt);
163 if (rc != SQLITE_ROW) {
164 gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
165 fprintf(stderr, err);
166 show_err_msg(GTK_MESSAGE_ERROR, err);
167 g_free(err);
168 } else {
169 row->id = sqlite3_column_int64(stmt, 0);
170 status = 0;
171 }
172
173 sqlite3_finalize(stmt);
174
175 return status;
176 }
177
178 gint update_lens(const Row* row) {
179 gint rc;
180 sqlite3_stmt* stmt;
181 gint status = 1;
182
183 rc = sqlite3_prepare_v2(db, "update lens set sn = ?1, description = ?2, notes = ?3 where id = ?4", -1, &stmt, 0);
184 if (rc != SQLITE_OK) {
185 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
186 fprintf(stderr, err);
187 show_err_msg(GTK_MESSAGE_ERROR, err);
188 g_free(err);
189 sqlite3_finalize(stmt);
190 return status;
191 }
192
193 rc = sqlite3_bind_text(stmt, 1, row->sn, -1, NULL);
194 if (rc) {
195 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
196 fprintf(stderr, err);
197 show_err_msg(GTK_MESSAGE_ERROR, err);
198 g_free(err);
199 sqlite3_finalize(stmt);
200 return status;
201 }
202
203 rc = sqlite3_bind_text(stmt, 2, row->data, -1, NULL);
204 if (rc) {
205 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
206 fprintf(stderr, err);
207 show_err_msg(GTK_MESSAGE_ERROR, err);
208 g_free(err);
209 sqlite3_finalize(stmt);
210 return status;
211 }
212
213 rc = sqlite3_bind_text(stmt, 3, row->notes, -1, NULL);
214 if (rc) {
215 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
216 fprintf(stderr, err);
217 show_err_msg(GTK_MESSAGE_ERROR, err);
218 g_free(err);
219 sqlite3_finalize(stmt);
220 return status;
221 }
222
223 rc = sqlite3_bind_int64(stmt, 4, row->id);
224 if (rc) {
225 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
226 fprintf(stderr, err);
227 show_err_msg(GTK_MESSAGE_ERROR, err);
228 g_free(err);
229 sqlite3_finalize(stmt);
230 return status;
231 }
232
233 rc = sqlite3_step(stmt);
234 if (rc != SQLITE_DONE) {
235 gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
236 fprintf(stderr, err);
237 show_err_msg(GTK_MESSAGE_ERROR, err);
238 g_free(err);
239 } else {
240 status = 0;
241 }
242
243 sqlite3_finalize(stmt);
244
245 return status;
246 }
247
248 gint delete_lens(const Row* row) {
249 gint rc;
250 sqlite3_stmt* stmt;
251 gint status = 1;
252
253 rc = sqlite3_prepare_v2(db, "delete from lens where id = ?1", -1, &stmt, 0);
254 if (rc != SQLITE_OK) {
255 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
256 fprintf(stderr, err);
257 show_err_msg(GTK_MESSAGE_ERROR, err);
258 g_free(err);
259 sqlite3_finalize(stmt);
260 return status;
261 }
262
263 rc = sqlite3_bind_int64(stmt, 1, row->id);
264 if (rc) {
265 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
266 fprintf(stderr, err);
267 show_err_msg(GTK_MESSAGE_ERROR, err);
268 g_free(err);
269 sqlite3_finalize(stmt);
270 return status;
271 }
272
273 rc = sqlite3_step(stmt);
274 if (rc != SQLITE_DONE) {
275 gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
276 fprintf(stderr, err);
277 show_err_msg(GTK_MESSAGE_ERROR, err);
278 g_free(err);
279 } else {
280 status = 0;
281 }
282
283 sqlite3_finalize(stmt);
284
285 return status;
286 }
287
288 gint add_maker(const gchar* maker, gchar** error) {
289 gint rc;
290 sqlite3_stmt* stmt;
291 gint status = -1;
292
293 rc = sqlite3_prepare_v2(db, "insert into lensmaker (maker) values (?1) returning id", -1, &stmt, 0);
294 if (rc != SQLITE_OK) {
295 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
296 fprintf(stderr, err);
297 show_err_msg(GTK_MESSAGE_ERROR, err);
298 g_free(err);
299 if (error)
300 *error = g_strdup(sqlite3_errmsg(db));
301 sqlite3_finalize(stmt);
302 return status;
303 }
304
305 rc = sqlite3_bind_text(stmt, 1, maker, -1, NULL);
306 if (rc) {
307 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
308 fprintf(stderr, err);
309 show_err_msg(GTK_MESSAGE_ERROR, err);
310 g_free(err);
311 if (error)
312 *error = g_strdup(sqlite3_errmsg(db));
313 sqlite3_finalize(stmt);
314 return status;
315 }
316
317 rc = sqlite3_step(stmt);
318 if (rc != SQLITE_ROW) {
319 gchar* err = g_strdup_printf("Couldn't insert maker: %s\n", sqlite3_errmsg(db));
320 fprintf(stderr, err);
321 show_err_msg(GTK_MESSAGE_ERROR, err);
322 g_free(err);
323 if (error)
324 *error = g_strdup(sqlite3_errmsg(db));
325 } else {
326 status = sqlite3_column_int64(stmt, 0);
327 }
328
329 sqlite3_finalize(stmt);
330
331 return status;
332 }
333
334 Maker* get_maker(gint id) {
335 gint rc;
336 sqlite3_stmt* stmt;
337 Maker* maker = NULL;
338
339 rc = sqlite3_prepare_v2(db, "select maker, page from lensmaker where id = ?1", -1, &stmt, 0);
340 if (rc != SQLITE_OK) {
341 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
342 fprintf(stderr, err);
343 show_err_msg(GTK_MESSAGE_ERROR, err);
344 g_free(err);
345 sqlite3_finalize(stmt);
346 return NULL;
347 }
348
349 rc = sqlite3_bind_int64(stmt, 1, id);
350 if (rc) {
351 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
352 fprintf(stderr, err);
353 show_err_msg(GTK_MESSAGE_ERROR, err);
354 g_free(err);
355 sqlite3_finalize(stmt);
356 return NULL;
357 }
358
359 if (sqlite3_step(stmt) == SQLITE_ROW) {
360 maker = g_new0(Maker, 1);
361 maker->id = id;
362 maker->maker_name = g_strdup((const gchar*)sqlite3_column_text(stmt, 0));
363 maker->page = sqlite3_column_int(stmt, 1);
364 }
365
366 sqlite3_finalize(stmt);
367
368 return maker;
369 }
370
371 void update_maker(const Maker* maker) {
372 gint rc;
373 sqlite3_stmt* stmt;
374
375 rc = sqlite3_prepare_v2(db, "update lensmaker set page = ?1 where id = ?2", -1, &stmt, 0);
376 if (rc != SQLITE_OK) {
377 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
378 fprintf(stderr, err);
379 show_err_msg(GTK_MESSAGE_ERROR, err);
380 g_free(err);
381 sqlite3_finalize(stmt);
382 return;
383 }
384
385 rc = sqlite3_bind_int(stmt, 1, maker->page);
386 if (rc) {
387 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
388 fprintf(stderr, err);
389 show_err_msg(GTK_MESSAGE_ERROR, err);
390 g_free(err);
391 sqlite3_finalize(stmt);
392 return;
393 }
394
395 rc = sqlite3_bind_int64(stmt, 2, maker->id);
396 if (rc) {
397 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
398 fprintf(stderr, err);
399 show_err_msg(GTK_MESSAGE_ERROR, err);
400 g_free(err);
401 sqlite3_finalize(stmt);
402 return;
403 }
404
405 //fprintf(stderr, "%s\n", sqlite3_expanded_sql(stmt));
406 rc = sqlite3_step(stmt);
407 if (rc != SQLITE_DONE) {
408 gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
409 fprintf(stderr, err);
410 show_err_msg(GTK_MESSAGE_ERROR, err);
411 g_free(err);
412 sqlite3_finalize(stmt);
413 }
414
415 sqlite3_finalize(stmt);
416 }
417
418 void maker_free(Maker* maker) {
419 if (maker) {
420 g_free(maker->maker_name);
421 g_free(maker);
422 }
423 }
424
425 gint delete_maker(const gchar* maker, gchar** error) {
426 gint rc;
427 sqlite3_stmt* stmt;
428 gint status = 0;
429
430 gint id = get_maker_id(maker);
431 rc = sqlite3_prepare_v2(db, "delete from lensmaker where id = ?1", -1, &stmt, 0);
432 if (rc != SQLITE_OK) {
433 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
434 fprintf(stderr, err);
435 show_err_msg(GTK_MESSAGE_ERROR, err);
436 g_free(err);
437 if (error)
438 *error = g_strdup(sqlite3_errmsg(db));
439 sqlite3_finalize(stmt);
440
441 return 1;
442 }
443
444 rc = sqlite3_bind_int(stmt, 1, id);
445 if (rc) {
446 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
447 fprintf(stderr, err);
448 show_err_msg(GTK_MESSAGE_ERROR, err);
449 g_free(err);
450 if (error)
451 *error = g_strdup(sqlite3_errmsg(db));
452 sqlite3_finalize(stmt);
453
454 return 1;
455 }
456
457 //fprintf(stderr, "%s\n", sqlite3_expanded_sql(stmt));
458 rc = sqlite3_step(stmt);
459 if (rc != SQLITE_DONE) {
460 gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
461 fprintf(stderr, err);
462 show_err_msg(GTK_MESSAGE_ERROR, err);
463 g_free(err);
464 if (error)
465 *error = g_strdup(sqlite3_errmsg(db));
466 sqlite3_finalize(stmt);
467
468 status = 1;
469 }
470
471 sqlite3_finalize(stmt);
472
473 return status;
474 }
475
476 GSList* get_makers() {
477 gint rc;
478 sqlite3_stmt* stmt;
479 GSList* makers = NULL;
480
481 rc = sqlite3_prepare_v2(db, "select maker from lensmaker order by id", -1, &stmt, 0);
482 if (rc != SQLITE_OK) {
483 gchar* err = g_strdup_printf("Failed to fetch data: %s\n", sqlite3_errmsg(db));
484 fprintf(stderr, err);
485 show_err_msg(GTK_MESSAGE_ERROR, err);
486 g_free(err);
487 sqlite3_finalize(stmt);
488 return NULL;
489 }
490
491 while (sqlite3_step(stmt) == SQLITE_ROW) {
492 gchar* maker = g_strdup((const gchar*)sqlite3_column_text(stmt, 0));
493 makers = g_slist_append(makers, maker);
494 }
495
496 sqlite3_finalize(stmt);
497
498 return makers;
499 }
500
501 gint get_maker_id(const gchar* maker) {
502 gint rc;
503 sqlite3_stmt* stmt;
504 gint id = -1;
505
506 rc = sqlite3_prepare_v2(db, "select id from lensmaker where maker = ?1", -1, &stmt, 0);
507 if (rc != SQLITE_OK) {
508 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
509 fprintf(stderr, err);
510 show_err_msg(GTK_MESSAGE_ERROR, err);
511 g_free(err);
512 sqlite3_finalize(stmt);
513 return -1;
514 }
515
516 rc = sqlite3_bind_text(stmt, 1, maker, -1, NULL);
517 if (rc) {
518 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
519 fprintf(stderr, err);
520 show_err_msg(GTK_MESSAGE_ERROR, err);
521 g_free(err);
522 sqlite3_finalize(stmt);
523 return -1;
524 }
525
526 if (sqlite3_step(stmt) == SQLITE_ROW) {
527 id = sqlite3_column_int64(stmt, 0);
528 }
529
530 sqlite3_finalize(stmt);
531
532 return id;
533 }
534
535 GSList* get_lens_by_maker(gint id) {
536 gint rc;
537 sqlite3_stmt* stmt;
538 GSList* lenses = NULL;
539
540 rc = sqlite3_prepare_v2(db, "select sn, description, notes, id from lens where maker = ?1", -1, &stmt, 0);
541 if (rc != SQLITE_OK) {
542 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
543 fprintf(stderr, err);
544 show_err_msg(GTK_MESSAGE_ERROR, err);
545 g_free(err);
546 sqlite3_finalize(stmt);
547 return NULL;
548 }
549
550 rc = sqlite3_bind_int64(stmt, 1, id);
551 if (rc) {
552 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
553 fprintf(stderr, err);
554 show_err_msg(GTK_MESSAGE_ERROR, err);
555 g_free(err);
556 sqlite3_finalize(stmt);
557 return NULL;
558 }
559
560 while (sqlite3_step(stmt) == SQLITE_ROW) {
561 Row* row = row_new();
562 row->sn = g_strdup((const gchar*)sqlite3_column_text(stmt, 0));
563 row->data = g_strdup((const gchar*)sqlite3_column_text(stmt, 1));
564 row->notes = g_strdup((const gchar*)sqlite3_column_text(stmt, 2));
565 row->id = sqlite3_column_int64(stmt, 3);
566 lenses = g_slist_append(lenses, row);
567 }
568
569 sqlite3_finalize(stmt);
570
571 return lenses;
572 }
573
574 GSList* get_lens_by_search(const Row* row) {
575 gint rc;
576 sqlite3_stmt* stmt;
577 GSList* lenses = NULL;
578 gchar* bind1 = NULL;
579 gchar* bind2 = NULL;
580 gchar* sql = NULL;
581
582 if (row->notes && row->data) {
583 sql = g_strconcat(search, " where ",
584 "upper(m.maker) like '%' || upper(?1) || '%' and upper(l.description) like '%' || upper(?2) || '%'",
585 NULL);
586 bind1 = g_strdup(row->notes);
587 bind2 = g_strdup(row->data);
588 } else if (!row->notes && !row->data) {
589 sql = g_strconcat(search, NULL);
590 } else {
591 if (row->notes) {
592 sql = g_strconcat(search, " where upper(m.maker) like '%' || upper(?1) || '%'", NULL);
593 bind1 = g_strdup(row->notes);
594 } else {
595 sql = g_strconcat(search, " where upper(l.description) like '%' || upper(?1) || '%'", NULL);
596 bind1 = g_strdup(row->data);
597 }
598 }
599
600 rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);
601 if (rc != SQLITE_OK) {
602 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
603 fprintf(stderr, err);
604 show_err_msg(GTK_MESSAGE_ERROR, err);
605 g_free(err);
606 sqlite3_finalize(stmt);
607 return NULL;
608 }
609
610 if (bind1) {
611 rc = sqlite3_bind_text(stmt, 1, bind1, -1, NULL);
612 if (rc) {
613 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
614 fprintf(stderr, err);
615 show_err_msg(GTK_MESSAGE_ERROR, err);
616 g_free(err);
617 sqlite3_finalize(stmt);
618 return NULL;
619 }
620 }
621
622 if (bind2) {
623 rc = sqlite3_bind_text(stmt, 2, bind2, -1, NULL);
624 if (rc) {
625 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
626 fprintf(stderr, err);
627 show_err_msg(GTK_MESSAGE_ERROR, err);
628 g_free(err);
629 sqlite3_finalize(stmt);
630 return NULL;
631 }
632 }
633
634 while (sqlite3_step(stmt) == SQLITE_ROW) {
635 Row* row = row_new();
636 row->id = sqlite3_column_int64(stmt, 0);
637 row->sn = g_strdup((const gchar*)sqlite3_column_text(stmt, 1));
638 row->data = g_strdup((const gchar*)sqlite3_column_text(stmt, 2));
639 row->notes = g_strdup((const gchar*)sqlite3_column_text(stmt, 3));
640 row->maker = sqlite3_column_int64(stmt, 4);
641 lenses = g_slist_append(lenses, row);
642 }
643
644 sqlite3_finalize(stmt);
645 g_free(bind1);
646 g_free(bind2);
647
648 return lenses;
649 }
650
651 Row* row_new() {
652 Row* row = g_new0(Row, 1);
653 row->id = 0;
654
655 return row;
656 }
657
658 void row_free(gpointer data, gpointer user_data) {
659 Row* row = (Row *) data;
660 g_free(row->sn);
661 g_free(row->data);
662 g_free(row->notes);
663 g_free(row);
664 }
665
666 void dump_storage(CsvParser* parser) {
667 gint rc;
668 sqlite3_stmt* stmt;
669 CvsError* err = NULL;
670
671 if (parser == NULL) return;
672
673 rc = sqlite3_prepare_v2(db, all, -1, &stmt, 0);
674 if (rc != SQLITE_OK) {
675 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
676 fprintf(stderr, err);
677 show_err_msg(GTK_MESSAGE_ERROR, err);
678 g_free(err);
679 sqlite3_finalize(stmt);
680 return;
681 }
682
683 Record* row = g_new0(Record, 1);
684 row->maker = g_strdup("maker");
685 row->sn = g_strdup("sn");
686 row->data = g_strdup("lens");
687 row->notes = g_strdup("notes");
688 row->date = g_strdup("date");
689 csv_parser_dump_row(parser, row, &err);
690 csv_record_free(row);
691 if (err) {
692 gchar* msg = g_strdup_printf("%zu: %s\n", err->line, err->message);
693 fprintf(stderr, msg);
694 show_err_msg(GTK_MESSAGE_ERROR, msg);
695 g_free(msg);
696 csv_error_clear(&err);
697 sqlite3_finalize(stmt);
698 return;
699 }
700
701 while (sqlite3_step(stmt) == SQLITE_ROW) {
702 row = g_new0(Record, 1);
703 row->maker = g_strdup((const gchar*)sqlite3_column_text(stmt, 0));
704 row->sn = g_strdup((const gchar*)sqlite3_column_text(stmt, 1));
705 row->data = g_strdup((const gchar*)sqlite3_column_text(stmt, 2));
706 row->notes = g_strdup((const gchar*)sqlite3_column_text(stmt, 3));
707 row->date = g_strdup((const gchar*)sqlite3_column_text(stmt, 4));
708 csv_parser_dump_row(parser, row, &err);
709 csv_record_free(row);
710 if (err) {
711 gchar* msg = g_strdup_printf("%zu: %s\n", err->line, err->message);
712 fprintf(stderr, msg);
713 show_err_msg(GTK_MESSAGE_ERROR, msg);
714 g_free(msg);
715 csv_error_clear(&err);
716 sqlite3_finalize(stmt);
717 return;
718 }
719 }
720
721 sqlite3_finalize(stmt);
722 }
723
724
This page took 0.968349 seconds and 6 git commands to generate.