]> git.datanom.net - lensdb.git/blob - src/sqlite-storage.c
Fix collecting lens data
[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 if (maker) {
417 g_free(maker->maker_name);
418 g_free(maker);
419 }
420 }
421
422 gint delete_maker(const gchar* maker, gchar** error) {
423 gint rc;
424 sqlite3_stmt* stmt;
425 gint status = 0;
426
427 gint id = get_maker_id(maker);
428 rc = sqlite3_prepare_v2(db, "delete from lensmaker where id = ?1", -1, &stmt, 0);
429 if (rc != SQLITE_OK) {
430 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
431 fprintf(stderr, err);
432 show_err_msg(GTK_MESSAGE_ERROR, err);
433 g_free(err);
434 if (error)
435 *error = g_strdup(sqlite3_errmsg(db));
436 sqlite3_finalize(stmt);
437
438 return 1;
439 }
440
441 rc = sqlite3_bind_int(stmt, 1, id);
442 if (rc) {
443 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
444 fprintf(stderr, err);
445 show_err_msg(GTK_MESSAGE_ERROR, err);
446 g_free(err);
447 if (error)
448 *error = g_strdup(sqlite3_errmsg(db));
449 sqlite3_finalize(stmt);
450
451 return 1;
452 }
453
454 //fprintf(stderr, "%s\n", sqlite3_expanded_sql(stmt));
455 rc = sqlite3_step(stmt);
456 if (rc != SQLITE_DONE) {
457 gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
458 fprintf(stderr, err);
459 show_err_msg(GTK_MESSAGE_ERROR, err);
460 g_free(err);
461 if (error)
462 *error = g_strdup(sqlite3_errmsg(db));
463 sqlite3_finalize(stmt);
464
465 status = 1;
466 }
467
468 sqlite3_finalize(stmt);
469
470 return status;
471 }
472
473 GSList* get_makers() {
474 gint rc;
475 sqlite3_stmt* stmt;
476 GSList* makers = NULL;
477
478 rc = sqlite3_prepare_v2(db, "select maker from lensmaker order by id", -1, &stmt, 0);
479 if (rc != SQLITE_OK) {
480 gchar* err = g_strdup_printf("Failed to fetch data: %s\n", sqlite3_errmsg(db));
481 fprintf(stderr, err);
482 show_err_msg(GTK_MESSAGE_ERROR, err);
483 g_free(err);
484 sqlite3_finalize(stmt);
485 return NULL;
486 }
487
488 while (sqlite3_step(stmt) == SQLITE_ROW) {
489 gchar* maker = g_strdup((const gchar*)sqlite3_column_text(stmt, 0));
490 makers = g_slist_append(makers, maker);
491 }
492
493 sqlite3_finalize(stmt);
494
495 return makers;
496 }
497
498 gint get_maker_id(const gchar* maker) {
499 gint rc;
500 sqlite3_stmt* stmt;
501 gint id = -1;
502
503 rc = sqlite3_prepare_v2(db, "select id from lensmaker where maker = ?1", -1, &stmt, 0);
504 if (rc != SQLITE_OK) {
505 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
506 fprintf(stderr, err);
507 show_err_msg(GTK_MESSAGE_ERROR, err);
508 g_free(err);
509 sqlite3_finalize(stmt);
510 return -1;
511 }
512
513 rc = sqlite3_bind_text(stmt, 1, maker, -1, NULL);
514 if (rc) {
515 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
516 fprintf(stderr, err);
517 show_err_msg(GTK_MESSAGE_ERROR, err);
518 g_free(err);
519 sqlite3_finalize(stmt);
520 return -1;
521 }
522
523 if (sqlite3_step(stmt) == SQLITE_ROW) {
524 id = sqlite3_column_int64(stmt, 0);
525 }
526
527 sqlite3_finalize(stmt);
528
529 return id;
530 }
531
532 GSList* get_lens_by_maker(gint id) {
533 gint rc;
534 sqlite3_stmt* stmt;
535 GSList* lenses = NULL;
536
537 rc = sqlite3_prepare_v2(db, "select sn, description, notes, id from lens where maker = ?1", -1, &stmt, 0);
538 if (rc != SQLITE_OK) {
539 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
540 fprintf(stderr, err);
541 show_err_msg(GTK_MESSAGE_ERROR, err);
542 g_free(err);
543 sqlite3_finalize(stmt);
544 return NULL;
545 }
546
547 rc = sqlite3_bind_int64(stmt, 1, id);
548 if (rc) {
549 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
550 fprintf(stderr, err);
551 show_err_msg(GTK_MESSAGE_ERROR, err);
552 g_free(err);
553 sqlite3_finalize(stmt);
554 return NULL;
555 }
556
557 while (sqlite3_step(stmt) == SQLITE_ROW) {
558 Row* row = row_new();
559 row->sn = g_strdup((const gchar*)sqlite3_column_text(stmt, 0));
560 row->data = g_strdup((const gchar*)sqlite3_column_text(stmt, 1));
561 row->notes = g_strdup((const gchar*)sqlite3_column_text(stmt, 2));
562 row->id = sqlite3_column_int64(stmt, 3);
563 lenses = g_slist_append(lenses, row);
564 }
565
566 sqlite3_finalize(stmt);
567
568 return lenses;
569 }
570
571 GSList* get_lens_by_search(const Row* row) {
572 gint rc;
573 sqlite3_stmt* stmt;
574 GSList* lenses = NULL;
575 gchar* bind1 = NULL;
576 gchar* bind2 = NULL;
577 gchar* sql = NULL;
578
579 if (row->notes && row->data) {
580 sql = g_strconcat(search, " where ",
581 "upper(m.maker) like '%' || upper(?1) || '%' and upper(l.description) like '%' || upper(?2) || '%'",
582 NULL);
583 bind1 = g_strdup(row->notes);
584 bind2 = g_strdup(row->data);
585 } else if (!row->notes && !row->data) {
586 sql = g_strconcat(search, NULL);
587 } else {
588 if (row->notes) {
589 sql = g_strconcat(search, " where upper(m.maker) like '%' || upper(?1) || '%'", NULL);
590 bind1 = g_strdup(row->notes);
591 } else {
592 sql = g_strconcat(search, " where upper(l.description) like '%' || upper(?1) || '%'", NULL);
593 bind1 = g_strdup(row->data);
594 }
595 }
596
597 rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);
598 if (rc != SQLITE_OK) {
599 gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
600 fprintf(stderr, err);
601 show_err_msg(GTK_MESSAGE_ERROR, err);
602 g_free(err);
603 sqlite3_finalize(stmt);
604 return NULL;
605 }
606
607 if (bind1) {
608 rc = sqlite3_bind_text(stmt, 1, bind1, -1, NULL);
609 if (rc) {
610 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
611 fprintf(stderr, err);
612 show_err_msg(GTK_MESSAGE_ERROR, err);
613 g_free(err);
614 sqlite3_finalize(stmt);
615 return NULL;
616 }
617 }
618
619 if (bind2) {
620 rc = sqlite3_bind_text(stmt, 2, bind2, -1, NULL);
621 if (rc) {
622 gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
623 fprintf(stderr, err);
624 show_err_msg(GTK_MESSAGE_ERROR, err);
625 g_free(err);
626 sqlite3_finalize(stmt);
627 return NULL;
628 }
629 }
630
631 while (sqlite3_step(stmt) == SQLITE_ROW) {
632 Row* row = row_new();
633 row->id = sqlite3_column_int64(stmt, 0);
634 row->sn = g_strdup((const gchar*)sqlite3_column_text(stmt, 1));
635 row->data = g_strdup((const gchar*)sqlite3_column_text(stmt, 2));
636 row->notes = g_strdup((const gchar*)sqlite3_column_text(stmt, 3));
637 row->maker = sqlite3_column_int64(stmt, 4);
638 lenses = g_slist_append(lenses, row);
639 }
640
641 sqlite3_finalize(stmt);
642 g_free(bind1);
643 g_free(bind2);
644
645 return lenses;
646 }
647
648 Row* row_new() {
649 Row* row = g_new0(Row, 1);
650 row->id = 0;
651
652 return row;
653 }
654
655 void row_free(gpointer data, gpointer user_data) {
656 Row* row = (Row *) data;
657 g_free(row->sn);
658 g_free(row->data);
659 g_free(row->notes);
660 g_free(row);
661 }
662
This page took 1.580454 seconds and 6 git commands to generate.