diff --git a/source/dbtest.java b/source/dbtest.java index a42221048..b87ccb594 100644 --- a/source/dbtest.java +++ b/source/dbtest.java @@ -13,6 +13,7 @@ import java.util.Iterator; import de.anomic.kelondro.kelondroBase64Order; import de.anomic.kelondro.kelondroIndex; +import de.anomic.kelondro.kelondroSplittedTree; import de.anomic.kelondro.kelondroTree; import de.anomic.ymage.ymageChart; import de.anomic.ymage.ymagePNGEncoderAWT; @@ -153,8 +154,8 @@ public class dbtest { String dbe = args[0]; // the database engine String command = args[1]; // test command String tablename = args[2]; // name of test-table - long startup = System.currentTimeMillis(); + try { kelondroIndex table = null; // create a memory profiler @@ -162,7 +163,7 @@ public class dbtest { profiler.start(); // create the database access - if (dbe.equals("kelondro")) { + if (dbe.equals("kelondroold")) { File tablefile = new File(tablename + ".kelondro.db"); if (tablefile.exists()) { table = new kelondroTree(tablefile, buffer); @@ -171,6 +172,14 @@ public class dbtest { } } + if (dbe.equals("kelondro")) { + File tablepath = new File(tablename).getParentFile(); + table = kelondroSplittedTree.open(tablepath, tablename, kelondroBase64Order.enhancedCoder, + buffer, + 8, + new int[]{keylength, valuelength, valuelength}, 1, 80, + true); + } if (dbe.equals("mysql")) { table = new dbTable("mysql"); } @@ -371,6 +380,16 @@ final class dbTable implements kelondroIndex { // Objects are of type byte[][] return null; } + + public int columns() { + // TODO Auto-generated method stub + return 0; + } + + public int columnSize(int column) { + // TODO Auto-generated method stub + return 0; + } } diff --git a/source/de/anomic/kelondro/kelondroBase64Order.java b/source/de/anomic/kelondro/kelondroBase64Order.java index 16a7fac4d..c586ceb58 100644 --- a/source/de/anomic/kelondro/kelondroBase64Order.java +++ b/source/de/anomic/kelondro/kelondroBase64Order.java @@ -50,24 +50,22 @@ import java.util.Comparator; public class kelondroBase64Order extends kelondroAbstractOrder implements kelondroOrder, kelondroCoding, Comparator { + private static final char[] alpha_standard = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray(); + private static final char[] alpha_enhanced = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".toCharArray(); + public static final kelondroBase64Order standardCoder = new kelondroBase64Order(true); public static final kelondroBase64Order enhancedCoder = new kelondroBase64Order(false); final boolean rfc1113compliant; - public final char[] alpha; - public final byte[] ahpla; + private final char[] alpha; + private final byte[] ahpla = new byte[256]; public kelondroBase64Order(boolean rfc1113compliant) { // if we choose not to be rfc1113compliant, // then we get shorter base64 results which are also filename-compatible this.rfc1113compliant = rfc1113compliant; - alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray(); - if (!(rfc1113compliant)) { - alpha[62] = '-'; - alpha[63] = '_'; - } - ahpla = new byte[256]; + alpha = (rfc1113compliant) ? alpha_standard : alpha_enhanced; for (int i = 0; i < 256; i++) ahpla[i] = -1; for (int i = 0; i < alpha.length; i++) ahpla[alpha[i]] = (byte) i; } diff --git a/source/de/anomic/kelondro/kelondroIndex.java b/source/de/anomic/kelondro/kelondroIndex.java index 18ae3ae3f..481a9ab50 100644 --- a/source/de/anomic/kelondro/kelondroIndex.java +++ b/source/de/anomic/kelondro/kelondroIndex.java @@ -55,6 +55,9 @@ import java.util.Iterator; public interface kelondroIndex { + public int columns(); + public int columnSize(int column); + public byte[][] get(byte[] key) throws IOException; public byte[][] put(byte[][] row) throws IOException; public byte[][] remove(byte[] key) throws IOException; diff --git a/source/de/anomic/kelondro/kelondroSplittedTree.java b/source/de/anomic/kelondro/kelondroSplittedTree.java new file mode 100644 index 000000000..8528d582b --- /dev/null +++ b/source/de/anomic/kelondro/kelondroSplittedTree.java @@ -0,0 +1,234 @@ +// kelondroSplittedTree.java +// ------------------------- +// part of The Kelondro Database +// (C) by Michael Peter Christen; mc@anomic.de +// first published on http://www.anomic.de +// Frankfurt, Germany, 2006 +// created 07.01.2006 +// +// $LastChangedDate: 2005-09-22 22:01:26 +0200 (Thu, 22 Sep 2005) $ +// $LastChangedRevision: 774 $ +// $LastChangedBy: orbiter $ +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// Using this software in any meaning (reading, learning, copying, compiling, +// running) means that you agree that the Author(s) is (are) not responsible +// for cost, loss of data or any harm that may be caused directly or indirectly +// by usage of this softare or this documentation. The usage of this software +// is on your own risk. The installation and usage (starting/running) of this +// software may allow other people or application to access your computer and +// any attached devices and is highly dependent on the configuration of the +// software which must be done by the user of the software; the author(s) is +// (are) also not responsible for proper configuration and usage of the +// software, even if provoked by documentation provided together with +// the software. +// +// Any changes to this file according to the GPL as documented in the file +// gpl.txt aside this file in the shipment you received can be done to the +// lines that follows this copyright notice here, but changes must not be +// done inside the copyright notive above. A re-distribution must contain +// the intact and unchanged copyright notice. +// Contributions and changes to the program code must be marked as such. + +package de.anomic.kelondro; + +import java.io.File; +import java.io.IOException; +import java.util.Iterator; + +public class kelondroSplittedTree implements kelondroIndex { + + private kelondroTree[] ktfs; + private kelondroOrder order; + private int ff; + + private static File dbFile(File path, String filenameStub, int forkfactor, int columns, int number) { + String ns = Integer.toHexString(number).toUpperCase(); + while (ns.length() < 2) ns = "0" + ns; + String fs = Integer.toHexString(forkfactor).toUpperCase(); + while (fs.length() < 2) fs = "0" + fs; + String cs = Integer.toHexString(columns).toUpperCase(); + while (cs.length() < 2) cs = "0" + cs; + return new File(path, filenameStub + "_" + ns + "." + fs + cs + ".ktf"); + } + + private static boolean existsAll(File pathToFiles, String filenameStub, int forkfactor, int columns){ + for (int i = 0; i < forkfactor; i++) { + if (!(dbFile(pathToFiles, filenameStub, forkfactor, columns, i)).exists()) return false; + } + return true; + } + + public kelondroSplittedTree(File pathToFiles, String filenameStub, kelondroOrder order, + long buffersize, + int forkfactor, + int[] columns, int txtProps, int txtPropsWidth, + boolean exitOnFail) { + ktfs = new kelondroTree[forkfactor]; + File f; + for (int i = 0; i < forkfactor; i++) { + f = dbFile(pathToFiles, filenameStub, forkfactor, columns.length, i); + if (f.exists()) { + try { + ktfs[i] = new kelondroTree(f, buffersize/forkfactor); + } catch (IOException e) { + ktfs[i] = new kelondroTree(f, buffersize/forkfactor, + columns, txtProps, txtPropsWidth, exitOnFail); + } + } else { + ktfs[i] = new kelondroTree(f, buffersize/forkfactor, + columns, txtProps, txtPropsWidth, exitOnFail); + } + } + ff = forkfactor; + this.order = order; + } + + public kelondroSplittedTree(File pathToFiles, String filenameStub, kelondroOrder order, + long buffersize, int forkfactor, int columns) throws IOException { + ktfs = new kelondroTree[forkfactor]; + for (int i = 0; i < forkfactor; i++) { + ktfs[i] = new kelondroTree(dbFile(pathToFiles, filenameStub, forkfactor, columns, i), + buffersize/forkfactor); + } + ff = forkfactor; + this.order = order; + } + + public static kelondroSplittedTree open(File pathToFiles, String filenameStub, kelondroOrder order, + long buffersize, + int forkfactor, + int[] columns, int txtProps, int txtPropsWidth, + boolean exitOnFail) throws IOException { + // generated a new splittet tree if it not exists or + // opens an existing one + if (existsAll(pathToFiles, filenameStub, forkfactor, columns.length)) { + return new kelondroSplittedTree(pathToFiles, filenameStub, order, buffersize, forkfactor, columns.length); + } else { + return new kelondroSplittedTree(pathToFiles, filenameStub, order, + buffersize, + forkfactor, + columns, txtProps, txtPropsWidth, + exitOnFail); + } + } + + + public int columns() { + return ktfs[0].columns(); + } + + public int columnSize(int column) { + return ktfs[0].columnSize(column); + } + + private int partition(byte[] key) { + // return number of db file where this key should be managed + return (int) order.partition(key, ff); + } + + public byte[][] get(byte[] key) throws IOException { + return ktfs[partition(key)].get(key); + } + + public byte[][] put(byte[][] row) throws IOException { + return ktfs[partition(row[0])].put(row); + } + + public byte[][] remove(byte[] key) throws IOException { + return ktfs[partition(key)].remove(key); + } + + public Iterator rows(boolean up, boolean rotating) throws IOException { + // TODO Auto-generated method stub + return null; + } + + public class ktfsIterator implements Iterator { + + int c = 0; + Iterator ktfsI; + boolean up, rot; + + public ktfsIterator(boolean up, boolean rotating) throws IOException { + this.up = up; + this.rot = rotating; + c = (up) ? 0 : (ff - 1); + ktfsI = ktfs[c].rows(up, false); + } + + public boolean hasNext() { + return ((rot) || + (ktfsI.hasNext()) || + ((up) && (c < ff)) || + ((!(up)) && (c > 0))); + } + + public Object next() { + if (ktfsI.hasNext()) return ktfsI.next(); + if (up) { + if (c < (ff - 1)) { + c++; + try { + ktfsI = ktfs[c].rows(true, false); + } catch (IOException e) { + return null; + } + return ktfsI.next(); + } else { + if (rot) { + c = 0; + try { + ktfsI = ktfs[c].rows(true, false); + } catch (IOException e) { + return null; + } + return ktfsI.next(); + } + return null; + } + } else { + if (c > 0) { + c--; + try { + ktfsI = ktfs[c].rows(false, false); + } catch (IOException e) { + return null; + } + return ktfsI.next(); + } else { + if (rot) { + c = ff - 1; + try { + ktfsI = ktfs[c].rows(false, false); + } catch (IOException e) { + return null; + } + return ktfsI.next(); + } + return null; + } + } + } + + public void remove() { + ktfsI.remove(); + } + + } + + +}