From 4e33906a765967084fd91406b5e935bc6803d45a Mon Sep 17 00:00:00 2001 From: navid Date: Wed, 21 Jan 2009 19:53:59 +0000 Subject: [PATCH] *** empty log message *** --- .../tuplesoup/core/DualFileTable.java | 596 ++++++++++++++++ .../tuplesoup/core/FlatIndex.java | 167 +++++ .../tuplesoup/core/HashedTable.java | 235 +++++++ .../tuplesoup/core/IndexedTableReader.java | 261 +++++++ .../tuplesoup/core/MemoryIndex.java | 117 ++++ .../tuplesoup/core/PagedIndex.java | 141 ++++ .../com/solidosystems/tuplesoup/core/Row.java | 400 +++++++++++ .../tuplesoup/core/RowMatcher.java | 108 +++ .../solidosystems/tuplesoup/core/Table.java | 147 ++++ .../tuplesoup/core/TableIndex.java | 45 ++ .../tuplesoup/core/TableIndexEntry.java | 235 +++++++ .../tuplesoup/core/TableIndexNode.java | 87 +++ .../tuplesoup/core/TableIndexPage.java | 260 +++++++ .../tuplesoup/core/TupleStream.java | 39 ++ .../tuplesoup/core/TupleStreamMerger.java | 74 ++ .../solidosystems/tuplesoup/core/Value.java | 639 ++++++++++++++++++ .../tuplesoup/filter/Conditional.java | 71 ++ .../tuplesoup/filter/HeapSort.java | 46 ++ .../tuplesoup/filter/JavaSort.java | 61 ++ .../solidosystems/tuplesoup/filter/Join.java | 80 +++ .../tuplesoup/filter/MergeSort.java | 182 +++++ .../tuplesoup/filter/MergeSort2.java | 227 +++++++ .../tuplesoup/filter/QuickSort.java | 46 ++ .../tuplesoup/filter/RadixSort.java | 46 ++ .../tuplesoup/filter/RowBuffer.java | 132 ++++ .../solidosystems/tuplesoup/filter/Sort.java | 53 ++ .../tuplesoup/filter/SortComparator.java | 67 ++ .../tuplesoup/filter/SortRule.java | 55 ++ .../tuplesoup/test/BasicTest.java | 117 ++++ .../tuplesoup/test/ComparisonTest.java | 339 ++++++++++ .../tuplesoup/test/CoreTest.java | 217 ++++++ .../test/ParallelPerformanceTest.java | 166 +++++ .../tuplesoup/test/ParallelThread.java | 72 ++ .../tuplesoup/test/PerformanceTest.java | 239 +++++++ .../solidosystems/tuplesoup/test/RowTest.java | 162 +++++ .../tuplesoup/test/SortTest.java | 179 +++++ .../tuplesoup/test/TableTest.java | 396 +++++++++++ .../tuplesoup/test/ValueTest.java | 364 ++++++++++ 38 files changed, 6868 insertions(+) create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/DualFileTable.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/FlatIndex.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/HashedTable.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/IndexedTableReader.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/MemoryIndex.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/PagedIndex.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/Row.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/RowMatcher.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/Table.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TableIndex.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TableIndexEntry.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TableIndexNode.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TableIndexPage.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TupleStream.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TupleStreamMerger.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/Value.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/Conditional.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/HeapSort.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/JavaSort.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/Join.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/MergeSort.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/MergeSort2.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/QuickSort.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/RadixSort.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/RowBuffer.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/Sort.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/SortComparator.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/SortRule.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/BasicTest.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/ComparisonTest.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/CoreTest.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/ParallelPerformanceTest.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/ParallelThread.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/PerformanceTest.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/RowTest.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/SortTest.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/TableTest.java create mode 100644 Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/ValueTest.java diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/DualFileTable.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/DualFileTable.java new file mode 100644 index 00000000..e26cfdaa --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/DualFileTable.java @@ -0,0 +1,596 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.core; + +import java.io.*; +import java.util.*; +import java.nio.channels.*; +import com.solidosystems.tuplesoup.filter.*; + +/** + * The table stores a group of rows. + * Every row must have a unique id within a table. + */ +public class DualFileTable implements Table{ + + + private int INDEXCACHESIZE=8192; + + private String filealock="filea-dummy"; + private String fileblock="fileb-dummy"; + + private DataOutputStream fileastream=null; + private DataOutputStream filebstream=null; + private RandomAccessFile filearandom=null; + private RandomAccessFile filebrandom=null; + FileChannel fca=null; + FileChannel fcb=null; + private TableIndex index=null; + + private long fileaposition=0; + private long filebposition=0; + + private boolean rowswitch=true; + + private String title; + private String location; + + private TableIndexNode indexcachefirst; + private TableIndexNode indexcachelast; + private int indexcacheusage; + private Hashtable indexcache; + + // Statistic counters + long stat_add=0; + long stat_update=0; + long stat_delete=0; + long stat_add_size=0; + long stat_update_size=0; + long stat_read_size=0; + long stat_read=0; + long stat_cache_hit=0; + long stat_cache_miss=0; + long stat_cache_drop=0; + + protected String statlock="stat-dummy"; + + /** + * Return the current values of the statistic counters and reset them. + * The current counters are: + * + * Furthermore, the index will be asked to deliver separate index specific counters + */ + public Hashtable readStatistics(){ + Hashtable hash=new Hashtable(); + synchronized(statlock){ + hash.put("stat_table_add",stat_add); + hash.put("stat_table_update",stat_update); + hash.put("stat_table_delete",stat_delete); + hash.put("stat_table_add_size",stat_add_size); + hash.put("stat_table_update_size",stat_update_size); + hash.put("stat_table_read_size",stat_read_size); + hash.put("stat_table_read",stat_read); + hash.put("stat_table_cache_hit",stat_cache_hit); + hash.put("stat_table_cache_miss",stat_cache_miss); + hash.put("stat_table_cache_drop",stat_cache_drop); + stat_add=0; + stat_update=0; + stat_delete=0; + stat_add_size=0; + stat_update_size=0; + stat_read_size=0; + stat_read=0; + stat_cache_hit=0; + stat_cache_miss=0; + stat_cache_drop=0; + Hashtable ihash=index.readStatistics(); + hash.putAll(ihash); + } + return hash; + } + + /** + * Create a new table object with the default flat index model + */ + public DualFileTable(String title,String location) throws IOException{ + this.title=title; + this.location=location; + if(!this.location.endsWith(File.separator))this.location+=File.separator; + index=new FlatIndex(getFileName(INDEX)); + indexcachefirst=null; + indexcachelast=null; + indexcacheusage=0; + indexcache=new Hashtable(); + } + + /** + * Create a new table object with a specific index model + */ + public DualFileTable(String title,String location, int indextype) throws IOException{ + this.title=title; + this.location=location; + if(!this.location.endsWith(File.separator))this.location+=File.separator; + switch(indextype){ + case PAGED : index=new PagedIndex(getFileName(INDEX)); + break; + case FLAT : index=new FlatIndex(getFileName(INDEX)); + break; + case MEMORY : index=new MemoryIndex(getFileName(INDEX)); + break; + } + indexcachefirst=null; + indexcachelast=null; + indexcacheusage=0; + indexcache=new Hashtable(); + } + + /** + * Set the maximal allowable size of the index cache. + */ + public void setIndexCacheSize(int newsize){ + INDEXCACHESIZE=newsize; + } + + /** + * Close all open file streams + */ + public void close(){ + try{ + if(fileastream!=null)fileastream.close(); + if(filebstream!=null)filebstream.close(); + if(filearandom!=null)filearandom.close(); + if(filebrandom!=null)filebrandom.close(); + index.close(); + }catch(Exception e){} + } + + /** + * Returns the name of this table + */ + public String getTitle(){ + return title; + } + + /** + * Returns the location of this tables datafiles + */ + public String getLocation(){ + return location; + } + + protected String getFileName(int type){ + switch(type){ + case FILEB : return location+title+".a"; + case FILEA : return location+title+".b"; + case INDEX : return location+title+".index"; + } + return null; + } + + /** + * Delete the files created by this table object. + * Be aware that this will delete any data stored in this table! + */ + public void deleteFiles(){ + try{ + File ftest=new File(getFileName(FILEA)); + ftest.delete(); + }catch(Exception e){} + try{ + File ftest=new File(getFileName(FILEB)); + ftest.delete(); + }catch(Exception e){} + try{ + File ftest=new File(getFileName(INDEX)); + ftest.delete(); + }catch(Exception e){} + } + + private synchronized void openFile(int type) throws IOException{ + switch(type){ + case FILEA : if(fileastream==null){ + fileastream=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(getFileName(FILEA),true))); + File ftest=new File(getFileName(FILEA)); + fileaposition=ftest.length(); + } + break; + case FILEB : if(filebstream==null){ + filebstream=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(getFileName(FILEB),true))); + File ftest=new File(getFileName(FILEB)); + filebposition=ftest.length(); + } + break; + } + } + + /** + * Adds a row of data to this table. + */ + public void addRow(Row row) throws IOException{ + // Distribute new rows between the two datafiles by using the rowswitch, but don't spend time synchronizing... this does not need to be acurate! + if(rowswitch){ + addRowA(row); + }else{ + addRowB(row); + } + rowswitch=!rowswitch; + } + + private void addCacheEntry(TableIndexEntry entry){ + synchronized(indexcache){ + if(indexcacheusage>INDEXCACHESIZE){ + // remove first entry + TableIndexNode node=indexcachefirst; + indexcache.remove(node.getData().getId()); + indexcacheusage--; + synchronized(statlock){ + stat_cache_drop++; + } + indexcachefirst=node.getNext(); + if(indexcachefirst==null){ + indexcachelast=null; + }else{ + indexcachefirst.setPrevious(null); + } + } + TableIndexNode node=new TableIndexNode(indexcachelast,entry); + if(indexcachelast!=null){ + indexcachelast.setNext(node); + } + if(indexcachefirst==null){ + indexcachefirst=node; + } + indexcachelast=node; + indexcache.put(entry.getId(),node); + indexcacheusage++; + } + } + + private void addRowA(Row row) throws IOException{ + synchronized(filealock){ + openFile(FILEA); + int pre=fileastream.size(); + row.writeToStream(fileastream); + int post=fileastream.size(); + fileastream.flush(); + synchronized(statlock){ + stat_add++; + stat_add_size+=row.getSize(); + } + index.addEntry(row.getId(),row.getSize(),FILEA,fileaposition); + if(INDEXCACHESIZE>0){ + TableIndexEntry entry=new TableIndexEntry(row.getId(),row.getSize(),FILEA,fileaposition); + addCacheEntry(entry); + } + fileaposition+=Row.calcSize(pre,post); + } + } + private void addRowB(Row row) throws IOException{ + synchronized(fileblock){ + openFile(FILEB); + int pre=filebstream.size(); + row.writeToStream(filebstream); + int post=filebstream.size(); + filebstream.flush(); + synchronized(statlock){ + stat_add++; + stat_add_size+=row.getSize(); + } + index.addEntry(row.getId(),row.getSize(),FILEB,filebposition); + if(INDEXCACHESIZE>0){ + TableIndexEntry entry=new TableIndexEntry(row.getId(),row.getSize(),FILEB,filebposition); + addCacheEntry(entry); + } + filebposition+=Row.calcSize(pre,post); + } + } + + + private void updateCacheEntry(TableIndexEntry entry){ + synchronized(indexcache){ + if(indexcache.containsKey(entry.getId())){ + TableIndexNode node=indexcache.get(entry.getId()); + node.setData(entry); + if(node!=indexcachelast){ + if(node==indexcachefirst){ + indexcachefirst=node.getNext(); + } + node.remove(); + indexcachelast.setNext(node); + node.setPrevious(indexcachelast); + node.setNext(null); + indexcachelast=node; + } + }else{ + addCacheEntry(entry); + } + } + } + + private void removeCacheEntry(String id){ + synchronized(indexcache){ + if(indexcache.containsKey(id)){ + TableIndexNode node=indexcache.get(id); + indexcache.remove(id); + if(indexcacheusage==1){ + indexcachefirst=null; + indexcachelast=null; + indexcacheusage=0; + return; + } + if(node==indexcachefirst){ + indexcachefirst=node.getNext(); + indexcachefirst.setPrevious(null); + }else if(node==indexcachelast){ + indexcachelast=node.getPrevious(); + indexcachelast.setNext(null); + }else{ + node.remove(); + } + indexcacheusage--; + synchronized(statlock){ + stat_cache_drop++; + } + } + } + } + + private TableIndexEntry getCacheEntry(String id){ + synchronized(indexcache){ + if(indexcache.containsKey(id)){ + TableIndexNode node=indexcache.get(id); + if(node!=indexcachelast){ + if(node==indexcachefirst){ + indexcachefirst=node.getNext(); + } + node.remove(); + indexcachelast.setNext(node); + node.setPrevious(indexcachelast); + node.setNext(null); + indexcachelast=node; + } + synchronized(statlock){ + stat_cache_hit++; + } + return node.getData(); + } + } + synchronized(statlock){ + stat_cache_miss++; + } + return null; + } + + /** + * Adds a row to this table if it doesn't already exist, if it does it updates the row instead. + * This method is much slower than directly using add or update, so only use it if you don't know wether or not the row already exists. + */ + public void addOrUpdateRow(Row row) throws IOException{ + Row tmprow=getRow(row.getId()); + if(tmprow==null){ + addRow(row); + }else{ + updateRow(row); + } + } + + /** + * Updates a row stored in this table. + */ + public void updateRow(Row row) throws IOException{ + TableIndexEntry entry=null; + // Handle index entry caching + if(INDEXCACHESIZE>0){ + synchronized(indexcache){ + entry=getCacheEntry(row.getId()); + if(entry==null){ + entry=index.scanIndex(row.getId()); + addCacheEntry(entry); + } + } + }else{ + entry=index.scanIndex(row.getId()); + } + if(entry.getRowSize()>=row.getSize()){ + // Add to the existing location + switch(entry.getLocation()){ + case FILEA :synchronized(filealock){ + if(filearandom==null){ + filearandom=new RandomAccessFile(getFileName(FILEA),"rw"); + fca=filearandom.getChannel(); + } + filearandom.seek(entry.getPosition()); + row.writeToFile(filearandom); + + fca.force(false); + } + break; + case FILEB :synchronized(fileblock){ + if(filebrandom==null){ + filebrandom=new RandomAccessFile(getFileName(FILEB),"rw"); + fcb=filebrandom.getChannel(); + } + filebrandom.seek(entry.getPosition()); + row.writeToFile(filebrandom); + + fcb.force(false); + } + break; + } + }else{ + if(rowswitch){ + updateRowA(row); + }else{ + updateRowB(row); + } + rowswitch=!rowswitch; + } + synchronized(statlock){ + stat_update++; + stat_update_size+=row.getSize(); + } + } + + private void updateRowA(Row row) throws IOException{ + synchronized(filealock){ + openFile(FILEA); + int pre=fileastream.size(); + row.writeToStream(fileastream); + int post=fileastream.size(); + fileastream.flush(); + index.updateEntry(row.getId(),row.getSize(),FILEA,fileaposition); + + // Handle index entry caching + if(INDEXCACHESIZE>0){ + updateCacheEntry(new TableIndexEntry(row.getId(),row.getSize(),FILEA,fileaposition)); + } + fileaposition+=Row.calcSize(pre,post); + } + } + + private void updateRowB(Row row) throws IOException{ + synchronized(fileblock){ + openFile(FILEB); + int pre=filebstream.size(); + row.writeToStream(filebstream); + int post=filebstream.size(); + filebstream.flush(); + index.updateEntry(row.getId(),row.getSize(),FILEB,filebposition); + // Handle index entry caching + // Handle index entry caching + if(INDEXCACHESIZE>0){ + updateCacheEntry(new TableIndexEntry(row.getId(),row.getSize(),FILEB,filebposition)); + } + filebposition+=Row.calcSize(pre,post); + } + } + + /** + * Marks a row as deleted in the index. + * Be aware that the space consumed by the row is not actually reclaimed. + */ + public void deleteRow(Row row) throws IOException{ + // Handle index entry caching + if(INDEXCACHESIZE>0){ + removeCacheEntry(row.getId()); + } + index.updateEntry(row.getId(),row.getSize(),DELETE,0); + synchronized(statlock){ + stat_delete++; + } + } + + /** + * Returns a tuplestream containing the given list of rows + */ + public TupleStream getRows(List rows) throws IOException{ + return new IndexedTableReader(this,index.scanIndex(rows)); + } + + /** + * Returns a tuplestream containing the rows matching the given rowmatcher + */ + public TupleStream getRows(RowMatcher matcher) throws IOException{ + return new IndexedTableReader(this,index.scanIndex(),matcher); + } + + /** + * Returns a tuplestream containing those rows in the given list that matches the given RowMatcher + */ + public TupleStream getRows(List rows,RowMatcher matcher) throws IOException{ + return new IndexedTableReader(this,index.scanIndex(rows),matcher); + } + + /** + * Returns a tuplestream of all rows in this table. + */ + public TupleStream getRows() throws IOException{ + // return new TableReader(this); + return new IndexedTableReader(this,index.scanIndex()); + } + + /** + * Returns a single row stored in this table. + * If the row does not exist in the table, null will be returned. + */ + public Row getRow(String id) throws IOException{ + TableIndexEntry entry=null; + // Handle index entry caching + if(INDEXCACHESIZE>0){ + synchronized(indexcache){ + entry=getCacheEntry(id); + if(entry==null){ + entry=index.scanIndex(id); + if(entry!=null){ + addCacheEntry(entry); + } + } + } + }else{ + entry=index.scanIndex(id); + } + if(entry!=null){ + long dataoffset=0; + DataInputStream data=null; + if(entry.location==Table.FILEA){ + data=new DataInputStream(new BufferedInputStream(new FileInputStream(getFileName(Table.FILEA)))); + }else if(entry.location==Table.FILEB){ + data=new DataInputStream(new BufferedInputStream(new FileInputStream(getFileName(Table.FILEB)))); + } + if(data!=null){ + while(dataoffset!=entry.position){ + dataoffset+=data.skipBytes((int)(entry.position-dataoffset)); + } + Row row=Row.readFromStream(data); + data.close(); + synchronized(statlock){ + stat_read++; + stat_read_size+=row.getSize(); + } + return row; + } + + } + return null; + } + } \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/FlatIndex.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/FlatIndex.java new file mode 100644 index 00000000..d133616e --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/FlatIndex.java @@ -0,0 +1,167 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.core; + +import java.util.*; +import java.io.*; +import java.nio.channels.*; + +public class FlatIndex implements TableIndex{ + private DataOutputStream out=null; + private String filename; + + private long stat_read=0; + private long stat_write=0; + private long stat_scan=0; + + public FlatIndex(String filename) throws IOException{ + this.filename=filename; + File ftest=new File(filename); + if(!ftest.exists())ftest.createNewFile(); + } + + public Hashtable readStatistics(){ + Hashtable hash=new Hashtable(); + hash.put("stat_index_read",stat_read); + hash.put("stat_index_write",stat_write); + hash.put("stat_index_scan",stat_scan); + stat_read=0; + stat_write=0; + stat_scan=0; + return hash; + } + + public void close(){ + try{ + out.close(); + }catch(Exception e){} + } + + public List scanIndex() throws IOException{ + ArrayList lst=new ArrayList(); + DataInputStream data=new DataInputStream(new BufferedInputStream(new FileInputStream(filename))); + try{ + while(true){ + TableIndexEntry entry=TableIndexEntry.readData(data); + stat_read++; + if(entry!=null){ + if(entry.getLocation()!=Table.DELETE){ + lst.add(entry); + } + } + } + }catch(EOFException eofe){ + } + return lst; + } + + private long getOffset(String id) throws IOException{ + DataInputStream in=new DataInputStream(new BufferedInputStream(new FileInputStream(filename))); + long offset=TableIndexEntry.scanForOffset(id,in); + stat_scan++; + in.close(); + return offset; + } + + public synchronized void updateEntry(String id,int rowsize,int location,long position) throws IOException{ + if(out!=null){ + out.close(); + out=null; + } + long offset=getOffset(id); + RandomAccessFile data=new RandomAccessFile(filename,"rw"); + data.seek(offset); + TableIndexEntry entry=new TableIndexEntry(id,rowsize,location,position); + entry.writeData(data); + stat_write++; + FileChannel fc=data.getChannel(); + fc.force(false); + data.close(); + } + + public synchronized void addEntry(String id,int rowsize,int location,long position) throws IOException{ + if(out==null)out=new DataOutputStream(new FileOutputStream(filename,true)); + TableIndexEntry entry=new TableIndexEntry(id,rowsize,location,position); + entry.writeData(out); + stat_write++; + out.flush(); + } + + public TableIndexEntry scanIndex(String id) throws IOException{ + DataInputStream data=new DataInputStream(new BufferedInputStream(new FileInputStream(filename))); + while(true){ + try{ + TableIndexEntry entry=TableIndexEntry.lookForData(id,data); + stat_read++; + if(entry!=null){ + data.close(); + return entry; + } + }catch(EOFException eofe){ + data.close(); + return null; + } + } + } + + public List scanIndex(List rows) throws IOException{ + HashSetrowhash=new HashSet(); + for(int i=0;i entries=new Hashtable(); + DataInputStream data=new DataInputStream(new BufferedInputStream(new FileInputStream(filename))); + try{ + while(true){ + TableIndexEntry entry=TableIndexEntry.readData(data); + stat_read++; + if(entry!=null){ + if(rowhash.contains(entry.getId())){ + if(entry.getLocation()!=Table.DELETE){ + entries.put(entry.getId(),entry); + } + } + } + } + }catch(EOFException eofe){ + } + List result=new ArrayList(); + Iteratorit=rows.iterator(); + while(it.hasNext()){ + String id=it.next(); + if(entries.containsKey(id)){ + result.add(entries.get(id)); + } + } + return result; + } +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/HashedTable.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/HashedTable.java new file mode 100644 index 00000000..6316dffb --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/HashedTable.java @@ -0,0 +1,235 @@ + +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.core; + +import java.io.*; +import java.util.*; +import java.nio.channels.*; +import com.solidosystems.tuplesoup.filter.*; + +/** + * The table stores a group of rows. + * Every row must have a unique id within a table. + */ +public class HashedTable implements Table{ + private int TABLESETSIZE=16; + private List tableset; + private String title; + private String location; + + /** + * Create a new table object with the default flat index model + */ + public HashedTable(String title,String location) throws IOException{ + this.title=title; + this.location=location; + tableset=new ArrayList
(); + for(int i=0;i(); + for(int i=0;i readStatistics(){ + Hashtable results=new Hashtable(); + for(int i=0;i tmp=tableset.get(i).readStatistics(); + Set keys=tmp.keySet(); + Iterator it=keys.iterator(); + while(it.hasNext()){ + String key=it.next(); + long value=tmp.get(key); + if(results.containsKey(key)){ + results.put(key,results.get(key)+value); + }else{ + results.put(key,value); + } + } + } + return results; + } + + /** + * Returns the name of this table + */ + public String getTitle(){ + return title; + } + + /** + * Returns the location of this tables datafiles + */ + public String getLocation(){ + return location; + } + + /** + * Delete the files created by this table object. + * Be aware that this will delete any data stored in this table! + */ + public void deleteFiles(){ + for(int i=0;i rows) throws IOException{ + List> listset=new ArrayList>(); + for(int i=0;i()); + } + for(int i=0;i0){ + merge.addStream(tableset.get(i).getRows(listset.get(i))); + } + } + return merge; + } + + /** + * Returns a tuplestream containing the rows matching the given rowmatcher + */ + public TupleStream getRows(RowMatcher matcher) throws IOException{ + TupleStreamMerger merge=new TupleStreamMerger(); + for(int i=0;i rows,RowMatcher matcher) throws IOException{ + List> listset=new ArrayList>(); + for(int i=0;i()); + } + for(int i=0;i0){ + merge.addStream(tableset.get(i).getRows(listset.get(i),matcher)); + } + } + return merge; + } + + /** + * Marks a row as deleted in the index. + * Be aware that the space consumed by the row is not actually reclaimed. + */ + public void deleteRow(Row row) throws IOException{ + getTableForId(row.getId()).deleteRow(row); + } + + /** + * Adds a row of data to this table. + */ + public void addRow(Row row) throws IOException{ + getTableForId(row.getId()).addRow(row); + } + + /** + * Adds a row to this table if it doesn't already exist, if it does it updates the row instead. + * This method is much slower than directly using add or update, so only use it if you don't know wether or not the row already exists. + */ + public void addOrUpdateRow(Row row) throws IOException{ + getTableForId(row.getId()).addOrUpdateRow(row); + } + + /** + * Updates a row stored in this table. + */ + public void updateRow(Row row) throws IOException{ + getTableForId(row.getId()).updateRow(row); + } +} diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/IndexedTableReader.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/IndexedTableReader.java new file mode 100644 index 00000000..0684c3b8 --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/IndexedTableReader.java @@ -0,0 +1,261 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + + package com.solidosystems.tuplesoup.core; + + import com.solidosystems.tuplesoup.filter.*; + import java.io.*; + import java.util.*; + +public class IndexedTableReader extends TupleStream{ + private DataInputStream fileastream=null; + private DataInputStream filebstream=null; + private long fileaposition=0; + private long filebposition=0; + + private Listfileaentries; + private Listfilebentries; + + private Listentries; + + private Hashtablefileabuffer; + private Hashtablefilebbuffer; + + private Listrows; + private int rowpointer; + private Row next=null; + + private DualFileTable table; + + private RowMatcher matcher=null; + + public IndexedTableReader(DualFileTable table,Listentries) throws IOException{ + this.table=table; + this.rows=rows; + rowpointer=0; + + this.entries=entries; + fileaentries=new ArrayList(); + filebentries=new ArrayList(); + + Iterator it=entries.iterator(); + while(it.hasNext()){ + TableIndexEntry entry=it.next(); + // TODO: we really shouldn't get nulls here + if(entry!=null){ + if(entry.location==Table.FILEA){ + fileaentries.add(entry); + }else if(entry.location==Table.FILEB){ + filebentries.add(entry); + } + } + } + + Collections.sort(fileaentries); + Collections.sort(filebentries); + + fileabuffer=new Hashtable(); + filebbuffer=new Hashtable(); + + readNext(); + } + + + public IndexedTableReader(DualFileTable table,Listentries,RowMatcher matcher) throws IOException{ + this.table=table; + this.rows=rows; + rowpointer=0; + this.matcher=matcher; + + this.entries=entries; + fileaentries=new ArrayList(); + filebentries=new ArrayList(); + + Iterator it=entries.iterator(); + while(it.hasNext()){ + TableIndexEntry entry=it.next(); + // TODO: we really shouldn't get nulls here + if(entry!=null){ + if(entry.location==Table.FILEA){ + fileaentries.add(entry); + }else if(entry.location==Table.FILEB){ + filebentries.add(entry); + } + } + } + + Collections.sort(fileaentries); + Collections.sort(filebentries); + + fileabuffer=new Hashtable(); + filebbuffer=new Hashtable(); + + readNext(); + } + + private void readNextFromFileA(TableIndexEntry entry) throws IOException{ + if(fileabuffer.containsKey(entry.id)){ + next=fileabuffer.remove(entry.id); + return; + } + while(true){ + if(fileaentries.size()>0){ + TableIndexEntry nextfilea=fileaentries.remove(0); + if(fileastream==null){ + fileastream=new DataInputStream(new BufferedInputStream(new FileInputStream(table.getFileName(Table.FILEA)))); + fileaposition=0; + } + if(fileaposition>nextfilea.position){ + // We have already read this entry... skip it + // readNextFromFileA(entry); + // return; + }else{ + while(fileaposition!=nextfilea.position){ + fileaposition+=fileastream.skipBytes((int)(nextfilea.position-fileaposition)); + } + Row row=Row.readFromStream(fileastream); + synchronized(table.statlock){ + table.stat_read_size+=row.getSize(); + table.stat_read++; + } + fileaposition+=row.getSize(); + if(row.getId().equals(entry.id)){ + next=row; + return; + }else{ + fileabuffer.put(row.getId(),row); + // readNextFromFileA(entry); + } + } + }else{ + next=null; + return; + } + } + } + + private void readNextFromFileB(TableIndexEntry entry) throws IOException{ + if(filebbuffer.containsKey(entry.id)){ + next=filebbuffer.remove(entry.id); + return; + } + while(true){ + if(filebentries.size()>0){ + TableIndexEntry nextfileb=filebentries.remove(0); + if(filebstream==null){ + filebstream=new DataInputStream(new BufferedInputStream(new FileInputStream(table.getFileName(Table.FILEB)))); + filebposition=0; + } + if(filebposition>nextfileb.position){ + // We have already read this entry... skip it + // readNextFromFileB(entry); + // return; + }else{ + while(filebposition!=nextfileb.position){ + filebposition+=filebstream.skipBytes((int)(nextfileb.position-filebposition)); + } + Row row=Row.readFromStream(filebstream); + synchronized(table.statlock){ + table.stat_read_size+=row.getSize(); + table.stat_read++; + } + filebposition+=row.getSize(); + if(row.getId().equals(entry.id)){ + next=row; + return; + }else{ + filebbuffer.put(row.getId(),row); + // readNextFromFileB(entry); + } + } + }else{ + next=null; + return; + } + } + } + + private void readNext() throws IOException{ + if(entries.size()>rowpointer){ + TableIndexEntry entry=entries.get(rowpointer++); + if(entry!=null){ + switch(entry.location){ + case Table.FILEA : readNextFromFileA(entry); + // return; + break; + case Table.FILEB : readNextFromFileB(entry); + // return; + break; + } + if(next!=null){ + if(matcher!=null){ + if(!matcher.matches(next)){ + readNext(); + } + } + } + return; + }else{ + readNext(); + return; + } + } + try{ + if(fileastream!=null)fileastream.close(); + }catch(Exception e){} + try{ + if(filebstream!=null)filebstream.close(); + }catch(Exception e){} + next=null; + } + + public boolean hasNext(){ + if(next!=null)return true; + return false; + } + + public Row next(){ + try{ + if(next!=null){ + Row tmp=next; + readNext(); + return tmp; + } + }catch(Exception e){ + e.printStackTrace(); + } + return null; + } + + public void remove(){ + + } +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/MemoryIndex.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/MemoryIndex.java new file mode 100644 index 00000000..87f70162 --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/MemoryIndex.java @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.core; + +import java.util.*; +import java.io.*; + +public class MemoryIndex implements TableIndex{ + private DataOutputStream out=null; + private String filename; + private Hashtable cache; + + private long stat_write=0; + + public MemoryIndex(String filename) throws IOException{ + this.filename=filename; + File ftest=new File(filename); + if(!ftest.exists())ftest.createNewFile(); + cache=new Hashtable(); + DataInputStream in=new DataInputStream(new BufferedInputStream(new FileInputStream(filename))); + try{ + while(true){ + TableIndexEntry entry=TableIndexEntry.readData(in); + if(entry.getLocation()==Table.DELETE){ + cache.remove(entry.getId()); + }else{ + cache.put(entry.getId(),entry); + } + } + }catch(EOFException e){} + out=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(filename,true))); + } + + public Hashtable readStatistics(){ + Hashtable hash=new Hashtable(); + hash.put("stat_index_write",stat_write); + stat_write=0; + return hash; + } + + public void close(){ + try{ + out.close(); + }catch(Exception e){} + } + + public synchronized List scanIndex() throws IOException{ + ArrayList lst=new ArrayList(); + Iterator it=cache.values().iterator(); + while(it.hasNext()){ + TableIndexEntry entry=it.next(); + if(entry.getLocation()!=Table.DELETE)lst.add(entry); + } + return lst; + } + + public synchronized void updateEntry(String id,int rowsize,int location,long position) throws IOException{ + TableIndexEntry entry=new TableIndexEntry(id,rowsize,location,position); + entry.writeData(out); + out.flush(); + stat_write++; + cache.put(entry.getId(),entry); + } + + public synchronized void addEntry(String id,int rowsize,int location,long position) throws IOException{ + TableIndexEntry entry=new TableIndexEntry(id,rowsize,location,position); + entry.writeData(out); + out.flush(); + stat_write++; + cache.put(entry.getId(),entry); + } + + public synchronized TableIndexEntry scanIndex(String id) throws IOException{ + if(!cache.containsKey(id))return null; + return cache.get(id); + } + + public synchronized List scanIndex(List rows) throws IOException{ + List result=new ArrayList(); + for(int i=0;i0){ + for(int i=0;i readStatistics(){ + Hashtable hash=new Hashtable(); + hash.put("stat_index_read",stat_read); + hash.put("stat_index_write",stat_write); + hash.put("stat_index_create_page",stat_create_page); + hash.put("stat_index_page_next",stat_page_next); + hash.put("stat_index_page_branch",stat_page_branch); + stat_read=0; + stat_write=0; + stat_create_page=0; + stat_page_next=0; + stat_page_branch=0; + return hash; + } + + private int rootHash(String id){ + return id.hashCode() & (INITIALPAGEHASH-1); + } + + private synchronized TableIndexPage getFirstFreePage(String id) throws IOException{ + return root[rootHash(id)].getFirstFreePage(id,id.hashCode()); + } + + private synchronized long getOffset(String id) throws IOException{ + if(root==null)return -1; + return root[rootHash(id)].getOffset(id,id.hashCode()); + } + + public synchronized void updateEntry(String id,int rowsize,int location,long position) throws IOException{ + long offset=getOffset(id); + out.seek(offset); + TableIndexEntry entry=new TableIndexEntry(id,rowsize,location,position); + entry.updateData(out); + stat_write++; + } + public synchronized void addEntry(String id,int rowsize,int location,long position) throws IOException{ + TableIndexPage page=getFirstFreePage(id); + page.addEntry(id,rowsize,location,position); + stat_write++; + } + public synchronized TableIndexEntry scanIndex(String id) throws IOException{ + if(root==null)return null; + return root[rootHash(id)].scanIndex(id,id.hashCode()); + } + public synchronized List scanIndex(List rows) throws IOException{ + List lst=new ArrayList(); + for(int i=0;i scanIndex() throws IOException{ + ArrayList lst=new ArrayList(); + for(int i=0;i values; + + /** + * Creates a new empty row with the given row id. + */ + public Row(String id){ + this.id=id; + size=-1; + values=new Hashtable(); + } + + /** + * Returns the number of keys in this row. + */ + public int getKeyCount(){ + return values.size(); + } + + public Set keySet(){ + return values.keySet(); + } + + /** + * Returns the actual size in bytes this row will take when written to a stream. + */ + public int getSize(){ + if(size==-1)recalcSize(); + return size; + } + + /** + * Returns a hashcode for this row. This hashcode will be based purely on the id of the row. + */ + public int hashCode(){ + return id.hashCode(); + } + + public boolean equals(Object obj){ + try{ + Row r=(Row)obj; + return r.id.equals(id); + }catch(Exception e){} + return false; + } + + /** + * Returns the id of this row. + */ + public String getId(){ + return id; + } + + /** + * Stores the given value for the given key. + */ + public void put(String key,Value value){ + size=-1; + values.put(key,value); + } + + /** + * Stores the given string wrapped in a value object for the given key. + */ + public void put(String key,String value){ + size=-1; + values.put(key,new Value(value)); + } + + /** + * Stores the given int wrapped in a value object for the given key. + */ + public void put(String key,int value){ + size=-1; + values.put(key,new Value(value)); + } + + /** + * Stores the given long wrapped in a value object for the given key. + */ + public void put(String key,long value){ + size=-1; + values.put(key,new Value(value)); + } + + /** + * Stores the given float wrapped in a value object for the given key. + */ + public void put(String key,float value){ + size=-1; + values.put(key,new Value(value)); + } + + /** + * Stores the given double wrapped in a value object for the given key. + */ + public void put(String key,double value){ + size=-1; + values.put(key,new Value(value)); + } + + /** + * Stores the given boolean wrapped in a value object for the given key. + */ + public void put(String key,boolean value){ + size=-1; + values.put(key,new Value(value)); + } + + /** + * Stores the given Date wrapped in a value object for the given key. + */ + public void put(String key,Date value){ + size=-1; + values.put(key,new Value(value)); + } + + /** + * Returns the value stored for the current key, or a null value (not null) if the key does not exist. + */ + public Value get(String key){ + if(!values.containsKey(key))return new Value(); + return values.get(key); + } + + /** + * Returns a string representation of the value stored for the current key. + * If the key does not exist, an empty string will be returned. + * See the documentation for Value to learn how the string value is generated. + */ + public String getString(String key){ + if(!values.containsKey(key))return ""; + return values.get(key).getString(); + } + + /** + * Returns an int representation of the value stored for the current key. + * If the key does not exist, 0 will be returned. + * See the documentation for Value to learn how the string value is generated. + */ + public int getInt(String key){ + if(!values.containsKey(key))return 0; + return values.get(key).getInt(); + } + + /** + * Returns a long representation of the value stored for the current key. + * If the key does not exist, 0 will be returned. + * See the documentation for Value to learn how the string value is generated. + */ + public long getLong(String key){ + if(!values.containsKey(key))return 0; + return values.get(key).getLong(); + } + + /** + * Returns a float representation of the value stored for the current key. + * If the key does not exist, 0 will be returned. + * See the documentation for Value to learn how the string value is generated. + */ + public float getFloat(String key){ + if(!values.containsKey(key))return 0f; + return values.get(key).getFloat(); + } + + /** + * Returns a double representation of the value stored for the current key. + * If the key does not exist, 0 will be returned. + * See the documentation for Value to learn how the string value is generated. + */ + public double getDouble(String key){ + if(!values.containsKey(key))return 0d; + return values.get(key).getDouble(); + } + + /** + * Returns a boolean representation of the value stored for the current key. + * If the key does not exist, false will be returned. + * See the documentation for Value to learn how the string value is generated. + */ + public boolean getBoolean(String key){ + if(!values.containsKey(key))return false; + return values.get(key).getBoolean(); + } + + /** + * Returns a Date representation of the value stored for the current key. + * If the key does not exist, the date initialized with 0 will be returned. + * See the documentation for Value to learn how the string value is generated. + */ + public Date getTimestamp(String key){ + if(!values.containsKey(key))return new Date(0); + return values.get(key).getTimestamp(); + } + + /** + * Utility function to calculate the distance between ints, allowing for a single wraparound. + */ + protected static int calcSize(int pre,int post){ + if(post>pre)return post-pre; + return (Integer.MAX_VALUE-pre)+post; + } + + /** + * Recalculate the size of the row. Be aware that this method will actually write the full row to a buffer to calculate the size. + * Its a slow and memory consuming method to call! + */ + private void recalcSize(){ + try{ + ByteArrayOutputStream bout=new ByteArrayOutputStream(); + DataOutputStream dout=new DataOutputStream(bout); + writeToStream(dout); + size=bout.size(); + dout.close(); + bout.close(); + }catch(Exception e){} + } + + /** + * Writes the contents of this row to the given RandomAccessFile + */ + public void writeToFile(RandomAccessFile out) throws IOException{ + long pre=out.getFilePointer(); + + out.writeUTF(id); + + Set keys=values.keySet(); + out.writeInt(keys.size()); + Iterator it=keys.iterator(); + while(it.hasNext()){ + String key=it.next(); + Value value=values.get(key); + out.writeUTF(key); + value.writeToFile(out); + } + long post=out.getFilePointer(); + int size=(int)(post-pre); + this.size=size+4; + out.writeInt(this.size); + } + + /** + * Writes the contents of this row to the given DataOutputStream. + */ + public void writeToStream(DataOutputStream out) throws IOException{ + int pre=out.size(); + out.writeUTF(id); + Set keys=values.keySet(); + out.writeInt(keys.size()); + Iterator it=keys.iterator(); + while(it.hasNext()){ + String key=it.next(); + Value value=values.get(key); + out.writeUTF(key); + value.writeToStream(out); + } + int post=out.size(); + int size=calcSize(pre,post); + this.size=size+4; + out.writeInt(this.size); + } + + /** + * Reads a full row from the given DataInputStream and returns it. + */ + public static Row readFromStream(DataInputStream in) throws IOException{ + String id=in.readUTF(); + Row row=new Row(id); + int size=in.readInt(); + for(int i=0;i{"name":string:"Kasper J. Jeppesen","age":int:31} + * + * @return a string representation of this row + */ + public String toString(){ + StringBuffer buf=new StringBuffer(); + buf.append("("+id+")=>{"); + Iterator it=values.keySet().iterator(); + boolean first=true; + while(it.hasNext()){ + if(!first){ + buf.append(","); + }else{ + first=false; + } + String key=it.next(); + buf.append("\""); + buf.append(key); + buf.append("\":"); + Value value=values.get(key); + buf.append(value.getTypeName()); + buf.append(":"); + if(value.getType()==Value.STRING){ + buf.append("\""); + // TODO: This string should be escaped properly + buf.append(value.getString()); + buf.append("\""); + }else{ + buf.append(value.getString()); + } + } + buf.append("}"); + return buf.toString(); + } + + /** + * Shorthand for calling toBasicXMLString("") + */ + public String toBasicXMLString(){ + return toBasicXMLString(""); + } + + /** + * Creates an indentation of the given size and calls toBasicXMLString(String) with the indentation string as parameter. + */ + public String toBasicXMLString(int indentation){ + StringBuffer buf=new StringBuffer(); + for(int i=0;i\n"); + Iterator it=values.keySet().iterator(); + while(it.hasNext()){ + String key=it.next(); + Value value=values.get(key); + buf.append(indentation); + buf.append(" "); + buf.append(value.toBasicXMLString(key)); + buf.append("\n"); + } + buf.append(indentation); + buf.append("\n"); + return buf.toString(); + } + } \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/RowMatcher.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/RowMatcher.java new file mode 100644 index 00000000..1debd7ba --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/RowMatcher.java @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + + package com.solidosystems.tuplesoup.core; + + import java.io.*; + import java.util.*; + +public class RowMatcher{ + public final static int LESSTHAN=0; + public final static int EQUALS=1; + public final static int GREATERTHAN=2; + public final static int STARTSWITH=3; + public final static int ENDSWITH=4; + public final static int CONTAINS=5; + public final static int ISNULL=6; + + public final static int NOT=7; + public final static int OR=8; + public final static int AND=9; + public final static int XOR=10; + + private String key=null; + private Value value=null; + private int type=-1; + + private RowMatcher match1=null; + private RowMatcher match2=null; + + public RowMatcher(String key,int type,Value value){ + this.key=key; + this.type=type; + this.value=value; + } + + public RowMatcher(String key,int type){ + this.key=key; + this.type=type; + } + + public RowMatcher(RowMatcher match1,int type,RowMatcher match2){ + this.match1=match1; + this.type=type; + this.match2=match2; + } + + public RowMatcher(int type,RowMatcher match1){ + this.match1=match1; + this.type=type; + } + + /** + * This method needs to be seriously optimized... especially the XOR method + */ + public boolean matches(Row row){ + if(value!=null){ + Value compare=row.get(key); + switch(type){ + case LESSTHAN : return compare.lessThan(value); + case EQUALS : return compare.equals(value); + case GREATERTHAN: return compare.greaterThan(value); + case STARTSWITH : return compare.startsWith(value); + case ENDSWITH : return compare.endsWith(value); + case CONTAINS : return compare.contains(value); + } + }else if(type==ISNULL){ + Value compare=row.get(key); + return compare.isNull(); + }else if((type==AND)||(type==OR)||(type==XOR)){ + switch(type){ + case AND : return match1.matches(row)&&match2.matches(row); + case OR : return match1.matches(row)||match2.matches(row); + case XOR : return (match1.matches(row)||match2.matches(row))&&(!(match1.matches(row)&&match2.matches(row))); + } + }else if(type==NOT){ + return !match1.matches(row); + } + return false; + } +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/Table.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/Table.java new file mode 100644 index 00000000..5ff49fae --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/Table.java @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.core; + +import java.io.*; +import java.util.*; +import java.nio.channels.*; +import com.solidosystems.tuplesoup.filter.*; + +/** + * The table stores a group of rows. + * Every row must have a unique id within a table. + */ +public interface Table{ + // Index type constants + public static final int MEMORY=0; + public static final int FLAT=1; + public static final int PAGED=2; + + // Row location constants + public static final int FILEA=0; + public static final int FILEB=1; + public static final int DELETE=2; + public static final int INDEX=3; + + /** + * Return the current values of the statistic counters and reset them. + * The current counters are: + *
    + *
  • stat_table_add + *
  • stat_table_update + *
  • stat_table_delete + *
  • stat_table_add_size + *
  • stat_table_update_size + *
  • stat_table_read_size + *
  • stat_table_read + *
  • stat_table_cache_hit + *
  • stat_table_cache_miss + *
  • stat_table_cache_drop + *
+ * Furthermore, the index will be asked to deliver separate index specific counters + */ + public Hashtable readStatistics(); + + /** + * Set the maximal allowable size of the index cache. + */ + public void setIndexCacheSize(int newsize); + + /** + * Close all open file streams + */ + public void close(); + + /** + * Returns the name of this table + */ + public String getTitle(); + + /** + * Returns the location of this tables datafiles + */ + public String getLocation(); + + /** + * Delete the files created by this table object. + * Be aware that this will delete any data stored in this table! + */ + public void deleteFiles(); + + /** + * Adds a row of data to this table. + */ + public void addRow(Row row) throws IOException; + + /** + * Adds a row to this table if it doesn't already exist, if it does it updates the row instead. + * This method is much slower than directly using add or update, so only use it if you don't know wether or not the row already exists. + */ + public void addOrUpdateRow(Row row) throws IOException; + + /** + * Updates a row stored in this table. + */ + public void updateRow(Row row) throws IOException; + + /** + * Marks a row as deleted in the index. + * Be aware that the space consumed by the row is not actually reclaimed. + */ + public void deleteRow(Row row) throws IOException; + + /** + * Returns a tuplestream containing the given list of rows + */ + public TupleStream getRows(List rows) throws IOException; + + /** + * Returns a tuplestream containing the rows matching the given rowmatcher + */ + public TupleStream getRows(RowMatcher matcher) throws IOException; + + /** + * Returns a tuplestream containing those rows in the given list that matches the given RowMatcher + */ + public TupleStream getRows(List rows,RowMatcher matcher) throws IOException; + + /** + * Returns a tuplestream of all rows in this table. + */ + public TupleStream getRows() throws IOException; + + /** + * Returns a single row stored in this table. + * If the row does not exist in the table, null will be returned. + */ + public Row getRow(String id) throws IOException; + } \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TableIndex.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TableIndex.java new file mode 100644 index 00000000..ba8b76ff --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TableIndex.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.core; + +import java.util.*; +import java.io.*; + +public interface TableIndex{ + public Hashtable readStatistics(); + public void updateEntry(String id,int rowsize,int location,long position) throws IOException; + public void addEntry(String id,int rowsize,int location,long position) throws IOException; + public TableIndexEntry scanIndex(String id) throws IOException; + public List scanIndex(List rows) throws IOException; + public List scanIndex() throws IOException; + public void close(); +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TableIndexEntry.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TableIndexEntry.java new file mode 100644 index 00000000..229d5f4d --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TableIndexEntry.java @@ -0,0 +1,235 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.core; + +import java.io.*; + +public class TableIndexEntry implements Comparable{ + public String id; + public int location; + public long position; + private int size; + private int rowsize; + + public TableIndexEntry(String id,int rowsize,int location,long position){ + this.id=id; + this.location=location; + this.position=position; + this.rowsize=rowsize; + size=-1; + } + public String getId(){ + return id; + } + public void setPosition(long position){ + this.position=position; + } + public long getPosition(){ + return position; + } + public void setLocation(int location){ + this.location=location; + } + public int getLocation(){ + return location; + } + + public int getRowSize(){ + return rowsize; + } + + public int compareTo(TableIndexEntry obj) throws ClassCastException{ + TableIndexEntry ent=(TableIndexEntry)obj; + if(position0)starthash=file.readInt(); + } + + public static TableIndexPage createNewPage(PagedIndex index,RandomAccessFile file,int size) throws IOException{ + long pre=file.length(); + file.setLength(file.length()+size+BASEOFFSET); + file.seek(pre); + file.writeInt(size); + file.writeLong(-1l); + file.writeLong(-1l); + file.writeInt(0); + file.writeInt(-1); + file.seek(pre); + index.stat_create_page++; + return new TableIndexPage(index,file); + } + + public void setFirst(){ + first=true; + } + + public long getLocation(){ + return location; + } + public long getEndLocation(){ + return location+size+BASEOFFSET; + } + + public String toString(){ + StringBuffer buf=new StringBuffer(); + buf.append("{\n"); + buf.append(" location "+location+"\n"); + buf.append(" size "+size+"\n"); + buf.append(" next "+next+"\n"); + buf.append(" lower "+lower+"\n"); + buf.append(" offset "+offset+"\n"); + buf.append(" starthash "+starthash+"\n"); + buf.append(" endhash "+endhash+"\n"); + buf.append("}\n"); + return buf.toString(); + } + + private void updateMeta() throws IOException{ + file.seek(location); + file.writeInt(size); + file.writeLong(next); + file.writeLong(lower); + file.writeInt(offset); + file.writeInt(endhash); + } + + public void addEntriesToList(List lst) throws IOException{ + if(lower>-1){ + if(lowerpage==null){ + file.seek(lower); + lowerpage=new TableIndexPage(index,file); + } + lowerpage.addEntriesToList(lst); + } + if(next>-1){ + if(nextpage==null){ + file.seek(next); + nextpage=new TableIndexPage(index,file); + } + nextpage.addEntriesToList(lst); + } + file.seek(location+BASEOFFSET); + long pre=file.getFilePointer(); + while(file.getFilePointer()endhash){ + if(next==-1)return null; + if(nextpage==null){ + file.seek(next); + nextpage=new TableIndexPage(index,file); + } + index.stat_page_next++; + return nextpage.scanIndex(id,hashcode); + } + file.seek(location+BASEOFFSET); + long pre=file.getFilePointer(); + while(file.getFilePointer()endhash){ + if(next==-1)return -1; + if(nextpage==null){ + file.seek(next); + nextpage=new TableIndexPage(index,file); + } + index.stat_page_next++; + return nextpage.getOffset(id,hashcode); + } + file.seek(location+BASEOFFSET); + long pre=file.getFilePointer(); + while(file.getFilePointer()id.length()*2+4+4+8+1+2)return this; + // Check next + if(next==-1){ + next=file.length(); + updateMeta(); + return createNewPage(index,file,PagedIndex.PAGESIZE); + } + if(nextpage==null){ + file.seek(next); + nextpage=new TableIndexPage(index,file); + } + index.stat_page_next++; + return nextpage.getFirstFreePage(id,hashcode); + } + + public void addEntry(String id,int rowsize,int location,long position) throws IOException{ + if(offset==0)starthash=id.hashCode(); + file.seek(this.location+BASEOFFSET+offset); + TableIndexEntry entry=new TableIndexEntry(id,rowsize,location,position); + entry.writeData(file); + offset+=entry.getSize(); + if(id.hashCode()>endhash)endhash=id.hashCode(); + updateMeta(); + } +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TupleStream.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TupleStream.java new file mode 100644 index 00000000..f6a7e81d --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TupleStream.java @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.core; + +import java.io.*; + +public abstract class TupleStream{ + public abstract boolean hasNext() throws IOException; + public abstract Row next() throws IOException; +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TupleStreamMerger.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TupleStreamMerger.java new file mode 100644 index 00000000..8d71ce4c --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/TupleStreamMerger.java @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.core; + +import java.io.*; +import java.util.*; + +public class TupleStreamMerger extends TupleStream{ + private List streams; + private TupleStream current=null; + private Row next=null; + + public TupleStreamMerger(){ + streams=new ArrayList(); + } + + public void addStream(TupleStream stream){ + streams.add(stream); + } + + public boolean hasNext() throws IOException{ + if(next!=null)return true; + if(current==null){ + if(streams.size()>0){ + current=streams.remove(0); + }else return false; + } + if(current.hasNext()){ + next=current.next(); + return true; + }else{ + current=null; + return hasNext(); + } + } + + public Row next() throws IOException{ + if(next==null)hasNext(); + Row tmp=next; + next=null; + return tmp; + } + + +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/Value.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/Value.java new file mode 100644 index 00000000..0da44524 --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/core/Value.java @@ -0,0 +1,639 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + + package com.solidosystems.tuplesoup.core; + + import java.util.*; + import java.io.*; + + /** + * The Value class holds a single data value. + * Current size estimate without string data: 8+4+4+8+8 = 32 bytes pr value in mem + */ + public class Value{ + public final static int NULL=0; + public final static int STRING=1; + public final static int INT=2; + public final static int LONG=3; + public final static int FLOAT=4; + public final static int DOUBLE=5; + public final static int BOOLEAN=6; + public final static int TIMESTAMP=7; + public final static int BINARY=8; + + private byte type=NULL; // The type of the value being held + private String str_value=null; + private long int_value=0; + private double float_value=0.0; + private byte[] binary=null; + + /** + * Returns the numerical type id for this value. + */ + public int getType(){ + return type; + } + + /** + * Returns the name this value's type. + */ + public String getTypeName(){ + switch(type){ + case STRING : return "string"; + case INT : return "int"; + case LONG : return "long"; + case FLOAT : return "float"; + case DOUBLE : return "double"; + case BOOLEAN : return "boolean"; + case TIMESTAMP : return "timestamp"; + case BINARY : return "binary"; + } + return "null"; + } + + /** + * An implementation of the hashCode method as defined in java.lang.Object + * + * @return a hash code value for this object + */ + public int hashCode(){ + int hash=0; + switch(type){ + case STRING : hash+=str_value.hashCode(); + case INT : hash+=(int)int_value; + case LONG : hash+=(int)int_value; + case FLOAT : hash+=(int)float_value; + case DOUBLE : hash+=(int)float_value; + case BOOLEAN : hash+=(int)int_value; + case TIMESTAMP : hash+=(int)int_value; + case BINARY : hash+=binary.hashCode(); + } + return hash; + } + + /** + * Returns true only if this Value has specifically been set to null. + * + * @return true if the data being held is null, false otherwise + */ + public boolean isNull(){ + return type==NULL; + } + + /** + * Returns -1, 0 or 1 if this value is smaller, equal or larger than the value given as a parameter. + */ + public int compareTo(Value value){ + if(type==STRING){ + return str_value.compareTo(value.getString()); + } + if(lessThan(value))return -1; + if(greaterThan(value))return 1; + return 0; + } + + /** + * Attempts to compare this Value to the value given as parameter and returns true if this value is less than the value given as a parameter. + * The types used for the comparison will always be based on the type of this Value based on the following rules. + *
    + *
  • If this Value is a numeric type, then the other Value will be asked to deliver the same numeric type for the comparison. + *
  • If this Value is a string, then both values will be asked to deliver a double value for the comparison. + *
  • If this Value is a timestamp, then both values will be asked to deliver a long value for the comparison. + *
  • If this Value is a boolean, false will be returned. + *
+ * + * @param value the value this value should be compared to + * @return true if this value is less than the value given as a parameter, false otherwise + */ + public boolean lessThan(Value value){ + switch(type){ + case STRING : return getDouble() + *
  • If this Value is a numeric type, then the other Value will be asked to deliver the same numeric type for the comparison. + *
  • If this Value is a string, then both values will be asked to deliver a double value for the comparison. + *
  • If this Value is a timestamp, then both values will be asked to deliver a long value for the comparison. + *
  • If this Value is a boolean, false will be returned. + * + * + * @param value the value this value should be compared to + * @return true if this value is greater than the value given as a parameter, false otherwise + */ + public boolean greaterThan(Value value){ + switch(type){ + case STRING : return getDouble()>value.getDouble(); + case INT : return getInt()>value.getInt(); + case LONG : return getLong()>value.getLong(); + case FLOAT : return getFloat()>value.getFloat(); + case DOUBLE : return getDouble()>value.getDouble(); + case TIMESTAMP : return getLong()>value.getLong(); + } + return false; + } + + /** + * Returns true if the string representation of this value starts with the string representation of the value given as parameter. + */ + public boolean startsWith(Value value){ + return getString().startsWith(value.getString()); + } + + /** + * Returns true if the string representation of this value ends with the string representation of the value given as parameter. + */ + public boolean endsWith(Value value){ + return getString().endsWith(value.getString()); + } + + /** + * Returns true if the string representation of this value contains the string representation of the value given as parameter. + */ + public boolean contains(Value value){ + return getString().indexOf(value.getString())>-1; + } + + /** + * Returns true if the contents of this value equals the contents of the value given as parameter. + */ + public boolean equals(Object obj){ + try{ + Value val=(Value)obj; + if(val.type==type){ + switch(type){ + case NULL : return true; + case STRING : return str_value.equals(val.str_value); + case INT : return int_value==val.int_value; + case LONG : return int_value==val.int_value; + case FLOAT : return float_value==val.float_value; + case DOUBLE : return float_value==val.float_value; + case BOOLEAN : return int_value==val.int_value; + case TIMESTAMP : return int_value==val.int_value; + case BINARY : if(binary.length==val.binary.length){ + for(int i=0;i"+str_value+""; + case INT : return ""+int_value+""; + case LONG : return ""+int_value+""; + case FLOAT : return ""+float_value+""; + case DOUBLE : return ""+float_value+""; + case BOOLEAN : if(int_value==1){ + return "TRUE"; + }else{ + return "FALSE"; + } + case TIMESTAMP : return ""+new Date(int_value).toString()+""; + case BINARY : return ""+getString()+""; + } + return ""; + } + + /** + * Returns this value as an xml tag. + * The following string is an example of the int value 1234 <value type="int">1234</value> + */ + public String toBasicXMLString(){ + switch(type){ + case STRING : return ""+str_value+""; + case INT : return ""+int_value+""; + case LONG : return ""+int_value+""; + case FLOAT : return ""+float_value+""; + case DOUBLE : return ""+float_value+""; + case BOOLEAN : if(int_value==1){ + return "TRUE"; + }else{ + return "FALSE"; + } + case TIMESTAMP : return ""+new Date(int_value).toString()+""; + case BINARY : return ""+getString()+""; + } + return ""; + } + + /** + * Returns a string representation of this value + */ + public String getString(){ + switch(type){ + case STRING : return str_value; + case INT : return ""+int_value; + case LONG : return ""+int_value; + case FLOAT : return ""+float_value; + case DOUBLE : return ""+float_value; + case BOOLEAN : if(int_value==1){ + return "TRUE"; + }else{ + return "FALSE"; + } + case TIMESTAMP : return new Date(int_value).toString(); + case BINARY : StringBuffer buf=new StringBuffer(); + for(int i=0;i lst){ + + } + public abstract boolean hasNext(); + public abstract Row next(); +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/JavaSort.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/JavaSort.java new file mode 100644 index 00000000..1dfb4a1f --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/JavaSort.java @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.filter; + +import com.solidosystems.tuplesoup.core.*; +import java.util.*; +import java.io.*; + +public class JavaSort extends Sort{ + private List sortlst; + private int offset; + private int datasize; + + public JavaSort(){ + } + public void initialize(String filename,TupleStream source,List lst) throws IOException{ + sortlst=new ArrayList(); + offset=0; + while(source.hasNext()){ + sortlst.add(source.next()); + } + Collections.sort(sortlst,new SortComparator(lst)); + datasize=sortlst.size(); + } + public boolean hasNext(){ + if(offset buffers) throws IOException{ + while(buffers.size()>2){ + RowBuffer tmp=new RowBuffer(filename+"."+(bufnum++)); + tmp.setCacheSize(allocBuffer()); + // Grab two and sort to buf + RowBuffer a=buffers.remove(0); + RowBuffer b=buffers.remove(0); + mergeSort(tmp,a,b); + a.close(); + freeBuffer(a); + b.close(); + freeBuffer(b); + buffers.add(tmp); + } + if(buffers.size()==1){ + result.close(); + result=buffers.get(0); + result.prepare(); + return; + } + if(buffers.size()==2){ + RowBuffer a=buffers.get(0); + RowBuffer b=buffers.get(1); + mergeSort(result,a,b); + a.close(); + freeBuffer(a); + b.close(); + freeBuffer(b); + result.prepare(); + return; + } + } + + private int allocBuffer(){ + if(BUFFERCACHE>=BUFFERLIMIT){ + BUFFERCACHE-=BUFFERLIMIT; + return BUFFERLIMIT; + } + int tmp=BUFFERCACHE; + BUFFERCACHE=0; + return tmp; + } + private void freeBuffer(RowBuffer buf){ + BUFFERCACHE+=buf.getCacheSize(); + } + + public void initialize(String filename,TupleStream source,List lst) throws IOException{ + this.filename=filename; + compare=new SortComparator(lst); + bufnum=0; + result=new RowBuffer(filename+".result"); + result.setCacheSize(BUFFERLIMIT); + List buffers=new ArrayList(); + int usage=0; + List sortlst=new ArrayList(); + while(source.hasNext()){ + Row row=source.next(); + if(usage+row.getSize()>MEMLIMIT){ + RowBuffer buf=new RowBuffer(filename+"."+(bufnum++)); + buf.setCacheSize(allocBuffer()); + Collections.sort(sortlst,new SortComparator(lst)); + for(int i=0;i(); + } + sortlst.add(row); + usage+=row.getSize(); + } + RowBuffer buf=new RowBuffer(filename+"."+(bufnum++)); + buf.setCacheSize(allocBuffer()); + Collections.sort(sortlst,new SortComparator(lst)); + for(int i=0;i buffers) throws IOException{ + while(buffers.size()>2){ + RowBuffer tmp=new RowBuffer(filename+"."+(bufnum++)); + tmp.setCacheSize(allocBuffer()); + // Grab two and sort to buf + RowBuffer a=buffers.remove(0); + RowBuffer b=buffers.remove(0); + mergeSort(tmp,a,b); + a.close(); + freeBuffer(a); + b.close(); + freeBuffer(b); + buffers.add(tmp); + } + if(buffers.size()==1){ + result.close(); + result=buffers.get(0); + result.prepare(); + return; + } + if(buffers.size()==2){ + RowBuffer a=buffers.get(0); + RowBuffer b=buffers.get(1); + mergeSort(result,a,b); + a.close(); + freeBuffer(a); + b.close(); + freeBuffer(b); + result.prepare(); + return; + } + } + + private int allocBuffer(){ + if(BUFFERCACHE>=BUFFERLIMIT){ + BUFFERCACHE-=BUFFERLIMIT; + return BUFFERLIMIT; + } + int tmp=BUFFERCACHE; + BUFFERCACHE=0; + return tmp; + } + private void freeBuffer(RowBuffer buf){ + BUFFERCACHE+=buf.getCacheSize(); + } + + public void initialize(String filename,TupleStream source,List lst) throws IOException{ + long prepart=System.currentTimeMillis(); + this.filename=filename; + compare=new SortComparator(lst); + bufnum=0; + result=new RowBuffer(filename+".result"); + result.setCacheSize(BUFFERLIMIT); + List buffers=new ArrayList(); + int usage=0; + + List prebuffers=new ArrayList(); + List prebufferends=new ArrayList(); + for(int i=0;i0){ + RowBuffer tmp=prebuffers.get(i); + tmp.addRow(rowa); + prebufferends.set(i,rowa); + rowa=null; + } + }else{ + prebufferends.add(rowa); + RowBuffer tmp=prebuffers.get(i); + tmp.addRow(rowa); + rowa=null; + } + } + if(rowa!=null){ + overflow.addRow(rowa); + over++; + } + } + for(int i=0;i sortlst=new ArrayList(); + while(source.hasNext()){ + Row row=source.next(); + if(usage+row.getSize()>MEMLIMIT){ + RowBuffer buf=new RowBuffer(filename+"."+(bufnum++)); + buf.setCacheSize(allocBuffer()); + Collections.sort(sortlst,new SortComparator(lst)); + for(int i=0;i(); + } + sortlst.add(row); + usage+=row.getSize(); + } + RowBuffer buf=new RowBuffer(filename+"."+(bufnum++)); + buf.setCacheSize(allocBuffer()); + Collections.sort(sortlst,new SortComparator(lst)); + for(int i=0;i lst){ + + } + public abstract boolean hasNext(); + public abstract Row next(); +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/RadixSort.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/RadixSort.java new file mode 100644 index 00000000..b64f2086 --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/RadixSort.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.filter; + +import com.solidosystems.tuplesoup.core.*; +import java.util.*; + +public abstract class RadixSort extends TupleStream{ + public RadixSort(){ + + } + public void initialize(TupleStream source,List lst){ + + } + public abstract boolean hasNext(); + public abstract Row next(); +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/RowBuffer.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/RowBuffer.java new file mode 100644 index 00000000..3635c2b6 --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/RowBuffer.java @@ -0,0 +1,132 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.filter; + +import java.util.*; +import java.io.*; +import com.solidosystems.tuplesoup.core.*; + +public class RowBuffer extends TupleStream{ + private int CACHESIZE=32768; + private int cacheusage=0; + + private int mempointer=0; + private boolean diskused=false; + + private List membuffer; + private String diskbuffer; + private DataOutputStream out; + private DataInputStream in; + + private Row next=null; + + public RowBuffer(String filename){ + membuffer=new ArrayList(); + diskbuffer=filename; + out=null; + in=null; + } + + public void setCacheSize(int size){ + CACHESIZE=size; + } + public int getCacheSize(){ + return CACHESIZE; + } + + public void addRow(Row row) throws IOException{ + if(cacheusage+row.getSize()<=CACHESIZE){ + membuffer.add(row); + cacheusage+=row.getSize(); + }else{ + cacheusage=CACHESIZE; + if(out==null)out=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(diskbuffer),2048)); + row.writeToStream(out); + diskused=true; + } + } + + public void prepare() throws IOException{ + if(out!=null){ + out.flush(); + out.close(); + } + mempointer=0; + if(diskused)in=new DataInputStream(new BufferedInputStream(new FileInputStream(diskbuffer),2048)); + readNext(); + } + + public void close(){ + try{ + File ftest=new File(diskbuffer); + if(ftest.exists()){ + if(out!=null)out.close(); + if(in!=null)in.close(); + ftest.delete(); + } + }catch(Exception e){ + + } + } + + private void readNext() throws IOException{ + if(mempointer lst=new ArrayList(); + lst.add(new SortRule(key,direction)); + initialize(filename,source,lst); + } + public void initialize(String filename,TupleStream source,String key,int direction,String key2,int direction2) throws IOException{ + List lst=new ArrayList(); + lst.add(new SortRule(key,direction)); + lst.add(new SortRule(key2,direction2)); + initialize(filename,source,lst); + } + public abstract void initialize(String filename,TupleStream source,List lst) throws IOException; + public abstract boolean hasNext() throws IOException; + public abstract Row next() throws IOException; +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/SortComparator.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/SortComparator.java new file mode 100644 index 00000000..33fe9093 --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/SortComparator.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.filter; + +import com.solidosystems.tuplesoup.core.*; +import java.util.*; + +public class SortComparator implements Comparator{ + private List rules; + + public SortComparator(List rules){ + this.rules=rules; + } + + private int compare(int rulenum,Row rowa,Row rowb){ + if(rules.size()<=rulenum)return 0; + SortRule rule=rules.get(rulenum); + Value a=rowa.get(rule.getKey()); + Value b=rowb.get(rule.getKey()); + int result=a.compareTo(b); + // TODO: add direction switcher here + if(result==0){ + rulenum++; + return compare(rulenum,rowa,rowb); + }else{ + if(rule.getDirection()==SortRule.DESC){ + if(result==-1){ + result=1; + }else if(result==1)result=-1; + } + return result; + } + } + + public int compare(Row rowa,Row rowb){ + return compare(0,rowa,rowb); + } +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/SortRule.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/SortRule.java new file mode 100644 index 00000000..206ae8d6 --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/filter/SortRule.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.filter; + +import com.solidosystems.tuplesoup.core.*; + +public class SortRule{ + public static final int ASC=0; + public static final int DESC=1; + + private String key; + private int direction; + + public SortRule(String key, int direction){ + this.key=key; + this.direction=direction; + } + + public int getDirection(){ + return direction; + } + + public String getKey(){ + return key; + } +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/BasicTest.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/BasicTest.java new file mode 100644 index 00000000..dabbf7b7 --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/BasicTest.java @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.test; + +import java.util.*; + +public class BasicTest{ + public Listerrors=new ArrayList(); + private int lastlength=0; + + public void err(String str){ + while(lastlength<40){ + System.out.print(" "); + lastlength++; + } + outbr(" ERR"); + outbr(" ! "+str); + errors.add(str); + } + + public void printErrorSummary(){ + outbr(""); + if(errors.size()==0){ + outbr("All tests passed!"); + }else if(errors.size()==1){ + outbr("1 test failed!"); + }else{ + outbr(errors.size()+" tests failed!"); + } + } + + public static void die(String reason){ + System.out.println("ERR"); + System.out.println(" ! "+reason); + System.exit(0); + } + + public void ok(){ + while(lastlength<40){ + System.out.print(" "); + lastlength++; + } + outbr(" OK"); + } + + public void outbr(String str){ + outbr(0,str); + } + + public void out(String str){ + out(0,str); + } + + public void outbr(int level, String str){ + switch(level){ + case 0:System.out.print(""); + break; + case 1:System.out.print(" + "); + break; + case 2:System.out.print(" * "); + break; + case 3:System.out.print(" - "); + break; + case 4:System.out.print(" + "); + break; + } + System.out.println(str); + } + + public void out(int level, String str){ + lastlength=0; + switch(level){ + case 0: System.out.print(""); + break; + case 1: System.out.print(" + "); + lastlength+=3; + break; + case 2: System.out.print(" * "); + lastlength+=5; + break; + case 3: System.out.print(" - "); + lastlength+=7; + break; + } + System.out.print(str); + lastlength+=str.length(); + } +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/ComparisonTest.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/ComparisonTest.java new file mode 100644 index 00000000..cef72e1e --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/ComparisonTest.java @@ -0,0 +1,339 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.test; + +import com.solidosystems.tuplesoup.core.*; +import com.solidosystems.tuplesoup.filter.*; + +import java.util.*; +import java.io.*; +import java.sql.*; + + +public class ComparisonTest{ + public int DATASET=50000; + public List>results; + public Listtestnames; + public Listidlist; + + + public String generateId(int i){ + return "user.number."+i+"@testdomain.lan"; + } + + public void testTupleSoup() throws Exception{ + System.out.println(" + Running TupleSoup test"); + Table tbl=new DualFileTable("CoreTestData","."); + tbl.deleteFiles(); + tbl=new DualFileTable("CoreTestData",".",Table.PAGED); + //tbl.setIndexCacheSize(DATASET/10); + tbl.setIndexCacheSize(50000); + long pre=System.currentTimeMillis(); + + for(int i=0;i lst=new ArrayList(); + lst.add(add); + lst.add(fetch); + lst.add(update); + lst.add(sort); + lst.add(sum); + results.add(lst); + } + + public ComparisonTest(){ + try{ + for(int n=1;n<=20;n++){ + DATASET=n*10000; + System.out.println("Running for "+DATASET); + idlist=new ArrayList(); + for(int i=0;i>(); + testnames=new ArrayList(); + // testGreedyTupleSoup(); + testTupleSoup(); + // testMySQL(); + // testPostgreSQL(); + } + // calcScores(); + }catch(Exception e){ + e.printStackTrace(); + } + } + + public void calcScores(){ + System.out.println("Compared results"); + } + + public static void main(String[] args){ + new ComparisonTest(); + } +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/CoreTest.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/CoreTest.java new file mode 100644 index 00000000..935a0ab6 --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/CoreTest.java @@ -0,0 +1,217 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + + package com.solidosystems.tuplesoup.test; + + import com.solidosystems.tuplesoup.core.*; + import com.solidosystems.tuplesoup.filter.*; + + import java.util.*; + + public class CoreTest{ + public static void main(String[] args){ + try{ + System.out.println("TupleSoup Core Data Test"); + System.out.println(" + Preparing data"); + Date dt=new Date(); + + Table tbl=new DualFileTable("CoreTestData","."); + tbl.deleteFiles(); + tbl=new DualFileTable("CoreTestData","."); + Row row1=new Row("1"); + row1.put("string","Hello World!"); + row1.put("int",42); + row1.put("long",314l); + row1.put("float",3.14f); + row1.put("double",3.1415d); + row1.put("timestamp",dt); + row1.put("boolean",true); + tbl.addRow(row1); + Row row2=new Row("2"); + row2.put("name","Kasper J"); + row2.put("int",43); + tbl.addRow(row2); + Row row3=new Row("3"); + row3.put("name","Kasper L"); + row3.put("int",44); + tbl.addRow(row3); + Row row4=new Row("4"); + row4.put("name","Christer"); + row4.put("int",45); + tbl.addRow(row4); + + System.out.print(" + Testing basic row storage ... "); + TupleStream it=tbl.getRows(); + int cnt=0; + while(it.hasNext()){ + it.next(); + cnt++; + } + if(cnt!=4)die("Wrong number of rows in table after adding 4 rows"); + Row tmp=tbl.getRow("1"); + if(tmp==null)die("Could not fetch the first row"); + if(!tmp.getString("string").equals("Hello World!"))die("String value incorrect after storage"); + if(tmp.getInt("int")!=42)die("Int value incorrect after storage"); + if(tmp.getLong("long")!=314l)die("Long value incorrect after storage"); + if(tmp.getFloat("float")!=3.14f)die("Float value incorrect after storage"); + if(tmp.getDouble("double")!=3.1415d)die("Double value incorrect after storage"); + if(!tmp.getTimestamp("timestamp").equals(dt))die("Timestamp value incorrect after storage"); + if(!tmp.getBoolean("boolean"))die("Boolean value incorrect after storage"); + System.out.println("OK"); + + System.out.print(" + Testing bulk fetch order ... "); + List lst=new ArrayList(); + lst.add("3"); + lst.add("1"); + lst.add("2"); + lst.add("4"); + lst.add("2"); + it=tbl.getRows(lst); + tmp=it.next(); + if(!tmp.getId().equals("3"))die("Elements returned in wrong order"); + tmp=it.next(); + if(!tmp.getId().equals("1"))die("Elements returned in wrong order"); + tmp=it.next(); + if(!tmp.getId().equals("2"))die("Elements returned in wrong order"); + tmp=it.next(); + if(!tmp.getId().equals("4"))die("Elements returned in wrong order"); + System.out.println("OK"); + + System.out.print(" + Testing RowMatcher ... "); + RowMatcher m=new RowMatcher("name",RowMatcher.STARTSWITH,new Value("Kasper")); + it=tbl.getRows(m); + cnt=0; + while(it.hasNext()){ + it.next(); + cnt++; + } + if(cnt!=2)die("String based RowMatcher failed using STARTSWITH"); + m=new RowMatcher("int",RowMatcher.GREATERTHAN,new Value(44)); + it=tbl.getRows(m); + tmp=it.next(); + if(!tmp.getId().equals("4"))die("Int based RowMatcher failed using GREATERTHAN"); + // TODO: Add full test of all types and comparison types in RowMatcher + System.out.println("OK"); + + System.out.print(" + Testing row updates and deletes ... "); + tbl.deleteRow(row2); + row4.put("int",8192); + tbl.updateRow(row4); + it=tbl.getRows(); + cnt=0; + while(it.hasNext()){ + it.next(); + cnt++; + } + if(cnt!=3)die("Wrong number of rows returned"); + tmp=tbl.getRow("4"); + if(tmp.getInt("int")!=8192)die("Wrong int value returned after update"); + + row1.put("longtext","Hello world again and again and again and again....."); + tbl.updateRow(row1); + tmp=tbl.getRow("1"); + if(!tmp.getString("longtext").equals("Hello world again and again and again and again....."))die("Wrong string value returned after update"); + + System.out.println("OK"); + + System.out.print(" + Testing close and reopen ... "); + tbl.close(); + tbl=new DualFileTable("CoreTestData","."); + it=tbl.getRows(); + cnt=0; + while(it.hasNext()){ + it.next(); + cnt++; + } + if(cnt!=3)die("Wrong number of rows returned"); + tmp=tbl.getRow("4"); + if(tmp.getInt("int")!=8192)die("Wrong int value returned after close"); + tmp=tbl.getRow("1"); + if(!tmp.getString("longtext").equals("Hello world again and again and again and again....."))die("Wrong string value returned after update"); + + System.out.println("OK"); + + System.out.print(" + Testing large data sets ... "); + tbl.deleteFiles(); + tbl=new DualFileTable("CoreTestData","."); + for(int i=0;i<50000;i++){ + tmp=new Row(i+"_"+Math.random()); + tmp.put("data1",Math.random()); + tmp.put("one",1); + tbl.addRow(tmp); + } + tbl.close(); + tbl=new DualFileTable("CoreTestData","."); + it=tbl.getRows(); + cnt=0; + while(it.hasNext()){ + it.next(); + cnt++; + } + if(cnt!=50000)die("Wrong number of rows returned"); + it=tbl.getRows(); + cnt=0; + while(it.hasNext()){ + tmp=it.next(); + cnt+=tmp.getInt("one"); + } + if(cnt!=50000)die("Wrong numeric data returned"); + + tmp=new Row("foo"); + tmp.put("bar","baz"); + tbl.addRow(tmp); + tbl.close(); + tbl=new DualFileTable("CoreTestData","."); + tmp=tbl.getRow("foo"); + if(!tmp.getString("bar").equals("baz"))die("Wrong string data returned"); + + it=tbl.getRows(); + cnt=0; + while(it.hasNext()){ + it.next(); + cnt++; + } + if(cnt!=50001)die("Wrong number of rows returned"); + System.out.println("OK"); + + System.exit(0); + tbl.close(); + tbl.deleteFiles(); + }catch(Exception e){ + e.printStackTrace(); + } + } + public static void die(String reason){ + System.out.println("ERR"); + System.out.println(" ! "+reason); + System.exit(0); + } + } \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/ParallelPerformanceTest.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/ParallelPerformanceTest.java new file mode 100644 index 00000000..8fb5a533 --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/ParallelPerformanceTest.java @@ -0,0 +1,166 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + + package com.solidosystems.tuplesoup.test; + + import com.solidosystems.tuplesoup.core.*; + import com.solidosystems.tuplesoup.filter.*; + + import java.util.*; + import java.io.*; + + +public class ParallelPerformanceTest extends BasicTest implements Runnable{ + + long writetime; + long readtime; + long randomtime; + + public ParallelPerformanceTest(){ + String path="/Volumes/My Book/test/"; + try{ + int records=50000; + for(int i=1;i<11;i++){ + outbr("Running Parallel DualFileTable Performance test"); + outbr(1,i+" x "+(records/i)+" Large records"); + + outbr(2,"Memory index"); + Table table=new DualFileTable("Performance-test",path,Table.MEMORY); + benchmark(table,i,(records/i)); + table.close(); + table.deleteFiles(); + + outbr(2,"Flat index"); + table=new DualFileTable("Performance-test",path,Table.FLAT); + benchmark(table,i,(records/i)); + table.close(); + table.deleteFiles(); + + outbr(2,"Paged index"); + table=new DualFileTable("Performance-test",path,Table.PAGED); + benchmark(table,i,(records/i)); + table.close(); + table.deleteFiles(); + + outbr("Running Parallel HashedTable Performance test"); + outbr(1,i+" x "+(records/i)+" Large records"); + + outbr(2,"Memory index"); + table=new HashedTable("Performance-test",path,Table.MEMORY); + benchmark(table,i,(records/i)); + table.close(); + table.deleteFiles(); + + outbr(2,"Flat index"); + table=new HashedTable("Performance-test",path,Table.FLAT); + benchmark(table,i,(records/i)); + table.close(); + table.deleteFiles(); + + outbr(2,"Paged index"); + table=new HashedTable("Performance-test",path,Table.PAGED); + benchmark(table,i,(records/i)); + table.close(); + table.deleteFiles(); + } + + + }catch(Exception e){ + e.printStackTrace(); + } + } + public static void main(String[] args){ + new ParallelPerformanceTest(); + } + + public void benchmark(Table table,int threadcount, int records) throws Exception{ + writetime=0; + readtime=0; + randomtime=0; + List lst=new ArrayList(); + for(int i=0;i hash){ + Set keys=hash.keySet(); + Iterator it=keys.iterator(); + while(it.hasNext()){ + String key=it.next(); + outbr(4,key+" "+hash.get(key)); + } + } +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/ParallelThread.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/ParallelThread.java new file mode 100644 index 00000000..2183470d --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/ParallelThread.java @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + + package com.solidosystems.tuplesoup.test; + + import com.solidosystems.tuplesoup.core.*; + import com.solidosystems.tuplesoup.filter.*; + + import java.util.*; + import java.io.*; + + +public class ParallelThread implements Runnable{ + String id; + int records; + ParallelPerformanceTest app; + Table table; + + public ParallelThread(ParallelPerformanceTest app,Table table,String id,int records){ + this.id=id; + this.records=records; + this.app=app; + this.table=table; + } + + public void run(){ + try{ + long time=app.benchmarkLargeWrite(table,records,id); + synchronized(app){ + app.writetime+=time; + } + time=app.benchmarkLargeRead(table,records,id); + synchronized(app){ + app.readtime+=time; + } + time=app.benchmarkLargeRandomRead(table,records,id); + synchronized(app){ + app.randomtime+=time; + } + }catch(Exception e){ + e.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/PerformanceTest.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/PerformanceTest.java new file mode 100644 index 00000000..e8640e62 --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/PerformanceTest.java @@ -0,0 +1,239 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + + package com.solidosystems.tuplesoup.test; + + import com.solidosystems.tuplesoup.core.*; + import com.solidosystems.tuplesoup.filter.*; + + import java.util.*; + import java.io.*; + + +public class PerformanceTest extends BasicTest{ + public PerformanceTest(){ + try{ + outbr("Running DualFileTable Performance test"); + outbr(1,"10000 small records"); + + outbr(2,"Memory index"); + Table table=new DualFileTable("Performance-test","./",Table.MEMORY); + benchmarkSmall(table,10000); + table.close(); + table.deleteFiles(); + + outbr(2,"Flat index"); + table=new DualFileTable("Performance-test","./",Table.FLAT); + benchmarkSmall(table,10000); + table.close(); + table.deleteFiles(); + + outbr(2,"Paged index"); + table=new DualFileTable("Performance-test","./",Table.PAGED); + benchmarkSmall(table,10000); + table.close(); + table.deleteFiles(); + + outbr(1,"20000 large records"); + + outbr(2,"Memory index"); + table=new DualFileTable("Performance-test","./",Table.MEMORY); + benchmarkLarge(table,20000); + table.close(); + table.deleteFiles(); + + outbr(2,"Flat index"); + table=new DualFileTable("Performance-test","./",Table.FLAT); + benchmarkLarge(table,20000); + table.close(); + table.deleteFiles(); + + outbr(2,"Paged index"); + table=new DualFileTable("Performance-test","./",Table.PAGED); + benchmarkLarge(table,20000); + table.close(); + table.deleteFiles(); + + outbr(1,"30000 large records"); + + outbr(2,"Memory index"); + table=new DualFileTable("Performance-test","./",Table.MEMORY); + benchmarkLarge(table,30000); + table.close(); + table.deleteFiles(); + + outbr(2,"Flat index"); + table=new DualFileTable("Performance-test","./",Table.FLAT); + benchmarkLarge(table,30000); + table.close(); + table.deleteFiles(); + + outbr(2,"Paged index"); + table=new DualFileTable("Performance-test","./",Table.PAGED); + benchmarkLarge(table,30000); + table.close(); + table.deleteFiles(); + + outbr("Running HashedTable Performance test"); + outbr(1,"10000 small records"); + + outbr(2,"Memory index"); + table=new HashedTable("Performance-test","./",Table.MEMORY); + benchmarkSmall(table,10000); + table.close(); + table.deleteFiles(); + + outbr(2,"Flat index"); + table=new HashedTable("Performance-test","./",Table.FLAT); + benchmarkSmall(table,10000); + table.close(); + table.deleteFiles(); + + outbr(2,"Paged index"); + table=new HashedTable("Performance-test","./",Table.PAGED); + benchmarkSmall(table,10000); + table.close(); + table.deleteFiles(); + + outbr(1,"20000 large records"); + + outbr(2,"Memory index"); + table=new HashedTable("Performance-test","./",Table.MEMORY); + benchmarkLarge(table,20000); + table.close(); + table.deleteFiles(); + + outbr(2,"Flat index"); + table=new HashedTable("Performance-test","./",Table.FLAT); + benchmarkLarge(table,20000); + table.close(); + table.deleteFiles(); + + outbr(2,"Paged index"); + table=new HashedTable("Performance-test","./",Table.PAGED); + benchmarkLarge(table,20000); + table.close(); + table.deleteFiles(); + + outbr(1,"30000 large records"); + + outbr(2,"Memory index"); + table=new HashedTable("Performance-test","./",Table.MEMORY); + benchmarkLarge(table,30000); + table.close(); + table.deleteFiles(); + + outbr(2,"Flat index"); + table=new HashedTable("Performance-test","./",Table.FLAT); + benchmarkLarge(table,30000); + table.close(); + table.deleteFiles(); + + outbr(2,"Paged index"); + table=new HashedTable("Performance-test","./",Table.PAGED); + benchmarkLarge(table,30000); + table.close(); + table.deleteFiles(); + + + }catch(Exception e){ + e.printStackTrace(); + } + } + public static void main(String[] args){ + new PerformanceTest(); + } + + public void benchmarkSmall(Table table,int records) throws IOException{ + long pre=System.currentTimeMillis(); + for(int i=0;i hash){ + Set keys=hash.keySet(); + Iterator it=keys.iterator(); + while(it.hasNext()){ + String key=it.next(); + outbr(4,key+" "+hash.get(key)); + } + } +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/RowTest.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/RowTest.java new file mode 100644 index 00000000..0616357e --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/RowTest.java @@ -0,0 +1,162 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.test; + +import com.solidosystems.tuplesoup.core.*; +import java.util.*; +import java.io.*; + +public class RowTest extends BasicTest{ + public RowTest(){ + + } + public void runTest(){ + outbr("Running core Row functionality test"); + outbr(1,"Constructor initializers"); + + out(2,"String"); + Row row=new Row("FooBarBaz"); + if(!row.getId().equals("FooBarBaz")){ + err("Id value not correct"); + }else if(row.getKeyCount()!=0){ + err("Key count not correct"); + }else ok(); + + outbr(1,"Setting and getting values"); + + out(2,"Setting values"); + row.put("key1",new Value(3.1415f)); + row.put("key2","FooBar"); + row.put("key3",1234); + row.put("key4",5123456789l); + row.put("key5",3.1415f); + row.put("key6",3.141592653689793284626433d); + row.put("key7",true); + row.put("key8",new java.util.Date(5)); + if(row.getKeyCount()!=8){ + err("Key count not correct"); + }else ok(); + + out(2,"Getting values"); + Value val1=new Value("FooBar"); + Value val2=new Value(1234); + Value val3=new Value(5123456789l); + Value val4=new Value(3.1415f); + Value val5=new Value(3.141592653689793284626433d); + Value val6=new Value(true); + Value val7=new Value(new java.util.Date(5)); + if(!row.get("key1").equals(val4)){ + err("Wrong Value value returned"); + }else if(!row.get("key2").equals(val1)){ + err("Wrong Value value returned"); + }else if(!row.get("key3").equals(val2)){ + err("Wrong Value value returned"); + }else if(!row.get("key4").equals(val3)){ + err("Wrong Value value returned"); + }else if(!row.get("key5").equals(val4)){ + err("Wrong Value value returned"); + }else if(!row.get("key6").equals(val5)){ + err("Wrong Value value returned"); + }else if(!row.get("key7").equals(val6)){ + err("Wrong Value value returned"); + }else if(row.getKeyCount()!=8){ + err("Wrong key count returned"); + }else if(row.getFloat("key1")!=3.1415f){ + err("Wrong value returned from getFloat"); + }else if(!row.getString("key2").equals("FooBar")){ + err("Wrong value returned from getString"); + }else if(row.getInt("key3")!=1234){ + err("Wrong value returned from getInt"); + }else if(row.getLong("key4")!=5123456789l){ + err("Wrong value returned from getLong"); + }else if(row.getFloat("key5")!=3.1415f){ + err("Wrong value returned from getFloat"); + }else if(row.getDouble("key6")!=3.141592653689793284626433d){ + err("Wrong value returned from getDouble"); + }else if(!row.getBoolean("key7")){ + err("Wrong value returned from getBoolean"); + }else if(row.getTimestamp("key8").getTime()!=5){ + err("Wrong value returned from getTimestamp"); + }else ok(); + + outbr(1,"Stream reading and writing"); + try{ + out(2,"Writing to stream"); + ByteArrayOutputStream bout=new ByteArrayOutputStream(); + DataOutputStream dout=new DataOutputStream(bout); + + row.writeToStream(dout); + row.put("key9","ExtraBonusValue"); + row.writeToStream(dout); + dout.flush(); + ok(); + + out(2,"Reading from stream"); + byte[] buf=bout.toByteArray(); + DataInputStream din=new DataInputStream(new ByteArrayInputStream(buf)); + row=Row.readFromStream(din); + if(row.getKeyCount()!=8){ + err("Wrong key count returned"); + }else if(row.getFloat("key1")!=3.1415f){ + err("Wrong value returned from getFloat"); + }else if(!row.getString("key2").equals("FooBar")){ + err("Wrong value returned from getString"); + }else if(row.getInt("key3")!=1234){ + err("Wrong value returned from getInt"); + }else if(row.getLong("key4")!=5123456789l){ + err("Wrong value returned from getLong"); + }else if(row.getFloat("key5")!=3.1415f){ + err("Wrong value returned from getFloat"); + }else if(row.getDouble("key6")!=3.141592653689793284626433d){ + err("Wrong value returned from getDouble"); + }else if(!row.getBoolean("key7")){ + err("Wrong value returned from getBoolean"); + }else if(row.getTimestamp("key8").getTime()!=5){ + err("Wrong value returned from getTimestamp"); + }else{ + row=Row.readFromStream(din); + if(!row.getString("key9").equals("ExtraBonusValue")){ + err("Wrong value returned on second row written"); + }else ok(); + } + + }catch(Exception e){ + err("Exception occured "+e); + } + + printErrorSummary(); + } + public static void main(String args[]){ + RowTest rowt=new RowTest(); + rowt.runTest(); + } +} \ No newline at end of file diff --git a/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/SortTest.java b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/SortTest.java new file mode 100644 index 00000000..28ccfa7d --- /dev/null +++ b/Robust/Transactions/origtuplesoup/tuplesoup/src/com/solidosystems/tuplesoup/test/SortTest.java @@ -0,0 +1,179 @@ +/* + * Copyright (c) 2007, Solido Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of Solido Systems nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package com.solidosystems.tuplesoup.test; + +import com.solidosystems.tuplesoup.core.*; +import com.solidosystems.tuplesoup.filter.*; +import java.util.*; +import java.io.*; + +public class SortTest{ + public static void main(String[] args){ + String[] first_names={"Adolf","Anders","Bo","Christer","Daniel","Erik","Frederik","Georg","Hans","Hans-Christian","Ingolf","Jens","Kasper","Lars","Mads","Niels","Ole","Per","Rasmus","Søren","Tue","Ulrik"}; + String[] last_names={"Jeppesen","Andersen","Hansen","Nielsen","Langer","Sørensen","Shore","Crane","Saustrup"}; + String[] domains={"email.lan","mymail.lan","lukewarmmail.lan","lessthanfree.lan","devnull.lan"}; + try{ + System.out.println("TupleSoup Performance Test"); + System.out.println(" + Simple user data"); + Table tbl=new DualFileTable("CoreTestData","."); + tbl.deleteFiles(); + tbl=new DualFileTable("CoreTestData",".",Table.PAGED); + tbl.setIndexCacheSize(10000); + int rows=100000; + System.out.print(" - Adding "+rows+" tuples in random order ... "); + long pre=System.currentTimeMillis(); + long size=0; + Listflst=new ArrayList(); + for(int i=0;i