add license

Author: siara-in

examples/Uno_and_above/Uno_and_above.ino

@@ -1,24 +1,44 @@
+/*
+  This example demonstrates how the Sqlite Micro Logger library
+  can be used to write Analog data into Sqlite database.
+  Works on any Arduino compatible microcontroller with SD Card attachment
+  having 2kb RAM or more (such as Arduino Uno).
+
+  How Sqlite Micro Logger works:
+  https://github.com/siara-in/sqlite_micro_logger
+
+  Copyright 2019 Arundale Ramanathan, Siara Logics (in)
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
 #include "ulog_sqlite.h"
 #include <SPI.h>
 #include <SD.h>
-//#include <SdFat.h>
 
-//SdFat SD;
 File myFile;
 
-int32_t read_fn(struct uls_write_context *ctx, void *buf, size_t len) {
+#define SD_CS_PIN 8
+
+int32_t read_fn(struct uls_write_context *ctx, void *buf, long pos, size_t len) {
+  myFile.seek(pos);
   size_t ret = myFile.read((byte *)buf, len);
   if (ret != len)
     return ULS_RES_READ_ERR;
   return ret;
 }
 
-int seek_fn(struct uls_write_context *ctx, long pos) {
+int32_t write_fn(struct uls_write_context *ctx, void *buf, long pos, size_t len) {
   myFile.seek(pos);
-  return ULS_RES_OK;
-}
-
-int32_t write_fn(struct uls_write_context *ctx, void *buf, size_t len) {
   size_t ret = myFile.write((byte *)buf, len);
   if (ret != len)
     return ULS_RES_ERR;
@@ -66,7 +86,6 @@ int input_num() {
   return ret;
 }
 
-#define SD_CS_PIN 8
 bool isInited = false;
 void setup() {
   // Open serial communications and wait for port to open:
@@ -99,13 +118,11 @@ void loop() {
   Serial.print(F("\nSqlite uLogger\n"));
   Serial.print(F("DB name: "));
   input_string(filename, sizeof(filename));
-  Serial.print(F("\nEntry count: "));
+  Serial.print(F("\nRecord count: "));
   num_entries = input_num();
   Serial.print(F("\nDelay(ms): "));
   dly = input_num();
 
-  //buf = (byte *) SD.file()->cacheClear();
-
   // open the file. note that only one file can be open at a time,
   // so you have to close this one before opening another.
   myFile = SD.open(filename, FILE_WRITE);
@@ -118,7 +135,6 @@ void loop() {
     ctx.page_size_exp = 9;
     ctx.max_pages_exp = 0;
     ctx.read_fn = read_fn;
-    ctx.seek_fn = seek_fn;
     ctx.flush_fn = flush_fn;
     ctx.write_fn = write_fn;
     int res = uls_write_init(&ctx);
@@ -131,7 +147,7 @@ void loop() {
             break;
         }
         if (num_entries) {
-          res = uls_create_new_row(&ctx);
+          res = uls_append_new_row(&ctx);
           if (res)
             break;
           delay(dly);

examples/Uno_and_above_Binary_Search/Uno_and_above_Binary_Search.ino

@@ -1,22 +1,44 @@
+/*
+  This example demonstrates how the Sqlite Micro Logger library
+  can be used to write Analog data into Sqlite database.
+  Works on any Arduino compatible microcontroller with SD Card attachment
+  having 2kb RAM or more (such as Arduino Uno).
+
+  How Sqlite Micro Logger works:
+  https://github.com/siara-in/sqlite_micro_logger
+
+  Copyright 2019 Arundale Ramanathan, Siara Logics (in)
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
 #include "ulog_sqlite.h"
 #include <SPI.h>
 #include <SD.h>
 
 File myFile;
 
-int32_t read_fn(struct uls_write_context *ctx, void *buf, size_t len) {
+#define SD_CS_PIN 8
+
+int32_t read_fn(struct uls_write_context *ctx, void *buf, long pos, size_t len) {
+  myFile.seek(pos);
   size_t ret = myFile.read((byte *)buf, len);
   if (ret != len)
     return ULS_RES_READ_ERR;
   return ret;
 }
 
-int seek_fn(struct uls_write_context *ctx, long pos) {
+int32_t write_fn(struct uls_write_context *ctx, void *buf, long pos, size_t len) {
   myFile.seek(pos);
-  return ULS_RES_OK;
-}
-
-int32_t write_fn(struct uls_write_context *ctx, void *buf, size_t len) {
   size_t ret = myFile.write((byte *)buf, len);
   if (ret != len)
     return ULS_RES_ERR;
@@ -64,7 +86,6 @@ int input_num() {
   return ret;
 }
 
-#define SD_CS_PIN 8
 bool isInited = false;
 void setup() {
   // Open serial communications and wait for port to open:
@@ -97,13 +118,11 @@ void loop() {
   Serial.print(F("\nSqlite uLogger\n"));
   Serial.print(F("DB name: "));
   input_string(filename, sizeof(filename));
-  Serial.print(F("\nEntry count: "));
+  Serial.print(F("\nRecord count: "));
   num_entries = input_num();
   Serial.print(F("\nDelay(ms): "));
   dly = input_num();
 
-  //buf = (byte *) SD.file()->cacheClear();
-
   // open the file. note that only one file can be open at a time,
   // so you have to close this one before opening another.
   myFile = SD.open(filename, FILE_WRITE);
@@ -116,7 +135,6 @@ void loop() {
     ctx.page_size_exp = 9;
     ctx.max_pages_exp = 0;
     ctx.read_fn = read_fn;
-    ctx.seek_fn = seek_fn;
     ctx.flush_fn = flush_fn;
     ctx.write_fn = write_fn;
     int res = uls_write_init(&ctx);
@@ -129,7 +147,7 @@ void loop() {
             break;
         }
         if (num_entries) {
-          res = uls_create_new_row(&ctx);
+          res = uls_append_new_row(&ctx);
           if (res)
             break;
           delay(dly);

src/test_ulog_sqlite.c

@@ -1,3 +1,29 @@
+/*
+  Testing program for Sqlite Micro Logger
+
+  Sqlite Micro Logger is a Fast, Lean and Mean 
+  Sqlite database logger targetting low memory systems such as Microcontrollers.
+
+  This Library can work on systems that have as little as 2kb,
+  such as the ATMega328 MCU.  It is available for the Arduino platform.
+
+  https://github.com/siara-in/sqlite_micro_logger
+
+  Copyright 2019 Arundale Ramanathan, Siara Logics (in)
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
 #ifndef ARDUINO
 
 #include "ulog_sqlite.h"
@@ -121,7 +147,7 @@ int test_multilevel(char *filename) {
       txt[j] = 'a' + (char)(rand() % 26);
     uls_set_col_val(&ctx, 4, ULS_TYPE_TEXT, txt, txt_len);
     if (i < max_rows - 1)
-      uls_create_new_row(&ctx);
+      uls_append_new_row(&ctx);
   }
   if (uls_finalize(&ctx)) {
     printf("Error during finalize\n");
@@ -156,7 +182,7 @@ int test_basic(char *filename) {
   uls_set_col_val(&ctx, 2, ULS_TYPE_TEXT, "How", 3);
   uls_set_col_val(&ctx, 3, ULS_TYPE_TEXT, "Are", 3);
   uls_set_col_val(&ctx, 4, ULS_TYPE_TEXT, "You", 3);
-  uls_create_new_row(&ctx);
+  uls_append_new_row(&ctx);
   uls_set_col_val(&ctx, 0, ULS_TYPE_TEXT, "I", 1);
   uls_set_col_val(&ctx, 1, ULS_TYPE_TEXT, "am", 2);
   uls_set_col_val(&ctx, 2, ULS_TYPE_TEXT, "fine", 4);
@@ -190,7 +216,7 @@ void print_usage() {
   printf("    Searches <db_name.db> for given row_id and prints result\n\n");
   printf("test_ulog_sqlite -b <db_name.db> <col_idx> <value>\n");
   printf("    Searches <db_name.db> and column for given value using\n");
-  printf("        binary search and prints result\n\n");
+  printf("        binary search and prints result. col_idx starts from 0.\n\n");
   printf("test_ulog_sqlite -n\n");
   printf("    Runs pre-defined tests and creates databases (verified manually)\n\n");
 }
@@ -264,7 +290,7 @@ int append_records(int argc, char *argv[], struct uls_write_context *ctx) {
       return -4;
     }
     if (i < argc - 1) {
-      if (uls_create_new_row(ctx)) {
+      if (uls_append_new_row(ctx)) {
         printf("Error during add col\n");
         return -5;
       }

src/ulog_sqlite.c

@@ -1,3 +1,29 @@
+/*
+  Sqlite Micro Logger
+
+  Fast, Lean and Mean Sqlite database logger targetting
+  low memory systems such as Microcontrollers.
+
+  This Library can work on systems that have as little as 2kb,
+  such as the ATMega328 MCU.  It is available for the Arduino platform.
+
+  https://github.com/siara-in/sqlite_micro_logger
+
+  Copyright 2019 Arundale Ramanathan, Siara Logics (in)
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
 #include "ulog_sqlite.h"
 
 #include <stdlib.h>
@@ -160,7 +186,7 @@ int32_t get_pagesize(byte page_size_exp) {
 uint16_t acquire_last_pos(struct uls_write_context *wctx, byte *ptr) {
   uint16_t last_pos = read_uint16(ptr + 5);
   if (last_pos == 0) {
-    uls_create_new_row(wctx);
+    uls_append_new_row(wctx);
     last_pos = read_uint16(ptr + 5);
   }
   return last_pos;
@@ -437,7 +463,7 @@ int form_page1(struct uls_write_context *wctx, char *table_name, char *table_scr
   int orig_col_count = wctx->col_count;
   wctx->cur_write_page = 0;
   wctx->col_count = 5;
-  uls_create_new_row(wctx);
+  uls_append_new_row(wctx);
   uls_set_col_val(wctx, 0, ULS_TYPE_TEXT, "table", 5);
   if (table_name == NULL)
     table_name = default_table_name;
@@ -479,7 +505,6 @@ int form_page1(struct uls_write_context *wctx, char *table_name, char *table_scr
   wctx->cur_write_page = 1;
   wctx->cur_write_rowid = 0;
   init_bt_tbl_leaf(wctx->buf);
-  uls_create_new_row(wctx);
 
   return ULS_RES_OK;
 
@@ -550,7 +575,7 @@ int uls_write_init(struct uls_write_context *wctx) {
 }
 
 // See .h file for API description
-int uls_create_new_row(struct uls_write_context *wctx) {
+int uls_append_new_row(struct uls_write_context *wctx) {
 
   wctx->cur_write_rowid++;
   byte *ptr = wctx->buf + (wctx->buf[0] == 13 ? 0 : 100);
@@ -821,7 +846,7 @@ int uls_init_for_append(struct uls_write_context *wctx) {
   res = read_bytes_wctx(wctx, wctx->buf, wctx->cur_write_page * page_size, page_size);
   if (res)
     return res;
-  res = uls_create_new_row(wctx);
+  res = uls_append_new_row(wctx);
   if (res)
     return res;
   return ULS_RES_OK;

src/ulog_sqlite.h

@@ -1,3 +1,29 @@
+/*
+  Sqlite Micro Logger
+
+  Fast, Lean and Mean Sqlite database logger targetting
+  low memory systems such as Microcontrollers.
+
+  This Library can work on systems that have as little as 2kb,
+  such as the ATMega328 MCU.  It is available for the Arduino platform.
+
+  https://github.com/siara-in/sqlite_micro_logger
+
+  Copyright 2019 Arundale Ramanathan, Siara Logics (in)
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
 #ifndef __ULOG_SQLITE__
 #define __ULOG_SQLITE__
 
@@ -62,7 +88,13 @@ int uls_init_for_append(struct uls_write_context *wctx);
 // Creates new record with all columns null
 // If no more space in page, writes it to disk
 // creates new page, and creates a new record
-int uls_create_new_row(struct uls_write_context *wctx);
+int uls_append_new_row(struct uls_write_context *wctx);
+
+// Creates new record with given column values
+// If no more space in page, writes it to disk
+// creates new page, and creates a new record
+int uls_append_new_row_with_values(struct uls_write_context *wctx,
+      uint8_t types[], const void *values[], uint16_t lengths[]);
 
 // Sets value of column in the current record for the given column index
 // If no more space in page, writes it to disk
@@ -144,7 +176,8 @@ int uls_srch_row_by_id(struct uls_read_context *rctx, uint32_t rowid);
 
 // Performs binary search on the inserted records
 // using the given Value and positions at the record found
-// Does not change position if record not found
+// Changes current position to closest match, if record not found
+// is_rowid = 1 is used to do Binary Search by RowId
 int uls_bin_srch_row_by_val(struct uls_read_context *rctx, int col_idx,
       int val_type, void *val, uint16_t len, byte is_rowid);