]> git.datanom.net - lensdb.git/blobdiff - src/sqlite-storage.c
Import and overwrite
[lensdb.git] / src / sqlite-storage.c
index 8206387037b612080da921b06038da6ba8357a82..a4ff57a8d33a925f0aa9a41235e999bc19a2bc93 100644 (file)
 
 #include <stdio.h>
 #include "sqlite-storage.h"
 
 #include <stdio.h>
 #include "sqlite-storage.h"
+#include "gui.h"
 #define DBNAME "lensdb.db"
 
 static sqlite3* db = NULL;
 static gchar* lensmaker = "create table lensmaker("
 #define DBNAME "lensdb.db"
 
 static sqlite3* db = NULL;
 static gchar* lensmaker = "create table lensmaker("
-                                                "id integer primary key not null AUTOINCREMENT,"
-                                                "maker text not null,"
-                                                "page int DEFAULT -1);";
+                                                "id integer not null,"
+                                                "maker text not null UNIQUE,"
+                                                "page int DEFAULT -1,"
+                                                "PRIMARY KEY(id AUTOINCREMENT));";
 static gchar* lens = "create table lens("
 static gchar* lens = "create table lens("
-                                        "id integer primary key not null AUTOINCREMENT,"
+                                        "id integer not null,"
                                         "sn text not null,"
                                         "maker integer not null,"
                                         "description text not null,"
                                         "notes text,"
                                         "sn text not null,"
                                         "maker integer not null,"
                                         "description text not null,"
                                         "notes text,"
+                                        "date_added datetime DEFAULT current_timestamp,"
+                                        "PRIMARY KEY(id AUTOINCREMENT),"
                                         "constraint fk_maker foreign key (maker) references lensmaker (id)"
                                         " on delete cascade);";
 static gchar* search = "SELECT l.id, l.sn, l.description, l.notes, l.maker"
                                           " FROM lens l JOIN lensmaker m on l.maker = m.id";
                                         "constraint fk_maker foreign key (maker) references lensmaker (id)"
                                         " on delete cascade);";
 static gchar* search = "SELECT l.id, l.sn, l.description, l.notes, l.maker"
                                           " FROM lens l JOIN lensmaker m on l.maker = m.id";
+static gchar* all = "SELECT m.maker,l.sn,l.description,l.notes,l.date_added"
+                                       " FROM lensmaker m JOIN lens l on m.id = l.maker";
 
 void close_storage() {
        if (db != NULL)
 
 void close_storage() {
        if (db != NULL)
@@ -59,26 +65,38 @@ gint init_storage(const gchar* path) {
        g_free(file);
        
        if (rc) {
        g_free(file);
        
        if (rc) {
-               fprintf(stderr, "Failed to open DB: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Failed to open DB: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
                return 1;
        }
        
        if (init_db) {
                rc = sqlite3_exec(db, "PRAGMA foreign_keys = ON", 0, 0, &ErrMsg);
                if (rc != SQLITE_OK) {
                return 1;
        }
        
        if (init_db) {
                rc = sqlite3_exec(db, "PRAGMA foreign_keys = ON", 0, 0, &ErrMsg);
                if (rc != SQLITE_OK) {
-                       fprintf(stderr, "SQL error: %s\n", ErrMsg);
+                       gchar* err = g_strdup_printf("SQL error: %s\n", ErrMsg);
+                       fprintf(stderr, err);
+                       show_message(GTK_MESSAGE_ERROR, err);
+                       g_free(err);
                        sqlite3_free(ErrMsg);
                        ErrMsg = NULL;
                }
                rc = sqlite3_exec(db, lensmaker, 0, 0, &ErrMsg);
                if (rc != SQLITE_OK) {
                        sqlite3_free(ErrMsg);
                        ErrMsg = NULL;
                }
                rc = sqlite3_exec(db, lensmaker, 0, 0, &ErrMsg);
                if (rc != SQLITE_OK) {
-                       fprintf(stderr, "SQL error: %s\n", ErrMsg);
+                       gchar* err = g_strdup_printf("SQL error: %s\n", ErrMsg);
+                       fprintf(stderr, err);
+                       show_message(GTK_MESSAGE_ERROR, err);
+                       g_free(err);
                        sqlite3_free(ErrMsg);
                        ErrMsg = NULL;
                }
                rc = sqlite3_exec(db, lens, 0, 0, &ErrMsg);
                if (rc != SQLITE_OK) {
                        sqlite3_free(ErrMsg);
                        ErrMsg = NULL;
                }
                rc = sqlite3_exec(db, lens, 0, 0, &ErrMsg);
                if (rc != SQLITE_OK) {
-                       fprintf(stderr, "SQL error: %s\n", ErrMsg);
+                       gchar* err = g_strdup_printf("SQL error: %s\n", ErrMsg);
+                       fprintf(stderr, err);
+                       show_message(GTK_MESSAGE_ERROR, err);
+                       g_free(err);
                        sqlite3_free(ErrMsg);
                }
        }
                        sqlite3_free(ErrMsg);
                }
        }
@@ -86,42 +104,69 @@ gint init_storage(const gchar* path) {
        return 0;
 }
 
        return 0;
 }
 
-gint add_lens(const Row* row) {
+gint add_lens(Row* row) {
        gint rc;
        sqlite3_stmt* stmt;
        gint status = 1;
        
        gint rc;
        sqlite3_stmt* stmt;
        gint status = 1;
        
-       rc = sqlite3_prepare_v2(db, "inserte lens (sn, description, notes) values (?1, ?2, ?3)", -1, &stmt, 0);
+       rc = sqlite3_prepare_v2(db, "insert into lens (sn, maker, description, notes) values (?1, ?2, ?3, ?4) returning id", -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
        if (rc != SQLITE_OK) {   
-        fprintf(stderr, "Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
         sqlite3_finalize(stmt);
         return status;
     }  
     
     rc = sqlite3_bind_text(stmt, 1, row->sn, -1, NULL);
     if (rc) {
         sqlite3_finalize(stmt);
         return status;
     }  
     
     rc = sqlite3_bind_text(stmt, 1, row->sn, -1, NULL);
     if (rc) {
-               fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
                sqlite3_finalize(stmt);
                return status;
        }
        
                sqlite3_finalize(stmt);
                return status;
        }
        
-    rc = sqlite3_bind_text(stmt, 2, row->data, -1, NULL);
+    rc = sqlite3_bind_int(stmt, 2, row->maker);
     if (rc) {
     if (rc) {
-               fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
                sqlite3_finalize(stmt);
                return status;
        }
        
                sqlite3_finalize(stmt);
                return status;
        }
        
-    rc = sqlite3_bind_text(stmt, 3, row->notes, -1, NULL);
+    rc = sqlite3_bind_text(stmt, 3, row->data, -1, NULL);
     if (rc) {
     if (rc) {
-               fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
                sqlite3_finalize(stmt);
                return status;
        }
        
                sqlite3_finalize(stmt);
                return status;
        }
        
-    if (sqlite3_step(stmt) != SQLITE_DONE) {
-               fprintf(stderr, "Step failure: %s\n", sqlite3_errmsg(db));
+    rc = sqlite3_bind_text(stmt, 4, row->notes, -1, NULL);
+    if (rc) {
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               sqlite3_finalize(stmt);
+               return status;
+       }
+       
+       rc = sqlite3_step(stmt);
+    if (rc != SQLITE_ROW) {
+               gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
     } else {
     } else {
+               row->id = sqlite3_column_int64(stmt, 0);
                status = 0;
        }
     
                status = 0;
        }
     
@@ -137,41 +182,60 @@ gint update_lens(const Row* row) {
        
        rc = sqlite3_prepare_v2(db, "update lens set sn = ?1, description = ?2, notes = ?3  where id = ?4", -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
        
        rc = sqlite3_prepare_v2(db, "update lens set sn = ?1, description = ?2, notes = ?3  where id = ?4", -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
-        fprintf(stderr, "Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
-        sqlite3_finalize(stmt);
+               gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               sqlite3_finalize(stmt);
         return status;
     }  
     
     rc = sqlite3_bind_text(stmt, 1, row->sn, -1, NULL);
     if (rc) {
         return status;
     }  
     
     rc = sqlite3_bind_text(stmt, 1, row->sn, -1, NULL);
     if (rc) {
-               fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
                sqlite3_finalize(stmt);
                return status;
        }
        
     rc = sqlite3_bind_text(stmt, 2, row->data, -1, NULL);
     if (rc) {
                sqlite3_finalize(stmt);
                return status;
        }
        
     rc = sqlite3_bind_text(stmt, 2, row->data, -1, NULL);
     if (rc) {
-               fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
                sqlite3_finalize(stmt);
                return status;
        }
        
     rc = sqlite3_bind_text(stmt, 3, row->notes, -1, NULL);
     if (rc) {
                sqlite3_finalize(stmt);
                return status;
        }
        
     rc = sqlite3_bind_text(stmt, 3, row->notes, -1, NULL);
     if (rc) {
-               fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
                sqlite3_finalize(stmt);
                return status;
        }
        
     rc = sqlite3_bind_int64(stmt, 4, row->id);
     if (rc) {
                sqlite3_finalize(stmt);
                return status;
        }
        
     rc = sqlite3_bind_int64(stmt, 4, row->id);
     if (rc) {
-               fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
                sqlite3_finalize(stmt);
                return status;
        }
        
                sqlite3_finalize(stmt);
                return status;
        }
        
-    if (sqlite3_step(stmt) != SQLITE_DONE) {
-               fprintf(stderr, "Step failure: %s\n", sqlite3_errmsg(db));
+       rc = sqlite3_step(stmt); 
+    if (rc != SQLITE_DONE) {
+               gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
     } else {
                status = 0;
        }
     } else {
                status = 0;
        }
@@ -181,12 +245,142 @@ gint update_lens(const Row* row) {
        return status;
 }
 
        return status;
 }
 
-gint add_maker(const gchar* maker) {
+gint update_lens_maker(const Row* row) {
+       gint rc;
+       sqlite3_stmt* stmt;
        gint status = 1;
        
        gint status = 1;
        
+       rc = sqlite3_prepare_v2(db, "update lens set maker = ?1 where id = ?2", -1, &stmt, 0);
+       if (rc != SQLITE_OK) {   
+               gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               sqlite3_finalize(stmt);
+        return status;
+    }  
+    
+    rc = sqlite3_bind_int64(stmt, 1, row->maker);
+    if (rc) {
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               sqlite3_finalize(stmt);
+               return status;
+       }
+       
+    rc = sqlite3_bind_int64(stmt, 2, row->id);
+    if (rc) {
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               sqlite3_finalize(stmt);
+               return status;
+       }
+       
+       rc = sqlite3_step(stmt); 
+    if (rc != SQLITE_DONE) {
+               gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+    } else {
+               status = 0;
+       }
+    
+    sqlite3_finalize(stmt);
+
        return status;
 }
 
        return status;
 }
 
+gint delete_lens(const Row* row) {
+       gint rc;
+       sqlite3_stmt* stmt;
+       gint status = 1;
+       
+       rc = sqlite3_prepare_v2(db, "delete from lens where id = ?1", -1, &stmt, 0);
+       if (rc != SQLITE_OK) {   
+               gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               sqlite3_finalize(stmt);
+        return status;
+    }  
+    
+    rc = sqlite3_bind_int64(stmt, 1, row->id);
+    if (rc) {
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               sqlite3_finalize(stmt);
+               return status;
+       }
+       
+       rc = sqlite3_step(stmt); 
+    if (rc != SQLITE_DONE) {
+               gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+    } else {
+               status = 0;
+       }
+    
+    sqlite3_finalize(stmt);
+
+       return status;
+}
+
+gint add_maker(const gchar* maker, gchar** error) {
+       gint rc;
+       sqlite3_stmt* stmt;
+       gint id = -1;
+       
+       rc = sqlite3_prepare_v2(db, "insert into lensmaker (maker) values (?1) returning id", -1, &stmt, 0);
+       if (rc != SQLITE_OK) {
+               gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               if (error)
+                       *error = g_strdup(sqlite3_errmsg(db));
+        sqlite3_finalize(stmt);
+        return id;
+    }  
+    
+    rc = sqlite3_bind_text(stmt, 1, maker, -1, NULL);
+    if (rc) {
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               if (error)
+                       *error = g_strdup(sqlite3_errmsg(db));
+               sqlite3_finalize(stmt);
+               return id;
+       }
+       
+       rc = sqlite3_step(stmt);
+    if (rc != SQLITE_ROW) {
+               gchar* err = g_strdup_printf("Couldn't insert maker: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               if (error)
+                       *error = g_strdup(sqlite3_errmsg(db));
+    } else {
+               id = sqlite3_column_int64(stmt, 0);
+       }
+
+    sqlite3_finalize(stmt);
+
+       return id;
+}
+
 Maker* get_maker(gint id) {
        gint rc;
        sqlite3_stmt* stmt;
 Maker* get_maker(gint id) {
        gint rc;
        sqlite3_stmt* stmt;
@@ -194,14 +388,20 @@ Maker* get_maker(gint id) {
        
        rc = sqlite3_prepare_v2(db, "select maker, page from lensmaker where id = ?1", -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
        
        rc = sqlite3_prepare_v2(db, "select maker, page from lensmaker where id = ?1", -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
-        fprintf(stderr, "Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
         sqlite3_finalize(stmt);
         return NULL;
     }  
     
     rc = sqlite3_bind_int64(stmt, 1, id);
     if (rc) {
         sqlite3_finalize(stmt);
         return NULL;
     }  
     
     rc = sqlite3_bind_int64(stmt, 1, id);
     if (rc) {
-               fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
                sqlite3_finalize(stmt);
                return NULL;
        }
                sqlite3_finalize(stmt);
                return NULL;
        }
@@ -224,40 +424,102 @@ void update_maker(const Maker* maker) {
        
        rc = sqlite3_prepare_v2(db, "update lensmaker set page = ?1 where id = ?2", -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
        
        rc = sqlite3_prepare_v2(db, "update lensmaker set page = ?1 where id = ?2", -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
-        fprintf(stderr, "Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
         sqlite3_finalize(stmt);
         return;
     }  
     
         sqlite3_finalize(stmt);
         return;
     }  
     
-    rc = sqlite3_bind_int64(stmt, 1, maker->page);
+    rc = sqlite3_bind_int(stmt, 1, maker->page);
     if (rc) {
     if (rc) {
-               fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
                sqlite3_finalize(stmt);
                return;
        }
        
                sqlite3_finalize(stmt);
                return;
        }
        
-    rc = sqlite3_bind_int64(stmt, 1, maker->id);
+    rc = sqlite3_bind_int64(stmt, 2, maker->id);
     if (rc) {
     if (rc) {
-               fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
                sqlite3_finalize(stmt);
                return;
        }
        
                sqlite3_finalize(stmt);
                return;
        }
        
-    if (sqlite3_step(stmt) != SQLITE_DONE) {
-               fprintf(stderr, "Step failure: %s\n", sqlite3_errmsg(db));
+       //fprintf(stderr, "%s\n", sqlite3_expanded_sql(stmt));
+       rc = sqlite3_step(stmt);
+    if (rc != SQLITE_DONE) {
+               gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               sqlite3_finalize(stmt);
     }
     }
-    
-    sqlite3_finalize(stmt);
+
+       sqlite3_finalize(stmt);
 }
 
 void maker_free(Maker* maker) {
 }
 
 void maker_free(Maker* maker) {
-       g_free(maker->maker_name);
-       g_free(maker);
+       if (maker) {
+               g_free(maker->maker_name);
+               g_free(maker);
+       }
 }
 
 }
 
-gint delete_maker(const gchar* maker) {
-       gint status = 1;
+gint delete_maker(const gchar* maker, gchar** error) {
+       gint rc;
+       sqlite3_stmt* stmt;
+       gint status = 0;
        
        
+       gint id = get_maker_id(maker);
+       rc = sqlite3_prepare_v2(db, "delete from lensmaker where id = ?1", -1, &stmt, 0);
+       if (rc != SQLITE_OK) {   
+               gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               if (error)
+                       *error = g_strdup(sqlite3_errmsg(db));
+               sqlite3_finalize(stmt);
+
+               return 1;
+    }    
+
+    rc = sqlite3_bind_int(stmt, 1, id);
+    if (rc) {
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               if (error)
+                       *error = g_strdup(sqlite3_errmsg(db));
+               sqlite3_finalize(stmt);
+
+               return 1;
+       }
+       
+       //fprintf(stderr, "%s\n", sqlite3_expanded_sql(stmt));
+       rc = sqlite3_step(stmt);
+    if (rc != SQLITE_DONE) {
+               gchar* err = g_strdup_printf("Step failure: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               if (error)
+                       *error = g_strdup(sqlite3_errmsg(db));
+               sqlite3_finalize(stmt);
+
+               status = 1;
+    }
+    
+    sqlite3_finalize(stmt);
+
        return status;
 }
 
        return status;
 }
 
@@ -266,10 +528,13 @@ GSList* get_makers() {
        sqlite3_stmt* stmt;
        GSList* makers = NULL;
        
        sqlite3_stmt* stmt;
        GSList* makers = NULL;
        
-       rc = sqlite3_prepare_v2(db, "select maker from lensmaker", -1, &stmt, 0);
+       rc = sqlite3_prepare_v2(db, "select maker from lensmaker order by id", -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
        if (rc != SQLITE_OK) {   
-        fprintf(stderr, "Failed to fetch data: %s\n", sqlite3_errmsg(db));
-        
+               gchar* err = g_strdup_printf("Failed to fetch data: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+               sqlite3_finalize(stmt);
         return NULL;
     }    
     
         return NULL;
     }    
     
@@ -286,18 +551,24 @@ GSList* get_makers() {
 gint get_maker_id(const gchar* maker) {
        gint rc;
        sqlite3_stmt* stmt;
 gint get_maker_id(const gchar* maker) {
        gint rc;
        sqlite3_stmt* stmt;
-       gint id = 0;
+       gint id = -1;
        
        rc = sqlite3_prepare_v2(db, "select id from lensmaker where maker = ?1", -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
        
        rc = sqlite3_prepare_v2(db, "select id from lensmaker where maker = ?1", -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
-        fprintf(stderr, "Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
         sqlite3_finalize(stmt);
         return -1;
     }  
     
     rc = sqlite3_bind_text(stmt, 1, maker, -1, NULL);
     if (rc) {
         sqlite3_finalize(stmt);
         return -1;
     }  
     
     rc = sqlite3_bind_text(stmt, 1, maker, -1, NULL);
     if (rc) {
-               fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
                sqlite3_finalize(stmt);
                return -1;
        }
                sqlite3_finalize(stmt);
                return -1;
        }
@@ -311,12 +582,6 @@ gint get_maker_id(const gchar* maker) {
        return id;
 }
 
        return id;
 }
 
-gint delete_lens(const Row* row) {
-       gint status = 1;
-       
-       return status;
-}
-
 GSList* get_lens_by_maker(gint id) {
        gint rc;
        sqlite3_stmt* stmt;
 GSList* get_lens_by_maker(gint id) {
        gint rc;
        sqlite3_stmt* stmt;
@@ -324,14 +589,20 @@ GSList* get_lens_by_maker(gint id) {
        
        rc = sqlite3_prepare_v2(db, "select sn, description, notes, id from lens where maker = ?1", -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
        
        rc = sqlite3_prepare_v2(db, "select sn, description, notes, id from lens where maker = ?1", -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
-        fprintf(stderr, "Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
         sqlite3_finalize(stmt);
         return NULL;
     }  
     
     rc = sqlite3_bind_int64(stmt, 1, id);
     if (rc) {
         sqlite3_finalize(stmt);
         return NULL;
     }  
     
     rc = sqlite3_bind_int64(stmt, 1, id);
     if (rc) {
-               fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
                sqlite3_finalize(stmt);
                return NULL;
        }
                sqlite3_finalize(stmt);
                return NULL;
        }
@@ -378,7 +649,10 @@ GSList* get_lens_by_search(const Row* row) {
 
        rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
 
        rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);
        if (rc != SQLITE_OK) {   
-        fprintf(stderr, "Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
         sqlite3_finalize(stmt);
         return NULL;
     }  
         sqlite3_finalize(stmt);
         return NULL;
     }  
@@ -386,7 +660,10 @@ GSList* get_lens_by_search(const Row* row) {
     if (bind1) {
                rc = sqlite3_bind_text(stmt, 1, bind1, -1, NULL);
                if (rc) {
     if (bind1) {
                rc = sqlite3_bind_text(stmt, 1, bind1, -1, NULL);
                if (rc) {
-                       fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+                       gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+                       fprintf(stderr, err);
+                       show_message(GTK_MESSAGE_ERROR, err);
+                       g_free(err);
                        sqlite3_finalize(stmt);
                        return NULL;
                }
                        sqlite3_finalize(stmt);
                        return NULL;
                }
@@ -395,7 +672,10 @@ GSList* get_lens_by_search(const Row* row) {
     if (bind2) {
                rc = sqlite3_bind_text(stmt, 2, bind2, -1, NULL);
                if (rc) {
     if (bind2) {
                rc = sqlite3_bind_text(stmt, 2, bind2, -1, NULL);
                if (rc) {
-                       fprintf(stderr, "Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+                       gchar* err = g_strdup_printf("Couldn't bind to prepared sql stmt: %s\n", sqlite3_errmsg(db));
+                       fprintf(stderr, err);
+                       show_message(GTK_MESSAGE_ERROR, err);
+                       g_free(err);
                        sqlite3_finalize(stmt);
                        return NULL;
                }
                        sqlite3_finalize(stmt);
                        return NULL;
                }
@@ -433,3 +713,62 @@ void row_free(gpointer data, gpointer user_data) {
        g_free(row);
 }
 
        g_free(row);
 }
 
+void dump_storage(CsvParser* parser) {
+       gint rc;
+       sqlite3_stmt* stmt;
+       CvsError* err = NULL;
+
+       if (parser == NULL) return;
+       
+       rc = sqlite3_prepare_v2(db, all, -1, &stmt, 0);
+       if (rc != SQLITE_OK) {   
+               gchar* err = g_strdup_printf("Couldn't prepare sql statement: %s\n", sqlite3_errmsg(db));
+               fprintf(stderr, err);
+               show_message(GTK_MESSAGE_ERROR, err);
+               g_free(err);
+        sqlite3_finalize(stmt);
+        return;
+    }  
+       
+       Record* row = g_new0(Record, 1);
+       row->maker = g_strdup("maker");
+       row->sn = g_strdup("sn");
+       row->data = g_strdup("lens");
+       row->notes = g_strdup("notes");
+       row->date = g_strdup("date");
+       csv_parser_dump_row(parser, row, &err);
+       csv_record_free(row);
+       if (err) {
+               gchar* msg = g_strdup_printf("%zu: %s\n", err->line, err->message);
+               fprintf(stderr, msg);
+               show_message(GTK_MESSAGE_ERROR, msg);
+               g_free(msg);
+               csv_error_clear(&err);
+               sqlite3_finalize(stmt);
+               return;
+       }
+       
+       while (sqlite3_step(stmt) == SQLITE_ROW) {
+               row = g_new0(Record, 1);
+               row->maker = g_strdup((const gchar*)sqlite3_column_text(stmt, 0));
+               row->sn = g_strdup((const gchar*)sqlite3_column_text(stmt, 1));
+               row->data = g_strdup((const gchar*)sqlite3_column_text(stmt, 2));
+               row->notes = g_strdup((const gchar*)sqlite3_column_text(stmt, 3));
+               row->date = g_strdup((const gchar*)sqlite3_column_text(stmt, 4));
+               csv_parser_dump_row(parser, row, &err);
+               csv_record_free(row);
+               if (err) {
+                       gchar* msg = g_strdup_printf("%zu: %s\n", err->line, err->message);
+                       fprintf(stderr, msg);
+                       show_message(GTK_MESSAGE_ERROR, msg);
+                       g_free(msg);
+                       csv_error_clear(&err);
+                       sqlite3_finalize(stmt);
+                       return;
+               }
+    }
+    
+    sqlite3_finalize(stmt);
+}
+
+
This page took 0.680124 seconds and 5 git commands to generate.