first cut or new cursors merge to trunk. addresses #250

git-svn-id: file:///svn/tokudb@1881 c7de825b-a66e-492c-adef-691d508d4ae1

newbrt/brt-internal.h

@@ -8,6 +8,7 @@
 #include "pma.h"
 #include "brt.h"
 #include "crc.h"
+#include "list.h"
 
 #ifndef BRT_FANOUT
 #define BRT_FANOUT 16
@@ -130,7 +131,7 @@ struct brt {
     // The header is shared.  It is also ephemeral.
     struct brt_header *h;
 
-    BRT_CURSOR cursors_head, cursors_tail;
+    struct list cursors;
 
     unsigned int nodesize;
     unsigned int flags;
@@ -162,47 +163,7 @@ void toku_brtnode_free (BRTNODE *node);
 #define DEADBEEF ((void*)0xDEADBEEFDEADBEEF)
 #endif
 
-
-#define CURSOR_PATHLEN_LIMIT 32
-struct brt_cursor {
-    BRT brt;
-    int path_len;                       /* -1 if the cursor points nowhere. */
-    BRTNODE path[CURSOR_PATHLEN_LIMIT]; /* Include the leaf (last).    These are all pinned. */
-    int pathcnum[CURSOR_PATHLEN_LIMIT]; /* which child did we descend to from here? */
-    PMA_CURSOR pmacurs;                 /* The cursor into the leaf.  NULL if the cursor doesn't exist. */
-    BRT_CURSOR prev,next;
-    int op; DBT *key; DBT *val;         /* needed when flushing buffers */
-};
-
-/* print the cursor path */
-void toku_brt_cursor_print(BRT_CURSOR cursor);
-
-/* is the cursor path empty? */
-static inline int toku_brt_cursor_path_empty(BRT_CURSOR cursor) {
-    return cursor->path_len == 0;
-}
-
-/*is the cursor path full? */
-static inline int toku_brt_cursor_path_full(BRT_CURSOR cursor) {
-    return cursor->path_len == CURSOR_PATHLEN_LIMIT;
-}
-
-static inline int toku_brt_cursor_active(BRT_CURSOR cursor) {
-    return cursor->path_len > 0;
-}
-
-/* brt has a new root.  add the root to this cursor. */
-void toku_brt_cursor_new_root(BRT_CURSOR cursor, BRT t, BRTNODE newroot, BRTNODE left, BRTNODE right);
-
-/* a brt leaf has split.  modify this cursor if it includes the old node in its path. */
-void toku_brt_cursor_leaf_split(BRT_CURSOR cursor, BRT t, BRTNODE oldnode, BRTNODE newright);
-
-/* a brt internal node has expanded.  modify this cursor if it includes the  old node in its path. */
-void toku_brt_cursor_nonleaf_expand(BRT_CURSOR cursor, BRT t, BRTNODE oldnode, int childnum, BRTNODE left, BRTNODE right, struct kv_pair *splitk);
-
-/* a brt internal node has split.  modify this cursor if it includes the old node in its path. */
-void toku_brt_cursor_nonleaf_split(BRT_CURSOR cursor, BRT t, BRTNODE oldnode, BRTNODE left, BRTNODE right);
-
+/* tree command types */
 enum brt_cmd_type {
     BRT_NONE = 0,
     BRT_INSERT = 1,
@@ -210,6 +171,7 @@ enum brt_cmd_type {
     BRT_DELETE_BOTH = 3,
 };
 
+/* tree commands */
 struct brt_cmd {
     enum brt_cmd_type type;
     union {
@@ -245,4 +207,12 @@ extern u_int32_t toku_calccrc32_cmdstruct (BRT_CMD *cmd);
 unsigned int toku_brt_pivot_key_len (BRT, struct kv_pair *); // Given the tree
 unsigned int toku_brtnode_pivot_key_len (BRTNODE, struct kv_pair *); // Given the node
 
+/* a brt cursor is represented as a kv pair in a tree */
+struct brt_cursor {
+    struct list cursors_link;
+    BRT brt;
+    DBT key;
+    DBT val;
+};
+
 #endif

newbrt/brt-search.h

+#ifndef BRT_SEARCH_H
+#define BRT_SEARCH_H
+
+enum {
+    BRT_SEARCH_LEFT = 1,  /* search left -> right, finds min xy as defined by the compare function */
+    BRT_SEARCH_RIGHT = 2, /* search right -> left, finds max xy as defined by the compare function */
+    BRT_SEARCH_ONE = 4,   /* look into only one subtree, used for point queries */
+};
+
+struct brt_search;
+
+/* the search compare function should return 0 for all xy < kv and 1 for all xy >= kv 
+   the compare function has liberty in implementing the semantics, but the result should
+   be a ramp */
+
+typedef int (*brt_search_compare_func_t)(struct brt_search */*so*/, DBT */*x*/, DBT */*y*/);
+
+/* the search object contains the compare function, search direction, and the kv pair that
+   is used in the compare function.  the context is the user's private data */
+
+typedef struct brt_search {
+    brt_search_compare_func_t compare;
+    int direction;
+    DBT *k;
+    DBT *v;
+    void *context;
+} brt_search_t;
+
+/* initialize the search compare object */
+static inline brt_search_t *brt_search_init(brt_search_t *so, brt_search_compare_func_t compare, int direction, DBT *k, DBT *v, void *context) {
+    so->compare = compare; so->direction = direction; so->k = k; so->v = v; so->context = context;
+    return so;
+}
+
+#endif

newbrt/brt.h

@@ -10,6 +10,7 @@
 #include "../include/db.h"
 #include "cachetable.h"
 #include "log.h"
+#include "brt-search.h"
 
 int toku_open_brt (const char *fname, const char *dbname, int is_create, BRT *, int nodesize, CACHETABLE, TOKUTXN, int(*)(DB*,const DBT*,const DBT*), DB*);
 

newbrt/list.h

+#ifndef _TOKUDB_LIST_H
+#define _TOKUDB_LIST_H
+
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
 // This list is intended to be embedded in other data structures.
@@ -59,7 +62,7 @@ static inline struct list *list_pop_head(struct list *head) {
 static inline void list_move(struct list *newhead, struct list *oldhead) {
     struct list *first = oldhead->next;
     struct list *last = oldhead->prev;
-    assert(!list_empty(oldhead));
+    // assert(!list_empty(oldhead));
     newhead->next = first;
     newhead->prev = last;
     last->next = first->prev = newhead;
@@ -75,6 +78,4 @@ static inline void list_move(struct list *newhead, struct list *oldhead) {
 #define list_struct(p, t, f) ((t*)((char*)(p) - ((char*)&((t*)0)->f)))
 #endif
 
-
-
-
+#endif

newbrt/pma.c

@@ -297,6 +297,42 @@ static unsigned int pma_search(PMA pma, DBT *k, DBT *v, int lo, int hi, int *fou
     }
 }
 
+static unsigned int pma_search_func(PMA pma, brt_search_t *search, int lo, int hi, int *found) {
+    assert(0 <= lo && lo <= hi);
+    if (lo >= hi) {
+        *found = 0;
+        return lo;
+    } else {
+        int mi = (lo + hi)/2;
+        assert(lo <= mi && mi < hi);
+        int omi = mi;
+        while (mi < hi && !kv_pair_inuse(pma->pairs[mi]))
+            mi++;
+        if (mi >= hi)
+            return pma_search_func(pma, search, lo, omi, found);
+        struct kv_pair *kv = kv_pair_ptr(pma->pairs[mi]);
+        DBT x, y;
+        int cmp = search->compare(search, search->k ? toku_fill_dbt(&x, kv_pair_key(kv), kv_pair_keylen(kv)) : 0, search->v ? toku_fill_dbt(&y, kv_pair_val(kv), kv_pair_vallen(kv)) : 0);
+        if (cmp == 0) {
+            if (search->direction == BRT_SEARCH_LEFT)
+                return pma_search_func(pma, search, mi+1, hi, found);
+            else
+                return pma_search_func(pma, search, lo, mi, found);
+        }
+
+        /* we have a match, try to find a better match on the left or right subtrees */
+        int here;
+        if (search->direction == BRT_SEARCH_LEFT)
+            here = pma_search_func(pma, search, lo, mi, found);
+        else
+            here = pma_search_func(pma, search, mi+1, hi, found);
+        if (*found == 0)
+            here = mi;
+        *found = 1;
+        return here;
+    }
+}
+
 // Return the smallest index such that no lower index contains a larger key.
 // This will be in the range 0 (inclusive) to  toku_pma_index_limit(pma) (inclusive).
 // Thus the returned index may not be a valid index into the array if it is == toku_pma_index_limit(pma)
@@ -840,6 +876,21 @@ enum pma_errors toku_pma_lookup (PMA pma, DBT *k, DBT *v) {
         return DB_NOTFOUND;
 }
 
+int toku_pma_search(PMA pma, brt_search_t *search, DBT *foundk, DBT *foundv) {
+    int found;
+    unsigned int here = pma_search_func(pma, search, 0, pma->N, &found);
+    struct kv_pair *kv = pma->pairs[here];
+    if (found && kv_pair_valid(kv)) {
+        int r = 0;
+        if (foundk)
+            r = toku_dbt_set_value(foundk, kv_pair_key(kv), kv_pair_keylen(kv), &pma->skey);
+        if (r == 0 && foundv)
+            r = toku_dbt_set_value(foundv, kv_pair_val(kv), kv_pair_vallen(kv), &pma->sval);
+        return r;
+    } else
+        return DB_NOTFOUND;
+}
+
 /* returns 0 if OK.
  * You must have freed all the cursors, otherwise returns nonzero and does nothing. */
 int toku_pma_free (PMA *pmap) {

newbrt/pma.h

@@ -8,6 +8,7 @@
 #include "yerror.h"
 #include "../include/db.h"
 #include "log.h"
+#include "brt-search.h"
 
 /* An in-memory Packed Memory Array dictionary. */
 /* There is a built-in-cursor. */
@@ -69,6 +70,8 @@ int toku_pma_insert_or_replace (PMA /*pma*/, DBT */*k*/, DBT */*v*/,
  * Don't modify the returned data.  Don't free it. */
 enum pma_errors toku_pma_lookup (PMA, DBT*, DBT*);
 
+int toku_pma_search(PMA, brt_search_t *, DBT *, DBT *);
+
 /*
  * The kv pairs in PMA are split into two (nearly) equal sized sets.
  * THe ones in the left half are left in PMA, the ones in the right half are put into NEWPMA.