Changeset: 7190e1d5d996 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=7190e1d5d996
Modified Files:
        gdk/Makefile.ag
        gdk/gdk.h
        gdk/gdk_align.c
        gdk/gdk_atoms.c
        gdk/gdk_batop.c
        gdk/gdk_col.c
        gdk/gdk_delta.c
        gdk/gdk_delta.h
        gdk/gdk_logger.c
        gdk/gdk_rangejoin.mx
        gdk/gdk_relop.mx
        gdk/gdk_scanselect.mx
        gdk/gdk_scanselect_defs.mx
        gdk/gdk_search.c
        gdk/gdk_search.h
        gdk/gdk_setop.c
        gdk/gdk_setop.mx
        gdk/gdk_storage.c
        monetdb5/modules/kernel/colcast.c.mx
Branch: headless
Log Message:

A bunch of changes.
- Fixed gdk/Makefile.ag.
- Renamed BUNfirst/BUNlast to COLfirst/COLlast.
- Fixed merge gone bad loosing COLcount.
- Fixed some incorrectly converted names.
- Removed COLputString: just use putvalue.
- Converted gdk_setop:
  - BATkunique/BATsunique are now COLunique_select and returns a list
    of OIDs.
  - BATkdiff/BATsdiff are now COLdiff_select and returns a list of
    OIDs.
  - BATkintersect/BATsintersect are now COLintersect_select and
    returns a list of OIDs.
  - BATkunion/BATsunion is gone.


diffs (truncated from 2737 to 300 lines):

diff --git a/gdk/Makefile.ag b/gdk/Makefile.ag
--- a/gdk/Makefile.ag
+++ b/gdk/Makefile.ag
@@ -22,7 +22,7 @@
 gdk_scanselect_CFLAGS = $(NO_INLINE_CFLAGS)
 # gdk_relop.mx
 
-EXTRA_DIST = gdk_scanselect_defs.mx gdk_logger.h
+EXTRA_DIST = gdk_scanselect_defs.mx gdk.h gdk_cbp.h gdk_col.h gdk_delta.h 
gdk_logger.h gdk_posix.h gdk_qsort_impl.h gdk_ssort_impl.h gdk_storage.h 
gdk_system.h gdk_tm.h gdk_utils.h gdk_setop.h
 
 lib_gdk = { 
        VERSION = $(GDK_VERSION)
@@ -39,17 +39,18 @@
 #              gdk_scanselect_defs_fix.mx \
 #              gdk_scanselect_defs_var.mx \
 #              gdk_scanselect.mx \
-#              gdk_batop.mx \
-#              gdk_search.mx \
-#              gdk_setop.mx gdk_utils.c gdk_atoms.mx \
+               gdk_batop.c \
+               gdk_search.c \
+               gdk_setop.c gdk_utils.c gdk_atoms.c \
 #              gdk_relop.mx \
-               gdk_tm.c gdk_align.mx gdk_cbp.c \
+               gdk_tm.c gdk_align.c gdk_cbp.c \
                gdk_heap.c  \
                gdk_qsort.c gdk_ssort.c gdk_storage.c gdk_col.c \
                gdk_delta.c \
-               gdk_system.c gdk_value.mx \
+               gdk_system.c gdk_value.c \
 #              gdk_rangejoin.mx \
-               gdk_posix.c gdk_logger.mx bat.feps bat1.feps bat2.feps \
+               gdk_posix.c \
+#              gdk_logger.c bat.feps bat1.feps bat2.feps \
                libbat.rc
        LIBS = ../common/options/libmoptions \
                ../common/stream/libstream \
@@ -57,5 +58,3 @@
                $(SOCKET_LIBS) $(zlib_LIBS) $(BZ_LIBS) \
                $(MALLOC_LIBS) $(PTHREAD_LIBS) $(DL_LIBS)
 }
-
-EXTRA_DIST = gdk.h gdk_cbp.h gdk_col.h gdk_delta.h gdk_logger.h gdk_posix.h 
gdk_qsort_impl.h gdk_ssort_impl.h gdk_storage.h gdk_system.h gdk_tm.h 
gdk_utils.h
diff --git a/gdk/gdk.h b/gdk/gdk.h
--- a/gdk/gdk.h
+++ b/gdk/gdk.h
@@ -1126,9 +1126,9 @@
  * @item
  * COLhtype(b) and  COLttype(b) find out the head and tail type of a COL.
  * @item
- * BUNfirst(b) returns a oid pointer to the first oid as a COL.
+ * COLfirst(b) returns a oid pointer to the first oid as a COL.
  * @item
- * BUNlast(b) returns the oid pointer directly after the last oid
+ * COLlast(b) returns the oid pointer directly after the last oid
  * in the COL.
  * @item
  * BUNhead(b, p) and BUNtail(b, p) return pointers to the
@@ -1233,7 +1233,7 @@
 
 #define bunfastins(b, v)                                               \
        do {                                                            \
-               register oid _p = BUNlast(b);                           \
+               register oid _p = COLlast(b);                           \
                if (_p == BUN_MAX || COLcount(b) == BUN_MAX) {          \
                        GDKerror("bunfastins: bat too large\n");        \
                        goto bunins_failed;                             \
@@ -1242,8 +1242,8 @@
                        if (COLextend((b), COLgrows(b)) == NULL)        \
                                goto bunins_failed;                     \
                }                                                       \
-               fastins_nocheck((b), _p, (v), (b)->width);                      
\
-               (b)->count++;                                   \
+               fastins_nocheck((b), _p, (v), (b)->width);              \
+               (b)->count++;                                           \
        } while (0)
 
 #define bunfastins_check(b, p, v) bunfastins(b, v)
@@ -1274,7 +1274,7 @@
                *(oid*) (v) < (bi).b->seqbase ||                        \
                *(oid*) (v) >= (bi).b->seqbase + (bi).b->count ?        \
                BUN_NONE :                                              \
-               BUNfirst((bi).b) + (oid) (*(oid*)(v) - (bi).b->seqbase)))
+               COLfirst((bi).b) + (oid) (*(oid*)(v) - (bi).b->seqbase)))
 
 #define BUNfndOID(p,bi,v)                      \
        if (COLdense(bi.b)) {                   \
@@ -1358,13 +1358,13 @@
        return bi;
 }
 
-#define BUNfirst(b)    (assert((b)->first <= BUN_MAX), (b)->first)
-#define BUNlast(b)     (assert((b)->first <= BUN_MAX),                 \
+#define COLfirst(b)    (assert((b)->first <= BUN_MAX), (b)->first)
+#define COLlast(b)     (assert((b)->first <= BUN_MAX),                 \
                         assert((b)->count <= BUN_MAX),                 \
                         assert((b)->count <= BUN_MAX - (b)->first),    \
                         (b)->first + (b)->count)
 
-#define BATcount(b)    ((b)->count)
+#define COLcount(b)    ((b)->count)
 
 /*
  *
@@ -1441,9 +1441,6 @@
  * and dirty columns.
  */
 gdk_export str COLrename(COL *b, const char *nme);
-#ifndef COLcount
-gdk_export oid COLcount(COL *b);
-#endif
 gdk_export oid COLcount_no_nil(COL *b);
 gdk_export void COLsetcapacity(COL *b, oid cnt);
 gdk_export void COLsetcount(COL *b, oid cnt);
@@ -1734,7 +1731,7 @@
                        COLiter bi = col_iterator(b);                   \
                        if (!(b)->dense &&                              \
                            (b)->type == TYPE_oid &&                    \
-                           (sqbs = (b)->count == 0 ? 0 : * (oid *) BUNhead(bi, 
BUNfirst(b))) != oid_nil) { \
+                           (sqbs = (b)->count == 0 ? 0 : * (oid *) BUNhead(bi, 
COLfirst(b))) != oid_nil) { \
                                (b)->dense = TRUE;                      \
                                COLseqbase((b), sqbs);                  \
                                (b)->descdirty = TRUE;                  \
@@ -1752,6 +1749,12 @@
                        if (!(b)->key)                                  \
                                COLkey((b), TRUE);                      \
                }                                                       \
+               if (!trivial && (b)->key) {                             \
+                       if ((b)->sorted)                                \
+                               (b)->nosorted_rev = 1;                  \
+                       if ((b)->revsorted)                             \
+                               (b)->nosorted = 1;                      \
+               }                                                       \
        } while (0)
 
 /*
@@ -2896,7 +2899,7 @@
  * p is the iteration variable.
  */
 #define COLloop(r, p, q) \
-       for(q = BUNlast(r), p = BUNfirst(r);p < q; p++)
+       for(q = COLlast(r), p = COLfirst(r);p < q; p++)
 
 #define COLforloop(b,o) for( o = 0; o < b->count; o++)
 #define COLgetString(b,o)      (str)(COLbase(b) + ((size_t) 
VarHeapValRaw(b,o,b->width)  << GDK_VARSHIFT))
@@ -2915,8 +2918,8 @@
  * inconsistent state till the next iteration of the batloop starts.
  */
 #define COLloopDEL(r, p, q)                            \
-       for(p = BUNfirst(r), q = BUNlast(r); p < q;     \
-           q = MIN(q,BUNlast(r)), p++)
+       for(p = COLfirst(r), q = COLlast(r); p < q;     \
+           q = MIN(q,COLlast(r)), p++)
 
 /*
  * sequential scan over deleted BUNs
@@ -3035,9 +3038,9 @@
 #define SORTloop(b,p,q,tl,th)                                          \
        if (!(b)->sorted) GDKerror("SORTloop: COL not sorted.\n");      \
        else for (p = (ATOMcmp((b)->type, tl, ATOMnilptr((b)->type)) ?  \
-                      SORTfndfirst(b, tl) : BUNfirst(b)),              \
+                      SORTfndfirst(b, tl) : COLfirst(b)),              \
                  q = (ATOMcmp((b)->type, th, ATOMnilptr((b)->type)) ?  \
-                      SORTfndlast(b, th) : BUNlast(b)); p < q; p++)
+                      SORTfndlast(b, th) : COLlast(b)); p < q; p++)
 
 
 /*
@@ -3196,6 +3199,7 @@
 #define JOIN_GE                2
 #define JOIN_BAND      3
 
+gdk_export COL *COLrand_select(COL *b, oid size);
 gdk_export COL *COL_select_(COL *b, ptr tl, ptr th, bit li, bit hi, bit anti);
 gdk_export COL *COLselect_(COL *b, ptr tl, ptr th, bit li, bit hi);
 gdk_export COL *COLantiselect_(COL *b, ptr tl, ptr th, bit li, bit hi);
@@ -3221,16 +3225,9 @@
 gdk_export COL *COLfetchjoin(COL *b, COL *s, oid estimate);
 gdk_export COL *COLleftfetchjoin(COL *b, COL *s, oid estimate);
 
-gdk_export COL *COLins_kunique(COL *bn, COL *b);
-gdk_export COL *COLsunique(COL *b);
-gdk_export COL *COLkunique(COL *b);
-gdk_export COL *COLukunique(COL *b);
-gdk_export COL *COLsintersect(COL *b, COL *c);
-gdk_export COL *COLkintersect(COL *b, COL *c);
-gdk_export COL *COLsunion(COL *b, COL *c);
-gdk_export COL *COLkunion(COL *b, COL *c);
-gdk_export COL *COLsdiff(COL *b, COL *c);
-gdk_export COL *COLkdiff(COL *b, COL *c);
+gdk_export COL *COLunique_select(COL *b);
+gdk_export COL *COLintersect_select(COL *b, COL *c);
+gdk_export COL *COLdiff_select(COL *b, COL *c);
 
 /* generic n-ary multijoin beast, with defines to interpret retval */
 #define MULTIJOIN_SORTED(r)    ((char*) &r)[0]
diff --git a/gdk/gdk_align.c b/gdk/gdk_align.c
--- a/gdk/gdk_align.c
+++ b/gdk/gdk_align.c
@@ -113,7 +113,7 @@
        COLcheck(b1, "ALIGNset: COL 1 required");
        COLcheck(b2, "ALIGNset: COL 2 required");
 
-       diff = (ssize_t) (BUNfirst(b1) - BUNfirst(b2));
+       diff = (ssize_t) (COLfirst(b1) - COLfirst(b2));
        if (b2->align == 0) {
                b2->align = OIDnew(1);
                b2->descdirty = TRUE;
@@ -204,7 +204,7 @@
 COL *
 VIEWcreate_(COL *h, int slice_view)
 {
-       COLstore *recycled = NULL;
+       COL *recycled = NULL;
        COL *bn;
        bat hp;
 
@@ -240,7 +240,7 @@
        bn->nokey[1] = h->nokey[1];
        bn->nosorted = h->nosorted;
        bn->nodense = h->nodense;
-       bn->seq = h->seq;
+       bn->seqbase = h->seqbase;
        bn->heap = h->heap;
        bn->vheap = h->vheap;
        bn->hash = h->hash;
@@ -301,8 +301,8 @@
        assert(!isVIEW(b));
        cnt = COLcapacity(b);
        head = b->heap;
-       p = BUNfirst(b);
-       q = BUNlast(b);
+       p = COLfirst(b);
+       q = COLlast(b);
        assert(cnt >= q - p);
        ALGODEBUG THRprintf(GDKout, "#COLmaterialize(%d);\n", (int) 
b->batCacheid);
 
@@ -458,7 +458,7 @@
                n->varsized = v->varsized;
                n->shift = v->shift;
                n->width = v->width;
-               n->seq = v->seq;
+               n->seqbase = v->seqbase;
 
                n->heap.parentid = 0;
                n->restricted = COL_WRITE;
@@ -527,7 +527,7 @@
                h = COLcount(b);
        if (h < l)
                h = l;
-       l += BUNfirst(b);
+       l += COLfirst(b);
        view->first = view->deleted = view->inserted = 0;
        cnt = h - l;
        view->heap.base = view->type ? BUNloc(bi, l) : NULL;
diff --git a/gdk/gdk_atoms.c b/gdk/gdk_atoms.c
--- a/gdk/gdk_atoms.c
+++ b/gdk/gdk_atoms.c
@@ -758,35 +758,6 @@
 #define mult10(x)      ((x) + (x) + ((x) << 3))
 #define mult7(x)       (((x) << 3) - (x))
 
-str COLputString(COL *b, oid o, str v) {
-       var_t _d;                                       
-       
-       if ((b)->varsized && (b)->type) {                       
-               ATOMput((b)->type, (b)->vheap, &_d, v);         
-               if ((b)->width < SIZEOF_VAR_T &&                
-                       ((b)->width <= 2 ? _d - GDK_VAROFFSET : _d) >= 
((size_t) 1 << (8 * (b)->width))) { 
-                       /* doesn't fit in current heap, upgrade it */ 
-                       COLaccessBegin(b, USE_HEAP, MMAP_SEQUENTIAL); 
-                       GDKupgradevarheap((b), _d, o);  
-                       COLaccessEnd(b, USE_HEAP, MMAP_SEQUENTIAL);     
-               }                                               
-               switch ((b)->width) {                           
-               case 1:                                         
-                       ((unsigned char *)b->heap)[o] = (unsigned char) (_d - 
GDK_VAROFFSET); 
-                       break;                                  
-               case 2:                                         
-                       ((unsigned short *)b->heap)[o] = (unsigned short) (_d - 
GDK_VAROFFSET); 
-                       break;                                  
-               case 4:                                         
-                       ((unsigned int *)b->heap)[o] = (unsigned int) (_d - 
GDK_VAROFFSET); 
-                       break;                                  
-               case 8:                                         
-                       ((unsigned lng *)b->heap)[o] = (unsigned lng) _d ; 
-                       break;                                  
-               }                                               
-       } 
-       return MAL_SUCCEED;
- }
 int
 voidFromStr(str src, int *len, void **dst)
 {
diff --git a/gdk/gdk_batop.c b/gdk/gdk_batop.c
--- a/gdk/gdk_batop.c
+++ b/gdk/gdk_batop.c
@@ -205,7 +205,7 @@
        ALIGNapp(b, "COLappend", force);
        COLcompatible(b, n);
_______________________________________________
Checkin-list mailing list
[email protected]
http://mail.monetdb.org/mailman/listinfo/checkin-list

Reply via email to