]> git.datanom.net - lensdb.git/blob - src/sqlite-storage.c
Check for exiftool
[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) returning id", -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_ROW) {
316 gchar* err = g_strdup_printf("Couldn't insert maker: %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 } else {
323 status = sqlite3_column_int64(stmt, 0);
324 }
325
326 sqlite3_finalize(stmt);
327
328 return status;
329 }
330
331 Maker* get_maker(gint id) {
332 gint rc;
333 sqlite3_stmt* stmt;
334 Maker* maker = NULL;
335
336 rc = sqlite3_prepare_v2(db, "select maker, page from lensmaker where id = ?1", -1, &stmt, 0);
337 if (rc != SQLITE_OK) {
338 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
339 fprintf(stderr, err);
340 show_err_msg(GTK_MESSAGE_ERROR, err);
341 g_free(err);
342 sqlite3_finalize(stmt);
343 return NULL;
344 }
345
346 rc = sqlite3_bind_int64(stmt, 1, id);
347 if (rc) {
348 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
349 fprintf(stderr, err);
350 show_err_msg(GTK_MESSAGE_ERROR, err);
351 g_free(err);
352 sqlite3_finalize(stmt);
353 return NULL;
354 }
355
356 if (sqlite3_step(stmt) == SQLITE_ROW) {
357 maker = g_new0(Maker, 1);
358 maker->id = id;
359 maker->maker_name = g_strdup((const gchar*)sqlite3_column_text(stmt, 0));
360 maker->page = sqlite3_column_int(stmt, 1);
361 }
362
363 sqlite3_finalize(stmt);
364
365 return maker;
366 }
367
368 void update_maker(const Maker* maker) {
369 gint rc;
370 sqlite3_stmt* stmt;
371
372 rc = sqlite3_prepare_v2(db, "update lensmaker set page = ?1 where id = ?2", -1, &stmt, 0);
373 if (rc != SQLITE_OK) {
374 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
375 fprintf(stderr, err);
376 show_err_msg(GTK_MESSAGE_ERROR, err);
377 g_free(err);
378 sqlite3_finalize(stmt);
379 return;
380 }
381
382 rc = sqlite3_bind_int(stmt, 1, maker->page);
383 if (rc) {
384 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
385 fprintf(stderr, err);
386 show_err_msg(GTK_MESSAGE_ERROR, err);
387 g_free(err);
388 sqlite3_finalize(stmt);
389 return;
390 }
391
392 rc = sqlite3_bind_int64(stmt, 2, maker->id);
393 if (rc) {
394 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
395 fprintf(stderr, err);
396 show_err_msg(GTK_MESSAGE_ERROR, err);
397 g_free(err);
398 sqlite3_finalize(stmt);
399 return;
400 }
401
402 //fprintf(stderr, "%s\n", sqlite3_expanded_sql(stmt));
403 rc = sqlite3_step(stmt);
404 if (rc != SQLITE_DONE) {
405 gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
406 fprintf(stderr, err);
407 show_err_msg(GTK_MESSAGE_ERROR, err);
408 g_free(err);
409 sqlite3_finalize(stmt);
410 }
411
412 sqlite3_finalize(stmt);
413 }
414
415 void maker_free(Maker* maker) {
416 g_free(maker->maker_name);
417 g_free(maker);
418 }
419
420 gint delete_maker(const gchar* maker, gchar** error) {
421 gint rc;
422 sqlite3_stmt* stmt;
423 gint status = 0;
424
425 gint id = get_maker_id(maker);
426 rc = sqlite3_prepare_v2(db, "delete from lensmaker where id = ?1", -1, &stmt, 0);
427 if (rc != SQLITE_OK) {
428 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
429 fprintf(stderr, err);
430 show_err_msg(GTK_MESSAGE_ERROR, err);
431 g_free(err);
432 if (error)
433 *error = g_strdup(sqlite3_errmsg(db));
434 sqlite3_finalize(stmt);
435
436 return 1;
437 }
438
439 rc = sqlite3_bind_int(stmt, 1, id);
440 if (rc) {
441 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
442 fprintf(stderr, err);
443 show_err_msg(GTK_MESSAGE_ERROR, err);
444 g_free(err);
445 if (error)
446 *error = g_strdup(sqlite3_errmsg(db));
447 sqlite3_finalize(stmt);
448
449 return 1;
450 }
451
452 //fprintf(stderr, "%s\n", sqlite3_expanded_sql(stmt));
453 rc = sqlite3_step(stmt);
454 if (rc != SQLITE_DONE) {
455 gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
456 fprintf(stderr, err);
457 show_err_msg(GTK_MESSAGE_ERROR, err);
458 g_free(err);
459 if (error)
460 *error = g_strdup(sqlite3_errmsg(db));
461 sqlite3_finalize(stmt);
462
463 status = 1;
464 }
465
466 sqlite3_finalize(stmt);
467
468 return status;
469 }
470
471 GSList* get_makers() {
472 gint rc;
473 sqlite3_stmt* stmt;
474 GSList* makers = NULL;
475
476 rc = sqlite3_prepare_v2(db, "select maker from lensmaker order by id", -1, &stmt, 0);
477 if (rc != SQLITE_OK) {
478 gchar* err = g_strdup_printf("Failed to fetch data: %s\n", sqlite3_errmsg(db));
479 fprintf(stderr, err);
480 show_err_msg(GTK_MESSAGE_ERROR, err);
481 g_free(err);
482 sqlite3_finalize(stmt);
483 return NULL;
484 }
485
486 while (sqlite3_step(stmt) == SQLITE_ROW) {
487 gchar* maker = g_strdup((const gchar*)sqlite3_column_text(stmt, 0));
488 makers = g_slist_append(makers, maker);
489 }
490
491 sqlite3_finalize(stmt);
492
493 return makers;
494 }
495
496 gint get_maker_id(const gchar* maker) {
497 gint rc;
498 sqlite3_stmt* stmt;
499 gint id = -1;
500
501 rc = sqlite3_prepare_v2(db, "select id from lensmaker where maker = ?1", -1, &stmt, 0);
502 if (rc != SQLITE_OK) {
503 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
504 fprintf(stderr, err);
505 show_err_msg(GTK_MESSAGE_ERROR, err);
506 g_free(err);
507 sqlite3_finalize(stmt);
508 return -1;
509 }
510
511 rc = sqlite3_bind_text(stmt, 1, maker, -1, NULL);
512 if (rc) {
513 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
514 fprintf(stderr, err);
515 show_err_msg(GTK_MESSAGE_ERROR, err);
516 g_free(err);
517 sqlite3_finalize(stmt);
518 return -1;
519 }
520
521 if (sqlite3_step(stmt) == SQLITE_ROW) {
522 id = sqlite3_column_int64(stmt, 0);
523 }
524
525 sqlite3_finalize(stmt);
526
527 return id;
528 }
529
530 GSList* get_lens_by_maker(gint id) {
531 gint rc;
532 sqlite3_stmt* stmt;
533 GSList* lenses = NULL;
534
535 rc = sqlite3_prepare_v2(db, "select sn, description, notes, id from lens where maker = ?1", -1, &stmt, 0);
536 if (rc != SQLITE_OK) {
537 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
538 fprintf(stderr, err);
539 show_err_msg(GTK_MESSAGE_ERROR, err);
540 g_free(err);
541 sqlite3_finalize(stmt);
542 return NULL;
543 }
544
545 rc = sqlite3_bind_int64(stmt, 1, id);
546 if (rc) {
547 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
548 fprintf(stderr, err);
549 show_err_msg(GTK_MESSAGE_ERROR, err);
550 g_free(err);
551 sqlite3_finalize(stmt);
552 return NULL;
553 }
554
555 while (sqlite3_step(stmt) == SQLITE_ROW) {
556 Row* row = row_new();
557 row->sn = g_strdup((const gchar*)sqlite3_column_text(stmt, 0));
558 row->data = g_strdup((const gchar*)sqlite3_column_text(stmt, 1));
559 row->notes = g_strdup((const gchar*)sqlite3_column_text(stmt, 2));
560 row->id = sqlite3_column_int64(stmt, 3);
561 lenses = g_slist_append(lenses, row);
562 }
563
564 sqlite3_finalize(stmt);
565
566 return lenses;
567 }
568
569 GSList* get_lens_by_search(const Row* row) {
570 gint rc;
571 sqlite3_stmt* stmt;
572 GSList* lenses = NULL;
573 gchar* bind1 = NULL;
574 gchar* bind2 = NULL;
575 gchar* sql = NULL;
576
577 if (row->notes && row->data) {
578 sql = g_strconcat(search, " where ",
579 "upper(m.maker) like '%' || upper(?1) || '%' and upper(l.description) like '%' || upper(?2) || '%'",
580 NULL);
581 bind1 = g_strdup(row->notes);
582 bind2 = g_strdup(row->data);
583 } else if (!row->notes && !row->data) {
584 sql = g_strconcat(search, NULL);
585 } else {
586 if (row->notes) {
587 sql = g_strconcat(search, " where upper(m.maker) like '%' || upper(?1) || '%'", NULL);
588 bind1 = g_strdup(row->notes);
589 } else {
590 sql = g_strconcat(search, " where upper(l.description) like '%' || upper(?1) || '%'", NULL);
591 bind1 = g_strdup(row->data);
592 }
593 }
594
595 rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);
596 if (rc != SQLITE_OK) {
597 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
598 fprintf(stderr, err);
599 show_err_msg(GTK_MESSAGE_ERROR, err);
600 g_free(err);
601 sqlite3_finalize(stmt);
602 return NULL;
603 }
604
605 if (bind1) {
606 rc = sqlite3_bind_text(stmt, 1, bind1, -1, NULL);
607 if (rc) {
608 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
609 fprintf(stderr, err);
610 show_err_msg(GTK_MESSAGE_ERROR, err);
611 g_free(err);
612 sqlite3_finalize(stmt);
613 return NULL;
614 }
615 }
616
617 if (bind2) {
618 rc = sqlite3_bind_text(stmt, 2, bind2, -1, NULL);
619 if (rc) {
620 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
621 fprintf(stderr, err);
622 show_err_msg(GTK_MESSAGE_ERROR, err);
623 g_free(err);
624 sqlite3_finalize(stmt);
625 return NULL;
626 }
627 }
628
629 while (sqlite3_step(stmt) == SQLITE_ROW) {
630 Row* row = row_new();
631 row->id = sqlite3_column_int64(stmt, 0);
632 row->sn = g_strdup((const gchar*)sqlite3_column_text(stmt, 1));
633 row->data = g_strdup((const gchar*)sqlite3_column_text(stmt, 2));
634 row->notes = g_strdup((const gchar*)sqlite3_column_text(stmt, 3));
635 row->maker = sqlite3_column_int64(stmt, 4);
636 lenses = g_slist_append(lenses, row);
637 }
638
639 sqlite3_finalize(stmt);
640 g_free(bind1);
641 g_free(bind2);
642
643 return lenses;
644 }
645
646 Row* row_new() {
647 Row* row = g_new0(Row, 1);
648 row->id = 0;
649
650 return row;
651 }
652
653 void row_free(gpointer data, gpointer user_data) {
654 Row* row = (Row *) data;
655 g_free(row->sn);
656 g_free(row->data);
657 g_free(row->notes);
658 g_free(row);
659 }
660
This page took 1.219484 seconds and 6 git commands to generate.