]> git.datanom.net - lensdb.git/blob - src/sqlite-storage.c
Implement Exif scanner
[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 "PRIMARY KEY(id AUTOINCREMENT),"
42 "constraint fk_maker foreign key (maker) references lensmaker (id)"
43 " on delete cascade);";
44 static gchar* search = "SELECT l.id, l.sn, l.description, l.notes, l.maker"
45 " FROM lens l JOIN lensmaker m on l.maker = m.id";
46
47 void close_storage() {
48 if (db != NULL)
49 sqlite3_close(db);
50 }
51
52 gint init_storage(const gchar* path) {
53 gboolean init_db = FALSE;
54 gint rc;
55 gchar* ErrMsg = NULL;
56
57 gchar* file = g_strconcat(path, "/", DBNAME, NULL);
58 if (!g_file_test(file, G_FILE_TEST_EXISTS)) {
59 init_db = TRUE;
60 }
61 rc = sqlite3_open(file, &db);
62 g_free(file);
63
64 if (rc) {
65 gchar* err = g_strdup_printf("Failed to open DB: %s\n", sqlite3_errmsg(db));
66 fprintf(stderr, err);
67 show_err_msg(GTK_MESSAGE_ERROR, err);
68 g_free(err);
69 return 1;
70 }
71
72 if (init_db) {
73 rc = sqlite3_exec(db, "PRAGMA foreign_keys = ON", 0, 0, &ErrMsg);
74 if (rc != SQLITE_OK) {
75 gchar* err = g_strdup_printf("SQL error: %s\n", ErrMsg);
76 fprintf(stderr, err);
77 show_err_msg(GTK_MESSAGE_ERROR, err);
78 g_free(err);
79 sqlite3_free(ErrMsg);
80 ErrMsg = NULL;
81 }
82 rc = sqlite3_exec(db, lensmaker, 0, 0, &ErrMsg);
83 if (rc != SQLITE_OK) {
84 gchar* err = g_strdup_printf("SQL error: %s\n", ErrMsg);
85 fprintf(stderr, err);
86 show_err_msg(GTK_MESSAGE_ERROR, err);
87 g_free(err);
88 sqlite3_free(ErrMsg);
89 ErrMsg = NULL;
90 }
91 rc = sqlite3_exec(db, lens, 0, 0, &ErrMsg);
92 if (rc != SQLITE_OK) {
93 gchar* err = g_strdup_printf("SQL error: %s\n", ErrMsg);
94 fprintf(stderr, err);
95 show_err_msg(GTK_MESSAGE_ERROR, err);
96 g_free(err);
97 sqlite3_free(ErrMsg);
98 }
99 }
100
101 return 0;
102 }
103
104 gint add_lens(Row* row) {
105 gint rc;
106 sqlite3_stmt* stmt;
107 gint status = 1;
108
109 rc = sqlite3_prepare_v2(db, "insert into lens (sn, maker, description, notes) values (?1, ?2, ?3, ?4) returning id", -1, &stmt, 0);
110 if (rc != SQLITE_OK) {
111 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
112 fprintf(stderr, err);
113 show_err_msg(GTK_MESSAGE_ERROR, err);
114 g_free(err);
115 sqlite3_finalize(stmt);
116 return status;
117 }
118
119 rc = sqlite3_bind_text(stmt, 1, row->sn, -1, NULL);
120 if (rc) {
121 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
122 fprintf(stderr, err);
123 show_err_msg(GTK_MESSAGE_ERROR, err);
124 g_free(err);
125 sqlite3_finalize(stmt);
126 return status;
127 }
128
129 rc = sqlite3_bind_int(stmt, 2, row->maker);
130 if (rc) {
131 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
132 fprintf(stderr, err);
133 show_err_msg(GTK_MESSAGE_ERROR, err);
134 g_free(err);
135 sqlite3_finalize(stmt);
136 return status;
137 }
138
139 rc = sqlite3_bind_text(stmt, 3, row->data, -1, NULL);
140 if (rc) {
141 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
142 fprintf(stderr, err);
143 show_err_msg(GTK_MESSAGE_ERROR, err);
144 g_free(err);
145 sqlite3_finalize(stmt);
146 return status;
147 }
148
149 rc = sqlite3_bind_text(stmt, 4, row->notes, -1, NULL);
150 if (rc) {
151 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
152 fprintf(stderr, err);
153 show_err_msg(GTK_MESSAGE_ERROR, err);
154 g_free(err);
155 sqlite3_finalize(stmt);
156 return status;
157 }
158
159 rc = sqlite3_step(stmt);
160 if (rc != SQLITE_ROW) {
161 gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
162 fprintf(stderr, err);
163 show_err_msg(GTK_MESSAGE_ERROR, err);
164 g_free(err);
165 } else {
166 row->id = sqlite3_column_int64(stmt, 0);
167 status = 0;
168 }
169
170 sqlite3_finalize(stmt);
171
172 return status;
173 }
174
175 gint update_lens(const Row* row) {
176 gint rc;
177 sqlite3_stmt* stmt;
178 gint status = 1;
179
180 rc = sqlite3_prepare_v2(db, "update lens set sn = ?1, description = ?2, notes = ?3 where id = ?4", -1, &stmt, 0);
181 if (rc != SQLITE_OK) {
182 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
183 fprintf(stderr, err);
184 show_err_msg(GTK_MESSAGE_ERROR, err);
185 g_free(err);
186 sqlite3_finalize(stmt);
187 return status;
188 }
189
190 rc = sqlite3_bind_text(stmt, 1, row->sn, -1, NULL);
191 if (rc) {
192 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
193 fprintf(stderr, err);
194 show_err_msg(GTK_MESSAGE_ERROR, err);
195 g_free(err);
196 sqlite3_finalize(stmt);
197 return status;
198 }
199
200 rc = sqlite3_bind_text(stmt, 2, row->data, -1, NULL);
201 if (rc) {
202 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
203 fprintf(stderr, err);
204 show_err_msg(GTK_MESSAGE_ERROR, err);
205 g_free(err);
206 sqlite3_finalize(stmt);
207 return status;
208 }
209
210 rc = sqlite3_bind_text(stmt, 3, row->notes, -1, NULL);
211 if (rc) {
212 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
213 fprintf(stderr, err);
214 show_err_msg(GTK_MESSAGE_ERROR, err);
215 g_free(err);
216 sqlite3_finalize(stmt);
217 return status;
218 }
219
220 rc = sqlite3_bind_int64(stmt, 4, row->id);
221 if (rc) {
222 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
223 fprintf(stderr, err);
224 show_err_msg(GTK_MESSAGE_ERROR, err);
225 g_free(err);
226 sqlite3_finalize(stmt);
227 return status;
228 }
229
230 rc = sqlite3_step(stmt);
231 if (rc != SQLITE_DONE) {
232 gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
233 fprintf(stderr, err);
234 show_err_msg(GTK_MESSAGE_ERROR, err);
235 g_free(err);
236 } else {
237 status = 0;
238 }
239
240 sqlite3_finalize(stmt);
241
242 return status;
243 }
244
245 gint delete_lens(const Row* row) {
246 gint rc;
247 sqlite3_stmt* stmt;
248 gint status = 1;
249
250 rc = sqlite3_prepare_v2(db, "delete from lens where id = ?1", -1, &stmt, 0);
251 if (rc != SQLITE_OK) {
252 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
253 fprintf(stderr, err);
254 show_err_msg(GTK_MESSAGE_ERROR, err);
255 g_free(err);
256 sqlite3_finalize(stmt);
257 return status;
258 }
259
260 rc = sqlite3_bind_int64(stmt, 1, row->id);
261 if (rc) {
262 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
263 fprintf(stderr, err);
264 show_err_msg(GTK_MESSAGE_ERROR, err);
265 g_free(err);
266 sqlite3_finalize(stmt);
267 return status;
268 }
269
270 rc = sqlite3_step(stmt);
271 if (rc != SQLITE_DONE) {
272 gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
273 fprintf(stderr, err);
274 show_err_msg(GTK_MESSAGE_ERROR, err);
275 g_free(err);
276 } else {
277 status = 0;
278 }
279
280 sqlite3_finalize(stmt);
281
282 return status;
283 }
284
285 gint add_maker(const gchar* maker, gchar** error) {
286 gint rc;
287 sqlite3_stmt* stmt;
288 gint status = 1;
289
290 rc = sqlite3_prepare_v2(db, "insert into lensmaker (maker) values (?1)", -1, &stmt, 0);
291 if (rc != SQLITE_OK) {
292 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
293 fprintf(stderr, err);
294 show_err_msg(GTK_MESSAGE_ERROR, err);
295 g_free(err);
296 if (error)
297 *error = g_strdup(sqlite3_errmsg(db));
298 sqlite3_finalize(stmt);
299 return status;
300 }
301
302 rc = sqlite3_bind_text(stmt, 1, maker, -1, NULL);
303 if (rc) {
304 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
305 fprintf(stderr, err);
306 show_err_msg(GTK_MESSAGE_ERROR, err);
307 g_free(err);
308 if (error)
309 *error = g_strdup(sqlite3_errmsg(db));
310 sqlite3_finalize(stmt);
311 return status;
312 }
313
314 rc = sqlite3_step(stmt);
315 if (rc != SQLITE_DONE) {
316 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
317 fprintf(stderr, err);
318 show_err_msg(GTK_MESSAGE_ERROR, err);
319 g_free(err);
320 if (error)
321 *error = g_strdup(sqlite3_errmsg(db));
322 sqlite3_finalize(stmt);
323 return status;
324 }
325
326 status = 0;
327 sqlite3_finalize(stmt);
328
329 return status;
330 }
331
332 Maker* get_maker(gint id) {
333 gint rc;
334 sqlite3_stmt* stmt;
335 Maker* maker = NULL;
336
337 rc = sqlite3_prepare_v2(db, "select maker, page from lensmaker where id = ?1", -1, &stmt, 0);
338 if (rc != SQLITE_OK) {
339 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
340 fprintf(stderr, err);
341 show_err_msg(GTK_MESSAGE_ERROR, err);
342 g_free(err);
343 sqlite3_finalize(stmt);
344 return NULL;
345 }
346
347 rc = sqlite3_bind_int64(stmt, 1, id);
348 if (rc) {
349 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
350 fprintf(stderr, err);
351 show_err_msg(GTK_MESSAGE_ERROR, err);
352 g_free(err);
353 sqlite3_finalize(stmt);
354 return NULL;
355 }
356
357 if (sqlite3_step(stmt) == SQLITE_ROW) {
358 maker = g_new0(Maker, 1);
359 maker->id = id;
360 maker->maker_name = g_strdup((const gchar*)sqlite3_column_text(stmt, 0));
361 maker->page = sqlite3_column_int(stmt, 1);
362 }
363
364 sqlite3_finalize(stmt);
365
366 return maker;
367 }
368
369 void update_maker(const Maker* maker) {
370 gint rc;
371 sqlite3_stmt* stmt;
372
373 rc = sqlite3_prepare_v2(db, "update lensmaker set page = ?1 where id = ?2", -1, &stmt, 0);
374 if (rc != SQLITE_OK) {
375 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
376 fprintf(stderr, err);
377 show_err_msg(GTK_MESSAGE_ERROR, err);
378 g_free(err);
379 sqlite3_finalize(stmt);
380 return;
381 }
382
383 rc = sqlite3_bind_int(stmt, 1, maker->page);
384 if (rc) {
385 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
386 fprintf(stderr, err);
387 show_err_msg(GTK_MESSAGE_ERROR, err);
388 g_free(err);
389 sqlite3_finalize(stmt);
390 return;
391 }
392
393 rc = sqlite3_bind_int64(stmt, 2, maker->id);
394 if (rc) {
395 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
396 fprintf(stderr, err);
397 show_err_msg(GTK_MESSAGE_ERROR, err);
398 g_free(err);
399 sqlite3_finalize(stmt);
400 return;
401 }
402
403 //fprintf(stderr, "%s\n", sqlite3_expanded_sql(stmt));
404 rc = sqlite3_step(stmt);
405 if (rc != SQLITE_DONE) {
406 gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
407 fprintf(stderr, err);
408 show_err_msg(GTK_MESSAGE_ERROR, err);
409 g_free(err);
410 sqlite3_finalize(stmt);
411 }
412
413 sqlite3_finalize(stmt);
414 }
415
416 void maker_free(Maker* maker) {
417 g_free(maker->maker_name);
418 g_free(maker);
419 }
420
421 gint delete_maker(const gchar* maker, gchar** error) {
422 gint rc;
423 sqlite3_stmt* stmt;
424 gint status = 0;
425
426 gint id = get_maker_id(maker);
427 rc = sqlite3_prepare_v2(db, "delete from lensmaker where id = ?1", -1, &stmt, 0);
428 if (rc != SQLITE_OK) {
429 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
430 fprintf(stderr, err);
431 show_err_msg(GTK_MESSAGE_ERROR, err);
432 g_free(err);
433 if (error)
434 *error = g_strdup(sqlite3_errmsg(db));
435 sqlite3_finalize(stmt);
436
437 return 1;
438 }
439
440 rc = sqlite3_bind_int(stmt, 1, id);
441 if (rc) {
442 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
443 fprintf(stderr, err);
444 show_err_msg(GTK_MESSAGE_ERROR, err);
445 g_free(err);
446 if (error)
447 *error = g_strdup(sqlite3_errmsg(db));
448 sqlite3_finalize(stmt);
449
450 return 1;
451 }
452
453 //fprintf(stderr, "%s\n", sqlite3_expanded_sql(stmt));
454 rc = sqlite3_step(stmt);
455 if (rc != SQLITE_DONE) {
456 gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
457 fprintf(stderr, err);
458 show_err_msg(GTK_MESSAGE_ERROR, err);
459 g_free(err);
460 if (error)
461 *error = g_strdup(sqlite3_errmsg(db));
462 sqlite3_finalize(stmt);
463
464 status = 1;
465 }
466
467 sqlite3_finalize(stmt);
468
469 return status;
470 }
471
472 GSList* get_makers() {
473 gint rc;
474 sqlite3_stmt* stmt;
475 GSList* makers = NULL;
476
477 rc = sqlite3_prepare_v2(db, "select maker from lensmaker order by id", -1, &stmt, 0);
478 if (rc != SQLITE_OK) {
479 gchar* err = g_strdup_printf("Failed to fetch data: %s\n", sqlite3_errmsg(db));
480 fprintf(stderr, err);
481 show_err_msg(GTK_MESSAGE_ERROR, err);
482 g_free(err);
483 sqlite3_finalize(stmt);
484 return NULL;
485 }
486
487 while (sqlite3_step(stmt) == SQLITE_ROW) {
488 gchar* maker = g_strdup((const gchar*)sqlite3_column_text(stmt, 0));
489 makers = g_slist_append(makers, maker);
490 }
491
492 sqlite3_finalize(stmt);
493
494 return makers;
495 }
496
497 gint get_maker_id(const gchar* maker) {
498 gint rc;
499 sqlite3_stmt* stmt;
500 gint id = 0;
501
502 rc = sqlite3_prepare_v2(db, "select id from lensmaker where maker = ?1", -1, &stmt, 0);
503 if (rc != SQLITE_OK) {
504 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
505 fprintf(stderr, err);
506 show_err_msg(GTK_MESSAGE_ERROR, err);
507 g_free(err);
508 sqlite3_finalize(stmt);
509 return -1;
510 }
511
512 rc = sqlite3_bind_text(stmt, 1, maker, -1, NULL);
513 if (rc) {
514 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
515 fprintf(stderr, err);
516 show_err_msg(GTK_MESSAGE_ERROR, err);
517 g_free(err);
518 sqlite3_finalize(stmt);
519 return -1;
520 }
521
522 if (sqlite3_step(stmt) == SQLITE_ROW) {
523 id = sqlite3_column_int64(stmt, 0);
524 }
525
526 sqlite3_finalize(stmt);
527
528 return id;
529 }
530
531 GSList* get_lens_by_maker(gint id) {
532 gint rc;
533 sqlite3_stmt* stmt;
534 GSList* lenses = NULL;
535
536 rc = sqlite3_prepare_v2(db, "select sn, description, notes, id from lens where maker = ?1", -1, &stmt, 0);
537 if (rc != SQLITE_OK) {
538 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
539 fprintf(stderr, err);
540 show_err_msg(GTK_MESSAGE_ERROR, err);
541 g_free(err);
542 sqlite3_finalize(stmt);
543 return NULL;
544 }
545
546 rc = sqlite3_bind_int64(stmt, 1, id);
547 if (rc) {
548 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
549 fprintf(stderr, err);
550 show_err_msg(GTK_MESSAGE_ERROR, err);
551 g_free(err);
552 sqlite3_finalize(stmt);
553 return NULL;
554 }
555
556 while (sqlite3_step(stmt) == SQLITE_ROW) {
557 Row* row = row_new();
558 row->sn = g_strdup((const gchar*)sqlite3_column_text(stmt, 0));
559 row->data = g_strdup((const gchar*)sqlite3_column_text(stmt, 1));
560 row->notes = g_strdup((const gchar*)sqlite3_column_text(stmt, 2));
561 row->id = sqlite3_column_int64(stmt, 3);
562 lenses = g_slist_append(lenses, row);
563 }
564
565 sqlite3_finalize(stmt);
566
567 return lenses;
568 }
569
570 GSList* get_lens_by_search(const Row* row) {
571 gint rc;
572 sqlite3_stmt* stmt;
573 GSList* lenses = NULL;
574 gchar* bind1 = NULL;
575 gchar* bind2 = NULL;
576 gchar* sql = NULL;
577
578 if (row->notes && row->data) {
579 sql = g_strconcat(search, " where ",
580 "upper(m.maker) like '%' || upper(?1) || '%' and upper(l.description) like '%' || upper(?2) || '%'",
581 NULL);
582 bind1 = g_strdup(row->notes);
583 bind2 = g_strdup(row->data);
584 } else if (!row->notes && !row->data) {
585 sql = g_strconcat(search, NULL);
586 } else {
587 if (row->notes) {
588 sql = g_strconcat(search, " where upper(m.maker) like '%' || upper(?1) || '%'", NULL);
589 bind1 = g_strdup(row->notes);
590 } else {
591 sql = g_strconcat(search, " where upper(l.description) like '%' || upper(?1) || '%'", NULL);
592 bind1 = g_strdup(row->data);
593 }
594 }
595
596 rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);
597 if (rc != SQLITE_OK) {
598 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
599 fprintf(stderr, err);
600 show_err_msg(GTK_MESSAGE_ERROR, err);
601 g_free(err);
602 sqlite3_finalize(stmt);
603 return NULL;
604 }
605
606 if (bind1) {
607 rc = sqlite3_bind_text(stmt, 1, bind1, -1, NULL);
608 if (rc) {
609 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
610 fprintf(stderr, err);
611 show_err_msg(GTK_MESSAGE_ERROR, err);
612 g_free(err);
613 sqlite3_finalize(stmt);
614 return NULL;
615 }
616 }
617
618 if (bind2) {
619 rc = sqlite3_bind_text(stmt, 2, bind2, -1, NULL);
620 if (rc) {
621 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
622 fprintf(stderr, err);
623 show_err_msg(GTK_MESSAGE_ERROR, err);
624 g_free(err);
625 sqlite3_finalize(stmt);
626 return NULL;
627 }
628 }
629
630 while (sqlite3_step(stmt) == SQLITE_ROW) {
631 Row* row = row_new();
632 row->id = sqlite3_column_int64(stmt, 0);
633 row->sn = g_strdup((const gchar*)sqlite3_column_text(stmt, 1));
634 row->data = g_strdup((const gchar*)sqlite3_column_text(stmt, 2));
635 row->notes = g_strdup((const gchar*)sqlite3_column_text(stmt, 3));
636 row->maker = sqlite3_column_int64(stmt, 4);
637 lenses = g_slist_append(lenses, row);
638 }
639
640 sqlite3_finalize(stmt);
641 g_free(bind1);
642 g_free(bind2);
643
644 return lenses;
645 }
646
647 Row* row_new() {
648 Row* row = g_new0(Row, 1);
649 row->id = 0;
650
651 return row;
652 }
653
654 void row_free(gpointer data, gpointer user_data) {
655 Row* row = (Row *) data;
656 g_free(row->sn);
657 g_free(row->data);
658 g_free(row->notes);
659 g_free(row);
660 }
661
This page took 1.488296 seconds and 6 git commands to generate.