tst1300.mil

一个内存数据库的源代码这是服务器端还有客户端

setoid(oid(20000000));

# First some procs for convenience: 
# - xtable_print(group[oid,oid], str, attr1[oid,a1], attr2[oid,a2], ...)
# 	print group count table 
# - xtable_realloc(bat, capacity):  bat
#	allocate more memory and return a copy of a bat
# - xtable_test(str title, bat x, bat y, bat z)
#	 major test script on xtable functionality
 
proc xtable_print := {
    printf("\n# %s (ct: %d elts, %d groups, %d bytes)\n",
                $2, $3.count, $1.count, $3.batsize);
    table($1.col_name("count"), $(4..));
}

proc xtable_histo_direct := {
    var histo := $2.histogram;
    histo.xtable_print($(1..), histo.mirror.col_name("gid"));
}

proc xtable_histo_remap := {
    var map := new(oid,oid).key(true).reverse.insert($2);
    map.join($2.histogram).xtable_print($(1..), map.col_name("gid"));
}
 
proc xtable_realloc(b,cap) := {
    var inf := b.info;
    var ht := monet_atomtbl.find(inf.find("head"));
    var tt := monet_atomtbl.find(inf.find("tail"));
    var bn := new(ht, tt, cap);
    bn.insert(b);
    if (ht = void) bn.seqbase(b.reverse.fetch(0));
    if (tt = void) bn.seqbase(b.fetch(0));
    return bn;
}
 
proc xtable_test(title, x, y, z) := {
    printf("# xtable_test: %s grouping (%d tuples, %d bytes)\n\n",
                title, x.count, x.batsize + y.batsize + z.batsize);
    x.col_name("x"); y.col_name("y"); z.col_name("z");
    var yy := [+](y,dbl(1.0)).col_name("yy");
 
    print(x.slice(0,7).col_name("x"),y,yy,z);
    printf("synced(x,y) := %s\n", synced(x,y).str);
    printf("synced(x,z) := %s\n", synced(x,z).str);

    # test group 
    var b1 := CTgroup(x);
    xtable_histo_direct("group(x)", b1, x);

    # test derive
    b1 := CTgroup(b1,y).access(BAT_WRITE);
    xtable_histo_direct("group(x,y)", b1, x, y);

    # test orderby
{   var b2 := CTrefine(x.reverse.sort.reverse, y);
    xtable_histo_remap("orderby(x,y)", b2, x, y); }
 
    # test subgroup
{   var b2 := {count}([<=](y,dbl(2.0)),b1,b1.histogram).col_name("count");
    b2.xtable_print("subhisto(x,y|1-2)", x, y, b2.mirror.col_name("gid")); }
    b1 := CTsubgroup(b1,y, y.uselect(dbl(1.0),dbl(2.0)));
    xtable_histo_direct("group(x,y|1-2)", b1, x, y);

    # test regroup
    CTregroup(b1,z);
    xtable_histo_direct("regroup(x,y,z)", b1, x, y, z);

    # test multigroup
    b1 := CTmultigroup(new(bat,void).insert(y,nil).insert(yy,nil)).reverse;
    xtable_histo_remap("multigroup(y)", b1.fetch(0), y); 
    xtable_histo_remap("multigroup(yy)", b1.fetch(1), yy); 

    # test multiderive
    b1 := CTmultiderive(new(bat,bat).insert(y,x).insert(yy,x)).reverse;
    xtable_histo_remap("multigroup(y,x)", b1.fetch(0), y, x); 
    xtable_histo_remap("multigroup(yy,x)", b1.fetch(1), yy, x); 

    # test multiregroup
    b1 := CTmultiregroup(project(b1.reverse,z)).reverse;
    xtable_histo_remap("multiregroup(y,x)", b1.fetch(0), y, x, z); 
    xtable_histo_remap("multiregroup(yy,x)", b1.fetch(1), yy, x, z); 
}

x := new(oid,chr);
x.insert(1@0,'a');
x.insert(2@0,'a');
x.insert(3@0,'b');
x.insert(4@0,'b');
x.insert(5@0,'b');
x.insert(6@0,'b');
x.insert(7@0,'c');
x.insert(8@0,'c');
 
y:= new(oid,dbl);
y.insert(1@0,dbl(1.0));
y.insert(2@0,dbl(2.0));
y.insert(3@0,dbl(2.0));
y.insert(4@0,dbl(2.0));
y.insert(5@0,dbl(2.0));
y.insert(6@0,dbl(3.0));
y.insert(7@0,dbl(1.0));
y.insert(8@0,dbl(1.0));
 
z:= new(oid,str);
z.insert(1@0,"c");
z.insert(2@0,"a");
z.insert(3@0,"b");
z.insert(4@0,"c");
z.insert(5@0,"a");
z.insert(6@0,"a");
z.insert(7@0,"c");
z.insert(8@0,"a");

xtable_test("small hash", x, y, z);
 
# create vectorized versions
x := x.reverse.project.reverse.copy;
y := y.reverse.project.reverse.copy;
z := z.reverse.project.reverse.copy;
 
# activate voids
x.seqbase(1@0);
y.seqbase(1@0);
z.seqbase(1@0);
 
xtable_test("small vectorized", x, y, z);
 
print("growing vectorized tables from 8 to 512k elements...");
x := x.xtable_realloc(512*1024);
y := y.xtable_realloc(512*1024);
z := z.xtable_realloc(512*1024);
var i := 17;
while((i := i - 1) > 0) {
        x.insert(x.copy);
        y.insert(y.copy);
        z.insert(z.copy);
        print(x.count);
}
print("done!");
 
xtable_test("big vectorized", x, y, z);
 
# materialize the oids again
x := [oid](x.reverse).reverse;
y := [oid](y.reverse).reverse;
z := [oid](z.reverse).reverse;
y.access(BAT_WRITE);
z.access(BAT_WRITE);
y.insert(0@0,dbl(nil));
z.insert(0@0,str(nil));
y.delete(0@0);
z.delete(0@0);
 
xtable_test("big hash", x, y, z);
 
# let the Mserver find out that the head columns are equal
y := x.mirror.join(y);
z := x.mirror.join(z);
 
xtable_test("big synced", x, y, z);