OTL defined exceptions

Code=32000: Incompatible data types in stream operation

• Cause: The data type of a variable used in the current stream operation is not compatible with the declared stream format
• Action: Check placeholders and declarations of their data types

• Cause: Stream is open for output and has a format of output rows. An output row is a tuple of all output variables put together. The current output row is not filled yet but the flush function is invoked. The stream buffer cannot be flushed until the current row of the output buffer is full.
• Action: Fill the row first, then flush the stream.

• Cause: stream has input variables but not all the variables have been initialized. An attempt to read data from the stream was made.
• Action: Assign all input variables first.

• Cause: Stream has no input variables. An attempt to write objects into the stream via one of the operator << was made.
• Action: Do not call the operator << for streams which have no input variables defined.

• Cause: Stream is open for output, e.g. an INSERT statement. The actual string value is larger than the buffer size, e.g. "123456789" is the string and the placeholder was defined as :f2<char[5]>
• Action: Truncate the input string or increase the size of the buffer of the placeholder <char[10]>

• Cause: Stream is open for output, e.g. an INSERT statement. The actual otl_long_string is larger than the buffer size, defined by set_max_long_size(), e.g. "123456789" is the long string and the following function call was made set_max_long_size(5).
• Action: Truncate the input long string or increase the size of the max long size: set_max_long_size(100)

• Cause: Size of PL/SQL.table to be declared in otl_stream is too large.
• Action: The maximum size of PL/SQL table is limited to 32767 elements.

• Cause: Actual number of bytes to be written into the LOB stream is greater than specified in the otl_lob_stream::set_len() function. X1-X4 are specified either in bytes or Unicode characters (in case if #define OTL_UNICODE is used).
  
• Action: Actual number of bytes to be written into the LOB stream should match the number, specified in the set_len() function.

• Cause: When otl_lob_stream::close() is called, it turns out that the number of bytes, written into the LOB stream, does not match the number of bytes, specified in otl_lob_stream::set_len().
• Action: Actual number of bytes to be written into the LOB stream should match the number, specified in the set_len() function

• Cause: An attempt was made to write into the LOB stream, which was not initialized for writing.
• Action: LOB stream that is not open for writing, cannot be used for writing.

Code=32012: CLOB/BLOB stream is not open for reading

• Cause: An attempt was made to read from the LOB stream, which was not initialized for reading.
• Action: LOB stream that is not open for reading, cannot be used for reading.

Code=32012: First session must be started with session_begin()

• Cause: An attempt to call otl_connect::session_reopen() was made, before calling session_begin().
• Action: Change the logic of the program to call session_begin() first, and only after that to call session_reopen().

Code=32013: Invalid bind variable declaration

• Cause: There was a typo in the bind variable declaration, e.g. :var<date>, instead of :var<timestamp>.
  
• Action: Correct the typo and try again. In the case of :var<char[1]>, check the minimum acceptable size.
  

Code=32014: No stored procedure was found

• Cause: Stored procedure name, being passed into otl_stream::create_stored_proc_call, cannot be found in the Oracle data dictionary.
• Action: Correct the stored procedure name, and try again.

Code=32015: Unsupported data type

• Cause: Data type of parameter of the stored procedure, specified in  otl_stream::create_stored_proc_call, is unsupported.
• Action: PL/SQL tables, as stored procedure parameters, are not supported by create_stored_proc_call(). Also, if a stored procedure, which returns a reference cursor as an output parameter, has INOUT, or OUT parameters, is not supported by create_stored_proc_call(). create_stored_proc_call() supports a limited set of types of stored procedures.
  

• Cause: Stored procedure name, being passed into otl_stream::create_stored_proc_call, is of unsupported type..
• Action: For more detail, see this.

• Cause: In case if varchar_long, raw_long are used in a combination with OTL/OCIx, the only allowed stream buffer size is 1.


In case if clob, blob are used in a combination with OTL/OCIx, the only allowed stream buffer size for INSERTs or UPDATEs is 1. Though, buffer sizes, larger than 1, are allowed for SELECT statements.

This exception gets raised when the above limitations are violated.
 

• Action: Set the buffer size to 1.

• Cause: A stream is being instantiated with a call to ODBC / DB2 CLI that returns a description of a system table catalog, or a description of table columns (see appendix B for more detail). The function name was not recognized as one from the list above.

 
• Action: Check the spelling of the function name that is being passed into the stream, fix it, recompile the program, and try again.

• Cause: One of the otl_stream::operators >>() should have been called before calling otl_stream::operator int(). Operator int() works only for streams that have some output (SELECT statements, stored procedures returning result sets, etc.). Otherwise, the meaning of operator int() is not defined, so the operator returns incorrect values, or values that do not make any sense, and do not reflect anything meaningful. Therefore, this exception gets thrown as a warning, when an attempt is made to call operator int() before any operators >>() are called. That is, before anything was read from the stream, and yet, operator int() is called, which does not make any sense, because the operator returns an "end-of-file" (eof) status of the stream, after something is supposed to be read from the stream. The difference in semantic between operator int() and eof() is that eof() should be called before anything is read from the stream, and operator int() should be called after something is read from the stream. In other words, operator int() returns a deferred end-of-file status of the stream, for example:
  
    while(s>>f1>>f2){ // operator int() gets called here AFTER
        // two operators >>() get called in the loop condition    
  
   versus the typical use of otl_stream::eof():
  
    while(!s.eof()){ // eof() gets called BEFORE something gets read from the stream
      s>>f1>>f2; // operators() >> get called AFTER the eof() status was checked
  
  
  
• Action: Change the logic of the program so that operator int() would be called only after some calls to operators >>()  have already been made, or so that operator int() would not be called at all. Also, it is a good idea to use otl_stream::eof() instead of implicit calls to operator int().
  

• Cause: The stream the iterator is attaching to is not open .
  
 
• Action: OTL stream read iterator cannot be attached to a stream that was not opened yet. Make sure that the program logic is correct, and it does not try to attact to a closed stream.
  

• Cause: Specified features are not supported.
  
 
• Action:  If you need to use "refcurs" or PL/SQL tables, use the OTL stream interface.
  

• Cause: otl_stream_read_iterator (in attach() or in describe()) calls otl_stream::describe_out_vars() under the covers. When describe_out_vars() returns a 0 pointer back to the caller function, it normally means that the underlying stream cannot desribe its output structure. Typically, this happens in the case of a stored procedure returning an implcit result set (ODBC, DB2-CLI), or a stored procedure that returns a referenced cursor (Oracle).
  
 
• Action: The stream output structure can be normally described after the execution of the underlying stored procedure. Therefore, the OTL stream read iterator should be attached to the stream after the execution of the stored procedure. Change your code accordingly.
  

• Cause: OTL stream read iterator template class provides a JDBC-like getter interface, which identifies output variables by their relative positions: 1,2,3,... This exception gets thrown when the specified "pos" parameter (in get() functions or in is_null() function) is out of range.
  
 
• Action: Make sure that the specified pos is within the range. The whole set of output variables of the underlying stream can be describe by calling otl_stream_read_iterator.htm::describe().
  

• Cause: The data type of a variable used in the current get() operation is not compatible with the declared stream format.
 
• Action: Make sure the data types are compatible.

• Cause:  operator int() is not supported in the LOB stream mode.
 
• Action: An attempt was made to call operator int() in the LOB stream mode.
  

• Cause:  otl_stream_read_iterator can only be used when the underlying otl_stream is in te LOB stream mode..
 
• Action: Set the underlying stream to the LOB stream mode.

• Cause:  OTL stream read iterator template class provides a JDBC-like getter interface, which identifies output columns / variables by their names This exception gets thrown when the specified "var_name" parameter (in get() functions or in is_null() function) is not recongnized.
  
 
• Action: Make sure that the specified name is among the output columns / variables. The whole set of output variables of the underlying stream can be described by calling otl_stream_read_iterator.htm::describe().
  

• Cause:  OTL stream finds a column in a SELECT statement / stored procedure call (ODBC, DB2 CLI) / reference cursor (Oracle) of an unsupported data type. For example, OTL does not support Oracle Objects.
  
 
• Action: Make sure that the data types of the all columns of your SELECT statement are supported by OTL. otl_exception::var_info contains info on which column exactly has an unsupported data type.

• Cause:  OTL stream read iterator template class can't read a raw value with otl_lob_stream.
  
• Action: otl_long_string needs to be used instead.

• Cause:  OTL stream was already open when otl_stream::open() was called on the same stream.
  
 
• Action: Before opening a stream, make sure that it's not already open by calling otl_stream::good() on the stream:
  
     if(!my_str.good()){
       // stream is not open
  

• Cause:  OTL connect object was already connected to the database when otl_connect::rlogon() was called on the same object.
  
 
• Action: Before connecting an otl_connect object to the database, make sure that the object is not already connected:
  
     if(!my_connect.connected){
       // connect object is not connected
  
  

• Cause:  OTL stream uses the TimesTen TT_PREFETCH_COUNT under #define OTL_ODBC_TIMESTEN_WIN, and OTL_ODBC_TIMESTEN_UNIX, which has the range of [0..128].
  
 
• Action: The OTL stream size buffer needs to be changed to a value in the range of [0..128].
  
  

• Cause:  OTL connect object needs to be connected to the database, before otl_subscriber objects can be used with the otl_connect object..
  
 
• Action: Connect your otl_connect object to the database, and then try to use your otl_subscriber objects with the otl_connect object.
  
  

• Cause:  OTL stream uses a refcur bind variable (in a combination with  otl_refcur_stream), or PL/SQL tables, and the stream buffer size is larger than 1.
  
 
• Action: Set the OTL stream buffer size to 1 and try again.
  
  

• Cause:  otl_stream::check_end_of_row() was called to check the "end-of-row" condition. The condition was not met, and the function threw this exception. The "end-of-row" check addresses the "row-tearing" problem in a SELECT statement, for example:
  
  otl_stream sql(10,"select a, b from some_table",db); // only TWO columns
  
  while(!sql.eof()){
      int a, b, c;
      sql>>a>>b>>c; // this causes "row-tearing"
      // ...
  }
  
  The way OTL uses the C++ stream idiom is said to be unsafe, and that it potentially could cause a "row-tearing" problem, which could be very hard to troubleshoot and maintain. The check_end_of_row() function addresses the problem, so, in order to make sure the code is safe and maintainable, here's how the example above can be rewritten:
  
  otl_stream sql(10,"select a, b from some_table",db); // only TWO columns
  
  while (!sql.eof()){
      int a, b;
      sql>>a>>b;
      sql.check_end_of_row();
      // ...
  }
  
  or this way:
  
  otl_stream sql(10,"select a, b from some_table",db); // only TWO columns
  
  while (!sql.eof()){
      int a, b;
      sql>>a>>b>>endr;
      // ...
  }
  
  
  or this way:
  
  otl_stream sql(10,"select a, b from some_table",db); // only TWO columns
  
  while (!sql.eof()){
      int a, b;
          otl_read_row(sql,a,b);
      // ...
  }
  
  
  In case the number of columns in the SELECT statement changes, and the actual loop is not changed, the check_end_of_row() function (or its alternative operator>>() form) will throw this exception.
  
  Besides the row-tearing problem in SELECT statements, this OTL defined exception also addresses a similar "row-tearing" in INSERT / UPDATE /DELETE statements, or in calls to stored procedures / anonymous PL/SQL blocks, for example:
  
  otl_stream sql(10,"INSERT INTO test_tab VALUES(:f1<int>,:f2<int>)",db); // only TWO columns
  int f1, f2;
  ...
  sql<<f1<<f2<<endr;
  sql<<f1<<f2;
  sql<<f2<<endr;
  ...
  otl_write_row(sql,f1,f2);
  sql<<f1<<f2;
  otl_write_row(sql,f2);
  
  
  As table layout and code change over time,  "end-of-row" check may play more important role in keeping the code base in good shape, and reduce code rot.
   
• Action: Modify your code so that the "end-of-row" condition is met at the end of reading each row in your SELECT statement, and try it again.
  

• Cause:  #define OTL_STREAM_THROWS_NOT_CONNECTED_TO_DATABASE_EXCEPTION was enabled, OTL stream did the otl_connect-not-connected-to-database check (if(!otl_connect::connected)), and the check returned true.
  
 
• Action: Make sure that the otl_connect object that is passed into the otl_stream open() call was connected to the database.

• Cause:  White spaces are not allowed in OTL bind variable declarations.
  
 
• Action: Fix the white spaces and try again.
  

Code=32038: otl_long_unicode_string should be used with strings when OTL_UNICODE is enabled, and otl_long_string should be use with strings when OTL_UNICODE is not enabled

• Cause:  a variable of the otl_long_string class when OTL_UNICODE was enabled with VARCHAR / NVARCHAR / NTEXT / CLOB / NCLOB / etc column types instead of otl_long_unicode_string. Or otl_long_unicode_string was used when OTL_UNICODE was not enabled.
  
 
• Action: Use the appropriate "OTL long string" class and try again.
  

Code=32039: otl_long_string should be used with nonstrings when OTL_UNICODE is enabled

• Cause:  a variable of the otl_long_unicode_string class when OTL_UNICODE was enabled with RAW / VARBINARY / LONG / VARBINARY(MAX) / etc. column types.
  
 
• Action: Use the appropriate "OTL long string" class and try again.
  

• Cause:  This exception is raised when the stream is opening a call to a stored procedure that returns an implicit result set, and the stream finds output, or input/output parameters in the call.
  
 
• Action: Fix the stored procedure call (use only input parameters), and try again.

Code=32041: Invalid stream buffer size (<=0)

• Cause:  This exception is raised when the stream buffer size is <= 0.
  
 
• Action: The stream buffer size should be a positive integer. Fix the buffer size and try again.

Code=32042: otl_lob_stream can't be used as an input parameter with a SELECT statement
 or a stored procedure that returns an implicit result set

• Cause:  This exception is raised when the stream is used with a SELECT statement, or a stored procedure that returns an implicit result set (DB2 CLI, or ODBC).
  
 
• Action: Fix the code and try again.

Code=32043: otl_stream::operator>>(XXX) has been called when EOF was already reached

• Cause:  This exception is raised when the otl_stream::eof() returns 1/true and an attempt to call otl_stream::operator>>(XXX) is being made. This exception can only raised when #define OTL_PARANOID_EOF is enabled.
  
 
• Action: Correct the program logic and try again.
  

• Cause:  This exception is raised when the otl_stream::eof() returns 1/true and an attempt to call otl_stream::operator>>(XXX) is being made. This exception can only raised when #define OTL_PARANOID_EOF is enabled.
  
 
• Action: Correct the program logic and try again.
  

• Cause:  Bind variable declaration is not complete: a terminator token of > or */ is missing.
  
 
• Action: Correct the bind variable declaration and try again.
  

• Cause:  Oracle specific: connect string contains an empty TNS name, for example "user/password@".
  
 
• Action: Correct the connect string and try again.

Code=32046: target std::array<char,...> container is too small

• Cause:  Under # define OTL_STREAM_WITH_STD_CHAR_ARRAY_ON, the actual output database string size exceeds the size of the target std::array<char,...> container.
  
 
• Action: Increase the container size and try again.

• Cause:  Under # define OTL_STREAM_WITH_STD_UNICODE_CHAR_ARRAY_ON, the actual output database string size exceeds the size of the target std::array<char16_t,...> container.
  
 
• Action: Increase the container size and try again.
  

Code=32048: rewind() cannot be called when implicit_select == otl_direct_exec_select

• Cause:  When otl_direct_exec_select is used for implicit_select in otl_stream::open() or otl_stream::otl_stream() calls in OTL for ODBC/DB2-CLI, otl_stream::rewind() can't be called (limitation of implementation)
  
 
• Action: Use otl_stream::open() instead of otl_stream::rewind().
  

Copyright © 1996-2024, Sergei Kuchin, email: skuchin@gmail.com, skuchin@gmail.com .

Permission to use, copy, modify and redistribute this document for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.