id.602271.stable.out

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

stdout of test 'ID.602271` in directory 'tests/BugsViaSourgeforce` itself:


# 22:18:35 >  
# 22:18:35 >  Mtimeout -timeout 60 Mserver "--config=/ufs/niels/data/monet/Linux/etc/monet.conf" --debug=10 --set "monet_mod_path=/ufs/niels/data/monet/Linux/lib/MonetDB" --dbfarm "/ufs/niels/data/monet/Linux/var/dbfarm" --set monet_prompt= --dbname=Tests_tests_BugsViaSourgeforce  < ID.602271.milS
# 22:18:35 >  

# Monet Database Server V4.3.5
# Copyright (c) 1993-2002, CWI. All rights reserved.
# compiled for i686-pc-linux-gnu/32bit; dynamically linked.

# Date:		2002-08-30 00:57
# Priority:	5
# Submitted By:	Alex van Ballegooij (bally)
# Assigned To:	Niels Nes (nielsnes)
# Category:	None
# Status:	Closed
# Summary:
# oid v.s. void bat behavior
# 
# void bats behave differntly fomr oid bats under insertion, 
# yet it is possible to unexpectedly end up with void 
# bats after certain operations (e.g. join), which could 
# lead to unpredictable behavior. 

# Build two simple bats, using OIDs.
var oid_oid_bat := insert(insert(bat(oid,oid),oid(0),oid(0)),oid(1),oid(1));
print(oid_oid_bat);
#-----------------#
# BAT:	  tmp_33  #
# (oid)	  (oid)	  #
#-----------------#
[ 0@0,	  0@0	  ]
[ 1@0,	  1@0	  ]

var oid_int_bat := insert(insert(bat(oid,int),oid(0),0),oid(1),1);
print(oid_int_bat);
#-----------------#
# BAT:	  tmp_32  #
# (oid)	  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]

# Monet decides to make the join result VOID (which is possible),
# what makes this problematic however is the difference in behavior in
# the subsequent insert-tests.
var void_int_bat := join(oid_oid_bat,oid_int_bat);
print(void_int_bat);
#-----------------#
# BAT:	  tmp_35  #
# (void)  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]

# inserting 'in-sequence' into an OID bat
# a single (OID) tuple 
print(insert(access(copy(oid_int_bat),BAT_WRITE),
      oid(2),2));
#-----------------#
# BAT:	  tmp_34  #
# (oid)	  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]
[ 2@0,	  2	  ]
# a complete (OID) bat.
print(insert(access(copy(oid_int_bat),BAT_WRITE),
      insert(bat(oid,int),oid(2),2)));
#-----------------#
# BAT:	  tmp_34  #
# (oid)	  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]
[ 2@0,	  2	  ]
# a complete (VOID) bat.
print(insert(access(copy(oid_int_bat),BAT_WRITE),
             insert(seqbase(bat(void,int),oid(2)),oid(2),2)));
#-----------------#
# BAT:	  tmp_34  #
# (oid)	  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]
[ 2@0,	  2	  ]

# inserting 'out-of-sequence' into an OID bat
# a single (OID) tuple 
print(insert(access(copy(oid_int_bat),BAT_WRITE),
      oid(10),10));
#-----------------#
# BAT:	  tmp_34  #
# (oid)	  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]
[ 10@0,	  10	  ]
# a complete (OID) bat.
print(insert(access(copy(oid_int_bat),BAT_WRITE),
      insert(bat(oid,int),oid(10),10)));
#-----------------#
# BAT:	  tmp_34  #
# (oid)	  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]
[ 10@0,	  10	  ]
# a complete (VOID) bat.
print(insert(access(copy(oid_int_bat),BAT_WRITE),
             insert(seqbase(bat(void,int),oid(10)),oid(10),10)));
#-----------------#
# BAT:	  tmp_34  #
# (oid)	  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]
[ 10@0,	  10	  ]

# inserting 'in-sequence' into a VOID bat
# a single (OID) tuple 
print(insert(access(copy(void_int_bat),BAT_WRITE),
      oid(2),2));
#-----------------#
# BAT:	  tmp_34  #
# (void)  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]
[ 2@0,	  2	  ]
# a complete (OID) bat.
print(insert(access(copy(void_int_bat),BAT_WRITE),
      insert(bat(oid,int),oid(2),2)));
#-----------------#
# BAT:	  tmp_34  #
# (void)  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]
[ 2@0,	  2	  ]
# a complete (VOID) bat.
print(insert(access(copy(void_int_bat),BAT_WRITE),
             insert(seqbase(bat(void,int),oid(2)),oid(2),2)));
#-----------------#
# BAT:	  tmp_34  #
# (void)  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]
[ 2@0,	  2	  ]

# inserting 'out-of-sequence' into a VOID bat
# a single (OID) tuple 
# This test gives an error:
print(insert(access(copy(void_int_bat),BAT_WRITE),
      oid(10),10));
#-----------------#
# BAT:	  tmp_34  #
# (oid)	  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]
[ 10@0,	  10	  ]
# These two tests give incorrect answers:
# a complete (OID) bat.
print(insert(access(copy(void_int_bat),BAT_WRITE),
      insert(bat(oid,int),oid(10),10)));
#-----------------#
# BAT:	  tmp_34  #
# (oid)	  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]
[ 10@0,	  10	  ]
# a complete (VOID) bat.
print(insert(access(copy(void_int_bat),BAT_WRITE),
             insert(seqbase(bat(void,int),oid(10)),oid(10),10)));
#-----------------#
# BAT:	  tmp_34  #
# (oid)	  (int)	  #
#-----------------#
[ 0@0,	  0	  ]
[ 1@0,	  1	  ]
[ 10@0,	  10	  ]

#
# The void-bats behave strange under insertion,
# Either errors should be given consequently 
# (as soon as a tuple 'out-of-sequence' is inserted)
# or void bats should be materialized to oid when needed.
#
# I would argue for the latter, as there is no real reason 
# for a user to expect the bat in this example to be void,
# (a join result of a [oid,oid] and a [oid,int] bat), yet
# it behaves differently from what a user would expect from
# the (expected) [oid,int] bat.
#
# The provided stable output has been hand-crafted to 
# depict that which I argue to be the 'correct' outpu.
#
quit();

# 18:07:21 >  
# 18:07:21 >  Done.
# 18:07:21 >