| java.lang.Object
 org.apache.derby.iapi.store.access.RowUtil
| RowUtil | | public class RowUtil (Code) | | A set of static utility methods to work with rows.
A row or partial row is described by two or three parameters.
- DataValueDescriptor[] row - an array of objects, one per column.
- FormatableBitSet validColumns -
an indication of which objects in row map to which columns
These objects can describe a complete row or a partial row. A partial row is
one where a sub-set (e.g. columns 0, 4 and 7) of the columns are supplied
for update, or requested to be fetched on a read. Here's an example
of code to set up a partial column list to fetch the 0th (type FOO),
4th (type BAR), and 7th (type MMM) columns from a row with 10 columns, note
that the format for a partial row changed from a "packed" representation
in the 3.0 release to a "sparse" representation in later releases:
// allocate/initialize the row
DataValueDescriptor row = new DataValueDescriptor[10]
row[0] = new FOO();
row[4] = new BAR();
row[7] = new MMM();
// allocate/initialize the bit set
FormatableBitSet FormatableBitSet = new FormatableBitSet(10);
FormatableBitSet.set(0);
FormatableBitSet.set(4);
FormatableBitSet.set(7);
Column mapping
When validColumns is null:
- The number of columns is given by row.length
- Column N maps to row[N], where column numbers start at zero.
When validColumns is not null, then
- The number of requested columns is given by the number of bits set in
validColumns.
- Column N is not in the partial row if validColumns.isSet(N)
returns false.
- Column N is in the partial row if validColumns.isSet(N) returns true.
- If column N is in the partial row then it maps to row[N].
If N >= row.length then the column is taken as non existent for an
insert or update, and not fetched on a fetch.
If row.length is greater than the number of columns indicated by validColumns
the extra entries are ignored.
|
| Method Summary | |
| public static int | columnOutOfRange(DataValueDescriptor[] row, FormatableBitSet columnList, int maxColumns)
Return the column number of the first column out of range, or a number
less than zero if all columns are in range. | | public static DataValueDescriptor | getColumn(DataValueDescriptor[] row, FormatableBitSet columnList, int columnId)
Get the object for a column identifer (0 based) from a complete or
partial row. | | public static Object | getColumn(Object[] row, FormatableBitSet columnList, int columnId)
| | final public static FetchDescriptor | getFetchDescriptorConstant(int single_column_number)
Return a FetchDescriptor which describes a single column set. | | public static int | getNumberOfColumns(int maxColumnNumber, FormatableBitSet columnList)
Get the number of columns represented by a FormatableBitSet.
This is simply a count of the number of bits set in the FormatableBitSet.
Parameters:
maxColumnNumber - Because the FormatableBitSet.size() can't be used asthe number of columns, allow caller to tellthe maximum column number if it knows. | | public static FormatableBitSet | getQualifierBitSet(Qualifier[][] qualifiers)
Get a FormatableBitSet representing all the columns represented in
a qualifier list. | | public static boolean | isRowEmpty(DataValueDescriptor[] row)
See if a row actually contains no columns. | | public static InstanceGetter[] | newClassInfoTemplate(FormatableBitSet column_list, int[] format_ids)
Generate a row of InstanceGetter objects to be used to generate "empty" rows.
Generate an array of InstanceGetter objects which will be used to make
repeated calls to newRowFromClassInfoTemplate(), to repeatedly and
efficiently generate new rows. | | public static DataValueDescriptor[] | newRowFromClassInfoTemplate(InstanceGetter[] classinfo_template)
Generate an "empty" row from an array of classInfo objects.
Generate an array of new'd objects by using the getNewInstance()
method on each of the InstanceGetter objects. | | public static int | nextColumn(Object[] row, FormatableBitSet columnList, int startColumn)
Get the next valid column after or including start column. | | final public static boolean | qualifyRow(Object[] row, Qualifier[][] qual_list)
Process the qualifier list on the row, return true if it qualifies.
A two dimensional array is to be used to pass around a AND's and OR's in
conjunctive normal form. | | public static String | toString(Object[] row)
return string version of row.
For debugging only. | | public static String | toString(Hashtable hash_table)
return string version of a HashTable returned from a FetchSet. |
| EMPTY_ROW | | final public static DataValueDescriptor[] EMPTY_ROW(Code) | | An object that can be used on a fetch to indicate no fields
need to be fetched.
|
| EMPTY_ROW_BITSET | | final public static FormatableBitSet EMPTY_ROW_BITSET(Code) | | An object that can be used on a fetch as a FormatableBitSet to indicate no fields
need to be fetched.
|
| EMPTY_ROW_FETCH_DESCRIPTOR | | final public static FetchDescriptor EMPTY_ROW_FETCH_DESCRIPTOR(Code) | | An object that can be used on a fetch as a FormatableBitSet to indicate no fields
need to be fetched.
|
| ROWUTIL_FETCH_DESCRIPTOR_CONSTANTS | | final public static FetchDescriptor[] ROWUTIL_FETCH_DESCRIPTOR_CONSTANTS(Code) | | |
| columnOutOfRange | | public static int columnOutOfRange(DataValueDescriptor[] row, FormatableBitSet columnList, int maxColumns)(Code) | | Return the column number of the first column out of range, or a number
less than zero if all columns are in range.
|
| getColumn | | public static DataValueDescriptor getColumn(DataValueDescriptor[] row, FormatableBitSet columnList, int columnId)(Code) | | Get the object for a column identifer (0 based) from a complete or
partial row.
Parameters:
row - the row
Parameters:
columnList - valid columns in the row
Parameters:
columnId - which column to return (0 based) the obejct for the column, or null if the column is not represented. |
| getFetchDescriptorConstant | | final public static FetchDescriptor getFetchDescriptorConstant(int single_column_number)(Code) | | Return a FetchDescriptor which describes a single column set.
This routine returns one of a set of constant FetchDescriptor's, and
should not be altered by the caller.
|
| getNumberOfColumns | | public static int getNumberOfColumns(int maxColumnNumber, FormatableBitSet columnList)(Code) | | Get the number of columns represented by a FormatableBitSet.
This is simply a count of the number of bits set in the FormatableBitSet.
Parameters:
maxColumnNumber - Because the FormatableBitSet.size() can't be used asthe number of columns, allow caller to tellthe maximum column number if it knows. -1 means caller does not know.>=0 number is the largest column number.
Parameters:
columnList - valid columns in the row The number of columns represented in the FormatableBitSet. |
| getQualifierBitSet | | public static FormatableBitSet getQualifierBitSet(Qualifier[][] qualifiers)(Code) | | Get a FormatableBitSet representing all the columns represented in
a qualifier list.
a FormatableBitSet describing the valid columns. |
| isRowEmpty | | public static boolean isRowEmpty(DataValueDescriptor[] row)(Code) | | See if a row actually contains no columns.
Returns true if row is null or row.length is zero.
true if row is empty. |
| newClassInfoTemplate | | public static InstanceGetter[] newClassInfoTemplate(FormatableBitSet column_list, int[] format_ids) throws StandardException(Code) | | Generate a row of InstanceGetter objects to be used to generate "empty" rows.
Generate an array of InstanceGetter objects which will be used to make
repeated calls to newRowFromClassInfoTemplate(), to repeatedly and
efficiently generate new rows. This is important for certain
applications like the sorter and fetchSet which generate large numbers
of "new" empty rows.
The new row.
Parameters:
format_ids - an array of format id's, one per column in row.
exception:
StandardException - Standard exception policy. |
| newRowFromClassInfoTemplate | | public static DataValueDescriptor[] newRowFromClassInfoTemplate(InstanceGetter[] classinfo_template) throws StandardException(Code) | | Generate an "empty" row from an array of classInfo objects.
Generate an array of new'd objects by using the getNewInstance()
method on each of the InstanceGetter objects. It is more
efficient to allocate new objects based on this "cache'd"
InstanceGetter object than to call the Monitor to generate a new class
from a format id.
The new row.
Parameters:
classinfo_template - An array of InstanceGetter objects each of which can be used to create a new instance of the appropriate type to build a new emptytemplate row.
exception:
StandardException - Standard exception policy. |
| nextColumn | | public static int nextColumn(Object[] row, FormatableBitSet columnList, int startColumn)(Code) | | Get the next valid column after or including start column.
Returns -1 if no valid columns exist after startColumn
|
| qualifyRow | | final public static boolean qualifyRow(Object[] row, Qualifier[][] qual_list) throws StandardException(Code) | | Process the qualifier list on the row, return true if it qualifies.
A two dimensional array is to be used to pass around a AND's and OR's in
conjunctive normal form. The top slot of the 2 dimensional array is
optimized for the more frequent where no OR's are present. The first
array slot is always a list of AND's to be treated as described above
for single dimensional AND qualifier arrays. The subsequent slots are
to be treated as AND'd arrays or OR's. Thus the 2 dimensional array
qual[][] argument is to be treated as the following, note if
qual.length = 1 then only the first array is valid and it is and an
array of and clauses:
(qual[0][0] and qual[0][0] ... and qual[0][qual[0].length - 1])
and
(qual[1][0] or qual[1][1] ... or qual[1][qual[1].length - 1])
and
(qual[2][0] or qual[2][1] ... or qual[2][qual[2].length - 1])
...
and
(qual[qual.length - 1][0] or qual[1][1] ... or qual[1][2])
true if the row qualifies.
Parameters:
row - The row being qualified.
Parameters:
qual_list - 2 dimensional array representing conjunctivenormal form of simple qualifiers.
exception:
StandardException - Standard exception policy. |
| toString | | public static String toString(Object[] row)(Code) | | return string version of row.
For debugging only.
The string version of row.
Parameters:
row - The row. |
| toString | | public static String toString(Hashtable hash_table)(Code) | | return string version of a HashTable returned from a FetchSet.
The string version of row. |
|
|