test_01.stable.out

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

    ed_a := calc.int(nil:void);	# 135 CALCnil2int (ed_a:int)<-(_155:void)
    fd_a := algebra.fragment(b,"fox","quick",ed_a,5);	# 136 ALGfragment (fd_a:bat[:str,:int])<-(b:bat[:str,:int])(_170:str)(_171:str)(ed_a:int)(_151:int)
    gd_a := io.print(fd_a);	# 137 IOprint_val (gd_a:void)<-(fd_a:bat[:str,:int])
#	io.print("b.fragment(\"fox\",\"quick\",int(nil),int(nil)).print();"); 	# 138  (_177:str)
    hd_a := calc.int(nil:void);	# 139 CALCnil2int (hd_a:int)<-(_155:void)
    id_a := calc.int(nil:void);	# 140 CALCnil2int (id_a:int)<-(_155:void)
    jd_a := algebra.fragment(b,"fox","quick",hd_a,id_a);	# 141 ALGfragment (jd_a:bat[:str,:int])<-(b:bat[:str,:int])(_170:str)(_171:str)(hd_a:int)(id_a:int)
    kd_a := io.print(jd_a);	# 142 IOprint_val (kd_a:void)<-(jd_a:bat[:str,:int])
#	io.print("b.fragment(\"fox\",str(nil),int(nil),int(nil)).print();"); 	# 143  (_182:str)
    ld_a := calc.str(nil:void);	# 144 CALCnil2str (ld_a:str)<-(_155:void)
    md_a := calc.int(nil:void);	# 145 CALCnil2int (md_a:int)<-(_155:void)
    nd_a := calc.int(nil:void);	# 146 CALCnil2int (nd_a:int)<-(_155:void)
    od_a := algebra.fragment(b,"fox",ld_a,md_a,nd_a);	# 147 ALGfragment (od_a:bat[:str,:int])<-(b:bat[:str,:int])(_170:str)(ld_a:str)(md_a:int)(nd_a:int)
    pd_a := io.print(od_a);	# 148 IOprint_val (pd_a:void)<-(od_a:bat[:str,:int])
#	io.print("b.fragment(str(nil),\"f\",int(nil),int(nil)).print();"); 	# 149  (_188:str)
    qd_a := calc.str(nil:void);	# 150 CALCnil2str (qd_a:str)<-(_155:void)
    rd_a := calc.int(nil:void);	# 151 CALCnil2int (rd_a:int)<-(_155:void)
    sd_a := calc.int(nil:void);	# 152 CALCnil2int (sd_a:int)<-(_192:void)
    td_a := algebra.fragment(b,qd_a,"f",rd_a,sd_a);	# 153 ALGfragment (td_a:bat[:str,:int])<-(b:bat[:str,:int])(qd_a:str)(_194:str)(rd_a:int)(sd_a:int)
    ud_a := io.print(td_a);	# 154 IOprint_val (ud_a:void)<-(td_a:bat[:str,:int])
#	io.print("b.reverse().fragment(int(nil),int(nil),str(nil),\"f\").print();"); 	# 155  (_196:str)
    vd_a := calc.int(nil:void);	# 156 CALCnil2int (vd_a:int)<-(_192:void)
    wd_a := calc.int(nil:void);	# 157 CALCnil2int (wd_a:int)<-(_192:void)
    xd_a := calc.str(nil:void);	# 158 CALCnil2str (xd_a:str)<-(_192:void)
    yd_a := bat.reverse(b);	# 159 BKCreverse (yd_a:bat[:int,:str])<-(b:bat[:str,:int])
    ae_a := algebra.fragment(yd_a,vd_a,wd_a,xd_a,"f");	# 160 ALGfragment (ae_a:bat[:int,:str])<-(yd_a:bat[:int,:str])(vd_a:int)(wd_a:int)(xd_a:str)(_194:str)
    be_a := io.print(ae_a);	# 161 IOprint_val (be_a:void)<-(ae_a:bat[:int,:str])
#	io.print("var b1:= b.join(bn.reverse());"); 	# 162  (_203:str)
    ce_a := bat.reverse(bn);	# 163 BKCreverse (ce_a:bat[:int,:str])<-(bn:bat[:str,:int])
    b1 := algebra.join(b,ce_a);	# 164 ALGjoin (b1:bat[:str,:str])<-(b:bat[:str,:int])(ce_a:bat[:int,:str])
#	io.print("b1.print();"); 	# 165  (_206:str)
    de_a := io.print(b1);	# 166 IOprint_val (de_a:void)<-(b1:bat[:str,:str])
#	io.print("var b2:= b.semijoin(b1.reverse());"); 	# 167  (_208:str)
    ee_a := bat.reverse(b1);	# 168 BKCreverse (ee_a:bat[:str,:str])<-(b1:bat[:str,:str])
    b2 := algebra.semijoin(b,ee_a);	# 169 ALGsemijoin (b2:bat[:str,:int])<-(b:bat[:str,:int])(ee_a:bat[:str,:str])
#	io.print("b2.print();"); 	# 170  (_211:str)
    fe_a := io.print(b2);	# 171 IOprint_val (fe_a:void)<-(b2:bat[:str,:int])
#	io.print("# testing the like command\n"); 	# 172  (_213:str)
    ge_a := bat.reverse(b);	# 173 BKCreverse (ge_a:bat[:int,:str])<-(b:bat[:str,:int])
    he_a := algebra.like(ge_a,"ox");	# 174 ALGlike (he_a:bat[:int,:str])<-(ge_a:bat[:int,:str])(_216:str)
    ie_a := io.print(he_a);	# 175 IOprint_val (ie_a:void)<-(he_a:bat[:int,:str])
#	io.print("b.reverse().like(\"fo\").print();"); 	# 176  (_218:str)
    je_a := bat.reverse(b);	# 177 BKCreverse (je_a:bat[:int,:str])<-(b:bat[:str,:int])
    ke_a := algebra.like(je_a,"fo");	# 178 ALGlike (ke_a:bat[:int,:str])<-(je_a:bat[:int,:str])(_221:str)
    le_a := io.print(ke_a);	# 179 IOprint_val (le_a:void)<-(ke_a:bat[:int,:str])
#	io.print("b.reverse().like(\"fox\").print();"); 	# 180  (_223:str)
    me_a := bat.reverse(b);	# 181 BKCreverse (me_a:bat[:int,:str])<-(b:bat[:str,:int])
    ne_a := algebra.like(me_a,"fox");	# 182 ALGlike (ne_a:bat[:int,:str])<-(me_a:bat[:int,:str])(_226:str)
    oe_a := io.print(ne_a);	# 183 IOprint_val (oe_a:void)<-(ne_a:bat[:int,:str])
#	io.print("b.reverse().like(\" fox\").print();"); 	# 184  (_228:str)
    pe_a := bat.reverse(b);	# 185 BKCreverse (pe_a:bat[:int,:str])<-(b:bat[:str,:int])
    qe_a := algebra.like(pe_a," fox");	# 186 ALGlike (qe_a:bat[:int,:str])<-(pe_a:bat[:int,:str])(_231:str)
    re_a := io.print(qe_a);	# 187 IOprint_val (re_a:void)<-(qe_a:bat[:int,:str])
#	io.print("quit();"); 	# 188  (_233:str)
    se_a := clients.quit();	# 189 CLTquitDefault (se_a:void)
end main;	# 190  
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "the",	  1	  ]
[ "quick",	  2	  ]
[ "brown",	  3	  ]
[ "fox",	  4	  ]
[ "jumps",	  5	  ]
[ "over",	  6	  ]
[ "lazy",	  7	  ]
[ "dog",	  8	  ]
[ nil,		  9	  ]
[ ".",		  10	  ]
[ "",		  nil	  ]
[ nil,		  nil	  ]
## Testing simple retrievals\n
[ 1 ]
#b.find(\"fox\").print();
[ 4 ]
#b.find(str(nil)).print();
[ nil ]
## This should cause an error\n
## Can we delete them and re-insert them later on\n
#b.delete(\"the\",1);
#b.delete(\".\",10);
#b.print();
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "",		  nil	  ]
[ "quick",	  2	  ]
[ "brown",	  3	  ]
[ nil,		  nil	  ]
[ "jumps",	  5	  ]
[ "over",	  6	  ]
[ "lazy",	  7	  ]
[ "dog",	  8	  ]
[ nil,		  9	  ]
#b.insert(\"fox\",4);
#b.insert(\"the\",1);
#b.insert(\".\",10);
#b.count().print();
[ 12 ]
## Lets cut out a few sections\n
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "quick",	  2	  ]
[ "brown",	  3	  ]
[ "fox",	  4	  ]
#b.select(7,int(nil)).print();
#-----------------#
# h	t	  # name
# str	int	  # type
#-----------------#
[ "lazy", 7	  ]
[ "dog",  8	  ]
[ nil,	  9	  ]
[ ".",	  10	  ]
#b.select(int(nil),7).print();
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "quick",	  2	  ]
[ "brown",	  3	  ]
[ "jumps",	  5	  ]
[ "over",	  6	  ]
[ "lazy",	  7	  ]
[ "fox",	  4	  ]
[ "the",	  1	  ]
#b.select(int(nil),int(nil)).print();
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "quick",	  2	  ]
[ "brown",	  3	  ]
[ "jumps",	  5	  ]
[ "over",	  6	  ]
[ "lazy",	  7	  ]
[ "dog",	  8	  ]
[ nil,		  9	  ]
[ "fox",	  4	  ]
[ "the",	  1	  ]
[ ".",		  10	  ]
#b.reverse().select(\"fox\",\"quick\").print();
#-------------------------#
# h	t		  # name
# int	str		  # type
#-------------------------#
[ 2,	  "quick"	  ]
[ 5,	  "jumps"	  ]
[ 6,	  "over"	  ]
[ 7,	  "lazy"	  ]
[ 4,	  "fox"		  ]
#b.reverse().select(\"fox\",str(nil)).print();
#-------------------------#
# h	t		  # name
# int	str		  # type
#-------------------------#
[ 2,	  "quick"	  ]
[ 5,	  "jumps"	  ]
[ 6,	  "over"	  ]
[ 7,	  "lazy"	  ]
[ 4,	  "fox"		  ]
[ 1,	  "the"		  ]
#b.reverse().select(str(nil),\"quick\").print();
#-------------------------#
# h	t		  # name
# int	str		  # type
#-------------------------#
[ nil,	  ""		  ]
[ 2,	  "quick"	  ]
[ 3,	  "brown"	  ]
[ 5,	  "jumps"	  ]
[ 6,	  "over"	  ]
[ 7,	  "lazy"	  ]
[ 8,	  "dog"		  ]
[ 4,	  "fox"		  ]
[ 10,	  "."		  ]
#b.reverse().select(str(nil),str(nil)).print();
#-------------------------#
# h	t		  # name
# int	str		  # type
#-------------------------#
[ nil,	  ""		  ]
[ 2,	  "quick"	  ]
[ 3,	  "brown"	  ]
[ 5,	  "jumps"	  ]
[ 6,	  "over"	  ]
[ 7,	  "lazy"	  ]
[ 8,	  "dog"		  ]
[ 4,	  "fox"		  ]
[ 1,	  "the"		  ]
[ 10,	  "."		  ]
## A 2-dimensional cut\n
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "quick",	  2	  ]
[ "jumps",	  5	  ]
[ "fox",	  4	  ]
#b.fragment(\"fox\",str(nil),1,5).print();
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "quick",	  2	  ]
[ "jumps",	  5	  ]
[ "fox",	  4	  ]
[ "the",	  1	  ]
#b.fragment(str(nil),\"quick\",1,5).print();
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "quick",	  2	  ]
[ "brown",	  3	  ]
[ "jumps",	  5	  ]
[ "fox",	  4	  ]
#b.fragment(str(nil),str(nil),1,5).print();
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "quick",	  2	  ]
[ "brown",	  3	  ]
[ "jumps",	  5	  ]
[ "fox",	  4	  ]
[ "the",	  1	  ]
#b.fragment(\"fox\",\"quick\",1,int(nil)).print();
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "quick",	  2	  ]
[ "jumps",	  5	  ]
[ "over",	  6	  ]
[ "lazy",	  7	  ]
[ "fox",	  4	  ]
#b.fragment(\"fox\",\"quick\",int(nil),5).print();
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "quick",	  2	  ]
[ "jumps",	  5	  ]
[ "fox",	  4	  ]
#b.fragment(\"fox\",\"quick\",int(nil),int(nil)).print();
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "quick",	  2	  ]
[ "jumps",	  5	  ]
[ "over",	  6	  ]
[ "lazy",	  7	  ]
[ "fox",	  4	  ]
#b.fragment(\"fox\",str(nil),int(nil),int(nil)).print();
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "quick",	  2	  ]
[ "jumps",	  5	  ]
[ "over",	  6	  ]
[ "lazy",	  7	  ]
[ "fox",	  4	  ]
[ "the",	  1	  ]
#b.fragment(str(nil),\"f\",int(nil),int(nil)).print();
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "",		  nil	  ]
[ "brown",	  3	  ]
[ nil,		  nil	  ]
[ "dog",	  8	  ]
[ nil,		  9	  ]
[ ".",		  10	  ]
#b.reverse().fragment(int(nil),int(nil),str(nil),\"f\").print();
#-------------------------#
# h	t		  # name
# int	str		  # type
#-------------------------#
[ nil,	  ""		  ]
[ 3,	  "brown"	  ]
[ nil,	  nil		  ]
[ 8,	  "dog"		  ]
[ 9,	  nil		  ]
[ 10,	  "."		  ]
#var b1:= b.join(bn.reverse());
#b1.print();
#---------------------------------#
# h		t		  # name
# str		str		  # type
#---------------------------------#
[ "quick",	  "quick"	  ]
[ "jumps",	  "jumps"	  ]
[ "fox",	  "fox"		  ]
#var b2:= b.semijoin(b1.reverse());
#b2.print();
#-------------------------#
# h		t	  # name
# str		int	  # type
#-------------------------#
[ "quick",	  2	  ]
[ "jumps",	  5	  ]
[ "fox",	  4	  ]
## testing the like command\n
#-----------------#
# h	t	  # name
# int	str	  # type
#-----------------#
[ 4,	  "fox"	  ]
#b.reverse().like(\"fo\").print();
#-----------------#
# h	t	  # name
# int	str	  # type
#-----------------#
[ 4,	  "fox"	  ]
#b.reverse().like(\"fox\").print();
#-----------------#
# h	t	  # name
# int	str	  # type
#-----------------#
[ 4,	  "fox"	  ]
#b.reverse().like(\" fox\").print();
#-----------------#
# h	t	  # name
# int	str	  # type
#-----------------#
#quit();

# 00:12:27 >  
# 00:12:27 >  Done.
# 00:12:27 >