Hi Bonny,
Here's a reply from Ed Solovey, one of our engineers in the LCDS team:
The first thing you want to do is enable Server-to-data-source paging,
also referred to as paged-fill, by implementing the useFillPage method
in your extension of AbstractAssembler:
@Override
public boolean useFillPage(List fillParameters)
{
// enabling paged-fill for all fills
return true;
}
LCDS will call this method when a fill request comes in to the server
to determine whether to call the Assembler fill method variant with
just a fill parameters argument or the fill method variant with
additional startIndex, and numberOfRows parameters. You can enable it
for a subset of fills by returning true/false based on the
fillParameters argument. Above, I've enabled it for all fills.
Next, you'll want to implement the paged-fill variant of the fill method:
@Override
public Collection fill(List fillParameters, int startIndex, int
numberOfRows)
{
System.out.println("paged fill called with: " + startIndex + ", "
+ numberOfRows);
ArrayList<Person> people = new ArrayList<Person>();
Connection c = null;
c = getConnection();
Statement s = c.createStatement();
// use the startIndex and numItems parameters to limit the result set
// returned by your data source. Details will depend on your
datasource;
// we are using MySQL here which supports a "LIMIT" clause
// to do exactly what we want
ResultSet rs = s.executeQuery("SELECT * FROM people LIMIT"
+ startIndex + ", " + numberOfRows);
while (rs.next())
{
Person person = new Person();
person.lastName = rs.getString("lastName");
person.firstName = rs.getString("firstName");
person.id = rs.getInt("id");
people.add(person);
}
return people;
}
(error handling is not included above, I'll include a full version of
the assembler at the bottom).
I am using MySQL in this sample and the line of interest above is
"ResultSet rs = s.executeQuery("SELECT * FROM people LIMIT " +
startIndex + ", " + numberOfRows);". Here I am using the startIndex
and numberOfRows parameters to limit the result set fetched by MySQL
thus extending paging all the way to the datasource. The exact syntax
here will depend on your specific datasource.
When you use paged-fill, LCDS can no longer determine the size of the
fill collection from the result of the first fill request because it
only returns the first page of your collection. So it is required
that the count method is implemented when paged-fill is used. Here is
my method:
@Override
public int count(List countParameters)
{
// when fill paging is enabled, this method will be called
// after the first fill request comes in because the size of
// the collection is no longer known from the result of that
// initial fill request. However, in the cases where a count
// query is almost as expensive as a full fill query, you may
// avoid it and return -1. In this case the client's notion of
// the size will be incremented with each page request causing
// UI components such as the DataGrid to adjust with each page request
boolean countQueryExpensive = false;
int count = -1;
if (!countQueryExpensive)
{
Connection c = null;
c = getConnection();
Statement s = c.createStatement();
ResultSet rs = s.executeQuery("SELECT COUNT(*) count FROM
people");
rs.next();
count = rs.getInt("count");
}
System.out.println("count returning: " + count);
return count;
}
(again, error handling is not included above, I'll include a full
version of the assembler at the bottom).
Note the comment at the top of the implementation, if count is
expensive you may return -1 and LCDS will adjust the collection size
dynamically.
At this point you should be ready to go. You can configure this
destination in data-management-config.xml just as you would any other:
<adapters>
<adapter-definition class="flex.data.adapters.JavaAdapter"
id="java-dao"></adapter-definition>
</adapters>
<destination adapter="java-dao" id="PagingDestination">
<properties>
<source>paging.PagingAssembler</source>
<scope>application</scope>
<network>
<paging enabled="true" pageSize="5"></paging>
</network>
<metadata>
<identity property="id"></identity>
</metadata>
</properties>
</destination>
As you would expect, to use server-to-data-source paging,
client-to-server paging must also be enabled. Note above that I've
set my page size to 5. You can now hit access your destination with a
simple client:
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml";
layout="absolute" applicationComplete="myDS.fill(myCollection)">
<mx:DataService id="myDS" destination="PagingDestination"/>
<mx:ArrayCollection id="myCollection"/>
<mx:DataGrid id="myDG" dataProvider="{myCollection}"/>
</mx:Application>
In your server output you should initially see:
paged fill called with: 0, 6
count returning: 25 (or count returning: -1, depending on whether
your count
is implemented or you are using dynamic sizing)
paged fill called with: 5, 6
as you scroll down on your DataGrid you'll see paged fill called with:
10, 6
etc...
The documentation regarding this feature is here:
http://livedocs.adobe.com/livecycle/8.2/programLC/programmer/lcds/index.html
Hope this helps,
Ed
package paging;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import flex.data.PropertySpecifier;
import flex.data.assemblers.AbstractAssembler;
public class PagingAssembler extends AbstractAssembler
{
public PagingAssembler()
{
super();
}
private Connection getConnection() throws SQLException
{
try
{
Class.forName("com.mysql.jdbc.Driver");
return
DriverManager.getConnection("jdbc:mysql://localhost:3306/paging","root",
"adobe");
}
catch (Exception e)
{
e.printStackTrace();
return null;
}
}
@Override
public int count(List countParameters)
{
// when fill paging is enabled, this method will be called
// after the first fill request comes in because the size of
// the collection is no longer known from the
// result of that initial fill request. However, in the cases
// where a count query is almost as expensive as a full fill
query,
// you may avoid it and return -1. In this case the client's
notion of
// the size will be incremented with each page request causing
// UI components such as the DataGrid to adjust with each page
request
boolean countQueryExpensive = true;
int count = -1;
if (!countQueryExpensive)
{
Connection c = null;
try
{
c = getConnection();
Statement s = c.createStatement();
ResultSet rs = s.executeQuery("SELECT COUNT(*) count
FROM people");
rs.next();
count = rs.getInt("count");
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
if (c != null)
{
try
{
c.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
}
System.out.println("count returning: " + count);
return count;
}
@Override
public Collection fill(List fillParameters, int startIndex, int
numberOfRows)
{
System.out.println("paged fill called with: " + startIndex +
", " + numberOfRows);
ArrayList<Person> people = new ArrayList<Person>();
Connection c = null;
try
{
c = getConnection();
Statement s = c.createStatement();
// use the startIndex and numItems parameters to limit the
result set returned by your data source.
// Details will depend on your datasource; we are using
MySQL here which supports a "LIMIT" clause
// to do exactly what we want
ResultSet rs = s.executeQuery("SELECT * FROM people LIMIT
" + startIndex + ", " + numberOfRows);
while (rs.next())
{
Person person = new Person();
person.lastName = rs.getString("lastName");
person.firstName = rs.getString("firstName");
person.id = rs.getInt("id");
people.add(person);
}
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
if (c != null)
{
try
{
c.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
return people;
}
@Override
public boolean useFillPage(List fillParameters)
{
// enabling paged-fill for all fills
return true;
}
public static class Person
{
public String lastName;
public String firstName;
public int id;
}
}
--- In flexcoders@yahoogroups.com, "bonny_us" <patelnirv...@...> wrote:
>
> Hi All,
> I am Bonny working as Flex Developer. I want to know about paging in
> LCDS. So please if you have any example for LCDS paging for server to
> datasource. Then please let me know about that. It is very helpful to
> me.
> Right now we are using client-server paging and want to move on server
> to datasource paging.
> Please help me if you have any Example or POC for this.
>
> Thanks & Regards,
> Bonny
>
