Hello all,
I am very new to java, so please ignore if you think this question is 
stupid. A task has been assigned to me in which I have to extract data from 
h2 database table with **more than 1 crore rows (SAD) from one table.** And 
finally show that data into a j table with pagination.
What i exactly want is that when the program starts, it extract lets say 1 
lac record from database and when user scroll down to the end of first lac 
records and again extract another lac data from database and so on …
It will be best if he goes scroll up, the program doesn’t extract rows 
which are already extracted. I Hope I explained my problem here very well.
Now, After a lot of googling, I found this 
 (https://coderanch.com/t/345383/java/JTable-Paging)very good article which 
does 90% of what I want, but not with database connection. Can any one tell 
how to do this ?
Here is the sample code :
public class PagingTableModel extends AbstractTableModel {
private static final int MAX_PAGE_SIZE = 1000000;
private static final int LATENCY_MILLIS = 1500;
private int dataOffset = 0;
private ArrayList<Integer> data = new ArrayList<Integer>();
private SortedSet<Segment> pending = new TreeSet<Segment>();
public int getColumnCount() {
return 2;
}
public String getColumnName(int col) {
if (col == 0)
return "ANUMBER";
if (col == 1)
return "BNUMBER";
return "DATETIME";
}
public int getRowCount() {
return 10000000; // one million
}
public Object getValueAt(int row, int col) {
ArrayList<Integer> page = data;
int pageIndex = row - dataOffset;
//JOptionPane.showMessageDialog(null, dataOffset);
if (pageIndex < 0 || pageIndex >= page.size()) {
System.out.println("object at " + row + " isn't loaded yet");
schedule(row);
return "..";
}
Object rowObject = page.get(pageIndex);
return rowObject;
}
private void schedule(int offset) {
if (isPending(offset)) {
return;
}
int startOffset = Math.max(0, offset - MAX_PAGE_SIZE / 2);
int length = offset + MAX_PAGE_SIZE / 2 - startOffset;
load(startOffset, length);
}
private boolean isPending(int offset) {
int sz = pending.size();
if (sz == 0)
return false;
if (sz == 1) {
Segment seg = pending.first();
return seg.contains(offset);
}
Segment lo = new Segment(offset - MAX_PAGE_SIZE, 0);
Segment hi = new Segment(offset + 1, 0);
for (Segment seg : pending.subSet(lo, hi)) {
if (seg.contains(offset))
return true;
}
return false;
}
private void load(final int startOffset, final int length) {
final Segment seg = new Segment(startOffset, length);
pending.add(seg);
Runnable fetch = new Runnable() {
public void run() {
try {
Thread.sleep(LATENCY_MILLIS);
} catch (InterruptedException ex) {
System.out.println("error retrieving page at " + startOffset + ": 
aborting");
pending.remove(seg);
return;
}
final ArrayList<Integer> page = new ArrayList<Integer>();
for (int j = 0; j < length; j += 1) {
page.add(new Integer(j + startOffset));
}
SwingUtilities.invokeLater(new Runnable() {
public void run() {
System.out.println("** loaded " + startOffset + " through " + (startOffset 
+ length - 1));
setData(startOffset, page);
pending.remove(seg);
}
});
}
};
new Thread(fetch).start();
}
private void setData(int offset, ArrayList<Integer> newData) {
// This method must be called from the event dispatch thread.
int lastRow = offset + newData.size() - 1;
dataOffset = offset;
data = newData;
fireTableRowsUpdated(offset, lastRow);
}
public static void main(String[] argv) {
JTable tab = new JTable(new PagingTableModel());
JScrollPane sp = new JScrollPane(tab);
JFrame f = new JFrame("PagingTableModel");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setContentPane(sp);
f.setBounds(30, 50, 1300, 600);
f.setVisible(true);
}
static final class Segment implements Comparable<Segment> {
private int base = 0, length = 1;
public Segment(int base, int length) {
this.base = base;
this.length = length;
}
public boolean contains(int pos) {
return (base <= pos && pos < base + length);
}
public boolean equals(Object o) {
return o instanceof Segment && base == ((Segment) o).base && length == 
((Segment) o).length;
}
public int compareTo(Segment other) {
int d = base - other.base;
if (d != 0)
return d;
return length - other.length;
}
}
}

-- 
You received this message because you are subscribed to the Google Groups "H2 
Database" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to h2-database+unsubscr...@googlegroups.com.
To post to this group, send email to h2-database@googlegroups.com.
Visit this group at https://groups.google.com/group/h2-database.
For more options, visit https://groups.google.com/d/optout.

Reply via email to