com.arsdigita.persistence
Interface DataQuery

All Known Subinterfaces:
DataAssociation, DataAssociationCursor, DataCollection
All Known Implementing Classes:
DataQueryDataCollectionAdapter, DataQueryDecorator, com.arsdigita.persistence.DataQueryImpl, DomainQuery

public interface DataQuery

An instance of the DataQuery class may be used to access the results of a named query. It is typically used in the following manner:

 DataQuery query = session.retrieveQuery("MyQuery");

 Filter f = query.addEqualsFilter("myProperty", value);

 query.addOrder("creationDate desc");

 int numLines = query.size();
 System.out.println("Lines: " + numLines);

 while (query.next()) {
   Object prop = query.get("myProperty");
   System.out.println("MyProperty: " + prop);
 }
 
Named queries are defined in a PDL file using the following syntax:
query MyQuery { do { select * from my_table; } map { myProperty = my_table.my_column; creationDate = my_table.creation_date; } }

Version:
$Revision: #13 $ $Date: 2004/04/07 $
Author:
rhs@mit.edu, randyg@alum.mit.edu

Field Summary
static String versionId
           
 
Method Summary
 Filter addEqualsFilter(String attribute, Object value)
          This creates the appropriate SQL for the given attribute and passed in value.
 Filter addFilter(Filter filter)
          This adds the passed in filter to this query and ANDs it with an existing filters.
 Filter addFilter(String conditions)
          Adds the conditions to the filter that will be used on this query.
 Filter addInSubqueryFilter(String propertyName, String subqueryName)
          Add an 'in' subquery to a query.
 Filter addInSubqueryFilter(String propertyName, String subQueryProperty, String queryName)
          Highly experimental; use with caution..
 Filter addNotEqualsFilter(String attribute, Object value)
          This creates the appropriate SQL for the given attribute and passed in value.
 Filter addNotInSubqueryFilter(String propertyName, String subqueryName)
           
 void addOrder(String order)
          Set the order in which the result of this query will be returned.
 void addOrderWithNull(String orderOne, Object orderTwo, boolean isAscending)
          This adds order on the first value if it is not null or the second value if the first value is null.
 void addPath(String path)
          Adds to the set of paths fetched by this DataQuery.
 void alias(String fromPrefix, String toPrefix)
          Alias a compound property name to a different value.
 void clearFilter()
          Clears the current filter for the data query.
 void clearOrder()
          Clears the current order clause for the data query.
 void close()
          Explicitly closes this DataQuery.
 boolean first()
          Moves the cursor to the first row in the query.
 Object get(String propertyName)
          Returns the value of the propertyName property associated with the current position in the sequence.
 FilterFactory getFilterFactory()
          This retrieves the factory that is used to create the filters for this DataQuery
 Object getParameter(String parameterName)
          Allows a caller to get a parameter value for a parameter that has already been set
 int getPosition()
          Returns the current position within the sequence.
 Map getPropertyValues()
          This method returns a map of all property/value pairs.
 CompoundType getType()
          Returns the type of this data query.
 boolean hasProperty(String propertyName)
          Returns true if this query fetches the given property.
 boolean isAfterLast()
          Indicates whether the cursor is after the last row of the query.
 boolean isBeforeFirst()
          Indicates whether the cursor is before the first row of the query.
 boolean isEmpty()
          Returns true if the query has no rows.
 boolean isFirst()
          Indicates whether the cursor is on the first row of the query.
 boolean isLast()
          Indicates whether the cursor is on the last row of the query.
 boolean last()
          Moves the cursor to the last row in the query.
 boolean next()
          Moves the cursor to the next row in the sequence.
 boolean previous()
          Moves to the previous row in the query.
 boolean removeFilter(Filter filter)
          Removes the passed in filter from this query if it was directly added to the query.
 void reset()
          Returns the data query to its initial state by rewinding it and clearing any filters or ordering.
 void rewind()
          Rewinds the row sequence to the beginning.
 Filter setFilter(String conditions)
          Deprecated. see addFilter(java.lang.String)
 void setOrder(String order)
          Deprecated. see addOrder(java.lang.String)
 void setParameter(String parameterName, Object value)
          Allows a user to bind a parameter within a named query.
 void setRange(Integer beginIndex)
          This method allows the developer to set the range of rows desired.
 void setRange(Integer beginIndex, Integer endIndex)
          This method allows the developer to set the range of rows desired.
 void setReturnsLowerBound(int lowerBound)
          This sets the lower bound on the number of rows that can be returned by this query
 void setReturnsUpperBound(int upperBound)
          This sets the upper bound on the number of rows that can be returned by this query
 long size()
          Returns the size of this query.
 

Field Detail

versionId

public static final String versionId
See Also:
Constant Field Values
Method Detail

getType

public CompoundType getType()
Returns the type of this data query.


hasProperty

public boolean hasProperty(String propertyName)
Returns true if this query fetches the given property.

Parameters:
propertyName - A property name.
Returns:
True if this query fetches the given property.

reset

public void reset()
Returns the data query to its initial state by rewinding it and clearing any filters or ordering.


first

public boolean first()
              throws PersistenceException
Moves the cursor to the first row in the query. Not implemented yet.

Returns:
true if the cursor is on a valid row; false if there are no rows in the query.
Throws:
PersistenceException - Always thrown!

isEmpty

public boolean isEmpty()
                throws PersistenceException
Returns true if the query has no rows.

Returns:
true if the query has no rows; false otherwise
Throws:
PersistenceException

isBeforeFirst

public boolean isBeforeFirst()
                      throws PersistenceException
Indicates whether the cursor is before the first row of the query.

Returns:
true if the cursor is before the first row; false if the cursor is at any other position or the result set contains rows.
Throws:
PersistenceException

isFirst

public boolean isFirst()
                throws PersistenceException
Indicates whether the cursor is on the first row of the query.

Returns:
true if the cursor is on the first row; false otherwise
Throws:
PersistenceException

isLast

public boolean isLast()
               throws PersistenceException
Indicates whether the cursor is on the last row of the query. Note: Calling the method isLast may be expensive because the JDBC driver might need to fetch ahead one row in order to determine whether the current row is the last row in the result set.

If the query has not yet been executed, it executes the query.

Not implemented yet.

Returns:
True if the cursor is on the last row, false otherwise.
Throws:
PersistenceException

isAfterLast

public boolean isAfterLast()
                    throws PersistenceException
Indicates whether the cursor is after the last row of the query.

Returns:
True if the cursor is after the last row, false if the cursor is at any other position or the result set contains no rows.
Throws:
PersistenceException

last

public boolean last()
             throws PersistenceException
Moves the cursor to the last row in the query. Not implemented yet.

Not implemented yet.

Returns:
true if the new current row is valid; false if there are no rows in the query
Throws:
PersistenceException - Always thrown!

previous

public boolean previous()
                 throws PersistenceException
Moves to the previous row in the query. Not implemented yet.

Returns:
true if the new current row is valid; false otherwise
Throws:
PersistenceException - Always thrown!

addPath

public void addPath(String path)
Adds to the set of paths fetched by this DataQuery. The path is specified by a series of identifiers seperated by dots ('.'). ID properties are automatically added as necessary.
 DataQuery query = ssn.retrieve("exampleQuery");
 query.addPath("foo.bar.name");
 query.addPath("foo.bar.desc");
 while (query.next()) {
     BigInteger id = query.get("foo.bar.id");
     String name = query.get("foo.bar.name");
     String desc = query.get("foo.bar.desc");
 }
 

Parameters:
path - the additional path to fetch

setFilter

public Filter setFilter(String conditions)
Deprecated. see addFilter(java.lang.String)

Sets a filter for this query. The filter consists of a set of SQL condition specified in terms of the properties of this query. The conditions may be combined with "and" and "or". Bind variables may be used in the body of the filter. The values are set by using the set method on the Filter object that is returned.
 Filter f = query.setFilter("id < :maxId and id > :minId");
 f.set("maxId", 10);
 f.set("minId", 1);
 

Parameters:
conditions - the conditions for the filter
Returns:
the newly created filter for this query

addFilter

public Filter addFilter(String conditions)
Adds the conditions to the filter that will be used on this query. If a filter already exists, this alters the filter object and returns the altered object. If one does not already exist, it creates a new filter. When adding filters the user should be aware that their query is wrapped and the filter is appended to the wrapped query. That is, your query will look like the following:

        select * from (<data query here>) results
        where <conditions here>
        

When adding filters, the user should not use the same parameter name in multiple filters. That is, the following will not work

 
 Filter filter = query.addFilter("priority > :bound");
 filter.set("bound", new Integer(3));
 filter = query.addFilter("priority < :bound");
 filter.set("bound", new Integer(8));
 
 
The above actually evaluates to "priority < 8 and priority > 8" which is clearly not what the developer wants.

The following will work.

 
 Filter filter = query.addFilter("priority > :lowerBound");
 filter.set("lowerBound", new Integer(3));
 filter = query.addFilter("priority < :upperBound");
 filter.set("upperBound", new Integer(8));
 
 
It is actually the same as
 
 Filter filter = query.addFilter("priority > :lowerBound
                                  and priority < :uperBound");
 filter.set("upperBound", new Integer(8));
 filter.set("lowerBound", new Integer(3));
 
 

Parameters:
conditions - The conditions for the filter. This is a string that should be used to filter the DataQuery. Specifically, if this is the first filter added, it appends the information on to a view-on-the-fly. e.g.

        select * from (<data query here>) results
        where <conditions here>
        
unless the WRAP_QUERIES option for the DataQuery is set to "false". If this is the case, the Filter is simply appended to the end of the query as follows:

        <data query here>)
        [where | or] <conditions here>
        
It should normally take the form of

        <attribute_name> <condition> <attribute bind variable>
        
where the "condition" is something like "=", "<", ">", or "!=". The "bind variable" should be a colon followed by some attribute name that will later be set with a call to Filter.set(java.lang.String, java.lang.Object)

It is possible to set multiple conditions with a single addFilter statement by combining the conditions with an "and" or an "or". Conditions may be grouped by using parentheses. Consecutive calls to addFilter append the filters using "and".

If there is already a filter that exists for this query then the passed in conditions are added to the current conditions with an AND like (<current conditions>) and (< passed in conditions>)

Returns:
The filter that has just been added to the query

addFilter

public Filter addFilter(Filter filter)
This adds the passed in filter to this query and ANDs it with an existing filters. It returns the filter for this query.


removeFilter

public boolean removeFilter(Filter filter)
Removes the passed in filter from this query if it was directly added to the query. To remove a filter that was added to a CompoundFilter, you must call CompoundFilter.removeFilter().


addInSubqueryFilter

public Filter addInSubqueryFilter(String propertyName,
                                  String subqueryName)
Add an 'in' subquery to a query.

Parameters:
propertyName - The column to be filtered on.
subqueryName - The full name of a query defined in a PDL file.

addInSubqueryFilter

public Filter addInSubqueryFilter(String propertyName,
                                  String subQueryProperty,
                                  String queryName)
Highly experimental; use with caution.. Add an 'in' subquery to a query. This version can be used with subqueries which return more than 1 column as it wraps the subquery. subQueryProperty is the column pulled out of the subquery.

Parameters:
propertyName - The column to be filtered on.
subQueryProperty - The column in the subquery to be used.
queryName - The full name of a query defined in a PDL file.
Returns:
The Filter object associated with this filter.

addNotInSubqueryFilter

public Filter addNotInSubqueryFilter(String propertyName,
                                     String subqueryName)

addEqualsFilter

public Filter addEqualsFilter(String attribute,
                              Object value)
This creates the appropriate SQL for the given attribute and passed in value. It creates a filter for "attribute = 'value.toString()'" unless the value is an integer (in which case it creates "attribute = value.toString()") or the developer is using oracle and the value is null. In this case, it would create "attribute is null".

This is simply a convenience method for addFilter(getFilterFactory().equals(attribute, value));

Parameters:
attribute - The name of the attribute to bind with the value
value - The value for the specified attribute

addNotEqualsFilter

public Filter addNotEqualsFilter(String attribute,
                                 Object value)
This creates the appropriate SQL for the given attribute and passed in value. It creates a filter for "attribute = 'value.toString()'" unless the value is an integer (in which case it creates "attribute != value.toString()") or the developer is using oracle and the value is null. In this case, it would create "attribute is not null".

This is simply a convenience method for addFilter(getFilterFactory().notEquals(attribute, value));

Parameters:
attribute - The name of the attribute to bind with the value
value - The value for the specified attribute

clearFilter

public void clearFilter()
Clears the current filter for the data query.


getFilterFactory

public FilterFactory getFilterFactory()
This retrieves the factory that is used to create the filters for this DataQuery


setOrder

public void setOrder(String order)
              throws PersistenceException
Deprecated. see addOrder(java.lang.String)

Set the order in which the result of this query will be returned. The string passed is a standard SQL order by clause specified in terms of the properties. For example:
 query.setOrder("creationDate desc, id");
 

Throws:
PersistenceException

addOrder

public void addOrder(String order)
              throws PersistenceException
Set the order in which the result of this query will be returned. The string passed is a standard SQL order by clause specified in terms of the properties. For example:
 query.addOrder("creationDate desc, id");
 

Parameters:
order - This String parameter specifies the ordering of the output. This should be a comma seperated list of Attribute names (not the database column names) in the order of precedence. Separating attributes by commas is the same as calling addOrder multiple times, each with the next attribute. For instance, this

              addOrder("creationDate");
              addOrder("creationUser");
              
is the same as

              addOrder("creationDate, creationUser");
              

If the items should be ordered in ascending order, the attribute name should be followed by the word "asc" If the items should be ordered in descending order, the attribute should be followed by the word "desc" For instance, or order by ascending date and descending user (for users created with the same date), you would use the following:


              addOrder("creationDate asc, creationUser desc");
              
Throws:
PersistenceException

addOrderWithNull

public void addOrderWithNull(String orderOne,
                             Object orderTwo,
                             boolean isAscending)
                      throws PersistenceException
This adds order on the first value if it is not null or the second value if the first value is null. This is similar to doing an addOrder(nvl(columnOne, columnTwo))

Parameters:
orderOne - This is typically the column that will be used for the ordering. If this column is null then the value of orderTwo is used for the ordering
orderTwo - This is typically an actual value (such as -1) but can also be a column name the value used for the ordering
isAscending - If this is true then the items are ordered in ascending order. Otherwise, they are ordering in descending order
Throws:
PersistenceException - is thrown if the query has already been executed.

clearOrder

public void clearOrder()
Clears the current order clause for the data query.


setParameter

public void setParameter(String parameterName,
                         Object value)
Allows a user to bind a parameter within a named query.

Parameters:
parameterName - The name of the parameter to bind
value - The value to assign to the parameter

getParameter

public Object getParameter(String parameterName)
Allows a caller to get a parameter value for a parameter that has already been set

Parameters:
parameterName - The name of the parameter to retrieve
Returns:
This returns the object representing the value of the parameter specified by the name or "null" if the parameter value has not yet been set.

setRange

public void setRange(Integer beginIndex)
This method allows the developer to set the range of rows desired. Thus, the DataQuery will only return the rows between beginIndex and endIndex. The range begins at the specified beginIndex and returns all rows after that. Thus, if a query returns 30 rows and the beginIndex is set to 6, the last 25 rows of the query will be returned.

Parameters:
beginIndex - This is the number of the first row that should be returned by this query. Setting beginIndex to 1 returns all rows. This is inclusive.

setRange

public void setRange(Integer beginIndex,
                     Integer endIndex)
This method allows the developer to set the range of rows desired. Thus, the DataQuery will only return the rows between beginIndex and endIndex. The range begins at the specified beginIndex and extends to the row at index endIndex - 1. Thus the number of rows returned is endIndex-beginIndex.

Parameters:
beginIndex - This is the number of the first row that should be returned by this query. Setting beginIndex to 1 returns the rows from the beginning. This is inclusive.
endIndex - This is the number of the row after the last row that should be returned. That is, this is exclusive (specifying beginIndex = 1 and endIndex = 10 returns 9 rows);
Throws:
A - PersistenceException is thrown if endIndex <= beginIndex

getPropertyValues

public Map getPropertyValues()
This method returns a map of all property/value pairs. This essentially allows a single "row" of the query to be passed around.


setReturnsUpperBound

public void setReturnsUpperBound(int upperBound)
This sets the upper bound on the number of rows that can be returned by this query


setReturnsLowerBound

public void setReturnsLowerBound(int lowerBound)
This sets the lower bound on the number of rows that can be returned by this query


alias

public void alias(String fromPrefix,
                  String toPrefix)
Alias a compound property name to a different value. Use the empty string ("") to add a prefix to all compound property names that don't match any other aliases.

Parameters:
fromPrefix - the prefix that you're mapping from i.e., the prefix in the PDL file.
toPrefix - the prefix that you're mapping to i.e., the prefix that the programmer is going to use.

close

public void close()
Explicitly closes this DataQuery. Query should automatically be closed when next returns false, but this method should be explicitly called in the case where all of the data in a query is not needed (e.g. a "while (next())" loop is exited early or only one value is retrieved with if (next()) {...}).


rewind

public void rewind()
Rewinds the row sequence to the beginning. It's as if next() was never called.


get

public Object get(String propertyName)
Returns the value of the propertyName property associated with the current position in the sequence.

Parameters:
propertyName - the name of the property
Returns:
the value of the property

getPosition

public int getPosition()
Returns the current position within the sequence. The first position is 1.

Returns:
the current position; 0 if there is no current position

next

public boolean next()
Moves the cursor to the next row in the sequence.

Returns:
true if the new current row is valid; false if there are no more rows.

size

public long size()
Returns the size of this query.

Returns:
the number of rows.


Copyright (c) 2004 Red Hat, Inc. Corporation. All Rights Reserved. Generated at July 20 2004:2337 UTC