@@ -0,0 +1,553 @@
1+/*
2+ * sqlite3api.c
3+ *
4+ *
5+ * Created by Melissa Farinaz MOZIFIAN on 22/06/2012.
6+ * Copyright 2012. All rights reserved.
7+ *
8+ */
9+
10+
11+#include "sqlite3api.h"
12+
13+
14+
15+static char sql_query_buffer[2000];
16+unsigned char* array;
17+
18+void* sqlite3_open_idr(const char *filename){
19+
20+ sqlite3 *db;
21+ int res =sqlite3_open(filename,&db);
22+
23+ if(res != SQLITE_OK){
24+ printf("Error occured while opening the databse.");
25+ return NULL;
26+ }
27+ DBinfo *dbi = malloc(sizeof(DBinfo));
28+ dbi->db_ptr = db;
29+ return dbi;
30+
31+}
32+
33+int sqlite3_close_idr(void* db){
34+
35+ DBinfo* dbi =(DBinfo*) db;
36+ int res =sqlite3_close(dbi->db_ptr);
37+ if (res == SQLITE_OK){
38+ free(dbi);
39+ printf("Successfuly closed the databse\n");
40+ return 0;
41+ }
42+
43+ if(res == SQLITE_BUSY){
44+ printf("SQL Busy");
45+ return 5;
46+ }
47+
48+ else {
49+ return 1;
50+ }
51+}
52+
53+int sqlite3_exec_idr(void* db, const char *sql)
54+{
55+
56+ DBinfo* dbi =(DBinfo*) db;
57+ char* err;
58+ int rc;
59+
60+ rc = sqlite3_exec(dbi->db_ptr,sql,NULL, NULL, &err);
61+ printf("%d\n", rc);
62+ if (rc != SQLITE_OK && err != NULL) {
63+ strncpy(dbi->buffer, err, sizeof(dbi->buffer));
64+ sqlite3_free(err);
65+ }
66+ return rc;
67+}
68+
69+
70+char* sqlite3_get_error(void* db) {
71+ DBinfo* dbi =(DBinfo*) db;
72+ return dbi->buffer;
73+}
74+
75+void* sqlite3_prepare_idr(void *db,const char *zSql){
76+
77+ sqlite3_stmt* stmt;
78+ const char *tail;
79+
80+ DBinfo* dbi =(DBinfo*) db;
81+
82+ int rec = sqlite3_prepare_v2(dbi->db_ptr,zSql,-1,&stmt,&tail);
83+ dbi ->ppStmt =stmt;
84+ dbi ->Ptr_tail = tail;
85+
86+ if(rec != SQLITE_OK){
87+ return NULL;
88+ }
89+
90+ return dbi;
91+}
92+
93+void* sqlite3_get_table_idr(void* db,
94+ const char *sql){
95+
96+ DBinfo* dbi =(DBinfo*) db;
97+ char* err;
98+
99+ Table* tbl = malloc(sizeof(Table));
100+ tbl->database = dbi;
101+
102+ int res = sqlite3_get_table(dbi->db_ptr,sql,&tbl->table_data,&tbl->num_row,&tbl->num_col,&err);
103+
104+ int array_size = sizeof(&tbl->table_data);
105+
106+ if( res != SQLITE_OK && err != NULL){
107+ strncpy(dbi->buffer, err, sizeof(dbi->buffer));
108+ sqlite3_free(err);
109+ return NULL;
110+ }
111+
112+ tbl -> data_size = array_size;
113+
114+ int i, j, row, col;
115+
116+ row = tbl->num_row;
117+ col = tbl->num_col;
118+
119+ for( i=0; i< row; i++){
120+ for(j=0;j<col; j++){
121+ printf("%s\n", tbl->table_data[(i+1)*col +j]);
122+
123+ }
124+
125+ }
126+ return tbl;
127+
128+}
129+
130+int sqlite3_get_num_row(void* p){
131+
132+ Table* tbl =(Table*) p;
133+ int row_number =tbl->num_row;
134+ return row_number;
135+
136+
137+}
138+
139+int sqlite3_get_num_col(void* p){
140+
141+ Table* tbl =(Table*) p;
142+ int col_number =tbl-> num_col;
143+ return col_number;
144+
145+}
146+
147+int sqlite3_get_data_type(void* p,const char* tbl_name, int nRow, int nCol){
148+
149+ DBinfo* dbi =(DBinfo*) p;
150+ sqlite3_stmt* stmt;
151+ const char *tail;
152+ int rc,i, val, counter;
153+ const char* char_int;
154+
155+ counter =0;
156+ strcpy(sql_query_buffer, "select * from ");
157+ strcat(sql_query_buffer, tbl_name);
158+
159+ rc = sqlite3_prepare_v2(dbi->db_ptr, sql_query_buffer, -1, &stmt, &tail);
160+ if(rc != SQLITE_OK){
161+ fprintf(stderr, "SQL Prepare error\n");
162+ return rc;
163+ }
164+ rc = sqlite3_step(stmt);
165+
166+ while (rc == SQLITE_ROW && counter < nRow){
167+
168+ rc = sqlite3_step(stmt);
169+ counter++;
170+
171+ }
172+
173+ val =sqlite3_column_type(stmt, nCol);
174+ printf("Type : %d\n", val );
175+
176+ rc =sqlite3_finalize(stmt);
177+ if( rc != SQLITE_OK){
178+ printf("Couldnt finalize:\n");
179+ }
180+ return val;
181+
182+}
183+
184+
185+int sqlite3_get_val_int(void* p,const char* tbl_name, int nRow, int nCol){
186+
187+
188+ DBinfo* dbi =(DBinfo*) p;
189+ sqlite3_stmt* stmt;
190+ const char *tail;
191+ int rc,i, val, counter;
192+ const char* char_int;
193+
194+ counter =0;
195+ strcpy(sql_query_buffer, "select * from ");
196+ strcat(sql_query_buffer, tbl_name);
197+
198+ rc = sqlite3_prepare_v2(dbi->db_ptr, sql_query_buffer, -1, &stmt, &tail);
199+ if(rc != SQLITE_OK){
200+ fprintf(stderr, "SQL Prepare error\n");
201+ return rc;
202+ }
203+ rc = sqlite3_step(stmt);
204+
205+ while (rc == SQLITE_ROW && counter < nRow){
206+
207+ rc = sqlite3_step(stmt);
208+ counter++;
209+
210+ }
211+
212+ val =sqlite3_column_int(stmt, nCol);
213+ printf("int_val : %d\n", val );
214+ rc =sqlite3_finalize(stmt);
215+ if( rc != SQLITE_OK){
216+ printf("Couldnt finalize:\n");
217+ }
218+ return val;
219+
220+
221+}
222+
223+
224+const unsigned char* sqlite3_get_val_text(void* p,const char* tbl_name,int nRow, int nCol){
225+
226+
227+ DBinfo* dbi =(DBinfo*) p;
228+ sqlite3_stmt* stmt;
229+ const char *tail;
230+ int rc,i, val, counter;
231+ const unsigned char* text_val;
232+
233+ counter =0;
234+ strcpy(sql_query_buffer, "select * from ");
235+ strcat(sql_query_buffer, tbl_name);
236+
237+ rc = sqlite3_prepare_v2(dbi->db_ptr, sql_query_buffer, -1, &stmt, &tail);
238+ if(rc != SQLITE_OK){
239+ fprintf(stderr, "SQL Prepare error\n");
240+ return NULL;
241+ }
242+ rc = sqlite3_step(stmt);
243+
244+ while (rc == SQLITE_ROW && counter < nRow){
245+
246+ rc = sqlite3_step(stmt);
247+ counter++;
248+
249+ }
250+
251+ array =(unsigned char *) malloc(1000*sizeof(char));
252+ text_val =sqlite3_column_text(stmt, nCol);
253+ memcpy(array, text_val, sizeof(text_val));
254+ printf("text_val : %s\n", text_val );
255+ rc =sqlite3_finalize(stmt);
256+ if( rc != SQLITE_OK){
257+ printf("Couldn't finalize.\n");
258+ }
259+
260+ return array;
261+
262+}
263+
264+float sqlite3_get_float(void* p,const char* tbl_name, int nRow, int nCol){
265+
266+ DBinfo* dbi =(DBinfo*) p;
267+ sqlite3_stmt* stmt;
268+ const char *tail;
269+ int rc,i, val, counter;
270+ double double_val;
271+
272+
273+ counter =0;
274+ strcpy(sql_query_buffer, "select * from ");
275+ strcat(sql_query_buffer, tbl_name);
276+
277+ rc = sqlite3_prepare_v2(dbi->db_ptr, sql_query_buffer, -1, &stmt, &tail);
278+ if(rc != SQLITE_OK){
279+ fprintf(stderr, "SQL Prepare error\n");
280+
281+ }
282+ rc = sqlite3_step(stmt);
283+
284+ while (rc == SQLITE_ROW && counter < nRow){
285+
286+
287+ rc = sqlite3_step(stmt);
288+ counter++;
289+
290+ }
291+ double_val =sqlite3_column_double(stmt, nCol);
292+ float float_val =(float)double_val;
293+ printf("float_val %f\n", float_val);
294+ rc =sqlite3_finalize(stmt);
295+ if( rc != SQLITE_OK){
296+ printf("Couldn't finalize.\n");
297+ }
298+ return float_val;
299+
300+}
301+
302+
303+void sqlite3_free_table_idr(void* db){
304+ Table* tbl =(Table*) db;
305+ sqlite3_free_table(tbl->table_data);
306+ free(tbl);
307+}
308+
309+
310+int sqlite3_step_idr(void* db){
311+
312+ DBinfo* dbi =(DBinfo*) db;
313+ int rc =sqlite3_step(dbi->ppStmt);
314+ return rc;
315+}
316+
317+int sqlite3_bind_int_idr(void* p,int index, int val){
318+
319+ DBinfo* dbi =(DBinfo*) p;
320+ int rc;
321+
322+ printf("\nThe statement has %d wildcards\n", sqlite3_bind_parameter_count(dbi->ppStmt));
323+ rc =sqlite3_bind_int(dbi->ppStmt,index,val);
324+ if(rc != SQLITE_OK){
325+ return 1;
326+ }
327+
328+ return rc;
329+}
330+
331+int sqlite3_bind_float_idr(void* p,int index, float val){
332+
333+ DBinfo* dbi =(DBinfo*) p;
334+ int rc;
335+ double res =(float)val;
336+
337+ rc =sqlite3_bind_double(dbi->ppStmt,index,res);
338+
339+ if(rc != SQLITE_OK){
340+ return 1;
341+ }
342+
343+ return rc;
344+}
345+
346+int sqlite3_bind_null_idr(void* p,int index){
347+
348+ DBinfo* dbi =(DBinfo*) p;
349+ int rc;
350+ rc =sqlite3_bind_null(dbi->ppStmt,index);
351+ if(rc != SQLITE_OK){
352+ return 1;
353+ }
354+
355+ return rc;
356+}
357+
358+int sqlite3_bind_text_idr(void* p,const char* text, int index,int length){
359+
360+ DBinfo* dbi =(DBinfo*) p;
361+ int rc;
362+ rc =sqlite3_bind_text(dbi->ppStmt,index,text,length,SQLITE_STATIC);
363+ if(rc != SQLITE_OK){
364+ return 1;
365+ }
366+
367+ return rc;
368+
369+}
370+int sqlite3_column_count_idr(void* db, const char* tbl_name){
371+ DBinfo* dbi =(DBinfo*) db;
372+ sqlite3_stmt* stmt;
373+ const char *tail;
374+ int rc;
375+
376+ strcpy(sql_query_buffer, "select * from ");
377+ strcat(sql_query_buffer, tbl_name);
378+
379+ rc = sqlite3_prepare_v2(dbi->db_ptr, sql_query_buffer, -1, &stmt, &tail);
380+ if(rc != SQLITE_OK){
381+ fprintf(stderr, "SQL Prepare error");
382+ return rc;
383+ }
384+ printf("Prepare successful %d\n", rc);
385+
386+ rc =sqlite3_column_count(stmt);
387+ if(rc == 0){
388+ fprintf(stderr, "SQL column count error\n");
389+ return rc;
390+ }
391+ sqlite3_finalize(stmt);
392+
393+ // rc = actual column count
394+ return rc;
395+}
396+
397+
398+int sqlite3_data_count_idr(void* db){
399+
400+ DBinfo* dbi =(DBinfo*) db;
401+ int rc = sqlite3_data_count(dbi->ppStmt);
402+
403+ return rc;
404+
405+}
406+
407+int sqlite3_finalize_idr(void* db){
408+
409+ DBinfo* dbi=(DBinfo*) db;
410+ int rc =sqlite3_finalize(dbi->ppStmt);
411+ return rc;
412+}
413+
414+int sqlite3_complete_idr(const char *sql){
415+
416+ int rc = sqlite3_complete(sql);
417+ return rc;
418+
419+
420+}
421+int sqlite3_reset_idr(void* db){
422+
423+ DBinfo* dbi=(DBinfo*) db;
424+ int rc = sqlite3_reset(dbi-> ppStmt);
425+ return rc;
426+
427+}
428+
429+const char *sqlite3_column_name_idr(void* db, int N){
430+
431+ DBinfo* dbi=(DBinfo*) db;
432+ const char *name = sqlite3_column_name(dbi->ppStmt, N);
433+
434+ return name;
435+}
436+
437+const char *sqlite3_column_decltype_idr(void* db,int n){
438+ DBinfo* dbi=(DBinfo*) db;
439+ const char *dectype = sqlite3_column_decltype(dbi->ppStmt, n);
440+
441+ return dectype;
442+
443+}
444+
445+
446+int sqlite3_column_bytes_idr(void* db, int n){
447+
448+ DBinfo* dbi=(DBinfo*) db;
449+ int res = sqlite3_column_bytes(dbi->ppStmt, n);
450+ return res;
451+
452+
453+}
454+
455+const void *sqlite3_column_blob_idr(void* db, int iCol){
456+ DBinfo* dbi=(DBinfo*) db;
457+ const void* data =sqlite3_column_blob(dbi-> ppStmt, iCol);
458+ return data;
459+}
460+
461+const unsigned char *sqlite3_column_text_idr(void* db, int iCol){
462+ DBinfo* dbi=(DBinfo*) db;
463+ const unsigned char* col_text =sqlite3_column_text(dbi->ppStmt, iCol);
464+ return col_text;
465+
466+}
467+
468+int sqlite3_column_int_idr(void* db, int iCol){
469+ DBinfo* dbi=(DBinfo*) db;
470+ int res =sqlite3_column_int(dbi-> ppStmt, iCol);
471+ return res;
472+
473+}
474+
475+
476+void* sqlite3_backup_init_idr(void* pDest,
477+ const char *zDestName,
478+ void* pSource,
479+ const char *zSourceName
480+ ){
481+
482+ DBinfo* dbi=(DBinfo*) pDest;
483+ DBbackup* dbi2=(DBbackup*) pSource;
484+
485+ void* res = sqlite3_backup_init(dbi->db_ptr,zDestName,
486+ dbi2->source_ptr,zSourceName);
487+
488+ if(res == NULL){
489+ printf("Error number in initializing backup : %d\n", sqlite3_errcode(dbi->db_ptr));
490+ }
491+
492+ dbi2->backup = res;
493+ return dbi2;
494+
495+
496+}
497+
498+int sqlite3_backup_step_idr(void *backup, int nPage){
499+
500+ DBbackup* dbi=(DBbackup*) backup;
501+ int res = sqlite3_backup_step(dbi->backup, nPage);
502+
503+ if( res == SQLITE_OK){
504+ printf("Backup Success\n");
505+ }
506+ return res;
507+
508+
509+}
510+int sqlite3_backup_finish_idr(void *backup){
511+
512+ DBbackup* dbi=(DBbackup*) backup;
513+ int res = sqlite3_backup_finish(dbi->backup);
514+ return res;
515+
516+
517+}
518+
519+int sqlite3_backup_remaining_idr(void *backup){
520+
521+ DBbackup* dbi=(DBbackup*) backup;
522+ int res = sqlite3_backup_remaining(dbi->backup);
523+
524+ return res;
525+}
526+
527+int sqlite3_backup_pagecount_idr(void *backup){
528+
529+ DBbackup* dbi=(DBbackup*) backup;
530+ int res =sqlite3_backup_pagecount(dbi-> backup);
531+ return res;
532+
533+}
534+
535+int sqlite3_value_bytes_idr(void* value){
536+
537+ DBinfo* dbi=(DBinfo*) value;
538+ int res = sqlite3_value_bytes(dbi->value);
539+ return res;
540+
541+}
542+
543+int sqlite3_value_bytes16_idr(void* value){
544+
545+ DBinfo* dbi=(DBinfo*) value;
546+ int res =sqlite3_value_bytes16(dbi->value);
547+ return res;
548+
549+}
550+
551+
552+
553+