com.softwareag.tamino.db.api.accessor
Class TStreamAccessorImpl

java.lang.Object
  extended by com.softwareag.tamino.db.api.accessor.TAbstractAccessor
      extended by com.softwareag.tamino.db.api.accessor.TStreamAccessorImpl
All Implemented Interfaces:
TAccessor, TInvalidatableAccessor, TStreamAccessor
Direct Known Subclasses:
TStreamAccessorTimeLoggingImpl

public class TStreamAccessorImpl
extends TAbstractAccessor
implements TStreamAccessor

TStreamAccessorImpl is the implementation class for TStreamAccessor.

Version:
$Revision: 1.56 $
Author:
Marcus Schreyer

Field Summary
 
Fields inherited from class com.softwareag.tamino.db.api.accessor.TAbstractAccessor
canBeCancelled, clientRequests, requestCounter, SGUAI
 
Constructor Summary
TStreamAccessorImpl(TAbstractAccessor abstractAccessor)
          Special Constructor.
TStreamAccessorImpl(TAccessLocation accessLocation, TInvocation invocation, java.util.Locale locale)
          Special Constructor.
 
Method Summary
 TInputStream admin(java.lang.String commandValue)
          Execute an administrative command with the given command value and return the result as an input stream.
 void cancelRequests()
          Cancels all requests issued using current accessor.
 TInputStream close(TPreparedXQuery pQuery)
          Removes prepared XQuery.
 TInputStream closeCursor(java.lang.String cursorHandle)
          Releases a cursor.
 TInputStream define(TDataObject dataObject)
          Defines a schema represented by the given schema within the specified collection.
 TInputStream define(TDataObject[] dataObjects)
          Defines multiple schemas stored in an array of dataObjects.
 TInputStream define(TDataObject[] dataObjects, TDefineMode defineMode)
          Defines multiple schemas stored in an array of dataObjects.
 TInputStream define(TDataObject dataObject, boolean asTest)
          Deprecated. Please use the method define( TDataObject dataObject, TDefineMode defineMode ) instead.
 TInputStream define(TDataObject dataObject, TDefineMode defineMode)
          Defines a Tamino schema depending on the defineMode indicator into the current database.
 TInputStream delete(TDataObject dataObject)
          Deletes the XML document represented by the TXMLObject instance within the Tamino database.
 TInputStream delete(TQuery xPath)
          Deletes all documents implicitly given by the specified XPath statement.
 TInputStream execute(TPreparedXQuery xQuery)
          Executes prepared XQuery.
 TInputStream fetchCursor(java.lang.String cursorHandle, int cursorPosition, int fetchQuantity)
          Fetches the results from a openCursor() from Tamino.
 TScroll getScrollType()
          Returns the scroll type.
 TInputStream insert(TDataObject dataObject)
          Inserts the XML document represented by the TXMLObject instance into the Tamino database.
 TInputStream openCursor(TPreparedXQuery xquery)
          Opens a Tamino cursor for a set of documents that satisfies the TPreparedXQuery expression.
 TInputStream openCursor(TPreparedXQuery xquery, int cursorPosition, int fetchQuantity)
          Opens a Tamino cursor for a set of documents that satisfies the TPreparedXQuery expression.
 TInputStream openCursor(TQuery xPath)
          Opens a Tamino cursor quering for a specific set of XML documents stored within Tamino.
 TInputStream openCursor(TQuery xPath, int cursorPosition, int fetchQuantity)
          Opens a Tamino cursor quering for a specific set of XML documents stored within Tamino.
 TInputStream openCursor(TXQuery xquery)
          Opens a Tamino cursor for a set of documents that satisfies the xquery expression.
 TInputStream openCursor(TXQuery xquery, int cursorPosition, int fetchQuantity)
          Opens a Tamino cursor for a set of documents that satisfies the xquery expression.
 TInputStream prepare(TPreparedXQuery xQuery)
          In order to separate the compilation from the execution of XQuery Tamino provides interfaces for PREPARE and EXECUTE.
 TInputStream query(TQuery xPath)
          Queries for a specific set of XML documents stored within Tamino implicitly given by the specified XPath statement.
 TInputStream retrieve(TDataObject dataObject)
          Retrieves a single XML document from Tamino in the state as it has been inserted.
 TStreamHeader retrieveHeader(TDataObject dataObject)
          Just retrieves the �meta? data of a single document from Tamino.
 void setScrollType(TScroll scroll)
          Sets the scroll type.
 TInputStream undefine(java.lang.String collection, java.lang.String schema)
          Undefines a schema represented by the given schema within the specified collection.
 TInputStream undefine(TUndefineItem[] undefineItems)
          Undefines schemas specified by its name from the specified collection.
 TInputStream update(TDataObject dataObject)
          Updates the XML document represented by the TXMLObject instance within the Tamino database.
 TInputStream xquery(TXQuery xQuery)
          Queries for a specific set of XML documents stored within Tamino implicitly given by the specified XQuery statement.
 
Methods inherited from class com.softwareag.tamino.db.api.accessor.TAbstractAccessor
getAccessCollection, getAccessLocation, getApplicationName, getCanBeCancelled, getDatabaseUri, getInvocation, getLocale, getLockMode, getLockwaitMode, getMaximumRequestDuration, invalidate, invoke, invoke, invoke, setAccessLocation, setApplicationName, setCanBeCancelled, setInvocation, setLockMode, setLockwaitMode, setMaximumRequestDuration
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 
Methods inherited from interface com.softwareag.tamino.db.api.accessor.TAccessor
getAccessLocation, getApplicationName, getCanBeCancelled, getLockMode, getLockwaitMode, getMaximumRequestDuration, setAccessLocation, setApplicationName, setCanBeCancelled, setLockMode, setLockwaitMode, setMaximumRequestDuration
 
Methods inherited from interface com.softwareag.tamino.db.api.accessor.TInvalidatableAccessor
invalidate
 

Constructor Detail

TStreamAccessorImpl

public TStreamAccessorImpl(TAccessLocation accessLocation,
                           TInvocation invocation,
                           java.util.Locale locale)
Special Constructor. Initializes the accessor with the given access location and invocation.

Parameters:
accessLocation - the shared access location.
invocation - the shared invocation.

TStreamAccessorImpl

public TStreamAccessorImpl(TAbstractAccessor abstractAccessor)
Special Constructor. Initializes the accessor with an existing abstract accessor, so that they share the properties given within the TAbstractAccessor.

Parameters:
abstractAccessor - to get the shared properties from.
Method Detail

insert

public TInputStream insert(TDataObject dataObject)
                    throws TInsertException
Inserts the XML document represented by the TXMLObject instance into the Tamino database. The id property that might be given on the TXMLObject is not considered for the insert. An insert can only be assured if no docname property is provided. Please note, that the insert operation might lead for specific settings of the docname property to an update operation on Tamino if such a document is already given. The following characterizes regarding the setting of the docname property which operation takes place on Tamino database:
!dataObject.hasDocname() Insert.
dataObject.hasDocname() Insert, if a document with the given ino:docname is not given yet.
dataObject.hasDocname() Update, if a document with the given ino:docname is already given yet.

Specified by:
insert in interface TStreamAccessor
Parameters:
dataObject - is the representation of the Tamino document that should be stored within Tamino.
Returns:
TInputStream containing Tamino's response document as a core input stream.
Throws:
TInsertException - signals an error while attempting the insert operation.

update

public TInputStream update(TDataObject dataObject)
                    throws TUpdateException
Updates the XML document represented by the TXMLObject instance within the Tamino database. As a prerequesite the TXMLObject either has to provide an id or docname. The id has a higher priority then the docname which means that if both are given, the id is taken as the update parameter instead of the docname. An update can only be assured when an id is provided. Please note, that the update operation might lead for specific settings of the docname property to an insert operation on Tamino if such a document is not given yet. The following characterizes regarding the setting of the id and docname properties which operation takes place on Tamino database:
dataObject.hasId() Update.
!dataObject.hasId() && nonXMLObject.hasDocname() Update, if the document with the given docname is existant.
!dataObject.hasId() && nonXMLObject.hasDocname() Insert, if the document with the given docname is not existant.

Specified by:
update in interface TStreamAccessor
Parameters:
dataObject - is the representation of the XML document that should be updated within Tamino.
Returns:
TInputStream containing Tamino's response document as a core input stream.
Throws:
TUpdateException - due to problems when initiating the update request.

delete

public TInputStream delete(TDataObject dataObject)
                    throws TDeleteException
Deletes the XML document represented by the TXMLObject instance within the Tamino database.

Specified by:
delete in interface TStreamAccessor
Parameters:
dataObject - is the representation of the XML document that should be deleted within Tamino.
Returns:
TInputStream containing Tamino's response document as a core input stream.
Throws:
TDeleteException - due to problems when initiating the delete request.

delete

public TInputStream delete(TQuery xPath)
                    throws TDeleteException
Deletes all documents implicitly given by the specified XPath statement.

Specified by:
delete in interface TStreamAccessor
Parameters:
xPath - denoted the XPath statement which references a set of documents stored in Tamino that should be deleted.
Returns:
TInputStream containing Tamino's response document as a core input stream.
Throws:
TDeleteException - due to problems when initiating the delete request.

query

public TInputStream query(TQuery xPath)
                   throws TQueryException
Queries for a specific set of XML documents stored within Tamino implicitly given by the specified XPath statement.

Specified by:
query in interface TStreamAccessor
Parameters:
xPath - denoted the XPath statement which references a set of xml documents stored in Tamino that should be retrieved.
Returns:
TInputStream containing Tamino's response document as a core input stream.
Throws:
TQueryException - due to access problems.

retrieve

public TInputStream retrieve(TDataObject dataObject)
                      throws TRetrieveException
Retrieves a single XML document from Tamino in the state as it has been inserted. Please note that the object is retrieved by either id or the docname property given within the TXMLObject instance. The document is not retrieved by an xpath query but rather by a single document retrieval mechanism. The prerequesite for this is, that the TXMLObject instance needs to provide a doctype and either the id or docname information.

Specified by:
retrieve in interface TStreamAccessor
Parameters:
dataObject - needs to specify the doctype and an id or either docname.
Returns:
TInputStream containing the XML document in the state as it has been inserted. Please note that the XML document is not wrapped within the standard Tamino response structure.
Throws:
TRetrieveException - due to any problems during the retrieval of the single document.

retrieveHeader

public TStreamHeader retrieveHeader(TDataObject dataObject)
                             throws TRetrieveException

Just retrieves the �meta? data of a single document from Tamino. This data is retrieved by its docname or id as set in the TDataObject instance passed as input parameter and not by a query expression. If both docname and id are present in the TDataObject instance, the docname is used.

This method behaves like the retrieve() method except that it does not retieve the whole document but only it �meta? data, which is contained in the TStreamHeader.

Specified by:
retrieveHeader in interface TStreamAccessor
Parameters:
dataObject - a TDataObject instance specifying by its doctype, id or docname information which document to retrieve from Tamino.
Returns:
a TStreamHeader instance containing the documents �meta? data.
Throws:
TRetrieveException - signals an error while attempting the retrieve operation.
See Also:
TStreamAccessor.retrieve(TDataObject)

define

public TInputStream define(TDataObject dataObject)
                    throws TDefineException
Defines a schema represented by the given schema within the specified collection.

Specified by:
define in interface TStreamAccessor
Parameters:
dataObject - denotes the schema instance which should be defined on Tamino. There is no side effect when the schema is being defined on Tamino.
Returns:
TInputStream containing Tamino's response document as a core input stream.
Throws:
TDefineException - due to any problems that might occur when defining the schema.

define

public TInputStream define(TDataObject dataObject,
                           boolean asTest)
                    throws TDefineException
Deprecated. Please use the method define( TDataObject dataObject, TDefineMode defineMode ) instead.

Defines a Tamino schema depending on the asTest indicator into the current database. If the asTest parameter is set to true, the define is simply tested on Tamino but not physically defined. If asTest is set to false the behaviour is the same as the define operation without additional parameters. Please note, that using this operation with asTest set to true is for SAG internal use only and that it can only be used with a Tamino supporting schema definition 3 language.

Specified by:
define in interface TStreamAccessor
Parameters:
dataObject - denotes the schema instance which should be defined on Tamino. There is no side effect when the schemaObject is being defined on Tamino.
asTest - indicates if define should only be tested. If set to true define is tested otherwise the schema is physically defined.
Returns:
TInputStream containing Tamino's response document as a core input stream.
Throws:
TDefineException - if the define for the given schema instance fails. This is the case regardless of the value for the asTest parameter.

define

public TInputStream define(TDataObject dataObject,
                           TDefineMode defineMode)
                    throws TDefineException
Defines a Tamino schema depending on the defineMode indicator into the current database. If defineMode.isTest() is true, Tamino only tests the input schema, but the schema is not defined in the database. If defineMode.isValidate() is true, first structure-based updefine tests are being performed for each doctype. If they fail, all instances of that doctype are validated against the new schema. No validation is being performed for the instances of non-XML doctypes. Please note, that the usage of this method is for SAG internal use only.

Specified by:
define in interface TStreamAccessor
Parameters:
dataObject - denotes the schema instance which should be defined on Tamino. There is no side effect when the schemaObject is being defined on Tamino.
defineMode - indicates if the input schema should only be tested and if it should be validated.
Returns:
TInputStream containing Tamino's response document as a core input stream.
Throws:
TDefineException - if the define for the given schema instance fails. This is the case regardless of the value for the asTest parameter.

define

public TInputStream define(TDataObject[] dataObjects)
                    throws TDefineException
Defines multiple schemas stored in an array of dataObjects. If the schema already exists in the same collection, Tamino attempts to update the schema, otherwise a new schema is created.

Specified by:
define in interface TStreamAccessor
Parameters:
array - of dataObjects containing the schemas to be defined in Tamino.
Returns:
TInputStream containing the Taminos response document.
Throws:
TDefineException - signals an error while attempting the define operation.

define

public TInputStream define(TDataObject[] dataObjects,
                           TDefineMode defineMode)
                    throws TDefineException
Defines multiple schemas stored in an array of dataObjects. If the schema already exists in the same collection, Tamino attempts to update the schema, otherwise a new schema is created.

Specified by:
define in interface TStreamAccessor
Parameters:
array - of dataObjects containing the schemas to be defined in Tamino.
defineMode - indicates if the input schema should only be tested and if it should be validated.
Returns:
TInputStream containing the Taminos response document.
Throws:
TDefineException - signals an error while attempting the define operation.

undefine

public TInputStream undefine(java.lang.String collection,
                             java.lang.String schema)
                      throws TUndefineException
Undefines a schema represented by the given schema within the specified collection. If no schema is specified Tamino is requested to undefine the entire specified collection.

Specified by:
undefine in interface TStreamAccessor
Parameters:
collection -
schema -
Returns:
TResponse containing Tamino's response document.
Throws:
TUndefineException - due to any problems that might occur when undefining the schema.

undefine

public TInputStream undefine(TUndefineItem[] undefineItems)
                      throws TUndefineException
Undefines schemas specified by its name from the specified collection. If no schema name is specified Tamino is requested to undefine the entire collection.

Specified by:
undefine in interface TStreamAccessor
Parameters:
collection - name of the Tamino collection.
schemas - name of a Tamino schemas, if null or an empty string the collection is undefined.
Returns:
TInputStream containing the Tamino response document.
Throws:
TUndefineException - signals an error while attempting the undefine operation.
See Also:
TUndefineItem

openCursor

public TInputStream openCursor(TQuery xPath)
                        throws TCursorException
Opens a Tamino cursor quering for a specific set of XML documents stored within Tamino. The set will be implicitly accessed in a cursor specific manner. This means that the entire result set will not be obtained at once but rather in pieces. In contrary to the query() method a cursor based query does not load the whole query set at once from the Tamino database. Instead for each iterator step one result ducument will be fetched from Tamino.

This feature requires Tamino 3.1

Specified by:
openCursor in interface TStreamAccessor
Parameters:
xpath - denotes the XPath expresssion which references a set of XML documents that should be retrieved.
Returns:
TInputStream containing the Tamino response XML document.
Throws:
TCursorException - due to any problems during the opening the cursor.

openCursor

public TInputStream openCursor(TXQuery xquery)
                        throws TCursorException
Opens a Tamino cursor for a set of documents that satisfies the xquery expression. The purpose of a cursor is to retrieve the documents in steps instead of as a complete set as it is the case for the xquery method. Tamino establishes a cursor for the result set and returns a cursor handle for this set. You can obtain the cursor handle from the response document. You can retrieve the documents of the result set by using the fetchCursor method and passing it the cursor handle. Note that a cursor can only be established in the context of a local transaction.

This feature requires Tamino 4.1

Specified by:
openCursor in interface TStreamAccessor
Parameters:
xquery - expression which specifies a set of XML documents to be retrieved.
Returns:
TInputStream containing the Tamino response document. The response document contains the cursor handle.
Throws:
TCursorException - signals an error while attempting the open cursor operation.

openCursor

public TInputStream openCursor(TPreparedXQuery xquery)
                        throws TCursorException
Opens a Tamino cursor for a set of documents that satisfies the TPreparedXQuery expression. The purpose of a cursor is to retrieve the documents in steps instead of as a complete set as it is the case for the xquery method. Tamino establishes a cursor for the result set and returns a prepare handle for this set. You can obtain the prepare handle from the response document. You can retrieve the documents of the result set by using the fetchCursor method and passing it the prepare handle. Note that a cursor can only be established in the context of a local transaction.

This feature requires Tamino 4.1

Specified by:
openCursor in interface TStreamAccessor
Parameters:
xquery - expression which specifies a set of XML documents to be retrieved.
Returns:
TInputStream containing the Tamino response document. The response document contains the prepare handle.
Throws:
TCursorException - signals an error while attempting the open cursor operation.

openCursor

public TInputStream openCursor(TQuery xPath,
                               int cursorPosition,
                               int fetchQuantity)
                        throws TCursorException
Opens a Tamino cursor quering for a specific set of XML documents stored within Tamino. The set will be implicitly accessed in a cursor specific manner. This means that the entire result set will not be obtained at once but rather in pieces. Here the openning of the cursor and the retrieval of the documents starting at position cursorPosition with the amount fetchQuantity is done simultaneously.

This feature requires Tamino 3.1 In contrary to the query() method a cursor based query does not load the whole query set at once from the Tamino database. Instead for each iterator step one result ducument will be fetched from Tamino.

Specified by:
openCursor in interface TStreamAccessor
Parameters:
xpath - denotes the XPath expresssion which references a set of XML documents that should be retrieved.
cursorPosition - denotes which part of the result set shall be loaded (starts with 1)
fetchQuantity - denotes the number of documents loaded.
Returns:
TInputStream containing the Tamino response XML document.
Throws:
TCursorException - due to any problems during the opening the cursor.

openCursor

public TInputStream openCursor(TXQuery xquery,
                               int cursorPosition,
                               int fetchQuantity)
                        throws TCursorException
Opens a Tamino cursor for a set of documents that satisfies the xquery expression. The purpose of a cursor is to retrieve the documents in steps instead of as a complete set as it is the case for the xquery method. Tamino establishes a cursor for the result set and returns a cursor handle for this set. You can obtain the cursor handle from the response document. The response document also contains a number of the documents included in the result set. The documents returned are specified by the cursorPosition and fetchQuantity parameters. You can retrieve further documents of the result set by using the fetchCursor method and passing it the cursor handle. Note that a cursor can only be established in the context of a local transaction.

This feature requires Tamino 4.1

Specified by:
openCursor in interface TStreamAccessor
Parameters:
xquery - expression which specifies a set of XML documents to be retrieved.
cursorPosition - the index of the first document in the result set to be returned. The first document in the result set has index 1.
fetchQuantity - the number of documents to be returned.
Returns:
TInputStream containing the Tamino response document.
Throws:
TCursorException - signals an error while attempting the open cursor operation.

openCursor

public TInputStream openCursor(TPreparedXQuery xquery,
                               int cursorPosition,
                               int fetchQuantity)
                        throws TCursorException
Opens a Tamino cursor for a set of documents that satisfies the TPreparedXQuery expression. The purpose of a cursor is to retrieve the documents in steps instead of as a complete set as it is the case for the xquery method. Tamino establishes a cursor for the result set and returns a prepare handle for this set. You can obtain the prepare handle from the response document. The response document also contains a number of the documents included in the result set. The documents returned are specified by the cursorPosition and fetchQuantity parameters. You can retrieve further documents of the result set by using the fetchCursor method and passing it the prepare handle. Note that a cursor can only be established in the context of a local transaction.

This feature requires Tamino 4.1

Specified by:
openCursor in interface TStreamAccessor
Parameters:
xquery - expression which specifies a set of XML documents to be retrieved.
cursorPosition - the index of the first document in the result set to be returned. The first document in the result set has index 1.
fetchQuantity - the number of documents to be returned.
Returns:
TInputStream containing the Tamino response document.
Throws:
TCursorException - signals an error while attempting the open cursor operation.

fetchCursor

public TInputStream fetchCursor(java.lang.String cursorHandle,
                                int cursorPosition,
                                int fetchQuantity)
                         throws TCursorException
Fetches the results from a openCursor() from Tamino.

This feature requires Tamino 3.1

Specified by:
fetchCursor in interface TStreamAccessor
Parameters:
cursorHandle - denotes the cursor handle which identifies the Tamino cursor.
cursorPosition - denotes which part of the result set shall be loaded (starts with 1)
fetchQuantity - denotes the number of documents loaded.
Returns:
TInputStream containing the Tamino XML document.
Throws:
TCursorException - due to any problems during the opening the cursor.

closeCursor

public TInputStream closeCursor(java.lang.String cursorHandle)
                         throws TCursorException
Releases a cursor. This operation releases the cursor specific resources. After a cursor is closed, no further operations referring to this cursor are possible.

This feature requires Tamino 3.1

Specified by:
closeCursor in interface TStreamAccessor
Parameters:
cursorHandle - the cursor handle identifying the Tamino cursor.
Returns:
TInputStream containing the Tamino response document.
Throws:
TCursorException - signals an error while attempting the close cursor operation.

close

public TInputStream close(TPreparedXQuery pQuery)
                   throws TXQueryException
Removes prepared XQuery.

Specified by:
close in interface TStreamAccessor
Parameters:
pQuery - the TPreparedXQuery to be removed.
Returns:
TInputStream containing Tamino's response document as a core input stream.
Throws:
TXQueryException - due to Prepared XQuery access problems.

xquery

public TInputStream xquery(TXQuery xQuery)
                    throws TXQueryException
Queries for a specific set of XML documents stored within Tamino implicitly given by the specified XQuery statement.

This feature requires Tamino 4.1

Specified by:
xquery in interface TStreamAccessor
Parameters:
xQuery - is the xquery expression.
Returns:
TInputStream containing Tamino's response document as a core input stream.
Throws:
TXQueryException - due to access problems.

prepare

public TInputStream prepare(TPreparedXQuery xQuery)
                     throws TXQueryException
In order to separate the compilation from the execution of XQuery Tamino provides interfaces for PREPARE and EXECUTE. The PREPARE command gets the XQuery string as argument. It returns a handle that identifies the prepared query within a session. This handle is stored in TXQuery object which is used afterwards to execute the prepared XQuery. A query can only be prepared in a session context. Therfore the live time of a prepared query is bounded to the enclosing session. All prepared queries die with closing the session.

This feature requires Tamino 4.4

Specified by:
prepare in interface TStreamAccessor
Parameters:
xQuery - is the xquery expression.
Returns:
TInputStream containing Tamino's response document as a core input stream.
Throws:
TXQueryException - due to access problems.

execute

public TInputStream execute(TPreparedXQuery xQuery)
                     throws TXQueryException
Executes prepared XQuery.

This feature requires Tamino 4.4

Specified by:
execute in interface TStreamAccessor
Parameters:
xQuery - is the xquery expression.
Returns:
TInputStream containing Tamino's response document as a core input stream.
Throws:
TXQueryException - due to access problems.

admin

public TInputStream admin(java.lang.String commandValue)
                   throws TAdminException
Execute an administrative command with the given command value and return the result as an input stream.

Specified by:
admin in interface TStreamAccessor
Returns:
TInputStream containing Tamino's response document as a core input stream.
Throws:
TAdminException - signals an error while executimg the command.

cancelRequests

public void cancelRequests()
                    throws TAdminException
Cancels all requests issued using current accessor.

Specified by:
cancelRequests in interface TAccessor
Overrides:
cancelRequests in class TAbstractAccessor
Throws:
TAdminException

setScrollType

public void setScrollType(TScroll scroll)
Sets the scroll type.

Specified by:
setScrollType in interface TStreamAccessor
Parameters:
scroll - - specifies whether cursor is scrollable or not.

getScrollType

public TScroll getScrollType()
Returns the scroll type.

Specified by:
getScrollType in interface TStreamAccessor
Returns:
TScroll - specifies whether cursor is scrollable or not.


Copyright (c) 2013 Software AG. All Rights Reserved.