public List<String> getRegionsAsString() {
List<String> reg = new ArrayList<String>();
for (Region r : this.regions) {
reg.add(r.toString());
}
return reg;
}
@Test
public void test1() {
MemcachedMPool pool = new MemcachedMPool();
pool.initialize(32, 0.25f, 4 << 10);
RecordManager manager = new RecordManager(pool);
KVIndexCache cache = new KVIndexCache(manager);
String keystr = "navis1";
String valurstr = "value1";
byte[] key = keystr.getBytes();
byte[] value = valurstr.getBytes();
long counter = 0;
int[][] eindex1 = TestUtils.eindex(pool, key, value, 0, ++counter);
int[][] eindex2 = TestUtils.eindex(pool, "navis2", "value2", 0, ++counter);
int[][] eindex3 = TestUtils.eindex(pool, "navis3", "value3", 0, ++counter);
int length = Region.toLength(eindex1[MEMORY]);
Assert.assertEquals(length, RECORD_HEADER_LEN + keystr.length() + valurstr.length());
Assert.assertNull(cache.store(0, eindex1));
int[][] retrieved = cache.get(key, Utils.hash(key));
Assert.assertSame(eindex1[MEMORY], retrieved[MEMORY]);
Assert.assertEquals(keystr, manager.keyString(eindex1[MEMORY]));
Assert.assertEquals(valurstr, manager.valueString(eindex1[MEMORY]));
Assert.assertEquals(
keystr + "=" + valurstr, manager.keyValueString(eindex1[MEMORY], (byte) '='));
int[] prev = eindex1[MEMORY];
int[] nindex = eindex1[MEMORY] = manager.cropData(eindex1[MEMORY]);
System.out.println(Region.toString(eindex1[MEMORY]) + " --> " + Region.toString(nindex));
Assert.assertNotSame(prev, nindex);
Assert.assertSame(eindex1, cache.get(key, Utils.hash(key)));
Assert.assertEquals(keystr, manager.keyString(nindex));
Assert.assertEquals(length - valurstr.length(), Region.toLength(nindex));
cache.store(0, eindex2);
cache.store(0, eindex3);
Assert.assertTrue(
TestUtils.equals(manager, cache.values(), true, "navis1", "navis2", "navis3"));
Assert.assertEquals("value2", manager.valueString(cache.retrieve("navis2")));
Assert.assertTrue(
TestUtils.equals(manager, cache.values(), true, "navis1", "navis3", "navis2"));
Assert.assertTrue(
TestUtils.equals(manager, cache.cvalues(), true, "navis1", "navis2", "navis3"));
System.out.println(
"LRU : " + Arrays.toString(TestUtils.toString(manager, cache.values(), false)));
System.out.println(
"C : " + Arrays.toString(TestUtils.toString(manager, cache.cvalues(), false)));
System.out.println(
"[KVIndexCacheTest/test1] remove mark " + manager.keyString(eindex1[MEMORY]));
cache.removeMark(eindex1);
Assert.assertNull(cache.retrieve("navis1"));
Assert.assertTrue(
TestUtils.equals(
manager, cache.values(), false, "navis1", "navis3:value3", "navis2:value2"));
Assert.assertTrue(
TestUtils.equals(
manager, cache.cvalues(), false, "navis2:value2", "navis3:value3", "navis1"));
System.out.println(
"LRU : " + Arrays.toString(TestUtils.toString(manager, cache.values(), false)));
System.out.println(
"C : " + Arrays.toString(TestUtils.toString(manager, cache.cvalues(), false)));
}
RTreeLoad(String[] args) {
try {
if (args.length != 4) {
System.err.println(
"Usage: RTreeLoad input_file tree_file capacity query_type [intersection | 10NN].");
System.exit(-1);
}
LineNumberReader lr = null;
try {
lr = new LineNumberReader(new FileReader(args[0]));
} catch (FileNotFoundException e) {
System.err.println("Cannot open data file " + args[0] + ".");
System.exit(-1);
}
// Create a disk based storage manager.
PropertySet ps = new PropertySet();
Boolean b = new Boolean(true);
ps.setProperty("Overwrite", b);
// overwrite the file if it exists.
ps.setProperty("FileName", args[1]);
// .idx and .dat extensions will be added.
Integer i = new Integer(4096);
ps.setProperty("PageSize", i);
// specify the page size. Since the index may also contain user defined data
// there is no way to know how big a single node may become. The storage manager
// will use multiple pages per node if needed. Off course this will slow down performance.
IStorageManager diskfile = new DiskStorageManager(ps);
IBuffer file = new RandomEvictionsBuffer(diskfile, 10, false);
// applies a main memory random buffer on top of the persistent storage manager
// (LRU buffer, etc can be created the same way).
// Create a new, empty, RTree with dimensionality 2, minimum load 70%, using "file" as
// the StorageManager and the RSTAR splitting policy.
PropertySet ps2 = new PropertySet();
Double f = new Double(0.7);
ps2.setProperty("FillFactor", f);
i = new Integer(args[2]);
ps2.setProperty("IndexCapacity", i);
ps2.setProperty("LeafCapacity", i);
// Index capacity and leaf capacity may be different.
i = new Integer(2);
ps2.setProperty("Dimension", i);
ISpatialIndex tree = new RTree(ps2, file);
int count = 0;
int indexIO = 0;
int leafIO = 0;
int id, op;
double x1, x2, y1, y2;
double[] f1 = new double[2];
double[] f2 = new double[2];
long start = System.currentTimeMillis();
String line = lr.readLine();
while (line != null) {
StringTokenizer st = new StringTokenizer(line);
op = new Integer(st.nextToken()).intValue();
id = new Integer(st.nextToken()).intValue();
x1 = new Double(st.nextToken()).doubleValue();
y1 = new Double(st.nextToken()).doubleValue();
x2 = new Double(st.nextToken()).doubleValue();
y2 = new Double(st.nextToken()).doubleValue();
if (op == 0) {
// delete
f1[0] = x1;
f1[1] = y1;
f2[0] = x2;
f2[1] = y2;
Region r = new Region(f1, f2);
if (tree.deleteData(r, id) == false) {
System.err.println("Cannot delete id: " + id + " , count: " + count + ".");
System.exit(-1);
}
} else if (op == 1) {
// insert
f1[0] = x1;
f1[1] = y1;
f2[0] = x2;
f2[1] = y2;
Region r = new Region(f1, f2);
String data = r.toString();
// associate some data with this region. I will use a string that represents the
// region itself, as an example.
// NOTE: It is not necessary to associate any data here. A null pointer can be used. In
// that
// case you should store the data externally. The index will provide the data IDs of
// the answers to any query, which can be used to access the actual data from the external
// storage (e.g. a hash table or a database table, etc.).
// Storing the data in the index is convinient and in case a clustered storage manager is
// provided (one that stores any node in consecutive pages) performance will improve
// substantially,
// since disk accesses will be mostly sequential. On the other hand, the index will need
// to
// manipulate the data, resulting in larger overhead. If you use a main memory storage
// manager,
// storing the data externally is highly recommended (clustering has no effect).
// A clustered storage manager is NOT provided yet.
// Also you will have to take care of converting you data to and from binary format, since
// only
// array of bytes can be inserted in the index (see RTree::Node::load and
// RTree::Node::store for
// an example of how to do that).
// tree.insertData(data.getBytes(), r, id);
tree.insertData(null, r, id);
// example of passing a null pointer as the associated data.
} else if (op == 2) {
// query
f1[0] = x1;
f1[1] = y1;
f2[0] = x2;
f2[1] = y2;
MyVisitor vis = new MyVisitor();
if (args[3].equals("intersection")) {
Region r = new Region(f1, f2);
tree.intersectionQuery(r, vis);
// this will find all data that intersect with the query range.
} else if (args[3].equals("10NN")) {
Point p = new Point(f1);
tree.nearestNeighborQuery(10, p, vis);
// this will find the 10 nearest neighbors.
} else {
System.err.println("Unknown query type.");
System.exit(-1);
}
}
if ((count % 1000) == 0) System.err.println(count);
count++;
line = lr.readLine();
}
long end = System.currentTimeMillis();
System.err.println("Operations: " + count);
System.err.println(tree);
System.err.println("Minutes: " + ((end - start) / 1000.0f) / 60.0f);
// since we created a new RTree, the PropertySet that was used to initialize the structure
// now contains the IndexIdentifier property, which can be used later to reuse the index.
// (Remember that multiple indices may reside in the same storage manager at the same time
// and every one is accessed using its unique IndexIdentifier).
Integer indexID = (Integer) ps2.getProperty("IndexIdentifier");
System.err.println("Index ID: " + indexID);
boolean ret = tree.isIndexValid();
if (ret == false) System.err.println("Structure is INVALID!");
// flush all pending changes to persistent storage (needed since Java might not call finalize
// when JVM exits).
tree.flush();
} catch (Exception e) {
e.printStackTrace();
}
}
