public void testInsert() {
people.insert(new String[] {"Holub", "Allen", "1"});
people.insert(new String[] {"Flintstone", "Wilma", "2"});
people.insert(
new String[] {"addrId", "first", "last"}, new String[] {"2", "Fred", "Flintstone"});
address.insert(new String[] {"1", "123 MyStreet", "Berkeley", "CA", "99999"});
List l = new ArrayList();
l.add("2");
l.add("123 Quarry Ln.");
l.add("Bedrock ");
l.add("XX");
l.add("12345");
assert (address.insert(l) == 1);
l.clear();
l.add("3");
l.add("Bogus");
l.add("Bad");
l.add("XX");
l.add("12345");
List c = new ArrayList();
c.add("addrId");
c.add("street");
c.add("city");
c.add("state");
c.add("zip");
assert (address.insert(c, l) == 1);
System.out.println(people.toString());
System.out.println(address.toString());
try {
people.insert(new String[] {"x"});
throw new AssertionError("insert wrong number of fields test failed");
} catch (Throwable t) {
/* Failed correctly, do nothing */
}
try {
people.insert(new String[] {"?"}, new String[] {"y"});
throw new AssertionError("insert-nonexistent-field test failed");
} catch (Exception t) {
/* Failed correctly, do nothing */
}
}
@ManagedOperation(description = "Prints the contents of the send windows for all members")
public String printSendWindowMessages() {
StringBuilder ret = new StringBuilder(local_addr + ":\n");
for (Map.Entry<Address, SenderEntry> entry : send_table.entrySet()) {
Address addr = entry.getKey();
Table<Message> buf = entry.getValue().sent_msgs;
ret.append(addr).append(": ").append(buf.toString()).append('\n');
}
return ret.toString();
}
// Test if toString() returns a correct PrimaryKey field description from a Table
public void testTableToStringWithPrimaryKey() {
Table t = getTableWithStringPrimaryKey();
t.addColumn(RealmFieldType.INTEGER, "intCol");
t.addColumn(RealmFieldType.BOOLEAN, "boolCol");
t.add("s1", 1, true);
t.add("s2", 2, false);
String expected =
"The Table has 'colName' field as a PrimaryKey, and contains 3 columns: colName, intCol, boolCol. And 2 rows.";
assertEquals(expected, t.toString());
}
/** @see org.melati.poem.Database#getDisplayTables() */
public void testGetDisplayTables() {
final String expected =
"user (from the data structure definition)"
+ "group (from the data structure definition)"
+ "capability (from the data structure definition)"
+ "groupMembership (from the data structure definition)"
+ "groupCapability (from the data structure definition)"
+ "tableInfo (from the data structure definition)"
+ "columnInfo (from the data structure definition)"
+ "tableCategory (from the data structure definition)"
+ "setting (from the data structure definition)";
String outcome = "";
for (Table<?> t : getDb().getDisplayTables()) {
outcome += t.toString();
}
if (getDb().getDbms().canDropColumns()) {
assertEquals(expected, outcome);
}
}
/**
* Run the LAPIN algorithm
*
* @param input the input file path
* @param minsupRel the minsup threshold as a percentage
*/
private void lapin(String input, double minsupRel) throws IOException {
if (DEBUG) {
System.out.println(
"=== First database scan to count number of sequences and support of single items ===");
}
// FIRST DATABASE SCAN: SCAN THE DATABASE TO COUNT
// - THE NUMBER OF SEQUENCES
// - THE SUPPORT OF EACH SINGLE ITEM
// - THE LARGEST ITEM ID
int sequenceCount = 0;
int largestItemID = 0;
// This map will store for each item (key) the first position where the item appears in each
// sequence where it appears (value)
Map<Integer, List<Position>> mapItemFirstOccurrences = new HashMap<Integer, List<Position>>();
try {
// Read the input file
BufferedReader reader =
new BufferedReader(new InputStreamReader(new FileInputStream(new File(input))));
String thisLine;
// for each sequence of the input fiel
while ((thisLine = reader.readLine()) != null) {
// we use a set to remember which item have been seen already
Set<Integer> itemsAlreadySeen = new HashSet<Integer>();
// to know the itemset number
short itemsetID = 0;
// for each token in this line
for (String integer : thisLine.split(" ")) {
// if it is the end of an itemset
if ("-1".equals(integer)) {
itemsetID++;
} else if ("-2".equals(integer)) { // if it is the end of line
// nothing to do here
} else {
// otherwise, it is an item
Integer item = Integer.valueOf(integer);
// if this item was not seen already in that sequence
if (itemsAlreadySeen.contains(item) == false) {
// Get the list of positions of that item
List<Position> list = mapItemFirstOccurrences.get(item);
// if that list is null, create a new list
if (list == null) {
list = new ArrayList<Position>();
mapItemFirstOccurrences.put(item, list);
}
// Add the position of the item in that sequence to the list of first positions
// of that item
Position position = new Position(sequenceCount, itemsetID);
list.add(position);
// Remember that we have seen this item
itemsAlreadySeen.add(item);
// Check if the item is the largest item until now
if (item > largestItemID) {
largestItemID = item;
}
}
}
}
// Increase the count of sequences from the input file
sequenceCount++;
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
;
// Initialize the list of tables
tables = new Table[sequenceCount];
// Calculate absolute minimum support as a number of sequences
minsup = (int) Math.ceil(minsupRel * sequenceCount);
if (minsup == 0) {
minsup = 1;
}
if (DEBUG) {
System.out.println("Number of items: " + mapItemFirstOccurrences.size());
System.out.println("Sequence count: " + sequenceCount);
System.out.println("Abs. minsup: " + minsup + " sequences");
System.out.println("Rel. minsup: " + minsupRel + " %");
System.out.println("=== Determining the frequent items ===");
}
// // For each frequent item, save it and add it to the list of frequent items
List<Integer> frequentItems = new ArrayList<Integer>();
for (Entry<Integer, List<Position>> entry : mapItemFirstOccurrences.entrySet()) {
// Get the border created by this item
List<Position> itemBorder = entry.getValue();
// if the item is frequent
if (itemBorder.size() >= minsup) {
// Output the item and add it to the list of frequent items
Integer item = entry.getKey();
savePattern(item, itemBorder.size());
frequentItems.add(item);
if (DEBUG) {
System.out.println(" Item " + item + " is frequent with support = " + itemBorder.size());
}
}
}
if (DEBUG) {
System.out.println("=== Second database scan to construct item-is-exist tables ===");
}
// sort the frequent items (useful when generating 2-IE-sequences, later on).
Collections.sort(frequentItems);
// SECOND DATABASE SCAN:
// Now we will read the database again to create the Item-is-exist-table
// and SE-position-lists and count support of 2-IE-sequences
matrixPairCount = new SparseTriangularMatrix(largestItemID + 1);
// Initialise the IE position lists and SE position lists
sePositionList = new SEPositionList[sequenceCount];
iePositionList = new IEPositionList[sequenceCount];
try {
// Prepare to read the file
BufferedReader reader =
new BufferedReader(new InputStreamReader(new FileInputStream(new File(input))));
String thisLine;
// For each sequence in the file
int currentSequenceID = 0;
while ((thisLine = reader.readLine()) != null) {
// (1) ------- PARSE THE SEQUENCE BACKWARD TO CREATE THE ITEM-IS-EXIST TABLE FOR THATS
// SEQUENCE
// AND COUNT THE SUPPORT OF 2-IE-Sequences
// We will also use a structure to remember in which sequence we have seen each pair of
// items
// Note that in this structure, we will add +1 to the sid because by default the matrix is
// filled with 0
// and we don't want to think that the first sequence was already seen for all pairs.
AbstractTriangularMatrix matrixPairLastSeenInSID =
new SparseTriangularMatrix(largestItemID + 1);
// We count the number of positions (number of itemsets).
// To do that we count the number of "-" symbols in the file.
// We need to subtract 1 because the end of line "-2" contains "-".
int positionCount = -1;
for (char caracter : thisLine.toCharArray()) {
if (caracter == '-') {
positionCount++;
}
}
// Now we will scan the sequence again.
// This time we will remember which item were seen already
Set<Integer> itemsAlreadySeen = new HashSet<Integer>();
// During this scan, we will create the table for this sequence
Table table = new Table();
// To do that, we first create an initial position vector for that table
BitSet currentBitset = new BitSet(mapItemFirstOccurrences.size()); // OK ?
// This variable will be used to remember if a new item appeared in the current itemset
boolean seenNewItem = false;
// We will scan the sequence backward, starting from the end because
// we should not create a bit vector for all positions but for only
// the positions that are different from the previous one.
String[] tokens = thisLine.split(" ");
// This is the number of itemsets
int currentPosition = positionCount;
// to keep the current itemset in memory
List<Integer> currentItemset = new ArrayList<Integer>();
// For each token in that sequence
for (int i = tokens.length - 1; i >= 0; i--) {
// get the token
String token = tokens[i];
// if we reached the end of an itemset
if ("-1".equals(token)) {
// update the triangular matrix for counting 2-IE-sequences
// by comparing each pairs of items in the current itemset
for (int k = 0; k < currentItemset.size(); k++) {
Integer item1 = currentItemset.get(k);
for (int m = k + 1; m < currentItemset.size(); m++) {
Integer item2 = currentItemset.get(m);
// if that pair is frequent
int sid = matrixPairLastSeenInSID.getSupportForItems(item1, item2);
// and if we have not seen this sequence yet
if (sid != currentSequenceID + 1) {
// increment support count of this pair
matrixPairCount.incrementCount(item1, item2);
// remember that we have seen this pair so that we don't count it again
matrixPairLastSeenInSID.setSupport(item1, item2, currentSequenceID + 1);
}
}
}
currentItemset.clear();
// Decrease the current index of the position (itemset) in the sequence
currentPosition--;
// if the bit vector has changed since previous position, then
// we need to add a new bit vector to the table
if (seenNewItem) {
// create the position vector and add it to the item-is-exist table
PositionVector vector =
new PositionVector(currentPosition, (BitSet) currentBitset.clone());
table.add(vector);
}
} else if ("-2".equals(token)) { // if end of sequence, nothing to do
} else {
// otherwise, it is an item
Integer item = Integer.valueOf(token);
if (mapItemFirstOccurrences.get(item).size() >= minsup) { // only for frequent items
// if first time that we see this item
if (itemsAlreadySeen.contains(item) == false) {
// remember that we have seen a new item
seenNewItem = true;
// remember that we have seen this item
itemsAlreadySeen.add(item);
// add this item to the current bit vector
currentBitset.set(item);
}
// add this item to the current itemset
currentItemset.add(item);
}
}
}
// Lastly,
// update the triangular matrix for counting 2-IE-sequences one more time
// for the case where the pair is in first position of the sequence
// by considering each pair of items in the last itemset.
// This is done like it was done above, so I will not comment this part of the code again.
for (int k = 0; k < currentItemset.size(); k++) {
Integer item1 = currentItemset.get(k);
for (int m = k + 1; m < currentItemset.size(); m++) {
Integer item2 = currentItemset.get(m);
// if th
int sid = matrixPairLastSeenInSID.getSupportForItems(item1, item2);
if (sid != currentSequenceID + 1) {
matrixPairCount.incrementCount(item1, item2);
matrixPairLastSeenInSID.setSupport(item1, item2, currentSequenceID + 1);
}
}
}
// If a new item was seen
// Add an extra row to the item-is-exist table that will be called -1 with all items in
// this sequence
if (seenNewItem) {
PositionVector vector = new PositionVector(-1, (BitSet) currentBitset.clone());
table.add(vector);
}
//
//
// // Initialize the IE lists and SE lists for that sequence
// which will be filled with the next database scan.
sePositionList[currentSequenceID] = new SEPositionList(itemsAlreadySeen);
iePositionList[currentSequenceID] = new IEPositionList();
if (DEBUG) {
System.out.println("Table for sequence " + currentSequenceID + " : " + thisLine);
System.out.println(table.toString());
}
// put the current table in the array of item-is-exist-tables
tables[currentSequenceID] = table;
// we will process the next sequence id
currentSequenceID++;
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
// THIRD SCAN TO
// PARSE THE SEQUENCE FORWARD TO CREATE THE SE-POSITION LIST OF THAT SEQUENCE
// AND IEPositionList for frequent 2-IE-SEQUENCES
try {
BufferedReader reader =
new BufferedReader(new InputStreamReader(new FileInputStream(new File(input))));
String thisLine;
// For each sequence
int currentSequenceID = 0;
while ((thisLine = reader.readLine()) != null) {
// We will scan the sequence backward, starting from the end.
String[] tokens = thisLine.split(" ");
// to keep the current itemset in memory
List<Integer> currentItemset = new ArrayList<Integer>();
// this variable will be used to remember which itemset we are visiting
short itemsetID = 0;
// empty the object to track the current itemset (if it was used for the previous sequence)
currentItemset.clear();
// for each token of the current sequence
for (int i = 0; i < tokens.length; i++) {
String token = tokens[i];
// if we reached the end of an itemset
if ("-1".equals(token)) {
// if the current itemset contains more than one item
if (currentItemset.size() > 1) {
// update the position list for 2-IE-sequences
for (int k = 0; k < currentItemset.size(); k++) {
Integer item1 = currentItemset.get(k);
for (int m = k + 1; m < currentItemset.size(); m++) {
Integer item2 = currentItemset.get(m);
// if the pair is frequent
int support = matrixPairCount.getSupportForItems(item1, item2);
if (support >= minsup) {
iePositionList[currentSequenceID].register(item1, item2, itemsetID);
}
}
}
}
// increase itemsetID
itemsetID++;
// clear itemset
currentItemset.clear();
} else if ("-2".equals(token)) {
// if the end of a sequence, nothing special to do
} else {
// otherwise, the current token is an item
Integer item = Integer.valueOf(token);
// if the item is frequent
if (mapItemFirstOccurrences.get(item).size() >= minsup) {
// we add the current position to the item SE-position list
sePositionList[currentSequenceID].register(item, itemsetID);
// we add the item to the current itemset
currentItemset.add(item);
}
}
}
if (DEBUG) {
System.out.println("SE Position list for sequence " + currentSequenceID);
System.out.println(sePositionList[currentSequenceID]);
System.out.println("IE Position list for sequence " + currentSequenceID);
System.out.println(iePositionList[currentSequenceID]);
}
iePositionList[currentSequenceID].sort(); // sort the IE-position list
// update the sequence id for the next sequence
currentSequenceID++;
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
if (DEBUG) {
System.out.println("=== Starting sequential pattern generation ===");
}
// For each frequent item, call the recursive method to explore larger patterns
for (int i = 0; i < frequentItems.size(); i++) {
// Get the item
int item1 = frequentItems.get(i);
// Get the border for that item
List<Position> item1Border = mapItemFirstOccurrences.get(item1);
if (DEBUG) {
System.out.println("=== Considering item " + item1);
System.out.println(" Border of " + item1);
for (Position pos : item1Border) {
System.out.println(" seq: " + pos.sid + " itemset: " + pos.position);
}
}
// if the border contains at least minsup sequence (if the item is frequent)
if (item1Border.size() >= minsup) {
// Create an object prefix to represent the sequential pattern containing the item
Prefix prefix = new Prefix();
List<Integer> itemset = new ArrayList<Integer>(1);
itemset.add(item1);
prefix.itemsets.add(itemset);
// make a recursive call to find s-extensions of this prefix
genPatterns(
prefix,
item1Border,
frequentItems,
frequentItems,
item1,
true); // true, to disallow I-extension because we explore 2-IE sequences separately
}
// For each frequent 2-IE sequences stating with item1, we will explore 2-IE sequences
// by considering each frequent item larger than item1
for (int k = i + 1; k < frequentItems.size(); k++) {
// We consider item2
int item2 = frequentItems.get(k);
// Get the support of item1, item2
int support = matrixPairCount.getSupportForItems(item1, item2);
// if the pair {item1, item2} is frequent
if (support >= minsup) {
// get the list of position of item2
List<Position> item2Border = mapItemFirstOccurrences.get(item2);
// Create the border by using the 2-IE position list
List<Position> ie12Border = new ArrayList<Position>();
// We will loop over the border of item1 or item2 (the smallest one)
List<Position> borderToUse;
if (item2Border.size() < item1Border.size()) {
borderToUse = item2Border;
} else {
borderToUse = item1Border;
}
// For each sequence of the border that we consider
for (Position sequenceToUse : borderToUse) {
// Get the sequence id
int sid = sequenceToUse.sid;
// For this sequence, we will get the position list of each item
List<Short> listPosition1 = sePositionList[sid].getListForItem(item1);
List<Short> listPosition2 = sePositionList[sid].getListForItem(item2);
// if one of them is null, that means that both item1 and item2 do not appear in that
// sequence
// so we continue to the next sequence
if (listPosition1 == null || listPosition2 == null) {
continue;
}
// otherwise
// find the first common position of item1 and item2 in the sequence
int index1 = 0;
int index2 = 0;
// we do that by the following while loop
while (index1 < listPosition1.size() && index2 < listPosition2.size()) {
short position1 = listPosition1.get(index1);
short position2 = listPosition2.get(index2);
if (position1 < position2) {
index1++;
} else if (position1 > position2) {
index2++;
} else {
// we have found the position, so we add it to the new border and
// then stop because we do not want to add more than one position for
// the same sequence in the new border
ie12Border.add(new Position(sid, position1));
break;
}
}
}
if (DEBUG) {
System.out.println(
"=== Considering the 2-IE sequence {"
+ item1
+ ","
+ item2
+ "} with support "
+ support);
System.out.println(" Border of {" + item1 + "," + item2 + "}");
for (Position pos : ie12Border) {
System.out.println(" seq: " + pos.sid + " itemset: " + pos.position);
}
}
// finally, we create the prefix for the pattern {item1, item2}
Prefix prefix = new Prefix();
List<Integer> itemset = new ArrayList<Integer>(2);
itemset.add(item1);
itemset.add(item2);
prefix.itemsets.add(itemset);
// save the pattern
savePattern(prefix, support);
// perform recursive call to extend that pattern
genPatterns(
prefix,
ie12Border,
frequentItems,
frequentItems,
item2,
false); // false, to allow I-extension
}
}
}
// Record the maximum memory usage
MemoryLogger.getInstance().checkMemory();
writer.close();
}
public String getTable(Table tbl) {
if (dbms == DBMS.H2) return tbl.getName();
return plugin.getConfig().getString("mysql.tables." + tbl.toString().toLowerCase());
}
public void testUndo() {
// Verify that commit works properly
people.begin();
System.out.println("begin/insert into people (Solo, Han, 5)");
people.insert(new String[] {"Solo", "Han", "5"});
System.out.println(people.toString());
people.begin();
System.out.println("begin/insert into people (Lea, Princess, 6)");
people.insert(new String[] {"Lea", "Princess", "6"});
System.out.println(people.toString());
System.out.println("commit(THIS_LEVEL)\n" + "rollback(Table.THIS_LEVEL)\n");
people.commit(Table.THIS_LEVEL);
people.rollback(Table.THIS_LEVEL);
System.out.println(people.toString());
// Now test that nested transactions work correctly.
System.out.println(people.toString());
System.out.println("begin/insert into people (Vader,Darth, 4)");
people.begin();
people.insert(new String[] {"Vader", "Darth", "4"});
System.out.println(people.toString());
System.out.println("begin/update people set last=Skywalker where last=Vader");
people.begin();
people.update(
new Selector() {
public boolean approve(Cursor[] tables) {
return tables[0].column("last").equals("Vader");
}
public void modify(Cursor current) {
current.update("last", "Skywalker");
}
});
System.out.println(people.toString());
System.out.println("delete from people where last=Skywalker");
people.delete(
new Selector.Adapter() {
@Override
public boolean approve(Cursor[] tables) {
return tables[0].column("last").equals("Skywalker");
}
});
System.out.println(people.toString());
System.out.println("rollback(Table.THIS_LEVEL) the delete and update");
people.rollback(Table.THIS_LEVEL);
System.out.println(people.toString());
System.out.println("rollback(Table.THIS_LEVEL) insert");
people.rollback(Table.THIS_LEVEL);
System.out.println(people.toString());
}
public void testJoin() {
// First test a two-way join
System.out.println(
"\nSELECT first,last,street,city,state,zip"
+ " FROM people, address"
+ " WHERE people.addrId = address.addrId");
// Collection version chains to String[] version,
// so this code tests both:
List columns = new ArrayList();
columns.add("first");
columns.add("last");
columns.add("street");
columns.add("city");
columns.add("state");
columns.add("zip");
List tables = new ArrayList();
tables.add(address);
// WHERE people.addrID = address.addrID
Table result =
people.select(
new Selector.Adapter() {
@Override
public boolean approve(Cursor[] tables) {
String a = tables[0].column("addrId");
String b = tables[1].column("addrId");
return StringUtil.equals(a, b);
// return tables[0].column("addrId").equals(tables[1].column("addrId"));
}
},
columns,
tables);
print(result);
System.out.println("");
// Now test a three-way join
//
System.out.println(
"\nSELECT first,last,street,city,state,zip,text"
+ " FROM people, address, third"
+ " WHERE (people.addrId = address.addrId)"
+ " AND (people.addrId = third.addrId)");
Table third = TableFactory.create("third", new String[] {"addrId", "text"});
third.insert(new String[] {"1", "addrId=1"});
third.insert(new String[] {"2", "addrId=2"});
result =
people.select(
new Selector.Adapter() {
@Override
public boolean approve(Cursor[] tables) {
return (StringUtil.equals(tables[0].column("addrId"), tables[1].column("addrId"))
&& StringUtil.equals(tables[0].column("addrId"), tables[2].column("addrId")));
}
},
new String[] {"last", "first", "state", "text"},
new Table[] {address, third});
System.out.println(result.toString() + "\n");
}
