Publishing Antelope - a DBMS for sensor devices. For details, see A Database in Every Sensor, N. Tsiftes and A. Dunkels, in Proceedings of ACM SenSys 2011.

apps/antelope/index-inline.c

@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2010, Swedish Institute of Computer Science
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/**
+ * \file
+ *	A binary search index for attributes that are constrained to be 
+ *      monotonically increasing, which is a rather common pattern for
+ *      time series or keys. Since this index has no storage overhead,
+ *      it does not wear out the flash memory nor does it occupy scarce
+ *      scarce space. Furthermore, unlike B+-trees, it has a O(1) memory
+ *      footprint in relation to the number of data items.
+ * \author
+ * 	Nicolas Tsiftes <nvt@sics.se>
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "index.h"
+#include "relation.h"
+#include "result.h"
+#include "storage.h"
+
+#define DEBUG DEBUG_NONE
+#include "net/uip-debug.h"
+
+struct search_handle {
+  index_t *index;
+  tuple_id_t start_row;
+  tuple_id_t end_row;
+};
+
+struct search_handle handle;
+
+static db_result_t null_op(index_t *);
+static db_result_t insert(index_t *, attribute_value_t *, tuple_id_t);
+static db_result_t delete(index_t *, attribute_value_t *);
+static tuple_id_t get_next(index_iterator_t *);
+
+/*
+ * The create, destroy, load, release, insert, and delete operations
+ * of the index API always succeed because the index does not store
+ * items separately from the row file. The four former operations share 
+ * the same signature, and are thus implemented by the null_op function 
+ * to save space.
+ */
+index_api_t index_inline = {
+  INDEX_INLINE,
+  INDEX_API_EXTERNAL | INDEX_API_COMPLETE | INDEX_API_RANGE_QUERIES,
+  null_op,
+  null_op,
+  null_op,
+  null_op,
+  insert,
+  delete,
+  get_next
+};
+
+static attribute_value_t *
+get_value(tuple_id_t *index, relation_t *rel, attribute_t *attr)
+{
+  unsigned char *row;
+  static attribute_value_t value;
+
+  row = alloca(rel->row_length);
+  if(row == NULL) {
+    return NULL;
+  }
+
+  if(DB_ERROR(storage_get_row(rel, index, row))) {
+    return NULL;
+  }
+
+  if(DB_ERROR(relation_get_value(rel, attr, row, &value))) {
+    PRINTF("DB: Unable to retrieve a value from tuple %ld\n", (long)(*index));
+    return NULL;
+  }
+
+  return &value;
+}
+
+static tuple_id_t
+binary_search(index_iterator_t *index_iterator,
+              attribute_value_t *target_value,
+              int exact_match)
+{
+  relation_t *rel;
+  attribute_t *attr;
+  attribute_value_t *cmp_value;
+  tuple_id_t min;
+  tuple_id_t max;
+  tuple_id_t center;
+
+  rel = index_iterator->index->rel;
+  attr = index_iterator->index->attr;
+
+  max = relation_cardinality(rel);
+  if(max == INVALID_TUPLE) {
+    return INVALID_TUPLE;
+  }
+  max--;
+  min = 0;
+
+  do {
+    center = min + ((max - min) / 2);
+
+    cmp_value = get_value(&center, rel, attr);
+    if(cmp_value == NULL) {
+      PRINTF("DB: Failed to get the center value, index = %ld\n",
+	(long)center);
+      return INVALID_TUPLE;
+    }
+
+    if(db_value_to_long(target_value) > db_value_to_long(cmp_value)) {
+      min = center + 1;
+    } else {
+      max = center - 1;
+    }
+  } while(min <= max && db_value_to_long(target_value) != db_value_to_long(cmp_value));
+
+  if(exact_match &&
+     db_value_to_long(target_value) != db_value_to_long(cmp_value)) {
+    PRINTF("DB: Could not find value %ld in the inline index\n",
+           db_value_to_long(target_value));
+    return INVALID_TUPLE;
+  }
+
+  return center;
+}
+
+static tuple_id_t
+range_search(index_iterator_t *index_iterator,
+             tuple_id_t *start, tuple_id_t *end)
+{
+  attribute_value_t *low_target;
+  attribute_value_t *high_target;
+  int exact_match;
+
+  low_target = &index_iterator->min_value;
+  high_target = &index_iterator->max_value;
+
+  PRINTF("DB: Search index for value range (%ld, %ld)\n",
+    db_value_to_long(low_target), db_value_to_long(high_target));
+
+  exact_match = db_value_to_long(low_target) == db_value_to_long(high_target);
+
+  /* Optimize later so that the other search uses the result
+     from the first one. */
+  *start = binary_search(index_iterator, low_target, exact_match);
+  if(*start == INVALID_TUPLE) {
+    return DB_INDEX_ERROR;
+  }
+
+  *end = binary_search(index_iterator, high_target, exact_match);
+  if(*end == INVALID_TUPLE) {
+    return DB_INDEX_ERROR;
+  }
+  return DB_OK;
+}
+
+static db_result_t
+null_op(index_t *index)
+{
+  return DB_OK;
+}
+
+static db_result_t
+insert(index_t *index, attribute_value_t *value, tuple_id_t tuple_id)
+{
+  return DB_OK;
+}
+
+static db_result_t
+delete(index_t *index, attribute_value_t *value)
+{
+  return DB_OK;
+}
+
+static tuple_id_t
+get_next(index_iterator_t *iterator)
+{
+  static tuple_id_t cached_start;
+  static tuple_id_t cached_end;
+
+  if(iterator->next_item_no == 0) {
+    /*
+     * We conduct the actual index search when the caller attempts to 
+     * access the first item in the iteration. The first and last tuple 
+     * id:s of the result get cached for subsequent iterations.
+     */
+    if(DB_ERROR(range_search(iterator, &cached_start, &cached_end))) {
+      cached_start = 0;
+      cached_end = 0;
+      return INVALID_TUPLE;
+    }
+    PRINTF("DB: Cached the tuple range (%ld,%ld)\n", 
+           (long)cached_start, (long)cached_end);
+    ++iterator->next_item_no;
+    return cached_start;
+  } else if(cached_start + iterator->next_item_no <= cached_end) {
+    return cached_start + iterator->next_item_no++;
+  }
+
+  return INVALID_TUPLE;
+}