Hi, Sorry I got in so late on the thread; I have been writing code and testing it on the beta grid most of today.
But what I was testing may be just what you need
This is the latest version of my DataStarage script, which I refer to as a “slice”.
The interface is now a lot less cryptic than the old one, and it handles several file types.
Variable length records, multiple fields per record and automatic or manual sorting.
I have also included a better description of the LinkMessages used to control it.
As such I hope, it will factor out some of the complexity for you.
// Indexed Sequential Access Method / Direct Access Storage Device
// data slice - A subscript of the ISAM/DASD componant of VK-Net
// Very Keynes - February 2008 tested in MONO and LSL2
// version 3.4 - 080210
//
//---------Technical Notes to aid in implementation---------------
//
// inter script communication:
//
// Commands are passed Via LinkMessages, parms are mapped as:
//
// link_message(integer tmp, integer num, string val, key arg)
// note: tmp may not be passed - used internally only.
// note: arg is further defined as - adr,ret,cmd,opt
// where: adr = script name being addressed
// ret = script name expecting the reply
// cmd = command to be processed
// opt = Optional parameter (not used in this module)
//
// Replys always appends the original arg to the reply arg
// so that the reciving scrip can understand the data returned
//
// Field content abbreviations:
// * - item is ignored
// [...] - item is optional
// rec# - record number (current record in reply)
// specifying rec# = 0 will address the column headers
// col# - column numbers starting at 1
// #recs - number of records
// #cols - number of columns
// mem - desired free space (free memory in reply)
//
// error format: num=err# val=* arg=ret,"err",arg
// error codes:
// num = -1 : not found
// num = -2 : incorrect number of fields passed
// num = -3 : slice is full
// num = -4 : invalid column number
// num = -5 : invalid record number
// if the command finished sucesfuly arg=ret,"ok ",arg
// is returned with num and val containing the data
//
// Command format in order of test/execution:
//
//System Commands
//
// Set and/or Return the current status of the slice:
// mem: num=[mem] val=* arg=adr,ret,"mem"
// reply num=mem val="#recs, #cols" arg=ret,status,arg
// note: if num >0 the low memory test will be adjusted to value of num
//
// Initialize the slice to type and define the column headers:
// new: num=type val="field names" arg=adr,ret,"new",
// reply num=mem val=adr arg=ret,status,arg
// note: supported file types (pass the numeric version in num)
// txt - 0 - Flatfile - single field per record no conversion
// dbx - 1 - Database file, unlimited fields per record CSV format
// idx - 2 - Index File, as above, with auto sort after each update
// note: Auto sort is by col#1 order is Ascending
//
// Sort the Table based on the 1st Field/Column:
// srt: num=[x] val=* arg=adr,ret,"srt",
// reply num=mem val=#recs, #cols arg=ret,status,arg
// note: if num != 0 sort Descending otherwise sort Ascending
// note: column headers are locked, rec#1 -> #recs are sorted
//
//data retrieval commands
//
// Find a record based on an Exact Match to the data supplied:
// fnd: num=col# val="search string" arg=adr,ret,"fnd",
// reply num=rec# val="Record Data" arg=ret,status,arg
// note: if col# > 0 only a match in that column is valid
// note: if col# = 0 a match in any column is valid
// note: error -1 returned if no match is found
// note: error -4 is returned if col# is not valid
//
// Return the current record in the Table:
// cur: num=* val=* arg=adr,ret,"cur",
// reply num=rec# val="Record Data" arg=ret,status,arg
//
// Return the first record in the Table:
// cur: num=* val=* arg=adr,ret,"fst",
// reply num=1 val="Record Data" arg=ret,status,arg
//
// Return the last record in the Table:
// cur: num=* val=* arg=adr,ret,"lst",
// reply num=rec# val="Record Data" arg=ret,status,arg
//
// Return the next record in the Table:
// nxt: num=* val=* arg=adr,ret,"nxt",
// reply num=rec# val="Record Data" arg=ret,status,arg
// note: error -5 is returned if rec# is not valid
//
// Return the previous record in the Table:
// prv: num=* val=* arg=adr,ret,"prv",
// reply num=rec# val="Record Data" arg=ret,status,arg
// note: error -5 is returned if rec# is not valid
//
// Return the record specified by rec#
// get: num=rec# val=* arg=adr,ret,"get",
// reply num=rec# val="Record Data" arg=ret,status,arg
// note: error -5 is returned if rec# is not valid
//
// Return a column of information specified by col#
// col: num=col# val=* arg=adr,ret,"col",
// reply num=col# val="Column Data" arg=ret,status,arg
// note: error -4 is returned if col# is not valid
//
//update commands
//
// Delete a record from the table:
// del: num=rec# val=* arg=adr,ret,"del",
// reply num=mem val=#recs, #cols arg=ret,status,arg
// note: column headers are locked, rec#0 cannot be deleted
// note: error -5 is returned if rec# is not valid
// note: mem is returned in the hope that this bug will be fixed in MONO
//
// Note: integrity test is performed for the following commands
// For dbx and idx types the number of data elements passed
// must match the number of fields defined else error -2
// is returned. txt files will accept any string value.
//
// Append a record to the end of the Table:
// add: num=* val="Record Data" arg=adr,ret,"add",
// reply num=rec# val=#recs, #cols arg=ret,status,arg
//
// Replace the record specified by rec#
// put: num=rec# val="Record Data" arg=adr,ret,"put",
// reply num=rec# val=#recs, #cols arg=ret,status,arg
// note: column headers are locked, so update rec#0 with care
//
//----------End of Documentation - Code starts here------------
//
//Default low memory test - adjust to suit your application
//for idx flies or if srt and col functions are requierd
//it should be set to 50% of space free on startup.
//i.e. 6500 for LSL2 and 30000 for MONO to be safe.
//note: mem may be adjusted at run time by the mem command.
integer mem = 6500;
//
// Do Not modify below this point, unless optimizing
// If you do optimize anything please drop a copy on me :)
//
//default type is idx - reset by new command
list data=["filename,adr"];integer sort = TRUE;integer stride = 2;
//working Variables
integer rec; //current record number
integer tot; //Total number of records in the table
string adr; //Slice Address
string cmd; //current command
list args; //[adr,ret,cmd,opt]
list lval; //val as list
float x;
//Functions
reply(integer num,string val,string msg){llMessageLinked(LINK_ROOT,num,val,llList2String(args,1)+","+msg);}
default
{
state_entry()
{
if(llGetStartParameter())llResetScript();//if spawned by redirect then reset
//determine name set by user or control/redirect pair and announce my presence
llMessageLinked(LINK_ROOT,llGetFreeMemory(),adr=llGetScriptName(),"all, created");
}
link_message(integer tmp, integer num, string val, key arg)
{
//decode the arg CSV format - adr,ret,cmd,opt
args=llCSV2List(arg);
if(llList2String(args,0)!=adr)return;//This command is not addressed to me so ignore it
cmd=llList2String(args,2);//extract cmd as it is used frequently
//Process cmd
//System Commands
// Set and/or Return the current status of the slice:
if("mem"==cmd)
{
if(0<num){mem=num;}
reply(llGetFreeMemory(),(string)tot+", "+(string)stride,"ok ,"+(string)arg);
return;
}
// Initialize the slice to type and define the column Headers:
if("new"==cmd)
{
if(0==num){data = [val]; stride=1; sort=FALSE;}
if(1==num){data = llCSV2List(val); stride=llGetListLength(data); sort=FALSE;}
if(2==num){data = llCSV2List(val); stride=llGetListLength(data); sort=TRUE;}
reply(stride,adr,"ok ,"+(string)arg);return;
}
// Sort the Table by the first Column:
if("srt"==cmd)
{
val=llList2CSV(llList2List(data,0,stride-1));
data = (data=[]) + llCSV2List(val) + llListSort(llDeleteSubList(data,0,stride-1),stride,!tmp);
reply(llGetFreeMemory(),(string)tot +", "+(string)stride,"ok ,"+(string)arg);return;
}
//data retrieval commands
// Find a record based on an Exact Match to the data supplied:
if("fnd"==cmd)
{
if(0 > num || stride < num)//invalid column number
{
reply(-4, "","err,"+(string)arg);
return;
}
x=llListFindList(data,[val]);
rec=(integer)x/stride;
x= 1+(stride*((x/stride)-rec));
tmp=(integer)x;
if(0!=rec)//Record was Found
{
if(0==num)//value was found and no column# was specified so return record
{
reply(rec,llList2CSV(llList2List(data,num=rec*stride,num+stride-1)),"ok ,"+(string)arg);
return;
}
else if(num==tmp)//column# matches so return record
{
reply(rec,llList2CSV(llList2List(data,num=rec*stride,num+stride-1)),"ok ,"+(string)arg);
return;
}
}
reply(-1,val,"err,"+(string)arg);//value not found in table
return;
}
// Return the current record in the Table:
if("cur"==cmd){num=rec;cmd="get";}
// Return the first record in the Table:
else if("fst"==cmd){num=1;cmd="get";}
// Return the last record in the Table:
else if("lst"==cmd){num=tot-1;cmd="get";}
// Return the next record in the Table:
else if("nxt"==cmd){num=rec+1;cmd="get";}
// Return the previous record in the Table:
else if("prv"==cmd){num=rec-1;cmd="get";}
// Return the record specified by rec#
if("get"==cmd)//get a record and return it
{
if(0 > num || tot < num){reply(-5, "","err,"+(string)arg);return;}
else if(1==stride){reply(rec=num,llList2String(data,num),"ok ,"+(string)arg);return;}//retain commas in txt files
else reply(rec=num,llList2CSV(llList2List(data,tmp=num*stride,tmp+stride-1)),"ok ,"+(string)arg);return;
}
// Return the column of information specified by col#
else if("col"==cmd)
{if(1 > num || stride < num){reply(-4, "","err,"+(string)arg);return;}
else {reply(num-1,llList2CSV(llList2ListStrided(llList2List(data, num-1, -1), 0, -1, stride)),"ok ,"+(string)arg);return;}
}
//update commands
// Delete a record from the table:
if("del"==cmd){if(1 > num || tot < num){reply(-5, "","err,"+(string)arg);return;}
data=(data=[])+llDeleteSubList(data,tmp=num*stride,tmp+stride-1);
reply(llGetFreeMemory(),(string)(--tot) +", "+(string)stride,"ok ,"+(string)arg);
jump internals;}//I hate jumps but had to skip to the internal processing
// decode the data string format - field1,field2,.....,fieldx
if(1==stride)lval=[val]; else lval=llCSV2List(val);
//test validity of data string
if(llGetListLength(lval)!=stride){reply(-2, "","err,"+(string)arg);return;}
// Append a record to the end of the existing Table:
else if("add"==cmd){cmd="put";num=tot+1;}//let put add the record to the table
// Replace the record specified by rec#
if("put"==cmd)//put (replace) a record in the table
{tot=(llGetListLength(data=(data=[])+llListReplaceList(data,lval,tmp=num*stride,tmp+stride-1))/stride)-1;
reply(rec=num,(string)tot+", "+(string)stride,"ok ,"+(string)arg);}
@internals;
//Internal Processing
//Auto Sort
if(sort){
val=llList2CSV(llList2List(data,0,stride-1));
data = (data=[]) + llCSV2List(val) + llListSort(llDeleteSubList(data,0,stride-1),stride,TRUE);}
tot=(llGetListLength(data)/stride-1);
//if mem is exceeded after executing commands send an Error to warn Caller:
if(llGetFreeMemory()<mem){reply(-3,"","err,"+(string)arg);}
//processing complete
return;
}
}
This is a sub component of a much larger system (still in development) but is usable as it is, without the controller script mentioned in the comments. The system will really come into it's own when MONO is released on the main Grid.
