home *** CD-ROM | disk | FTP | other *** search
/ Windows 95 v2.4 Fix / W95-v2.4fix.iso / ACADWIN / ASE / ASICLASS.H < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-08  |  181.3 KB  |  4,759 lines
  1. /*****************************************************************************
  2.     Name: asiclass.h                           ast_asi_inc_appl_asiclass_h
  3.  
  4.     Description:  Header file for AutoCAD SQL Interface.
  5.                   ASI C++ User Interface.
  6.  
  7.     Author: Alexander Nikolayev
  8.             Autodesk, Inc.
  9.             Moscow, Russia.
  10.  
  11.       (C) Copyright 1991-93 by Autodesk, Inc.
  12.    ***************************************************************************
  13.       This program is copyrighted by Autodesk, Inc. and is  licensed
  14.       to you under the following conditions.  You may not distribute
  15.       or  publish the source code of this program in any form.   You
  16.       may  incorporate this code in object form in derivative  works
  17.       provided  such  derivative  works  are  (i.) are  designed and
  18.       intended  to  work  solely  with  Autodesk, Inc. products, and
  19.       (ii.)  contain  Autodesk's  copyright  notice  "(C)  Copyright
  20.       1988-1993 by Autodesk, Inc."
  21.    ***************************************************************************
  22.  
  23.       THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED
  24.       WARRANTY.  ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR
  25.       PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.
  26.  
  27.    ***************************************************************************
  28.                            RESTRICTED RIGHTS LEGEND
  29.  
  30.       Use, duplication, or disclosure by the U.S. Government is subject
  31.       to restrictions set forth in FAR 52.227-19 (Commerical Computer
  32.       Software - Restricted Rights) and DFAR 252.227-7013 (c) (1) (ii)
  33.       (Rights in Technical Data and Computer Software), as applicable.
  34.    ***************************************************************************
  35.  
  36.  
  37.     Entry Points:
  38.  
  39.     Modification History:
  40.        27 Sep 1993  - ann    -  original written
  41.  
  42.     Bugs and restriction on use:
  43.  
  44.     Notes:
  45.  
  46. *****************************************************************************/
  47. #ifndef ASI_ASICLASS_HH
  48. #define ASI_ASICLASS_HH asiclasshh
  49.  
  50. ///////////////////////////////////////////////////////////////////////////
  51. // INCLUDES 
  52. ///////////////////////////////////////////////////////////////////////////
  53. #include <setjmp.h>
  54.  
  55. ///////////////////////////////////////////////////////////////////////////
  56. // DEFINES 
  57. ///////////////////////////////////////////////////////////////////////////
  58. #define ASI_TRY           { \
  59.                             CAsiExceptionHandler AsiExceptionHandler; \
  60.                             if ( ::setjmp(AsiExceptionHandler.jbBuffer) == 0 )
  61. #define ASI_CATCH(x)      else { \
  62.                             CAsiException* x = AsiExceptionHandler.pException;
  63. #define ASI_END_CATCH     }}
  64. #define ASI_THROW(x)      AsiExceptionThrow(x);
  65. #define ASI_THROW_LAST    AsiExceptionThrow(0);
  66.  
  67.  
  68. ///////////////////////////////////////////////////////////////////////////
  69. // FORWARD DEFINITIONS 
  70. ///////////////////////////////////////////////////////////////////////////
  71.  
  72. // ASI Class Hierarchy
  73. //
  74. class CAsiObject;             // Superclass for all classes
  75.   class CAsiIdent;            // Identifier
  76.   class CAsiData;             // ASI Data generic class
  77.     class CAsiNum;            // Numeric data
  78.       class CAsiExactNum;     // Exact numeric data
  79.         class CAsiSmallInt;   // Small Integer
  80.         class CAsiInt;        // Integer
  81.         class CAsiNumeric;    // Numeric
  82.         class CAsiDecimal;    // Decimal
  83.       class CAsiApproxNum;    // Approximate numeric data
  84.         class CAsiFloat;      // Float
  85.         class CAsiReal;       // Real
  86.         class CAsiDouble;     // Double precision
  87.     class CAsiChar;           // Character
  88.     class CAsiBinary;         // Binary 
  89.     class CAsiIQualifier;     // Interval qualifier
  90.       class CAsiInterval;     // Interval
  91.          class CAsiYM;        // Year month intervals
  92.          class CAsiDT;        // Day Time intervals
  93.     class CAsiDatetime;       // Datetime data
  94.       class CAsiDate;         // Date
  95.       class CAsiTime;         // Time
  96.       class CAsiTimeStamp;    // Timestamp
  97.     class CAsiImplDef;        // Implementation defined data
  98.  
  99.   class CAsiColumn;           // Column definition
  100.   class CAsiRow;              // Array of columns
  101.   class CAsiHostBuffer;       // Host program buffer
  102.     class CAsiParameter;      // Parameter desriptor
  103.   
  104.   class CAsiException;        // ASI Exception
  105.  
  106.   class CAsiSQLObject;        // ASI User Interface base class
  107.     class CAsiSession;        // SQL Session
  108.     class CAsiStm;            // Generic SQL statement functionality
  109.        class CAsiExecStm;     // Executable SQL statement
  110.           class CAsiNativeStm;// Native DBMS statement 
  111.        class CAsiCsr;         // Cursor
  112.  
  113. class CAsiUcStr;              // Unicode string
  114. class CAsiUcChar;             // Unicode character
  115. class CAsiExceptionHandler;   // Exception handler
  116. class CAsiCollation;          // Collation
  117.  
  118.  
  119. ///////////////////////////////////////////////////////////////////////////
  120. //     TYPEDEFS 
  121. ///////////////////////////////////////////////////////////////////////////
  122.  
  123. /////////////////////////////////////////////////////////////////////////
  124. class CAsiExceptionHandler
  125. // This class is used internaly to support asi exception handling 
  126. // feature
  127. {
  128. public:
  129.     // Constrution/destruction
  130.     // 
  131.     CAsiExceptionHandler(void);
  132.     ~CAsiExceptionHandler(void);
  133.  
  134.     // Internal data for support TRY/CATCH
  135.     // 
  136.     CAsiException*        pException;
  137.     CAsiExceptionHandler* pPrevHandler;
  138.     jmp_buf               jbBuffer;
  139. };
  140.  
  141.  
  142. ///////////////////////////////////////////////////////////////////////////
  143. class CAsiObject
  144. //
  145. // This class is a principal base class for ALL ASI classes. It provides
  146. // services for memory management by reloading new and delete operators.
  147. //
  148. {
  149. public:
  150.             CAsiObject                (void);
  151.     virtual ~CAsiObject               (void);
  152.  
  153.             void*         operator new    (unsigned int);
  154.             void          operator delete (void*);
  155.  
  156.      // Duplicate 
  157.      //
  158.      virtual CAsiObject  * duplicate  (void) const;
  159.  
  160.      // Nullify all members
  161.      //
  162.      virtual void          Clear      (void);  
  163.  
  164.      // Runtime class iteraction functions. Used internaly
  165.      //
  166.      virtual unsigned long packSize   (void) const;
  167.      virtual unsigned long packTo     (void*) const;
  168.      virtual EAsiBoolean   unpackFrom (void*);
  169.  
  170. };
  171.  
  172.  
  173. //////////////////////////////////////////////////////////////////////
  174. class CAsiException : public CAsiObject
  175. //
  176. // This class provides functionality of the SQL exception condition
  177. // It is thrown by ASI member function when an exception condition was 
  178. // raised. (ASI_TRY, ASI_CATCH, ASI_THROW facility).
  179. //
  180. {
  181. public:
  182.     // Constrution/destruction
  183.     // 
  184.             CAsiException (void);
  185.     virtual ~CAsiException (void);
  186.  
  187.     // Getting Diagnostics Information   
  188.     //
  189.             int           CondQty    (void) const;       // Number of conditions in diag
  190.             AsiError      Err        (int d = 0) const;  // get completion code
  191.             CAsiUcStr    *ErrMsg     (int d = 0) const;  // get error message
  192.             char         *SQLSTATE   (int d = 0) const;  // get SQLSTATE
  193.   
  194.             // Get Diagnostics Parameter
  195.             //
  196.             EAsiBoolean getDiagPar (int, AsiDiag, integer *) const;
  197.             EAsiBoolean getDiagPar (int, AsiDiag, CAsiUcStr *) const;
  198.  
  199.      // Setting Diagnostics information
  200.  
  201.             EAsiBoolean setErr      (AsiError);           // set completion code
  202.             EAsiBoolean setErrMsg   (const CAsiUcStr &);  // set error message
  203.             EAsiBoolean setSQLSTATE (const char *);       // set SQLSTATE
  204.  
  205.             // Set Diagnostics Parameter
  206.             //
  207.             EAsiBoolean setDiagPar (AsiDiag, integer);
  208.             EAsiBoolean setDiagPar (AsiDiag, const CAsiUcStr &);
  209.  
  210.         
  211.             EAsiBoolean pushCond   (void);       // Push diagnostics information
  212.             EAsiBoolean flushCond  (void);       // Clear diagnostics
  213.  
  214.     ////////////////////////////////////////////////////
  215.     // Utility
  216.     //
  217.     void*       getDiagData (void) const;
  218.  
  219.     virtual CAsiObject * duplicate (void) const;         
  220.  
  221. private:
  222.     void* pExceptionBody;
  223. };
  224.  
  225.  
  226. ////////////////////////////////////////////////////////////////////////////////
  227. class CAsiIdent : public CAsiObject
  228. //
  229. //  SQL Identifier. Most SQL names are represented as identifiers.
  230. //  Identifier can be regular and delimitered. Regular identifier body 
  231. //  is always converted to upper case. Delimitered identifier body 
  232. //  is not converted to upper case.
  233. //
  234. {
  235. public:
  236.      // Construct identifier
  237.      //
  238.               CAsiIdent (void);
  239.               CAsiIdent (const char *);
  240.               CAsiIdent (const AsiUcStr);
  241.               CAsiIdent (const CAsiUcStr &);
  242.               CAsiIdent (const CAsiUcStr &, const CAsiUcStr &);
  243.               CAsiIdent (const CAsiIdent &);
  244.       virtual ~CAsiIdent (void);
  245.  
  246.       // Set and get identifier value
  247.       //
  248.               void          set          (EAsiBoolean, const CAsiUcStr &, 
  249.                                                    const CAsiUcStr &);
  250.  
  251.               void          setDelimited (EAsiBoolean);
  252.               void          setDelimited (void);
  253.               void          setCharSet   (const CAsiUcStr &);
  254.               void          setBody      (const CAsiUcStr &);
  255.  
  256.               EAsiBoolean   isDelimited  (void) const;   // True if delimitered identifier
  257.         const CAsiUcStr   & CharSet      (void) const;
  258.         const CAsiUcStr   & Body         (void) const;
  259.  
  260.       // Length of Identifer (inc. introducer, char set name and 
  261.       // identifier itself
  262.  
  263.               int           Length        (void) const; 
  264.  
  265.       // Clear components
  266.       //
  267.       virtual void          Clear         (void);
  268.  
  269.  
  270.       // Operators
  271.       //
  272.               CAsiIdent    &operator= (const CAsiIdent &);  // Assign another identifier
  273.               CAsiIdent    &operator= (const CAsiUcStr &);  // Assign regular identifier
  274.  
  275.               int           operator==(const CAsiIdent &) const;
  276.  
  277.       // Print identifier
  278.       //
  279.               void          ToString  (CAsiUcStr *) const; // Append identifier to string
  280.  
  281.       // Duplicate 
  282.       // 
  283.       virtual CAsiObject   *duplicate () const;
  284.  
  285.       // Runtime class iteraction functions
  286.       //
  287.       virtual unsigned long packSize   (void) const;
  288.       virtual unsigned long packTo     (void*) const;
  289.       virtual EAsiBoolean   unpackFrom (void*);
  290.  
  291. private:
  292.     EAsiBoolean isDelim;      // Is delimited identifier 
  293.     CAsiUcStr   charset;      // Character set name
  294.     CAsiUcStr   ident;        // Identifier body
  295. };
  296.  
  297.  
  298.  
  299.  
  300. ////////////////////////////////////////////////////////////////////////////////
  301. class CAsiSQLObject : public CAsiObject
  302. //
  303. // This is a base class for classes that support SQL Connection-Session-
  304. // Statement-Cursor functionality. It provides storage for the diagnostics 
  305. // information generated by the derived classes.
  306. // Besides diagnostics this class allows to get information about foreground
  307. // DBMS driver, and the current ASI version.
  308. //
  309. // MEMBER FUNCTIONS
  310. // ----------------
  311. //
  312. //  
  313. // Getting Statement Information
  314. //
  315. // EAsiStatement StmType       (void) const    
  316. // EAsiStatement CmdStmType    (void) const    
  317. // long          RowCount      (void) const    
  318. //
  319. // These function retrieve SQL statement type, SQL Command statement type,
  320. // number of rows affected by the <update:searched>, <delete: searched>, or 
  321. // insert statements
  322. //
  323. //
  324. // Syntax error position
  325. //
  326. // int ErrPosition   (void) const     
  327. //
  328. // Getting Diagnostics Information   
  329. //
  330. // int CondQty (void) const
  331. //
  332. // This function returns number of conditions stored in diagnostics area
  333. // associated with the SQL object. Diagnostics area can hold several items
  334. // belonging to the same or different conditions. Eash new condition in the
  335. // diagnostics area introduces a new condition or clarifies a previouss one.
  336. //
  337. //
  338. // EAsiError Err(
  339. //   int icond) const       // Condition number
  340. //
  341. // This function returns error code associated with the condition specified 
  342. // by its number. Condition codes are listed in the asiconst.h header file.
  343. // If a wrong condition number was passed,  kAsiERUndefined is returned.
  344. //
  345. //
  346. // CAsiUcStr *ErrMsg (
  347. //   int icond) const       // Condition number
  348. //
  349. // This function returns pointer to the Unicode string object that contains
  350. // message associated with specified condition. If invalid condition number 
  351. // was specified, 0 is returned instead of it.
  352. //
  353. //
  354. // char * SQLSTATE (
  355. //   int icond) const       // Condition number
  356. //
  357. // This function returns pointer to the character ASCII string containing
  358. // SQLSTATE diagnostics parameter associated with the specified condition.
  359. // (SQLSTATE parameter is a 5 bytes null terminated charater string,
  360. // consisting of class and subclass codes). If an invalid condition number
  361. // was specified, NULL is returned instead of pointer.
  362. //
  363. //
  364. // EAsiBoolean getDiagPar (int icond,              // Condition number
  365. //     EAsiDiag pCode,         // Parameter code
  366. //     integer *ivalue         // Integer parameter value
  367. //    ) const
  368. // EAsiBoolean getDiagPar (int icond,              // Condition number
  369. //     EAsiDiag pCode,         // Parameter code
  370. //     CAsiUcStr *ucvalue      // Character parameter value
  371. //    ) const;
  372. //
  373. // These functions store value of diagnostics parameter specified by its
  374. // code (pCode) for the specified condition into integer or Unicode 
  375. // character string buffers. Return kAsiTrue if succeeded, or kAsiFalse 
  376. // if an invalid condition number was specified.
  377. //
  378. // Parameters
  379. //
  380. // icond      Condition number
  381. // pCode      Diagnostics parameter code
  382. // ivalue     Destination for an integer value
  383. // ucvalue    Destination for an Unicode character string
  384. //
  385. //
  386. // Linked DBMS information
  387. //
  388. // The following functions allow to get information about DBMS driver 
  389. // that maintains link between ASI application and DBMS server.
  390. //
  391. // EAsiBoolean DBMS (
  392. //   CAsiUcStr & dbms         // DBMS Name
  393. //  ) const    
  394. //
  395. // Stores DBMS name into Ucode string. Reference to the Unicode string 
  396. // shall be provided by caller.
  397. //
  398. //
  399. // EAsiBoolean SQLObject (
  400. //   CAsiUcStr &objid         // SQL object identifier
  401. //  ) const    
  402. //
  403. // Stores SQL object identifier into Ucode string. Reference to the destination
  404. // Unicode string shall be provided by caller.
  405. //
  406. //
  407. // EAsiBoolean DrvMessage (
  408. //   CAsiUcStr &mess          // Driver message
  409. //  ) const
  410. //
  411. // Stores driver message into Ucode string. Reference to the destination
  412. // Unicode string shall be provided by caller.
  413. //
  414. //
  415. // EAsiBoolean CheckOp (
  416. //    ulong operation        // Operation codes
  417. //   )                
  418. //
  419. // Return kAsiTrue if operations specified in the parameter are supported 
  420. // by DBMS driver. Operation codes are a bit coded fields, that can be ored.
  421. // kAsiFalse is returned if at least one operation is not supported.
  422. //
  423. //
  424. // ASI version
  425. //
  426. // EAsiBoolean Version (
  427. //    CAsiUcStr*             // Ponter for store ASI version string
  428. //   ) const
  429. //
  430. // const char* Version (void) const
  431. //
  432. // Return pointer to the unocode string containing ASI version.
  433. //
  434. //
  435. {
  436. public:
  437.     // Constrution/destruction
  438.     // 
  439.             CAsiSQLObject();
  440.     virtual ~CAsiSQLObject();
  441.  
  442.     // Getting Statement Information
  443.     //
  444.             EAsiStatement StmType       (void) const;    // statement type
  445.             EAsiStatement CmdStmType    (void) const;    // command stm type
  446.             long          RowCount      (void) const;    // get row count
  447.  
  448.     // Syntax error position
  449.             int           ErrPosition   (void) const;     
  450.  
  451.     // Getting Diagnostics Information   
  452.     //
  453.             int        CondQty     (void) const;       // Number of conditions in diag
  454.             EAsiError  Err         (int d = 0) const;  // get completion code
  455.             CAsiUcStr *ErrMsg      (int d = 0) const;  // get error message
  456.             char      *SQLSTATE    (int d = 0) const;  // get SQLSTATE
  457.  
  458.             // Get Diagnostics Parameter
  459.             //
  460.             EAsiBoolean getDiagPar (int d,       // Integer condition
  461.                                     EAsiDiag,
  462.                                     integer *) const;
  463.             EAsiBoolean getDiagPar (int d,       // character condition
  464.                                     EAsiDiag,
  465.                                     CAsiUcStr *) const;
  466.             
  467.  
  468.     // Linked DBMS information
  469.     //
  470.             EAsiBoolean DBMS       (CAsiUcStr *) const;        // DBMS type
  471.             EAsiBoolean SQLObject  (CAsiUcStr *) const;        // SQL object identifier
  472.             EAsiBoolean DrvMessage (CAsiUcStr *) const;        // Driver message
  473.             EAsiBoolean CheckOp    (ulong);                    // Check base operation
  474.             EAsiBoolean GetStatus  (EAsiStatInfo, ulong *);    // Get check status
  475.  
  476.     //  ASI version
  477.     //
  478.             EAsiBoolean Version    (CAsiUcStr*) const;
  479.             const char* Version    (void) const;
  480.  
  481. protected:
  482.             EAsiBoolean isInit     (void) const;
  483.  
  484. protected:
  485.     // Methods for setting diagnosticss information. It may just consist of
  486.     // linking object with DDA.
  487.     //
  488.             ulong        objIdSes;     // Session id
  489.             ulong        objIdStm;     // Statement id
  490.             ulong        objIdCsr;     // Cursor id
  491.             CAsiObject * diag;         // Diagnostics and Descriptors
  492.             CAsiObject * control;      // Control 
  493.  
  494. private:
  495.     // ASI version string
  496.     //
  497.     static const char* pAsiVersion;
  498.  
  499. };
  500.  
  501.  
  502. ////////////////////////////////////////////////////////////////////////////
  503. class CAsiAppl: public CAsiSQLObject
  504. // This class is introduces functionality of ASI application 
  505. // initialization/termination and disconnectinf from all 
  506. // SQL environments. It is derived from the CAsiSQLObject class
  507. // to provide caller with diagnostics info.
  508. //
  509. {
  510. friend class CAsiSession;
  511.  
  512. public:
  513.       //  Construction/destruction
  514.       //
  515.               CAsiAppl  ();  
  516.       virtual ~CAsiAppl ();
  517.  
  518.       //  Application initialization/termination, Disconnect all
  519.       //
  520.       EAsiBoolean   Init             (void);  // Initialize application
  521.       EAsiBoolean   Term             (void);  // Terminate application
  522.       EAsiBoolean   Abort            (void);  // Abort application (rollback 
  523.                                               // all active transactions
  524.       EAsiBoolean   DisconnectAll    (void);  // Disconnect from all environmants
  525.  
  526. protected:
  527.       EAsiBoolean   addConnection    (CAsiSession *);
  528.       EAsiBoolean   removeConnection (CAsiSession *);
  529.       EAsiBoolean   deleteConnection (CAsiSession *);
  530.  
  531. private: 
  532.       EAsiBoolean   rollbackAll      (void);
  533.  
  534. private:
  535.       CAsiObject  * cncList;     // Connections
  536. };
  537.  
  538.  
  539.  
  540. ////////////////////////////////////////////////////////////////////////////////
  541. class CAsiSession: public CAsiSQLObject
  542. //
  543. // This class provides services of the SQL connection and session management.
  544. // Besides natural connection functionality (connect to and disconnect
  545. // from SQL environment), this class provides straightforward way of executing
  546. // transaction management and session management statements. Of course they
  547. // can be also executed as a ordinary SQL statements by means of prepare and
  548. // execute.
  549. //
  550. // MEMBER FUNCTIONS
  551. // ----------------
  552. //
  553. // Construction/Destruction
  554. //
  555. // CAsiSession (CAsiAppl *)
  556. //
  557. // CAsiSession constructor constructs SQL-session object, but doesn't start
  558. // the SQL session. Session is started when connecting to SQL environemnt
  559. // is performed by means of the Connect () method provided by this class.
  560. //
  561. //
  562. // ~CAsiSession ()
  563. //
  564. // Destroy CAsiSession object. If SQL-session is active when destructor is
  565. // called, then terminate current transaction by ROLLBACK.
  566. //
  567. //
  568. // Starting/Terminating Session
  569. //
  570. // EAsiBoolean Connect (
  571. //   const CAsiUcStr &envname,        // SQL environment name
  572. //   const CAsiUcStr &usrname,        // User name
  573. //   const CAsiUcStr &password)       // Password
  574. //
  575. // Connect ot SQL environment and start SQL-session. Environment name
  576. // is a section in the ASI Configuration File. This function can throw
  577. // ASI exception and sets complition condition. Return kAsiTrue if succeeded
  578. // and kAsiFalse otherwise.
  579. //
  580. //
  581. // EAsiBoolean Disconnect (void)
  582. //
  583. // Terminate SQL session and disconnect from SQL environment if there is
  584. // mo active transaction associated with the session. Otherwise throw
  585. // exception condition (if ASI_TRY was established), and store complition
  586. // condition.
  587. //
  588. //
  589. // Setting Session Context
  590. //
  591. // The function listed below are provided to set context of the current 
  592. // SQL session. Session context items that can be set by means of them 
  593. // comprise the following items:
  594. //
  595. //   catalog name,
  596. //   schema name,
  597. //   character set name,
  598. //   time zone displacement, and
  599. //   authorization
  600. //
  601. // These function can throw ASI exception and set complition condition.
  602. // They return kAsiTrue if succeeded and kAsiFalse otherwise.
  603. //
  604. // EAsiBoolean SetCatalog  (
  605. //   const CAsiUcStr &catalog)     // Catalog name
  606. //
  607. // EAsiBoolean SetSchema   (
  608. //   const CAsiUcStr &schema)      // Schema name
  609. //
  610. // EAsiBoolean SetNames    (
  611. //   const CAsiUcStr &name)        // Character set name
  612. //
  613. // EAsiBoolean SetTimeZone (
  614. //   const CAsiDT &timezone)   // Time Zone 
  615. //
  616. // EAsiBoolean SetAuthor   (
  617. //   const CAsiUcStr & user);      // Authorization
  618. //
  619. //
  620. // Transaction management
  621. //
  622. // EAsiBoolean SetTrans (
  623. //   EAsiTILevel ilevel,         // Isolation level
  624. //   EAsiTMode tmpode,           // Transaction mode
  625. //   uint size                   // Diagnostics area size 
  626. //  )
  627. // Set transaction isolation level and transaction mode for the
  628. // next transaction. If transaction is currently active, then throw ASI
  629. // exception. Store complition condition. 
  630. //
  631. //
  632. // EAsiBoolean DeferrConstr (
  633. //   CAsiIdent *consname)        // Constraint name
  634. //
  635. // Change constraint checking mode to deffered.
  636. //
  637. // EAsiBoolean ImmConstr (
  638. //   const CAsiIdent &consname)  // Constraint name
  639. //
  640. // Change constraint checking mode to immediate
  641. //
  642. // EAsiBoolean Commit       (void);                   // Commit work
  643. //
  644. // Terminate transaction by commit
  645. //
  646. // EAsiBoolean Rollback     (void);                   // Rollback
  647. //
  648. // Terminate transaction by rollback
  649. //            
  650. //
  651. // Misceleneous
  652. //
  653. // EAsiBoolean Cancel (void)
  654. //
  655. // Break execution of the SQL statment (asynchronous break)
  656. //
  657. {
  658. friend class CAsiExecStm;
  659. friend class CAsiNativeStm;
  660. friend class CAsiInterDBStm;
  661. friend class CAsiAppl;
  662.  
  663. public:
  664.     // Construction/Destruction
  665.     //
  666.             CAsiSession (CAsiAppl *);
  667.     virtual ~CAsiSession ();
  668.  
  669.     // Starting/Terminating Session
  670.     //
  671.             EAsiBoolean Connect    (const CAsiUcStr &, const CAsiUcStr &,
  672.                                     const CAsiUcStr &);
  673.             EAsiBoolean Disconnect (void);
  674.            
  675.     // Setting Session Context
  676.     //
  677.             EAsiBoolean SetCatalog  (const CAsiUcStr &);
  678.             EAsiBoolean SetSchema   (const CAsiUcStr &);
  679.             EAsiBoolean SetNames    (const CAsiUcStr &);
  680.             EAsiBoolean SetTimeZone (const CAsiDT &);
  681.             EAsiBoolean SetTimeZone (void);          // Set local time zone 
  682.             EAsiBoolean SetAuthor   (const CAsiUcStr &);
  683.  
  684.     // Transaction management
  685.     //
  686.             EAsiBoolean SetTrans     (EAsiTILevel, EAsiTMode, uint dSize = 64);  // Set transaction
  687.             EAsiBoolean DeferrConstr (CAsiIdent * cnst = 0);   // Deffer constraint
  688.             EAsiBoolean ImmConstr    (CAsiIdent * cnst = 0);   // Immediate constraint
  689.  
  690.             EAsiBoolean Commit       (void);                   // Commit work
  691.             EAsiBoolean Rollback     (void);                   // Rollback
  692.  
  693.     // Misceleneous
  694.     //
  695.             EAsiBoolean Cancel       (void);                   // Break execution
  696.      const  CAsiUcStr & Name         (void) const;             // Session/connection name
  697.  
  698. protected:
  699.             EAsiBoolean Disconnect (CAsiObject *);
  700.             EAsiBoolean iexecute   (const CAsiUcStr &);
  701.  
  702. private:
  703.     virtual CAsiObject * duplicate (void) const;             // Duplicate
  704.  
  705. private: 
  706.     EAsiBoolean   isconnected;
  707.     CAsiAppl    * Appl;           // Aplication
  708.     CAsiUcStr     sname;          // Environment name 
  709.  
  710. };
  711.  
  712.  
  713. ////////////////////////////////////////////////////////////////////////////////
  714. class CAsiStm: public CAsiSQLObject
  715. //
  716. // This class introduces functionality of the SQL statement descriptors
  717. // Basic categories of services provided by this class are listed below:
  718. //  - Input parameters manipulation (bind buffers)
  719. //  - Output parameter manipulation (resulting columns)
  720. //
  721. //  MEMBER FUNCTIONS
  722. //  ----------------
  723. //
  724. // Construction/Destruction
  725. //
  726. //  CAsiStm (void)
  727. //
  728. //  Allocate SQL statement descriptor.
  729. //
  730. //  virtual ~CAsiStm                   (void);
  731. //
  732. //  Destroy statement descriptor.
  733. //
  734. //
  735. // Input Parameters Manipulation
  736. //
  737. // int ParamQty (void)
  738. //
  739. // Return number of input parameters (bind variables) in the original
  740. // SQL statement. Number of parameter becomes available after SQL statement
  741. // was prepared.
  742. //
  743. //
  744. // CAsiParameter * ParamDsc (
  745. //   int ipar                // Parameter number
  746. //  ) const
  747. //
  748. // Get parameter descriptor. ipar shall be greater than or equal to 0 and 
  749. // less than number of parameters returned by the ParamQty ().
  750. // If wrong parameter number was specified return 0 instead of pointer to it.
  751. //
  752. //
  753. // Bind parameter with host buffer
  754. //
  755. // EAsiBoolean Bind ( ... )
  756. //
  757. // Two basic methods for binding input paramters with the host variable
  758. // buffers are provided by the CAsiStm class. They are
  759. //
  760. // - by parameter number
  761. // - by parameter name
  762. //
  763. // Input parameter is bound with CAsiData object
  764. //
  765. //
  766. // Output Column Descriptors / Column Values
  767. //
  768. // This set of services are provided in order to get description and 
  769. // values of the resulting columns for the single row select statement
  770. // and cursor. For other types of statements these services have no sence
  771. // and always return kAsiBad.
  772. //
  773. // int ColQty (void) const
  774. //
  775. // Return number of columns in resuting rowset. 
  776. //
  777. //
  778. // CAsiColumn *ColDsc (
  779. //   int colnum                    // Column number
  780. // ) const;         
  781. //
  782. // Return pointer to descripttor of the specified column.
  783. //
  784. //
  785. // Two basic methods are provided to retrieve values of the resulting 
  786. // columns:
  787. //
  788. //  - bind output column with the host buffer, and
  789. //  - retrieve column value from descriptor
  790. //
  791. // These two methods are incompatible, i.e. if one method is used, another
  792. // is not allowed.
  793. //
  794. // Both methods are simular and allow to store output value into 
  795. // CAsiData object
  796. //
  797. // EAsiBoolean Sob ( ... )
  798. //
  799. // Bind output column with the host program buffer
  800. //
  801. //
  802. // EAsiBoolean Cvl (...)
  803. //
  804. // Retrieve column data from descriptor
  805. //
  806. //
  807. {
  808.  
  809. public:
  810.     // Construction/Destruction
  811.     //
  812.             CAsiStm                    (void);
  813.     virtual ~CAsiStm                   (void);
  814.  
  815.  
  816.     // Input Parameters Manipulation
  817.     //
  818.     //
  819.             int             ParamQty    (void) const; // Parameter quantity
  820.             CAsiParameter * ParamDsc    (int) const;  // Get parameter descriptor
  821.  
  822.          // Bind input parameter by number with
  823.          //
  824.     virtual EAsiBoolean Bind (int, CAsiData *);    // CAsiData object
  825.     virtual EAsiBoolean Bind (int, void *, short *,
  826.                               int, EAsiHostType);  // Host buffer
  827.  
  828.          // Bind input parameter by name with
  829.          //
  830.     virtual EAsiBoolean Bind (const CAsiIdent &, CAsiData *); // CAsiData object
  831.     virtual EAsiBoolean Bind (const CAsiIdent &, void *, short *,
  832.                               int, EAsiHostType);    // Host buffer
  833.  
  834.     // Output Column Descriptors / Column Values
  835.     //
  836.     //
  837.             int         ColQty (void) const;      // Column quantity
  838.             CAsiColumn *ColDsc (int) const;       // Get column descriptor
  839.  
  840.             // Bind output parameter (column) with 
  841.             EAsiBoolean Sob    (int, CAsiData *);    // CAsiData object
  842.             EAsiBoolean Sob    (int, void *, short *,// Host buffer
  843.                                 int, EAsiHostType); 
  844.  
  845.             // Retrieve value of output parameter (column) into
  846.             EAsiBoolean Cvl    (int, CAsiData *);    // CAsiData object
  847.             EAsiBoolean Cvl    (int, void *, short *,// Host buffer
  848.                                 int, EAsiHostType); 
  849.  
  850.             // Some methods for recive raw data
  851.     virtual long        Read   (int, char *, long, long) const = 0;
  852.     virtual long        Size   (int) const = 0;
  853.  
  854. protected:
  855.             EAsiBoolean CvlInt (int, CAsiData *) const;    // CAsiData object
  856.             EAsiBoolean pInput (void);
  857.  
  858. protected:
  859.     CAsiObject * input;     
  860.     CAsiObject * output;
  861. };
  862.  
  863.  
  864. class CAsiExecStm: public CAsiStm
  865. //
  866. // This class introduces functionality of the executable SQL statement. 
  867. // Another type of statement is a cursor that can't be executed, and 
  868. // should be opend.
  869. // Basic categories of services provided by this class are listed below:
  870. //  - Statement preparing
  871. //  - Statement execution
  872. //
  873. //  MEMBER FUNCTIONS
  874. //  ----------------
  875. //
  876. // Construction/Destruction
  877. //
  878. //  CAsiExecStm (void)
  879. //
  880. //  Constructs SQL statement object
  881. //
  882. //  virtual ~CAsiExecStm  (void);
  883. //
  884. //  Destroy statement. If statement was not deallocated explicitly by
  885. //  means of Dealocate method, then statement is deallocated implicitly.
  886. //  
  887. //
  888. // Preparing/Deallocating
  889. //
  890. // EAsiBoolean Prepare (
  891. //   CAsiSession *session,       // Session
  892. //   const CAsiUcStr &stm        // Statement
  893. //  )   
  894.  
  895. // Prepare standard SQL statement. Associate
  896. // SQL statement with the session and prepares it.
  897. // This function stores complition condtion and 
  898. // throws ASI exception if error condition was encounted. 
  899. //
  900. // EAsiBoolean Deallocate  (void)
  901. //
  902. // Deallocate either standard or interdatabase SQL statement. If statement is 
  903. // a cursor specification associated with cursor in the open state, then
  904. // ASI exception is raised.
  905. //
  906. //
  907. // Execute statement
  908. //
  909. // EAsiBoolean Execute (void)
  910. //
  911. // Execute prepared SQL statement. Complition condition is always set and  
  912. // ASI exception can be thrown.
  913. //
  914. //
  915. // Immediate SQL and Native statement execution
  916. //
  917. // EAsiBoolean ImmediateExecute (
  918. //   CAsiSession *session,     // session
  919. //   const CAsiUcStr &stm)     // SQL statement
  920. //
  921. // Immediate execute standard SQL statement 
  922. // Successful execution results is returning kAsiGood. If execution fails, 
  923. // then ASI exception is thrown, complition
  924. // conditon is stored CAsiSQLObject and kAsiBad is returned. Execution
  925. // of this statement can start transaction.
  926. //
  927. {
  928. friend class CAsiCsr;
  929.  
  930. public:
  931.     // Construction/Destruction
  932.     //
  933.             CAsiExecStm                 (void);
  934.     virtual ~CAsiExecStm                (void);
  935.  
  936.     // Preparing/Deallocating
  937.     //
  938.     virtual EAsiBoolean Prepare          (CAsiSession *, const CAsiUcStr &);
  939.     virtual EAsiBoolean Deallocate       (void);  // Deallocate statement
  940.  
  941.     // Prepared and execute statement (immediate execution)
  942.     //
  943.     virtual EAsiBoolean Execute          (void);
  944.     virtual EAsiBoolean ImmediateExecute (CAsiSession *, const CAsiUcStr &);
  945.  
  946.     virtual EAsiBoolean Bind (int, CAsiData *);
  947.     virtual EAsiBoolean Bind (int, void *, short *, int, EAsiHostType);
  948.     virtual EAsiBoolean Bind (const CAsiIdent &, CAsiData *);
  949.     virtual EAsiBoolean Bind (const CAsiIdent &, void *, short *, int, EAsiHostType);
  950.  
  951.             // Some methods for recive raw data
  952.     virtual long        Read   (int, char *, long, long) const;
  953.     virtual long        Size   (int) const;
  954.  
  955. private:
  956.     virtual CAsiObject * duplicate (void) const;
  957.  
  958. };  
  959.  
  960. ////////////////////////////////////////////////////////////////////////////
  961. class CAsiNativeStm: public CAsiExecStm
  962. //
  963. //  This class represents functionality of the Native DBMS statement 
  964. //  processing. Native statements are passed to DBMS driver 
  965. //  without preliminary preprocessing. Native statements can be 
  966. //  just immediate executed.
  967. //  CAsiNativeStm is derived from the CAsiExecStm class and inherits 
  968. //  functionality of the statement immediate execution. 
  969. //  
  970. {
  971. public:
  972.     // Construction/Destruction
  973.     //
  974.             CAsiNativeStm                 (void);
  975.     virtual ~CAsiNativeStm                (void);
  976.  
  977.     // Statement procession
  978.     virtual EAsiBoolean ImmediateExecute (CAsiSession *, const CAsiUcStr &);
  979.  
  980. private:
  981.     // Overload these methods just to signal that they are not supported
  982.     // by the Native statement
  983.     virtual EAsiBoolean Prepare          (CAsiSession *, const CAsiUcStr &);
  984.     virtual EAsiBoolean Execute          (void);
  985. };
  986.  
  987.  
  988. ////////////////////////////////////////////////////////////////////////////
  989. class CAsiCsr: public CAsiStm
  990. //
  991. // This class proivides functionality of cursor 
  992. //
  993. // Construction/Destruction
  994. //
  995. // CAsiCsr (void);
  996. //
  997. // Construct cusror object
  998. //
  999. // ~CAsiCsr (void);
  1000. //
  1001. // Destroy cursor object. If cursor was in open state, close cursor implicitly.
  1002. //
  1003. //
  1004. // Allocate/Deallocate Cursor
  1005. //
  1006. // EAsiBoolean Allocate  (
  1007. //   CAsiExecStm * statement,         // Prepared cursor specification
  1008. //   const CAsiIdent & name,          // Cursor name
  1009. //   EAsiCurScr Scrollability,        // Cursor Scrollability
  1010. //   EAsiCurSns Sensivity);           // Cursor Sensitivity
  1011. //
  1012. // Allocate cursor. Statement shall be a prepared cursor specification.
  1013. // Otherwise ASI exception is thrown.
  1014. //
  1015. //
  1016. //
  1017. // Open/Close Cursor
  1018. //     
  1019. // EAsiBoolean Open (void)
  1020. //
  1021. // Open cursor. Cursor state becomes open and cursor position becomes before
  1022. // the first row of the selection set.
  1023. //
  1024. //
  1025. // EAsiBoolean Close (void)
  1026. //
  1027. // Close cursor. Cursor state is set to 'close'.
  1028. //
  1029. //
  1030. // Fetching Resulting Rowset        
  1031. //
  1032. // These services allow to fetch
  1033. //   - Next row
  1034. //   - Prior row
  1035. //   - First row
  1036. //   - Last row
  1037. //   - by the Relative row number (offset)
  1038. //   - by the Absolute row number (direct)
  1039. //
  1040. //   EAsiBoolean Fetch (void)
  1041. //
  1042. //   EAsiBoolean FetchPrior (void)
  1043. //
  1044. //   EAsiBoolean FetchFirst (void)
  1045. //   
  1046. //   EAsiBoolean FetchLast (void)
  1047. //
  1048. //   EAsiBoolean FetchRelative (
  1049. //     long rrow)                  // Relative row number
  1050. //
  1051. //   EAsiBoolean FetchAbsolute (
  1052. //     long row)                   // Absolute row number
  1053. //
  1054. //
  1055. // Storing Resulting Column Values
  1056. //
  1057. // CAsiRow   * getCurrentRow (void) const 
  1058. //
  1059. // Return pointer to the CAsiRow object containing current row 
  1060. //
  1061. //
  1062. // Delete/Update Current Row (Delete: positioned, Update: positioned)
  1063. //
  1064. // EAsiBoolean Delete  (void)
  1065. //
  1066. // Delete current row
  1067. //
  1068. //
  1069. // EAsiBoolean Update  (const CAsiRow &) 
  1070. //
  1071. // Update current row. Only columns that are present in the CAsiRow 
  1072. // object are updated. Association is done by column name
  1073. //
  1074. //
  1075. // Misceleneous 
  1076. // 
  1077. // EAsiBoolean is_updatable  (void);      // Is cursor updatable
  1078. // EAsiBoolean is_scrollable (void);      // Is cursor scrollable
  1079. // EAsiBoolean is_open       (void);      // Is cursor in open state
  1080. //
  1081. {
  1082. public:
  1083.     // Construction/Destruction
  1084.     //
  1085.              CAsiCsr (void);
  1086.     virtual ~CAsiCsr (void);
  1087.  
  1088.     // Allocate Cursor
  1089.     //
  1090.             EAsiBoolean Allocate      (CAsiExecStm *, const CAsiIdent &, 
  1091.                                        EAsiCurScr sc = kAsiNonScroll, 
  1092.                                        EAsiCurSns sn = kAsiSnsUndef);
  1093.  
  1094.     // Open/Close Cursor
  1095.     //     
  1096.             EAsiBoolean Open          (void);     // Open cursor
  1097.             EAsiBoolean Close         (void);     // Close
  1098.  
  1099.     // Fetching Resulting Rowset        
  1100.     //
  1101.             EAsiBoolean Fetch         (void);   // Fetch next row
  1102.             EAsiBoolean FetchPrior    (void);   // Fetch Prior row
  1103.             EAsiBoolean FetchFirst    (void);   // Fetch First row
  1104.             EAsiBoolean FetchLast     (void);   // Fetch Last row
  1105.             EAsiBoolean FetchRelative (long);   // Fetch Relative row
  1106.             EAsiBoolean FetchAbsolute (long);   // Fetch Absolute row
  1107.  
  1108.     // Storing Resulting Column Values
  1109.     //
  1110.             CAsiRow   * getCurrentRow (void) const;   // Get pointer to current row
  1111.  
  1112.     // Delete/Update Current Row (Delete: positioned, Update: positioned)
  1113.     //
  1114.             EAsiBoolean Delete        (void);            // Delete current row
  1115.             EAsiBoolean Update        (const CAsiRow &); // Update current row
  1116.  
  1117.     // Misceleneous 
  1118.     // 
  1119.             EAsiBoolean is_updatable   (void);      // Is cursor updatable
  1120.             EAsiBoolean is_scrollable  (void);      // Is cursor scrollable
  1121.             EAsiBoolean is_insensitive (void);      // Is cursor insensitive
  1122.             EAsiBoolean is_open        (void);      // Is cursor in open state
  1123.             EAsiCurPos  position       (void);      // Cursor position
  1124.  
  1125.             // Some methods for recive raw data
  1126.     virtual long        Read   (int, char *, long, long) const;
  1127.     virtual long        Size   (int) const;
  1128.  
  1129. private:
  1130.     virtual CAsiObject * duplicate (void) const;
  1131.  
  1132. private:
  1133.             CAsiIdent   csrname;
  1134.             EAsiBoolean opnFlag;
  1135.             EAsiCurScr  scrFlag;
  1136.             EAsiCurSns  snsFlag;
  1137. };
  1138.  
  1139.  
  1140. ////////////////////////////////////////////////////////////////////
  1141. //
  1142. //  ASI Data classes
  1143. //
  1144.  
  1145.  
  1146.  
  1147. /////////////////////////////////////////////////////////////////////////
  1148. //
  1149. //
  1150. //
  1151. class CAsiData : public CAsiObject
  1152. //
  1153. //  SQL Data
  1154. //
  1155. //
  1156. // This class is a base class for all ASI data classes.
  1157. // The basic functionality of it comprise the foolowing:
  1158. //   - Getting data type descriptor;
  1159. //   - Getting value in specified format;
  1160. //   - Storing value provided in arbitrary format;
  1161. //   - NULL value manipulating;
  1162. //   - Supporting of the Application/Driver generic data link
  1163. //   - Self duplicating
  1164. // 
  1165. //
  1166. //  MEMBER FUNCTIONS:
  1167. //  -----------------
  1168. //
  1169. //  Get data descriptor
  1170. //
  1171. //  EAsiDataType  Type          (void)  // type of data
  1172. //  EAsiDTType    DateTimeType  (void)  // Datetime type
  1173. //  EAsiIType     IntervalType  (void)  // Interval type
  1174. //  int           ImplDataType  (void)  // Implemetation defined type
  1175. //  uint          Length        (void)  // Length of character or bit data
  1176. //  uint          Precision     (void)  // Precision
  1177. //  uint          Scale         (void)  // Scale
  1178. //  uint          TimePrec      (void)  // Time Precision
  1179. //  uint          TimeStampPrec (void)  // Timestamp precision
  1180. //  uint          LeadFieldPrec (void)  // Leading field precision
  1181. //  uint          FracSecPrec   (void)  // Fractional second precision
  1182. //  uint          ReturnLength  (void)  // Actual length of data
  1183. //
  1184. //  The functions listed above allow to retrieve desription of the 
  1185. //  the SQL data in terms of SQL. They are pure virtual functions,
  1186. //  actual transaltion of internal data descriptioon to the SQL data description
  1187. //  is done by the derived classes.
  1188. //
  1189. //
  1190. // ASI application/DBMS driver data exchange
  1191. //
  1192. // The CAsiData class provides services for reading generic data, 
  1193. // without respect to the data internal structure, just as a sequence 
  1194. // of bytes. These services provide ASI application and DBMS driver with 
  1195. // ability to exchange data in the ASI application/DBMS driver interaction.
  1196. // (Note. To use this facility CAsiData shall be bound with input or 
  1197. // output parameter of the SQL statement)
  1198. // Driver and Application use Client/Server paradigm in their interaction.
  1199. // When application needs to read value of the output columns
  1200. // from the driver, they are Client and Server respectivly (Application
  1201. // asks Driver to provide it with data). On the other hand, when driver 
  1202. // needs values for input parameters it asks Application to provide them for
  1203. // it. In this case Driver is a Client and Application is a Server. 
  1204. // 
  1205. // Client shall use member functions size() and read() to get size of
  1206. // data and to read block of data. Server shall provide function readFromServer
  1207. // that stores specified number of bytes into destination buffer. 
  1208. // Functions size and readFromServer shall be reloaded by the derived classes.
  1209. // Default versions do nothing.
  1210. //
  1211. //
  1212. //  virtual long  readFromServer (
  1213. //    char *dst,         // Destination buffer
  1214. //    long start,        // Starting position
  1215. //    long len           // Number of bytes to read
  1216. //  )
  1217. //  
  1218. //  Read specified number of bytes into destination buffer starting from 
  1219. //  specified position. Return actual number of bytes stored in destination
  1220. //  buffer. This function shall be reloaded by the derived classes.
  1221. //
  1222. //
  1223. //  virtual long  size           (void)
  1224. //
  1225. //  Return size of data in bytes
  1226. //
  1227. //
  1228. //  long read (
  1229. //    char *dst,         // Destination buffer
  1230. //    long start,        // Starting position
  1231. //    long len           // Number of bytes to read
  1232. //  )
  1233. //
  1234. //  Fill in destination buffer by 'len' bytes starting from the 'start'
  1235. //  byte of data. This function shall be called when data from Server have 
  1236. //  to be retrieved by Client
  1237. //
  1238. //
  1239. //  NULL value manipulation
  1240. //
  1241. //  void setNull (void)  
  1242. //
  1243. //    Set internal data to NULL value (absence of value)
  1244. //
  1245. //
  1246. //  EAsiBoolean isNull (void) const
  1247. //
  1248. //    Return kAsiTrue if data is NULL and kAsiFalse otherwise
  1249. //
  1250. //
  1251. // Store Data value
  1252. //
  1253. //  virtual EAsiBoolean   storeValue   (...);
  1254. //
  1255. // These functions allow to store data into class derived from
  1256. // the CAsiData. Source data is converted to the actual type of the CAsiData
  1257. // If conversion is possible and data was successfully stored and kAsiTrue is
  1258. // returned, if conversion is impossible, kAsiFalse is returned. 
  1259. //
  1260. //
  1261. // Get data value
  1262. //
  1263. //  virtual void getValue (...)
  1264. //
  1265. // Store value of the CAsiData object into destination buffer and perform all
  1266. // needed converisons. If operation succeeded, kAsiTrue is returned, if not
  1267. // kSiFalse is returned and contents of destination buffer is undefined.
  1268. // If null value is stored, destination buffer contents is undefined.
  1269. //
  1270. //  EAsiBoolean   SQLType    (CAsiUcStr * dst) const
  1271. //  EAsiBoolean   SQLLiteral (CAsiUcStr * dst) const    
  1272. //
  1273. //  This functions stores SQL data type string and SQL literal into destination
  1274. //  buffer. For example, for Year to month interval first function will
  1275. //  return INTERVAL YEAR TO MONTH, the second one - INTERVAL 'yy-dd' YEAR TO MONTH
  1276. //  
  1277. // Duplicate
  1278. //
  1279. // virtual CAsiObject *duplicate (void) const
  1280. //
  1281. // Create duplicate of the CAsiData object.
  1282. //
  1283. //
  1284. //  Operations with the Internal Data (Operators)
  1285. //
  1286. //  Each class derived from CAsiData defines a set of functions that 
  1287. //  perform certain operations with it. These functions comprise:
  1288. //    - assignment operator;
  1289. //    - arithmetics operator;
  1290. //    - data specific operations
  1291. //
  1292. //  For more details see appropriate class definition.
  1293. //
  1294. //
  1295. {
  1296. friend class CAsiColumn;
  1297.  
  1298. public:
  1299.  
  1300.     //  Construction destruction
  1301.     //
  1302.  
  1303.             CAsiData  (void);
  1304.     virtual ~CAsiData (void);
  1305.  
  1306.     //  Get data descriptor
  1307.     //
  1308.     virtual EAsiDataType  Type          (void) const = 0;  // type of data
  1309.     virtual EAsiDTType    DateTimeType  (void) const; // Datetime type
  1310.     virtual EAsiIType     IntervalType  (void) const; // Interval type
  1311.     virtual int           ImplDataType  (void) const; // Implemetation defined type
  1312.     virtual uint          Length        (void) const; // Length of character or bit data
  1313.     virtual uint          Precision     (void) const; // Precision
  1314.     virtual uint          Scale         (void) const; // Scale
  1315.     virtual uint          TimePrec      (void) const; // Time Precision
  1316.     virtual uint          TimeStampPrec (void) const; // Timestamp precision
  1317.     virtual uint          LeadFieldPrec (void) const; // Leading field precision
  1318.     virtual uint          FracSecPrec   (void) const; // Fractional second precision
  1319.     virtual uint          ReturnLength  (void) const; // Actual length of data
  1320.  
  1321.     //  is_ functions
  1322.     //
  1323.     virtual EAsiBoolean   is_numeric       (void) const;
  1324.     virtual EAsiBoolean   is_exactnumeric  (void) const;
  1325.     virtual EAsiBoolean   is_approxnumeric (void) const;
  1326.     virtual EAsiBoolean   is_character     (void) const;
  1327.     virtual EAsiBoolean   is_binary        (void) const;
  1328.     virtual EAsiBoolean   is_datetime      (void) const;
  1329.     virtual EAsiBoolean   is_interval      (void) const;
  1330.     virtual EAsiBoolean   is_yminterval    (void) const;
  1331.     virtual EAsiBoolean   is_dtinterval    (void) const;
  1332.     virtual EAsiBoolean   is_implement     (void) const;
  1333.  
  1334.     virtual EAsiBoolean   is_comparable    (const CAsiData *) const;
  1335.     virtual EAsiBoolean   is_storable      (const CAsiData *) const;
  1336.     virtual EAsiBoolean   is_castable      (const CAsiData *) const;
  1337.  
  1338.     // Check certain operations and return resulting descriptor
  1339.     virtual CAsiData *    checkAdd (const CAsiData *) const;
  1340.     virtual CAsiData *    checkSub (const CAsiData *) const;
  1341.     virtual CAsiData *    checkMul (const CAsiData *) const;
  1342.     virtual CAsiData *    checkDiv (const CAsiData *) const;
  1343.     virtual CAsiData *    checkCat (const CAsiData *) const;
  1344.  
  1345.     // ASI application/DBMS driver data exchange
  1346.     //
  1347.     virtual long          read           (char *, long, long) const;
  1348.     virtual long          size           (void) const;
  1349.  
  1350.     //  NULL value manipulation
  1351.     //
  1352.             void          setNull  (void);            // Assign NULL
  1353.             EAsiBoolean   isNull   (void) const;      // Is Null ?
  1354.  
  1355.     // Store Data value
  1356.     //
  1357.     virtual EAsiBoolean   storeValue (real);                 // Real
  1358.     virtual EAsiBoolean   storeValue (integer);              // Integer
  1359.     virtual EAsiBoolean   storeValue (smallint);             // Smallint
  1360.     virtual EAsiBoolean   storeValue (char *, uint);         // ASCII string
  1361.     virtual EAsiBoolean   storeValue (const CAsiUcStr &);    // Unicode string
  1362.     virtual EAsiBoolean   storeValue (char *, uint, uint *); // Binary Buffer
  1363.     virtual EAsiBoolean   storeValue (const CAsiData &);
  1364.     virtual EAsiBoolean   storeValue (const AsiUcStr);       // Store AsiUcStr
  1365.  
  1366.     //  Retrive data value
  1367.     //
  1368.     virtual EAsiBoolean   getValue (real *) const;               // Real
  1369.     virtual EAsiBoolean   getValue (integer *) const;            // Integer
  1370.     virtual EAsiBoolean   getValue (smallint *) const;           // Smallint
  1371.     virtual EAsiBoolean   getValue (char *, uint) const;         // ASCII string
  1372.     virtual EAsiBoolean   getValue (CAsiUcStr *) const;          // Unicode string
  1373.     virtual EAsiBoolean   getValue (char *, uint, uint *) const; // Binary Buffer
  1374.     virtual EAsiBoolean   getValue (AsiUcStr, uint) const;       // Unicode string 
  1375.     virtual EAsiBoolean   getValue (CAsiData &) const;
  1376.  
  1377.     virtual EAsiBoolean   SQLType    (CAsiUcStr *) const = 0;    // SQL data type as string
  1378.     virtual EAsiBoolean   SQLLiteral (CAsiUcStr *) const = 0;    // SQL compatible literal
  1379.  
  1380.     // Runtime class iteraction functions
  1381.     //
  1382.     virtual unsigned long packSize   (void) const = 0;
  1383.     virtual unsigned long packTo     (void*) const = 0;
  1384.     virtual EAsiBoolean   unpackFrom (void*) = 0;
  1385.  
  1386.     // Duplicate itself
  1387.     //
  1388.     virtual CAsiObject   *duplicate (void) const = 0;
  1389.  
  1390.     // Nullify all members
  1391.  
  1392.     virtual void          Clear     (void);
  1393.  
  1394. protected:
  1395.     EAsiBoolean isnull;                           // kAsiTrue if data is null
  1396.     CAsiObject *pDataLink;                        // Link with server data
  1397. };
  1398.  
  1399.  
  1400. ////////////////////////////////////////////////
  1401. //
  1402. //
  1403. class CAsiNum : public CAsiData
  1404. //
  1405. // Numeric data
  1406. //
  1407. {
  1408. public:
  1409.     // Construction/destruction
  1410.     //
  1411.             CAsiNum ();           // Constructor
  1412.     virtual ~CAsiNum ();          // Destructor
  1413.  
  1414.     // Get data descriptor
  1415.     //
  1416.     virtual uint          Precision     (void) const;
  1417.     virtual uint          Scale         (void) const;
  1418.  
  1419.     //  is_ functions
  1420.     //
  1421.     virtual EAsiBoolean   is_numeric       (void) const;
  1422.     virtual EAsiBoolean   is_exectnumeric (void) const;
  1423.     virtual EAsiBoolean   is_approxnumeric (void) const;
  1424.     virtual EAsiBoolean   is_comparable    (const CAsiData *) const;
  1425.     virtual EAsiBoolean   is_storable      (const CAsiData *) const;
  1426.     virtual EAsiBoolean   is_castable      (const CAsiData *) const;
  1427.  
  1428.     virtual CAsiData *    checkAdd (const CAsiData *) const;
  1429.     virtual CAsiData *    checkSub (const CAsiData *) const;
  1430.     virtual CAsiData *    checkMul (const CAsiData *) const;
  1431.     virtual CAsiData *    checkDiv (const CAsiData *) const;
  1432.  
  1433.     // Get data value
  1434.     //
  1435.     virtual integer     intValue  (void) const;
  1436.     virtual real        realValue (void) const;
  1437.  
  1438.  
  1439.     // virtual Comparision operators
  1440.     //
  1441.     virtual int         operator>  (const CAsiSmallInt &) const;
  1442.     virtual int         operator>  (const CAsiInt &)      const;
  1443.     virtual int         operator>  (const CAsiNumeric &)  const;
  1444.     virtual int         operator>  (const CAsiDecimal &)  const;
  1445.     virtual int         operator>  (const CAsiFloat &)    const;
  1446.     virtual int         operator>  (const CAsiReal &)     const;
  1447.     virtual int         operator>  (const CAsiDouble &)   const;
  1448.     virtual int         operator>  (const smallint)       const;
  1449.     virtual int         operator>  (const integer)        const;
  1450.     virtual int         operator>  (const real)           const;
  1451.     virtual int         operator>  (const int)            const;
  1452.                  
  1453.     virtual int         operator>= (const CAsiSmallInt &) const;
  1454.     virtual int         operator>= (const CAsiInt &)      const;
  1455.     virtual int         operator>= (const CAsiNumeric &)  const;
  1456.     virtual int         operator>= (const CAsiDecimal &)  const;
  1457.     virtual int         operator>= (const CAsiFloat &)    const;
  1458.     virtual int         operator>= (const CAsiReal &)     const;
  1459.     virtual int         operator>= (const CAsiDouble &)   const;
  1460.     virtual int         operator>= (const smallint)       const;
  1461.     virtual int         operator>= (const integer)        const;
  1462.     virtual int         operator>= (const real)           const;
  1463.     virtual int         operator>= (const int)            const;
  1464.                 
  1465.     virtual int         operator== (const CAsiSmallInt &) const;
  1466.     virtual int         operator== (const CAsiInt &)      const;
  1467.     virtual int         operator== (const CAsiNumeric &)  const;
  1468.     virtual int         operator== (const CAsiDecimal &)  const;
  1469.     virtual int         operator== (const CAsiFloat &)    const;
  1470.     virtual int         operator== (const CAsiReal &)     const;
  1471.     virtual int         operator== (const CAsiDouble &)   const;
  1472.     virtual int         operator== (const smallint)       const;
  1473.     virtual int         operator== (const integer)        const;
  1474.     virtual int         operator== (const real)           const;
  1475.     virtual int         operator== (const int)            const;
  1476.                  
  1477.     virtual int         operator<= (const CAsiSmallInt &) const;
  1478.     virtual int         operator<= (const CAsiInt &)      const;
  1479.     virtual int         operator<= (const CAsiNumeric &)  const;
  1480.     virtual int         operator<= (const CAsiDecimal &)  const;
  1481.     virtual int         operator<= (const CAsiFloat &)    const;
  1482.     virtual int         operator<= (const CAsiReal &)     const;
  1483.     virtual int         operator<= (const CAsiDouble &)   const;
  1484.     virtual int         operator<= (const smallint)       const;
  1485.     virtual int         operator<= (const integer)        const;
  1486.     virtual int         operator<= (const real)           const;
  1487.     virtual int         operator<= (const int)            const;
  1488.                  
  1489.     virtual int         operator<  (const CAsiSmallInt &) const;
  1490.     virtual int         operator<  (const CAsiInt &)      const;
  1491.     virtual int         operator<  (const CAsiNumeric &)  const;
  1492.     virtual int         operator<  (const CAsiDecimal &)  const;
  1493.     virtual int         operator<  (const CAsiFloat &)    const;
  1494.     virtual int         operator<  (const CAsiReal &)     const;
  1495.     virtual int         operator<  (const CAsiDouble &)   const;
  1496.     virtual int         operator<  (const smallint)       const;
  1497.     virtual int         operator<  (const integer)        const;
  1498.     virtual int         operator<  (const real)           const;
  1499.     virtual int         operator<  (const int)            const;
  1500.      
  1501.     virtual int         operator!= (const CAsiSmallInt &) const;
  1502.     virtual int         operator!= (const CAsiInt &)      const;
  1503.     virtual int         operator!= (const CAsiNumeric &)  const;
  1504.     virtual int         operator!= (const CAsiDecimal &)  const;
  1505.     virtual int         operator!= (const CAsiFloat &)    const;
  1506.     virtual int         operator!= (const CAsiReal &)     const;
  1507.     virtual int         operator!= (const CAsiDouble &)   const;
  1508.     virtual int         operator!= (const smallint)       const;
  1509.     virtual int         operator!= (const integer)        const;
  1510.     virtual int         operator!= (const real)           const;
  1511.     virtual int         operator!= (const int)            const;
  1512.  
  1513.  
  1514. protected:
  1515.     uint precision;
  1516.     uint scale;
  1517.  
  1518. };
  1519.  
  1520.  
  1521. ////////////////////////////////////////////////
  1522. //
  1523. //
  1524. class CAsiExactNum : public CAsiNum
  1525. //
  1526. // Exact numeric data
  1527. //
  1528. {
  1529. public:
  1530.     // Construction/destruction
  1531.     //
  1532.             CAsiExactNum ();      // Constructor
  1533.     virtual ~CAsiExactNum ();     // Destructor
  1534.  
  1535.     //  is_ functions
  1536.     //
  1537.     virtual EAsiBoolean   is_exactnumeric (void) const;
  1538.  
  1539.     // Comparision operators
  1540.     //
  1541.     virtual int         operator>  (const CAsiSmallInt &) const;
  1542.     virtual int         operator>  (const CAsiInt &)      const;
  1543.     virtual int         operator>  (const CAsiNumeric &)  const;
  1544.     virtual int         operator>  (const CAsiDecimal &)  const;
  1545.     virtual int         operator>  (const CAsiFloat &)    const;
  1546.     virtual int         operator>  (const CAsiReal &)     const;
  1547.     virtual int         operator>  (const CAsiDouble &)   const;
  1548.     virtual int         operator>  (const smallint)       const;
  1549.     virtual int         operator>  (const integer)        const;
  1550.     virtual int         operator>  (const real)           const;
  1551.     virtual int         operator>  (const int)            const;
  1552.                         
  1553.     virtual int         operator>= (const CAsiSmallInt &) const;
  1554.     virtual int         operator>= (const CAsiInt &)      const;
  1555.     virtual int         operator>= (const CAsiNumeric &)  const;
  1556.     virtual int         operator>= (const CAsiDecimal &)  const;
  1557.     virtual int         operator>= (const CAsiFloat &)    const;
  1558.     virtual int         operator>= (const CAsiReal &)     const;
  1559.     virtual int         operator>= (const CAsiDouble &)   const;
  1560.     virtual int         operator>= (const smallint)       const;
  1561.     virtual int         operator>= (const integer)        const;
  1562.     virtual int         operator>= (const real)           const;
  1563.     virtual int         operator>= (const int)            const;
  1564.                         
  1565.     virtual int         operator== (const CAsiSmallInt &) const;
  1566.     virtual int         operator== (const CAsiInt &)      const;
  1567.     virtual int         operator== (const CAsiNumeric &)  const;
  1568.     virtual int         operator== (const CAsiDecimal &)  const;
  1569.     virtual int         operator== (const CAsiFloat &)    const;
  1570.     virtual int         operator== (const CAsiReal &)     const;
  1571.     virtual int         operator== (const CAsiDouble &)   const;
  1572.     virtual int         operator== (const smallint)       const;
  1573.     virtual int         operator== (const integer)        const;
  1574.     virtual int         operator== (const real)           const;
  1575.     virtual int         operator== (const int)            const;
  1576.                         
  1577.     virtual int         operator<= (const CAsiSmallInt &) const;
  1578.     virtual int         operator<= (const CAsiInt &)      const;
  1579.     virtual int         operator<= (const CAsiNumeric &)  const;
  1580.     virtual int         operator<= (const CAsiDecimal &)  const;
  1581.     virtual int         operator<= (const CAsiFloat &)    const;
  1582.     virtual int         operator<= (const CAsiReal &)     const;
  1583.     virtual int         operator<= (const CAsiDouble &)   const;
  1584.     virtual int         operator<= (const smallint)       const;
  1585.     virtual int         operator<= (const integer)        const;
  1586.     virtual int         operator<= (const real)           const;
  1587.     virtual int         operator<= (const int)            const;
  1588.                         
  1589.     virtual int         operator<  (const CAsiSmallInt &) const;
  1590.     virtual int         operator<  (const CAsiInt &)      const;
  1591.     virtual int         operator<  (const CAsiNumeric &)  const;
  1592.     virtual int         operator<  (const CAsiDecimal &)  const;
  1593.     virtual int         operator<  (const CAsiFloat &)    const;
  1594.     virtual int         operator<  (const CAsiReal &)     const;
  1595.     virtual int         operator<  (const CAsiDouble &)   const;
  1596.     virtual int         operator<  (const smallint)       const;
  1597.     virtual int         operator<  (const integer)        const;
  1598.     virtual int         operator<  (const real)           const;
  1599.     virtual int         operator<  (const int)            const;
  1600.      
  1601.     virtual int         operator!= (const CAsiSmallInt &) const;
  1602.     virtual int         operator!= (const CAsiInt &)      const;
  1603.     virtual int         operator!= (const CAsiNumeric &)  const;
  1604.     virtual int         operator!= (const CAsiDecimal &)  const;
  1605.     virtual int         operator!= (const CAsiFloat &)    const;
  1606.     virtual int         operator!= (const CAsiReal &)     const;
  1607.     virtual int         operator!= (const CAsiDouble &)   const;
  1608.     virtual int         operator!= (const smallint)       const;
  1609.     virtual int         operator!= (const integer)        const;
  1610.     virtual int         operator!= (const real)           const;
  1611.     virtual int         operator!= (const int)            const;
  1612.  
  1613.  
  1614.  
  1615. protected:
  1616.             int         cmpeqlen(const  CAsiExactNum *)   const;
  1617.             int         cmpeqlan(const  CAsiNum *)        const;
  1618.             int         cmpeqlenC(const real)             const;
  1619.             int         cmpneqen(const  CAsiExactNum *)   const;
  1620.             int         cmpneqan(const  CAsiNum *)        const;
  1621.             int         cmpneqenC(const real)             const;
  1622.             int         cmpltren(const  CAsiExactNum *)   const;
  1623.             int         cmpltran(const  CAsiNum *)        const;
  1624.             int         cmpltrenC(const real)             const;
  1625.             int         cmplteen(const  CAsiExactNum *)   const;
  1626.             int         cmpltean(const  CAsiNum *)        const;
  1627.             int         cmplteenC(const real)             const;
  1628.             int         cmpgtren(const  CAsiExactNum *)   const;
  1629.             int         cmpgtran(const  CAsiNum *)        const;
  1630.             int         cmpgtrenC(const real)             const;
  1631.             int         cmpgteen(const  CAsiExactNum *)   const;
  1632.             int         cmpgtean(const  CAsiNum *)        const;
  1633.             int         cmpgteenC(const real)             const;
  1634.  
  1635. };
  1636.  
  1637.  
  1638.  
  1639. ////////////////////////////////////////////////
  1640. //
  1641. //
  1642. class CAsiApproxNum : public CAsiNum
  1643. //
  1644. // Approximate numeric data
  1645. //
  1646. {
  1647. public:
  1648.     // Construction/destruction
  1649.     //
  1650.             CAsiApproxNum ();     // Constructor
  1651.     virtual ~CAsiApproxNum ();    // Destructor
  1652.  
  1653.     //  is_ functions
  1654.     //
  1655.     virtual EAsiBoolean   is_approxnumeric    (void) const;
  1656.  
  1657.     // Comparision operators
  1658.     //
  1659.     virtual int         operator>  (const CAsiSmallInt &) const;
  1660.     virtual int         operator>  (const CAsiInt &)      const;
  1661.     virtual int         operator>  (const CAsiNumeric &)  const;
  1662.     virtual int         operator>  (const CAsiDecimal &)  const;
  1663.     virtual int         operator>  (const CAsiFloat &)    const;
  1664.     virtual int         operator>  (const CAsiReal &)     const;
  1665.     virtual int         operator>  (const CAsiDouble &)   const;
  1666.     virtual int         operator>  (const smallint)       const;
  1667.     virtual int         operator>  (const integer)        const;
  1668.     virtual int         operator>  (const real)           const;
  1669.     virtual int         operator>  (const int)            const;
  1670.                         
  1671.     virtual int         operator>= (const CAsiSmallInt &) const;
  1672.     virtual int         operator>= (const CAsiInt &)      const;
  1673.     virtual int         operator>= (const CAsiNumeric &)  const;
  1674.     virtual int         operator>= (const CAsiDecimal &)  const;
  1675.     virtual int         operator>= (const CAsiFloat &)    const;
  1676.     virtual int         operator>= (const CAsiReal &)     const;
  1677.     virtual int         operator>= (const CAsiDouble &)   const;
  1678.     virtual int         operator>= (const smallint)       const;
  1679.     virtual int         operator>= (const integer)        const;
  1680.     virtual int         operator>= (const real)           const;
  1681.     virtual int         operator>= (const int)            const;
  1682.                         
  1683.     virtual int         operator== (const CAsiSmallInt &) const;
  1684.     virtual int         operator== (const CAsiInt &)      const;
  1685.     virtual int         operator== (const CAsiNumeric &)  const;
  1686.     virtual int         operator== (const CAsiDecimal &)  const;
  1687.     virtual int         operator== (const CAsiFloat &)    const;
  1688.     virtual int         operator== (const CAsiReal &)     const;
  1689.     virtual int         operator== (const CAsiDouble &)   const;
  1690.     virtual int         operator== (const smallint)       const;
  1691.     virtual int         operator== (const integer)        const;
  1692.     virtual int         operator== (const real)           const;
  1693.     virtual int         operator== (const int)            const;
  1694.                         
  1695.     virtual int         operator<= (const CAsiSmallInt &) const;
  1696.     virtual int         operator<= (const CAsiInt &)      const;
  1697.     virtual int         operator<= (const CAsiNumeric &)  const;
  1698.     virtual int         operator<= (const CAsiDecimal &)  const;
  1699.     virtual int         operator<= (const CAsiFloat &)    const;
  1700.     virtual int         operator<= (const CAsiReal &)     const;
  1701.     virtual int         operator<= (const CAsiDouble &)   const;
  1702.     virtual int         operator<= (const smallint)       const;
  1703.     virtual int         operator<= (const integer)        const;
  1704.     virtual int         operator<= (const real)           const;
  1705.     virtual int         operator<= (const int)            const;
  1706.                         
  1707.     virtual int         operator<  (const CAsiSmallInt &) const;
  1708.     virtual int         operator<  (const CAsiInt &)      const;
  1709.     virtual int         operator<  (const CAsiNumeric &)  const;
  1710.     virtual int         operator<  (const CAsiDecimal &)  const;
  1711.     virtual int         operator<  (const CAsiFloat &)    const;
  1712.     virtual int         operator<  (const CAsiReal &)     const;
  1713.     virtual int         operator<  (const CAsiDouble &)   const;
  1714.     virtual int         operator<  (const smallint)       const;
  1715.     virtual int         operator<  (const integer)        const;
  1716.     virtual int         operator<  (const real)           const;
  1717.     virtual int         operator<  (const int)            const;
  1718.      
  1719.     virtual int         operator!= (const CAsiSmallInt &) const;
  1720.     virtual int         operator!= (const CAsiInt &)      const;
  1721.     virtual int         operator!= (const CAsiNumeric &)  const;
  1722.     virtual int         operator!= (const CAsiDecimal &)  const;
  1723.     virtual int         operator!= (const CAsiFloat &)    const;
  1724.     virtual int         operator!= (const CAsiReal &)     const;
  1725.     virtual int         operator!= (const CAsiDouble &)   const;
  1726.     virtual int         operator!= (const smallint)       const;
  1727.     virtual int         operator!= (const integer)        const;
  1728.     virtual int         operator!= (const real)           const;
  1729.     virtual int         operator!= (const int)            const;
  1730.  
  1731.  
  1732.  
  1733. protected:
  1734.  
  1735. };
  1736.  
  1737.  
  1738.  
  1739.  
  1740. ////////////////////////////////////////////////
  1741. //
  1742. //
  1743. class CAsiSmallInt : public CAsiExactNum
  1744. //
  1745. // SMALL INTEGER
  1746. //
  1747. {
  1748. public:
  1749.     // Construction/destruction
  1750.     //
  1751.             CAsiSmallInt (void);
  1752.             CAsiSmallInt (const CAsiSmallInt &);
  1753.     virtual ~CAsiSmallInt (void);
  1754.  
  1755.  
  1756.     //  Get data descriptor
  1757.     //
  1758.     virtual EAsiDataType Type         (void) const;
  1759.     virtual uint         ReturnLength (void) const;
  1760.  
  1761.     // Store Data value
  1762.     //
  1763.     virtual EAsiBoolean   storeValue (real) ;
  1764.     virtual EAsiBoolean   storeValue (integer) ;
  1765.     virtual EAsiBoolean   storeValue (smallint) ;
  1766.     virtual EAsiBoolean   storeValue (char *, uint) ;
  1767.     virtual EAsiBoolean   storeValue (const CAsiUcStr &) ;
  1768.     virtual EAsiBoolean   storeValue (const CAsiData &);
  1769.  
  1770.     //  Get data value 
  1771.     //
  1772.     virtual integer       intValue  (void) const;
  1773.     virtual real          realValue (void) const;
  1774.  
  1775.     virtual EAsiBoolean   getValue (real *) const;
  1776.     virtual EAsiBoolean   getValue (integer *) const;
  1777.     virtual EAsiBoolean   getValue (smallint *) const;
  1778.     virtual EAsiBoolean   getValue (char *, uint) const;
  1779.     virtual EAsiBoolean   getValue (CAsiUcStr *) const;
  1780.  
  1781.     virtual EAsiBoolean   SQLType    (CAsiUcStr *) const;        // SQL data type as string
  1782.     virtual EAsiBoolean   SQLLiteral (CAsiUcStr *) const;        // SQL compatible literal
  1783.  
  1784.  
  1785.     // ASI application/DBMS driver data exchange
  1786.     //
  1787.     virtual long          read           (char *, long, long) const;
  1788.     virtual long          size           (void) const;
  1789.  
  1790.     // Runtime class iteraction functions
  1791.     //
  1792.     virtual unsigned long packSize   (void) const;
  1793.     virtual unsigned long packTo     (void*) const;
  1794.     virtual EAsiBoolean   unpackFrom (void*);
  1795.  
  1796.     // Duplicate itself
  1797.     //
  1798.     virtual CAsiObject   *duplicate (void) const;
  1799.  
  1800.     // Operators
  1801.     //
  1802.             // Assignment
  1803.             CAsiSmallInt &operator= (const CAsiSmallInt &);
  1804.             CAsiSmallInt &operator= (const CAsiInt &);
  1805.             CAsiSmallInt &operator= (const CAsiNumeric &);
  1806.             CAsiSmallInt &operator= (const CAsiDecimal &);
  1807.             CAsiSmallInt &operator= (const CAsiFloat &);
  1808.             CAsiSmallInt &operator= (const CAsiReal &);
  1809.             CAsiSmallInt &operator= (const CAsiDouble &);
  1810.             CAsiSmallInt &operator= (const smallint);
  1811.             CAsiSmallInt &operator= (const integer);
  1812.             CAsiSmallInt &operator= (const real);
  1813.             CAsiSmallInt &operator= (const int);
  1814.  
  1815.             // Arithmetic operators
  1816.             CAsiSmallInt &operator+= (const CAsiSmallInt &);
  1817.             CAsiSmallInt &operator+= (const CAsiInt &);
  1818.             CAsiSmallInt &operator+= (const CAsiNumeric &);
  1819.             CAsiSmallInt &operator+= (const CAsiDecimal &);
  1820.             CAsiSmallInt &operator+= (const CAsiFloat &);
  1821.             CAsiSmallInt &operator+= (const CAsiReal &);
  1822.             CAsiSmallInt &operator+= (const CAsiDouble &);
  1823.             CAsiSmallInt &operator+= (const smallint);
  1824.             CAsiSmallInt &operator+= (const integer);
  1825.             CAsiSmallInt &operator+= (const real);
  1826.             CAsiSmallInt &operator+= (const int);
  1827.  
  1828.             CAsiSmallInt &operator-= (const CAsiSmallInt &);
  1829.             CAsiSmallInt &operator-= (const CAsiInt &);
  1830.             CAsiSmallInt &operator-= (const CAsiNumeric &);
  1831.             CAsiSmallInt &operator-= (const CAsiDecimal &);
  1832.             CAsiSmallInt &operator-= (const CAsiFloat &);
  1833.             CAsiSmallInt &operator-= (const CAsiReal &);
  1834.             CAsiSmallInt &operator-= (const CAsiDouble &);
  1835.             CAsiSmallInt &operator-= (const smallint);
  1836.             CAsiSmallInt &operator-= (const integer);
  1837.             CAsiSmallInt &operator-= (const real);
  1838.             CAsiSmallInt &operator-= (const int);
  1839.  
  1840.             CAsiSmallInt &operator*= (const CAsiSmallInt &);
  1841.             CAsiSmallInt &operator*= (const CAsiInt &);
  1842.             CAsiSmallInt &operator*= (const CAsiNumeric &);
  1843.             CAsiSmallInt &operator*= (const CAsiDecimal &);
  1844.             CAsiSmallInt &operator*= (const CAsiFloat &);
  1845.             CAsiSmallInt &operator*= (const CAsiReal &);
  1846.             CAsiSmallInt &operator*= (const CAsiDouble &);
  1847.             CAsiSmallInt &operator*= (const smallint);
  1848.             CAsiSmallInt &operator*= (const integer);
  1849.             CAsiSmallInt &operator*= (const real);
  1850.             CAsiSmallInt &operator*= (const int);
  1851.  
  1852.             CAsiSmallInt &operator/= (const CAsiSmallInt &);
  1853.             CAsiSmallInt &operator/= (const CAsiInt &);
  1854.             CAsiSmallInt &operator/= (const CAsiNumeric &);
  1855.             CAsiSmallInt &operator/= (const CAsiDecimal &);
  1856.             CAsiSmallInt &operator/= (const CAsiFloat &);
  1857.             CAsiSmallInt &operator/= (const CAsiReal &);
  1858.             CAsiSmallInt &operator/= (const CAsiDouble &);
  1859.             CAsiSmallInt &operator/= (const smallint);
  1860.             CAsiSmallInt &operator/= (const integer);
  1861.             CAsiSmallInt &operator/= (const real);
  1862.             CAsiSmallInt &operator/= (const int);
  1863.  
  1864.             CAsiDouble operator+ (const CAsiSmallInt &) const;
  1865.             CAsiDouble operator+ (const smallint)       const;
  1866.             CAsiDouble operator+ (const integer)        const;
  1867.             CAsiDouble operator+ (const real)           const;
  1868.             CAsiDouble operator+ (const int)            const;
  1869.      friend CAsiDouble operator+ (const smallint, const CAsiSmallInt &);
  1870.      friend CAsiDouble operator+ (const integer,  const CAsiSmallInt &);
  1871.      friend CAsiDouble operator+ (const real,     const CAsiSmallInt &);
  1872.      friend CAsiDouble operator+ (const int,      const CAsiSmallInt &);
  1873.  
  1874.             CAsiDouble operator- (const CAsiSmallInt &) const;
  1875.             CAsiDouble operator- (const smallint)       const;
  1876.             CAsiDouble operator- (const integer)        const;
  1877.             CAsiDouble operator- (const real)           const;
  1878.             CAsiDouble operator- (const int)            const;
  1879.      friend CAsiDouble operator- (const smallint, const CAsiSmallInt &);
  1880.      friend CAsiDouble operator- (const integer,  const CAsiSmallInt &);
  1881.      friend CAsiDouble operator- (const real,     const CAsiSmallInt &);
  1882.      friend CAsiDouble operator- (const int,      const CAsiSmallInt &);
  1883.  
  1884.  
  1885.             CAsiDouble operator* (const CAsiSmallInt &) const;
  1886.             CAsiDouble operator* (const smallint)       const;
  1887.             CAsiDouble operator* (const integer)        const;
  1888.             CAsiDouble operator* (const real)           const;
  1889.             CAsiDouble operator* (const int)            const;
  1890.      friend CAsiDouble operator* (const smallint, const CAsiSmallInt &);
  1891.      friend CAsiDouble operator* (const integer,  const CAsiSmallInt &);
  1892.      friend CAsiDouble operator* (const real,     const CAsiSmallInt &);
  1893.      friend CAsiDouble operator* (const int,      const CAsiSmallInt &);
  1894.  
  1895.  
  1896.  
  1897.             CAsiDouble operator/ (const CAsiSmallInt &) const;
  1898.             CAsiDouble operator/ (const smallint)  const;
  1899.             CAsiDouble operator/ (const integer)   const;
  1900.             CAsiDouble operator/ (const real)      const;
  1901.             CAsiDouble operator/ (const int)       const;
  1902.      friend CAsiDouble operator/ (const smallint, const CAsiSmallInt &);
  1903.      friend CAsiDouble operator/ (const integer,  const CAsiSmallInt &);
  1904.      friend CAsiDouble operator/ (const real,     const CAsiSmallInt &);
  1905.      friend CAsiDouble operator/ (const int,      const CAsiSmallInt &);
  1906.  
  1907.  
  1908.             CAsiSmallInt &operator-- (void);
  1909.             CAsiSmallInt &operator++ (void);
  1910.  
  1911.             CAsiSmallInt &operator-  (void);
  1912.  
  1913. private:
  1914.     smallint sivalue;
  1915. };
  1916.  
  1917.  
  1918. ////////////////////////////////////////////////
  1919. //
  1920. //
  1921. class CAsiInt : public CAsiExactNum
  1922. //
  1923. // INTEGER
  1924. //
  1925. // This class introduces functionality of the SQL INTEGER data type.
  1926. // It redefines all arithmetic and comparision operators in which 
  1927. // integer number can be involved in SQL. Memeber functions also allow 
  1928. // to set and retrieve value of the internal integer number in double and
  1929. // integer formats.
  1930. //
  1931. {
  1932. public:
  1933.             CAsiInt ();
  1934.             CAsiInt (const CAsiInt &);
  1935.     virtual ~CAsiInt ();
  1936.  
  1937.     //  Get data descriptor
  1938.     //
  1939.     virtual EAsiDataType Type         (void) const;
  1940.     virtual uint         ReturnLength (void) const;
  1941.  
  1942.     // Store Data value
  1943.     //
  1944.     virtual EAsiBoolean   storeValue (real);
  1945.     virtual EAsiBoolean   storeValue (integer);
  1946.     virtual EAsiBoolean   storeValue (smallint);
  1947.     virtual EAsiBoolean   storeValue (char *, uint);
  1948.     virtual EAsiBoolean   storeValue (const CAsiUcStr &);
  1949.     virtual EAsiBoolean   storeValue (const CAsiData &);
  1950.  
  1951.     //  Get data value
  1952.     //
  1953.     virtual integer       intValue  (void) const;
  1954.     virtual real          realValue (void) const;
  1955.  
  1956.     virtual EAsiBoolean   getValue (real *) const;
  1957.     virtual EAsiBoolean   getValue (integer *) const;
  1958.     virtual EAsiBoolean   getValue (smallint *) const;
  1959.     virtual EAsiBoolean   getValue (char *, uint) const;
  1960.     virtual EAsiBoolean   getValue (CAsiUcStr *) const;
  1961.  
  1962.     virtual EAsiBoolean   SQLType    (CAsiUcStr *) const;        // SQL data type as string
  1963.     virtual EAsiBoolean   SQLLiteral (CAsiUcStr *) const;        // SQL compatible literal
  1964.  
  1965.     // ASI application/DBMS driver data exchange
  1966.     //
  1967.     virtual long          read           (char *, long, long) const;
  1968.     virtual long          size           (void) const;
  1969.  
  1970.     // Runtime class iteraction functions
  1971.     //
  1972.     virtual unsigned long packSize   (void) const;
  1973.     virtual unsigned long packTo     (void*) const;
  1974.     virtual EAsiBoolean   unpackFrom (void*);
  1975.  
  1976.     // Duplicate itself
  1977.     //
  1978.     virtual CAsiObject   *duplicate (void) const;
  1979.  
  1980.     // Operators
  1981.     //
  1982.             // Assignment
  1983.             CAsiInt &operator= (const CAsiSmallInt &);
  1984.             CAsiInt &operator= (const CAsiInt &);
  1985.             CAsiInt &operator= (const CAsiNumeric &);
  1986.             CAsiInt &operator= (const CAsiDecimal &);
  1987.             CAsiInt &operator= (const CAsiFloat &);
  1988.             CAsiInt &operator= (const CAsiReal &);
  1989.             CAsiInt &operator= (const CAsiDouble &);
  1990.             CAsiInt &operator= (const smallint);
  1991.             CAsiInt &operator= (const integer);
  1992.             CAsiInt &operator= (const real);
  1993.             CAsiInt &operator= (const int);
  1994.  
  1995.             // Arithmetic operators
  1996.  
  1997.             CAsiInt &operator+= (const CAsiSmallInt &);
  1998.             CAsiInt &operator+= (const CAsiInt &);
  1999.             CAsiInt &operator+= (const CAsiNumeric &);
  2000.             CAsiInt &operator+= (const CAsiDecimal &);
  2001.             CAsiInt &operator+= (const CAsiFloat &);
  2002.             CAsiInt &operator+= (const CAsiReal &);
  2003.             CAsiInt &operator+= (const CAsiDouble &);
  2004.             CAsiInt &operator+= (const smallint);
  2005.             CAsiInt &operator+= (const integer);
  2006.             CAsiInt &operator+= (const real);
  2007.             CAsiInt &operator+= (const int);
  2008.  
  2009.             CAsiInt &operator-= (const CAsiSmallInt &);
  2010.             CAsiInt &operator-= (const CAsiInt &);
  2011.             CAsiInt &operator-= (const CAsiNumeric &);
  2012.             CAsiInt &operator-= (const CAsiDecimal &);
  2013.             CAsiInt &operator-= (const CAsiFloat &);
  2014.             CAsiInt &operator-= (const CAsiReal &);
  2015.             CAsiInt &operator-= (const CAsiDouble &);
  2016.             CAsiInt &operator-= (const smallint);
  2017.             CAsiInt &operator-= (const integer);
  2018.             CAsiInt &operator-= (const real);
  2019.             CAsiInt &operator-= (const int);
  2020.  
  2021.             CAsiInt &operator*= (const CAsiSmallInt &);
  2022.             CAsiInt &operator*= (const CAsiInt &);
  2023.             CAsiInt &operator*= (const CAsiNumeric &);
  2024.             CAsiInt &operator*= (const CAsiDecimal &);
  2025.             CAsiInt &operator*= (const CAsiFloat &);
  2026.             CAsiInt &operator*= (const CAsiReal &);
  2027.             CAsiInt &operator*= (const CAsiDouble &);
  2028.             CAsiInt &operator*= (const smallint);
  2029.             CAsiInt &operator*= (const integer);
  2030.             CAsiInt &operator*= (const real);
  2031.             CAsiInt &operator*= (const int);
  2032.  
  2033.             CAsiInt &operator/= (const CAsiSmallInt &);
  2034.             CAsiInt &operator/= (const CAsiInt &);
  2035.             CAsiInt &operator/= (const CAsiNumeric &);
  2036.             CAsiInt &operator/= (const CAsiDecimal &);
  2037.             CAsiInt &operator/= (const CAsiFloat &);
  2038.             CAsiInt &operator/= (const CAsiReal &);
  2039.             CAsiInt &operator/= (const CAsiDouble &);
  2040.             CAsiInt &operator/= (const smallint);
  2041.             CAsiInt &operator/= (const integer);
  2042.             CAsiInt &operator/= (const real);
  2043.             CAsiInt &operator/= (const int);
  2044.  
  2045.             CAsiDouble operator+ (const CAsiSmallInt &) const;
  2046.      friend CAsiDouble operator+ (const CAsiSmallInt &, const CAsiInt &);
  2047.             CAsiDouble operator+ (const CAsiInt &) const;
  2048.             CAsiDouble operator+ (const smallint)  const;
  2049.      friend CAsiDouble operator+ (const smallint, const CAsiInt &);
  2050.             CAsiDouble operator+ (const integer) const;
  2051.      friend CAsiDouble operator+ (const integer, const CAsiInt &);
  2052.             CAsiDouble operator+ (const real) const;
  2053.      friend CAsiDouble operator+ (const real, const CAsiInt &);
  2054.             CAsiDouble operator+ (const int) const;
  2055.      friend CAsiDouble operator+ (const int, const CAsiInt &);
  2056.  
  2057.  
  2058.             CAsiDouble operator- (const CAsiSmallInt &) const;
  2059.      friend CAsiDouble operator- (const CAsiSmallInt &, const CAsiInt &);
  2060.             CAsiDouble operator- (const CAsiInt &) const;
  2061.             CAsiDouble operator- (const smallint)  const;
  2062.      friend CAsiDouble operator- (const smallint, const CAsiInt &);
  2063.             CAsiDouble operator- (const integer) const;
  2064.      friend CAsiDouble operator- (const integer, const CAsiInt &);
  2065.             CAsiDouble operator- (const real) const;
  2066.      friend CAsiDouble operator- (const real, const CAsiInt &);
  2067.             CAsiDouble operator- (const int) const;
  2068.      friend CAsiDouble operator- (const int, const CAsiInt &);
  2069.  
  2070.             CAsiDouble operator* (const CAsiSmallInt &) const;
  2071.      friend CAsiDouble operator* (const CAsiSmallInt &, const CAsiInt &);
  2072.             CAsiDouble operator* (const CAsiInt &) const;
  2073.             CAsiDouble operator* (const smallint)  const;
  2074.      friend CAsiDouble operator* (const smallint, const CAsiInt &);
  2075.             CAsiDouble operator* (const integer) const;
  2076.      friend CAsiDouble operator* (const integer, const CAsiInt &);
  2077.             CAsiDouble operator* (const real) const;
  2078.      friend CAsiDouble operator* (const real, const CAsiInt &);
  2079.             CAsiDouble operator* (const int) const;
  2080.      friend CAsiDouble operator* (const int, const CAsiInt &);
  2081.  
  2082.             CAsiDouble operator/ (const CAsiSmallInt &) const;
  2083.      friend CAsiDouble operator/ (const CAsiSmallInt &, const CAsiInt &);
  2084.             CAsiDouble operator/ (const CAsiInt &) const;
  2085.             CAsiDouble operator/ (const smallint) const;
  2086.      friend CAsiDouble operator/ (const smallint, const CAsiInt &);
  2087.             CAsiDouble operator/ (const integer) const;
  2088.      friend CAsiDouble operator/ (const integer, const CAsiInt &);
  2089.             CAsiDouble operator/ (const real) const;
  2090.      friend CAsiDouble operator/ (const real, const CAsiInt &);
  2091.             CAsiDouble operator/ (const int) const;
  2092.      friend CAsiDouble operator/ (const int, const CAsiInt &);
  2093.  
  2094.             CAsiInt &operator-- (void);
  2095.             CAsiInt &operator++ (void);
  2096.  
  2097.             CAsiInt &operator-  (void);
  2098.  
  2099. private:
  2100.     integer ivalue;
  2101. };
  2102.  
  2103.  
  2104. ////////////////////////////////////////////////
  2105. //
  2106. //
  2107. class CAsiNumeric: public CAsiExactNum
  2108. //
  2109. // NUMERIC
  2110. //
  2111. {
  2112. private:
  2113.     //  private helper
  2114.             EAsiBoolean SetNumeric (real);
  2115. //
  2116. public:
  2117.             CAsiNumeric (uint, uint);
  2118.             CAsiNumeric (uint);
  2119.             CAsiNumeric (const CAsiNumeric &);
  2120.             CAsiNumeric (void);
  2121.     virtual ~CAsiNumeric (void);
  2122.  
  2123.     //  Get data descriptor
  2124.     //
  2125.     virtual EAsiDataType Type      (void) const;
  2126.     virtual uint         ReturnLength (void) const;
  2127.  
  2128.     // Store Data value
  2129.     //
  2130.     virtual EAsiBoolean   storeValue (real);
  2131.     virtual EAsiBoolean   storeValue (integer);
  2132.     virtual EAsiBoolean   storeValue (smallint);
  2133.     virtual EAsiBoolean   storeValue (char *, uint);
  2134.     virtual EAsiBoolean   storeValue (const CAsiUcStr &);
  2135.     virtual EAsiBoolean   storeValue (const CAsiData &);
  2136.  
  2137.     virtual EAsiBoolean   SQLType    (CAsiUcStr *) const;        // SQL data type as string
  2138.     virtual EAsiBoolean   SQLLiteral (CAsiUcStr *) const;        // SQL compatible literal
  2139.  
  2140.     //  Get data value
  2141.     //
  2142.     virtual integer       intValue  (void) const;
  2143.     virtual real          realValue (void) const;
  2144.  
  2145.     virtual EAsiBoolean   getValue (real *) const;
  2146.     virtual EAsiBoolean   getValue (integer *) const;
  2147.     virtual EAsiBoolean   getValue (smallint *) const;
  2148.     virtual EAsiBoolean   getValue (char *, uint) const;
  2149.     virtual EAsiBoolean   getValue (CAsiUcStr *) const;
  2150.  
  2151.     // ASI application/DBMS driver data exchange
  2152.     //
  2153.     virtual long          read           (char *, long, long) const;
  2154.     virtual long          size           (void) const;
  2155.  
  2156.     // Runtime class iteraction functions
  2157.     //
  2158.     virtual unsigned long packSize   (void) const;
  2159.     virtual unsigned long packTo     (void*) const;
  2160.     virtual EAsiBoolean   unpackFrom (void*);
  2161.  
  2162.     // Duplicate itself
  2163.     //
  2164.     virtual CAsiObject     *duplicate (void) const;
  2165.  
  2166.     // Operators
  2167.     //
  2168.             // Assignment
  2169.             CAsiNumeric &operator= (const CAsiSmallInt &);
  2170.             CAsiNumeric &operator= (const CAsiInt &);
  2171.             CAsiNumeric &operator= (const CAsiNumeric &);
  2172.             CAsiNumeric &operator= (const CAsiDecimal &);
  2173.             CAsiNumeric &operator= (const CAsiFloat &);
  2174.             CAsiNumeric &operator= (const CAsiReal &);
  2175.             CAsiNumeric &operator= (const CAsiDouble &);
  2176.             CAsiNumeric &operator= (const smallint);
  2177.             CAsiNumeric &operator= (const integer);
  2178.             CAsiNumeric &operator= (const real);
  2179.             CAsiNumeric &operator= (const int);
  2180.  
  2181.             // Arithmetic operators
  2182.  
  2183.             CAsiNumeric &operator+= (const CAsiSmallInt &);
  2184.             CAsiNumeric &operator+= (const CAsiInt &);
  2185.             CAsiNumeric &operator+= (const CAsiNumeric &);
  2186.             CAsiNumeric &operator+= (const CAsiDecimal &);
  2187.             CAsiNumeric &operator+= (const CAsiFloat &);
  2188.             CAsiNumeric &operator+= (const CAsiReal &);
  2189.             CAsiNumeric &operator+= (const CAsiDouble &);
  2190.             CAsiNumeric &operator+= (const smallint);
  2191.             CAsiNumeric &operator+= (const integer);
  2192.             CAsiNumeric &operator+= (const real);
  2193.             CAsiNumeric &operator+= (const int);
  2194.  
  2195.             CAsiNumeric &operator-= (const CAsiSmallInt &);
  2196.             CAsiNumeric &operator-= (const CAsiInt &);
  2197.             CAsiNumeric &operator-= (const CAsiNumeric &);
  2198.             CAsiNumeric &operator-= (const CAsiDecimal &);
  2199.             CAsiNumeric &operator-= (const CAsiFloat &);
  2200.             CAsiNumeric &operator-= (const CAsiReal &);
  2201.             CAsiNumeric &operator-= (const CAsiDouble &);
  2202.             CAsiNumeric &operator-= (const smallint);
  2203.             CAsiNumeric &operator-= (const integer);
  2204.             CAsiNumeric &operator-= (const real);
  2205.             CAsiNumeric &operator-= (const int);
  2206.  
  2207.             CAsiNumeric &operator*= (const CAsiSmallInt &);
  2208.             CAsiNumeric &operator*= (const CAsiInt &);
  2209.             CAsiNumeric &operator*= (const CAsiNumeric &);
  2210.             CAsiNumeric &operator*= (const CAsiDecimal &);
  2211.             CAsiNumeric &operator*= (const CAsiFloat &);
  2212.             CAsiNumeric &operator*= (const CAsiReal &);
  2213.             CAsiNumeric &operator*= (const CAsiDouble &);
  2214.             CAsiNumeric &operator*= (const smallint);
  2215.             CAsiNumeric &operator*= (const integer);
  2216.             CAsiNumeric &operator*= (const real);
  2217.             CAsiNumeric &operator*= (const int);
  2218.  
  2219.             CAsiNumeric &operator/= (const CAsiSmallInt &);
  2220.             CAsiNumeric &operator/= (const CAsiInt &);
  2221.             CAsiNumeric &operator/= (const CAsiNumeric &);
  2222.             CAsiNumeric &operator/= (const CAsiDecimal &);
  2223.             CAsiNumeric &operator/= (const CAsiFloat &);
  2224.             CAsiNumeric &operator/= (const CAsiReal &);
  2225.             CAsiNumeric &operator/= (const CAsiDouble &);
  2226.             CAsiNumeric &operator/= (const smallint);
  2227.             CAsiNumeric &operator/= (const integer);
  2228.             CAsiNumeric &operator/= (const real);
  2229.             CAsiNumeric &operator/= (const int);
  2230.  
  2231.             CAsiDouble operator+ (const CAsiSmallInt &) const;
  2232.             CAsiDouble operator+ (const CAsiInt &)      const;
  2233.             CAsiDouble operator+ (const CAsiNumeric &)  const;
  2234.      friend CAsiDouble operator+ (const CAsiSmallInt &, const CAsiNumeric &);
  2235.      friend CAsiDouble operator+ (const CAsiInt &, const CAsiNumeric &);
  2236.             CAsiDouble operator+ (const smallint) const;
  2237.             CAsiDouble operator+ (const integer)  const;
  2238.             CAsiDouble operator+ (const real)     const;
  2239.             CAsiDouble operator+ (const int)      const;
  2240.      friend CAsiDouble operator+ (const smallint, const CAsiNumeric &);
  2241.      friend CAsiDouble operator+ (const integer, const CAsiNumeric &);
  2242.      friend CAsiDouble operator+ (const real, const CAsiNumeric &);
  2243.      friend CAsiDouble operator+ (const int, const CAsiNumeric &);
  2244.  
  2245.             CAsiDouble operator- (const CAsiSmallInt &) const;
  2246.             CAsiDouble operator- (const CAsiInt &)      const;
  2247.             CAsiDouble operator- (const CAsiNumeric &)  const;
  2248.      friend CAsiDouble operator- (const CAsiSmallInt &, const CAsiNumeric &);
  2249.      friend CAsiDouble operator- (const CAsiInt &, const CAsiNumeric &);
  2250.             CAsiDouble operator- (const smallint) const;
  2251.             CAsiDouble operator- (const integer)  const;
  2252.             CAsiDouble operator- (const real)     const;
  2253.             CAsiDouble operator- (const int)      const;
  2254.      friend CAsiDouble operator- (const smallint, const CAsiNumeric &);
  2255.      friend CAsiDouble operator- (const integer, const CAsiNumeric &);
  2256.      friend CAsiDouble operator- (const real, const CAsiNumeric &);
  2257.      friend CAsiDouble operator- (const int, const CAsiNumeric &) ;
  2258.  
  2259.             CAsiDouble operator* (const CAsiSmallInt &) const;
  2260.             CAsiDouble operator* (const CAsiInt &)      const;
  2261.             CAsiDouble operator* (const CAsiNumeric &)  const;
  2262.      friend CAsiDouble operator* (const CAsiSmallInt &, const CAsiNumeric &);
  2263.      friend CAsiDouble operator* (const CAsiInt &, const CAsiNumeric &);
  2264.             CAsiDouble operator* (const smallint) const;
  2265.             CAsiDouble operator* (const integer)  const;
  2266.             CAsiDouble operator* (const real)     const;
  2267.             CAsiDouble operator* (const int)      const;
  2268.      friend CAsiDouble operator* (const smallint, const CAsiNumeric &);
  2269.      friend CAsiDouble operator* (const integer, const CAsiNumeric &) ;
  2270.      friend CAsiDouble operator* (const real, const CAsiNumeric &)    ;
  2271.      friend CAsiDouble operator* (const int, const CAsiNumeric &)     ;
  2272.  
  2273.             CAsiDouble operator/ (const CAsiSmallInt &) const;
  2274.             CAsiDouble operator/ (const CAsiInt &)      const;
  2275.             CAsiDouble operator/ (const CAsiNumeric &)  const;
  2276.      friend CAsiDouble operator/ (const CAsiSmallInt &, const CAsiNumeric &);
  2277.      friend CAsiDouble operator/ (const CAsiInt &, const CAsiNumeric &)     ;
  2278.             CAsiDouble operator/ (const smallint) const;
  2279.             CAsiDouble operator/ (const integer)  const;
  2280.             CAsiDouble operator/ (const real)     const;
  2281.             CAsiDouble operator/ (const int)      const;
  2282.      friend CAsiDouble operator/ (const smallint, const CAsiNumeric &);
  2283.      friend CAsiDouble operator/ (const integer, const CAsiNumeric &) ;
  2284.      friend CAsiDouble operator/ (const real, const CAsiNumeric &)    ;
  2285.      friend CAsiDouble operator/ (const int, const CAsiNumeric &)     ;
  2286.  
  2287.             CAsiNumeric &operator++ (void);
  2288.             CAsiNumeric &operator-- (void);
  2289.  
  2290.             CAsiNumeric &operator- (void);
  2291.  
  2292. private:
  2293.     real nvalue;
  2294. };
  2295.  
  2296.  
  2297. ////////////////////////////////////////////////
  2298. //
  2299. //
  2300. class CAsiDecimal: public CAsiExactNum
  2301. //
  2302. // DECIMAL
  2303. //
  2304. {
  2305. private:
  2306.     //  private helper
  2307.             EAsiBoolean SetDecimal (real);
  2308.  
  2309. public:
  2310.             CAsiDecimal (uint, uint);
  2311.             CAsiDecimal (uint);
  2312.             CAsiDecimal (const CAsiDecimal &);
  2313.             CAsiDecimal ();
  2314.     virtual ~CAsiDecimal ();
  2315.  
  2316.     //  Get data descriptor
  2317.     //
  2318.     virtual EAsiDataType Type      (void) const;
  2319.     virtual uint         ReturnLength (void) const;
  2320.  
  2321.     // Store Data value
  2322.     //
  2323.     virtual EAsiBoolean   storeValue (real);
  2324.     virtual EAsiBoolean   storeValue (integer);
  2325.     virtual EAsiBoolean   storeValue (smallint);
  2326.     virtual EAsiBoolean   storeValue (char *, uint);
  2327.     virtual EAsiBoolean   storeValue (const CAsiUcStr &);
  2328.     virtual EAsiBoolean   storeValue (const CAsiData &);
  2329.  
  2330.     virtual EAsiBoolean   SQLType    (CAsiUcStr *) const;        // SQL data type as string
  2331.     virtual EAsiBoolean   SQLLiteral (CAsiUcStr *) const;        // SQL compatible literal
  2332.  
  2333.     //  Get data value 
  2334.     //
  2335.     virtual integer       intValue  (void) const;
  2336.     virtual real          realValue (void) const;
  2337.  
  2338.     virtual EAsiBoolean   getValue (real *) const;
  2339.     virtual EAsiBoolean   getValue (integer *) const;
  2340.     virtual EAsiBoolean   getValue (smallint *) const;
  2341.     virtual EAsiBoolean   getValue (char *, uint) const;
  2342.     virtual EAsiBoolean   getValue (CAsiUcStr *) const;
  2343.  
  2344.     // ASI application/DBMS driver data exchange
  2345.     //
  2346.     virtual long          read           (char *, long, long) const;
  2347.     virtual long          size           (void) const;
  2348.  
  2349.     // Runtime class iteraction functions
  2350.     //
  2351.     virtual unsigned long packSize   (void) const;
  2352.     virtual unsigned long packTo     (void*) const;
  2353.     virtual EAsiBoolean   unpackFrom (void*);
  2354.  
  2355.     // Duplicate itself
  2356.     //
  2357.     virtual CAsiObject   *duplicate (void) const;
  2358.  
  2359.     // Operators
  2360.     //
  2361.             // Assignment
  2362.             CAsiDecimal &operator= (const CAsiSmallInt &);
  2363.             CAsiDecimal &operator= (const CAsiInt &);
  2364.             CAsiDecimal &operator= (const CAsiNumeric &);
  2365.             CAsiDecimal &operator= (const CAsiDecimal &);
  2366.             CAsiDecimal &operator= (const CAsiFloat &);
  2367.             CAsiDecimal &operator= (const CAsiReal &);
  2368.             CAsiDecimal &operator= (const CAsiDouble &);
  2369.             CAsiDecimal &operator= (const smallint);
  2370.             CAsiDecimal &operator= (const integer);
  2371.             CAsiDecimal &operator= (const real);
  2372.             CAsiDecimal &operator= (const int);
  2373.  
  2374.             // Arithmetic operators
  2375.  
  2376.             CAsiDecimal &operator+= (const CAsiSmallInt &);
  2377.             CAsiDecimal &operator+= (const CAsiInt &);
  2378.             CAsiDecimal &operator+= (const CAsiNumeric &);
  2379.             CAsiDecimal &operator+= (const CAsiDecimal &);
  2380.             CAsiDecimal &operator+= (const CAsiFloat &);
  2381.             CAsiDecimal &operator+= (const CAsiReal &);
  2382.             CAsiDecimal &operator+= (const CAsiDouble &);
  2383.             CAsiDecimal &operator+= (const smallint);
  2384.             CAsiDecimal &operator+= (const integer);
  2385.             CAsiDecimal &operator+= (const real);
  2386.             CAsiDecimal &operator+= (const int);
  2387.  
  2388.             CAsiDecimal &operator-= (const CAsiSmallInt &);
  2389.             CAsiDecimal &operator-= (const CAsiInt &);
  2390.             CAsiDecimal &operator-= (const CAsiNumeric &);
  2391.             CAsiDecimal &operator-= (const CAsiDecimal &);
  2392.             CAsiDecimal &operator-= (const CAsiFloat &);
  2393.             CAsiDecimal &operator-= (const CAsiReal &);
  2394.             CAsiDecimal &operator-= (const CAsiDouble &);
  2395.             CAsiDecimal &operator-= (const smallint);
  2396.             CAsiDecimal &operator-= (const integer);
  2397.             CAsiDecimal &operator-= (const real);
  2398.             CAsiDecimal &operator-= (const int);
  2399.  
  2400.             CAsiDecimal &operator*= (const CAsiSmallInt &);
  2401.             CAsiDecimal &operator*= (const CAsiInt &);
  2402.             CAsiDecimal &operator*= (const CAsiNumeric &);
  2403.             CAsiDecimal &operator*= (const CAsiDecimal &);
  2404.             CAsiDecimal &operator*= (const CAsiFloat &);
  2405.             CAsiDecimal &operator*= (const CAsiReal &);
  2406.             CAsiDecimal &operator*= (const CAsiDouble &);
  2407.             CAsiDecimal &operator*= (const smallint);
  2408.             CAsiDecimal &operator*= (const integer);
  2409.             CAsiDecimal &operator*= (const real);
  2410.             CAsiDecimal &operator*= (const int);
  2411.  
  2412.             CAsiDecimal &operator/= (const CAsiSmallInt &);
  2413.             CAsiDecimal &operator/= (const CAsiInt &);
  2414.             CAsiDecimal &operator/= (const CAsiNumeric &);
  2415.             CAsiDecimal &operator/= (const CAsiDecimal &);
  2416.             CAsiDecimal &operator/= (const CAsiFloat &);
  2417.             CAsiDecimal &operator/= (const CAsiReal &);
  2418.             CAsiDecimal &operator/= (const CAsiDouble &);
  2419.             CAsiDecimal &operator/= (const smallint);
  2420.             CAsiDecimal &operator/= (const integer);
  2421.             CAsiDecimal &operator/= (const real);
  2422.             CAsiDecimal &operator/= (const int);
  2423.  
  2424.             CAsiDouble operator+ (const CAsiSmallInt &) const;
  2425.             CAsiDouble operator+ (const CAsiInt &)      const;
  2426.             CAsiDouble operator+ (const CAsiNumeric &)  const;
  2427.             CAsiDouble operator+ (const CAsiDecimal &)  const;
  2428.      friend CAsiDouble operator+ (const CAsiSmallInt &, const CAsiDecimal &);
  2429.      friend CAsiDouble operator+ (const CAsiInt &, const CAsiDecimal &)     ;
  2430.      friend CAsiDouble operator+ (const CAsiNumeric &, const CAsiDecimal &) ;
  2431.             CAsiDouble operator+ (const smallint) const;
  2432.             CAsiDouble operator+ (const integer)  const;
  2433.             CAsiDouble operator+ (const real)     const;
  2434.      friend CAsiDouble operator+ (const smallint, const CAsiDecimal &);
  2435.      friend CAsiDouble operator+ (const integer, const CAsiDecimal &) ;
  2436.      friend CAsiDouble operator+ (const real, const CAsiDecimal &)    ;
  2437.             CAsiDouble operator+ (const int) const;
  2438.      friend CAsiDouble operator+ (const int, const CAsiDecimal &);
  2439.  
  2440.  
  2441.             CAsiDouble operator- (const CAsiSmallInt &) const;
  2442.             CAsiDouble operator- (const CAsiInt &)      const;
  2443.             CAsiDouble operator- (const CAsiNumeric &)  const;
  2444.             CAsiDouble operator- (const CAsiDecimal &)  const;
  2445.      friend CAsiDouble operator- (const CAsiSmallInt &, const CAsiDecimal &);
  2446.      friend CAsiDouble operator- (const CAsiInt &, const CAsiDecimal &);
  2447.      friend CAsiDouble operator- (const CAsiNumeric &, const CAsiDecimal &);
  2448.             CAsiDouble operator- (const smallint) const;
  2449.             CAsiDouble operator- (const integer)  const;
  2450.             CAsiDouble operator- (const real)     const;
  2451.      friend CAsiDouble operator- (const smallint, const CAsiDecimal &);
  2452.      friend CAsiDouble operator- (const integer, const CAsiDecimal &) ;
  2453.      friend CAsiDouble operator- (const real, const CAsiDecimal &)    ;
  2454.             CAsiDouble operator- (const int) const;
  2455.      friend CAsiDouble operator- (const int, const CAsiDecimal &);
  2456.  
  2457.             CAsiDouble operator* (const CAsiSmallInt &) const;
  2458.             CAsiDouble operator* (const CAsiInt &)      const;
  2459.             CAsiDouble operator* (const CAsiNumeric &)  const;
  2460.             CAsiDouble operator* (const CAsiDecimal &)  const;
  2461.      friend CAsiDouble operator* (const CAsiSmallInt &, const CAsiDecimal &);
  2462.      friend CAsiDouble operator* (const CAsiInt &, const CAsiDecimal &)     ;
  2463.      friend CAsiDouble operator* (const CAsiNumeric &, const CAsiDecimal &) ;
  2464.             CAsiDouble operator* (const smallint) const;
  2465.             CAsiDouble operator* (const integer)  const;
  2466.             CAsiDouble operator* (const real)     const;
  2467.      friend CAsiDouble operator* (const smallint, const CAsiDecimal &);
  2468.      friend CAsiDouble operator* (const integer, const CAsiDecimal &) ;
  2469.      friend CAsiDouble operator* (const real, const CAsiDecimal &)    ;
  2470.             CAsiDouble operator* (const int)                          ;
  2471.      friend CAsiDouble operator* (const int, const CAsiDecimal &)     ;
  2472.  
  2473.             CAsiDouble operator/ (const CAsiSmallInt &) const;
  2474.             CAsiDouble operator/ (const CAsiInt &)      const;
  2475.             CAsiDouble operator/ (const CAsiNumeric &)  const;
  2476.             CAsiDouble operator/ (const CAsiDecimal &)  const;
  2477.      friend CAsiDouble operator/ (const CAsiSmallInt &, const CAsiDecimal &);
  2478.      friend CAsiDouble operator/ (const CAsiInt &, const CAsiDecimal &);
  2479.      friend CAsiDouble operator/ (const CAsiNumeric &, const CAsiDecimal &);
  2480.             CAsiDouble operator/ (const smallint) const;
  2481.             CAsiDouble operator/ (const integer)  const;
  2482.             CAsiDouble operator/ (const real)     const;
  2483.      friend CAsiDouble operator/ (const smallint, const CAsiDecimal &);
  2484.      friend CAsiDouble operator/ (const integer, const CAsiDecimal &) ;
  2485.      friend CAsiDouble operator/ (const real, const CAsiDecimal &)    ;
  2486.             CAsiDouble operator/ (const int) const;
  2487.      friend CAsiDouble operator/ (const int, const CAsiDecimal &);
  2488.  
  2489.             CAsiDecimal &operator++ (void);
  2490.             CAsiDecimal &operator-- (void);
  2491.             CAsiDecimal &operator- (void);
  2492.  
  2493. private:
  2494.     real dvalue;
  2495. };
  2496.  
  2497.  
  2498. ////////////////////////////////////////////////
  2499. //
  2500. //
  2501. class CAsiFloat: public CAsiApproxNum
  2502. //
  2503. // FLOAT
  2504. //
  2505. {
  2506. public:
  2507.             CAsiFloat (void);
  2508.             CAsiFloat (uint);
  2509.             CAsiFloat (const CAsiFloat &);
  2510.     virtual ~CAsiFloat (void);
  2511.  
  2512.     //  Get data descriptor
  2513.     //
  2514.     virtual EAsiDataType Type         (void) const;
  2515.     virtual uint         ReturnLength (void) const;
  2516.  
  2517.     // Store Data value
  2518.     //
  2519.     virtual EAsiBoolean   storeValue (real);
  2520.     virtual EAsiBoolean   storeValue (integer);
  2521.     virtual EAsiBoolean   storeValue (smallint);
  2522.     virtual EAsiBoolean   storeValue (char *, uint);
  2523.     virtual EAsiBoolean   storeValue (const CAsiUcStr &);
  2524.     virtual EAsiBoolean   storeValue (const CAsiData &);
  2525.  
  2526.     virtual EAsiBoolean   SQLType    (CAsiUcStr *) const;        // SQL data type as string
  2527.     virtual EAsiBoolean   SQLLiteral (CAsiUcStr *) const;        // SQL compatible literal
  2528.  
  2529.     //  Get data value
  2530.     //
  2531.     virtual integer       intValue  (void) const;
  2532.     virtual real          realValue (void) const;
  2533.  
  2534.     virtual EAsiBoolean   getValue (real *) const;
  2535.     virtual EAsiBoolean   getValue (integer *) const;
  2536.     virtual EAsiBoolean   getValue (smallint *) const;
  2537.     virtual EAsiBoolean   getValue (char *, uint) const;
  2538.     virtual EAsiBoolean   getValue (CAsiUcStr *) const;
  2539.  
  2540.     // ASI application/DBMS driver data exchange
  2541.     //
  2542.     virtual long          read           (char *, long, long) const;
  2543.     virtual long          size           (void) const;
  2544.  
  2545.     // Runtime class iteraction functions
  2546.     //
  2547.     virtual unsigned long packSize   (void) const;
  2548.     virtual unsigned long packTo     (void*) const;
  2549.     virtual EAsiBoolean   unpackFrom (void*);
  2550.  
  2551.     // Duplicate itself
  2552.     //
  2553.     virtual CAsiObject   *duplicate (void) const;
  2554.  
  2555.     // Operators
  2556.     //
  2557.             // Assignment
  2558.             CAsiFloat &operator= (const CAsiSmallInt &);
  2559.             CAsiFloat &operator= (const CAsiInt &);
  2560.             CAsiFloat &operator= (const CAsiNumeric &);
  2561.             CAsiFloat &operator= (const CAsiDecimal &);
  2562.             CAsiFloat &operator= (const CAsiFloat &);
  2563.             CAsiFloat &operator= (const CAsiReal &);
  2564.             CAsiFloat &operator= (const CAsiDouble &);
  2565.             CAsiFloat &operator= (const smallint);
  2566.             CAsiFloat &operator= (const integer);
  2567.             CAsiFloat &operator= (const real);
  2568.             CAsiFloat &operator= (const int);
  2569.  
  2570.             // Arithmetic operators
  2571.             CAsiFloat &operator+= (const CAsiSmallInt &);
  2572.             CAsiFloat &operator+= (const CAsiInt &);
  2573.             CAsiFloat &operator+= (const CAsiNumeric &);
  2574.             CAsiFloat &operator+= (const CAsiDecimal &);
  2575.             CAsiFloat &operator+= (const CAsiFloat &);
  2576.             CAsiFloat &operator+= (const CAsiReal &);
  2577.             CAsiFloat &operator+= (const CAsiDouble &);
  2578.             CAsiFloat &operator+= (const smallint);
  2579.             CAsiFloat &operator+= (const integer);
  2580.             CAsiFloat &operator+= (const real);
  2581.             CAsiFloat &operator+= (const int);
  2582.  
  2583.             CAsiFloat &operator-= (const CAsiSmallInt &);
  2584.             CAsiFloat &operator-= (const CAsiInt &);
  2585.             CAsiFloat &operator-= (const CAsiNumeric &);
  2586.             CAsiFloat &operator-= (const CAsiDecimal &);
  2587.             CAsiFloat &operator-= (const CAsiFloat &);
  2588.             CAsiFloat &operator-= (const CAsiReal &);
  2589.             CAsiFloat &operator-= (const CAsiDouble &);
  2590.             CAsiFloat &operator-= (const smallint);
  2591.             CAsiFloat &operator-= (const integer);
  2592.             CAsiFloat &operator-= (const real);
  2593.             CAsiFloat &operator-= (const int);
  2594.  
  2595.             CAsiFloat &operator*= (const CAsiSmallInt &);
  2596.             CAsiFloat &operator*= (const CAsiInt &);
  2597.             CAsiFloat &operator*= (const CAsiNumeric &);
  2598.             CAsiFloat &operator*= (const CAsiDecimal &);
  2599.             CAsiFloat &operator*= (const CAsiFloat &);
  2600.             CAsiFloat &operator*= (const CAsiReal &);
  2601.             CAsiFloat &operator*= (const CAsiDouble &);
  2602.             CAsiFloat &operator*= (const smallint);
  2603.             CAsiFloat &operator*= (const integer);
  2604.             CAsiFloat &operator*= (const real);
  2605.             CAsiFloat &operator*= (const int);
  2606.  
  2607.             CAsiFloat &operator/= (const CAsiSmallInt &);
  2608.             CAsiFloat &operator/= (const CAsiInt &);
  2609.             CAsiFloat &operator/= (const CAsiNumeric &);
  2610.             CAsiFloat &operator/= (const CAsiDecimal &);
  2611.             CAsiFloat &operator/= (const CAsiFloat &);
  2612.             CAsiFloat &operator/= (const CAsiReal &);
  2613.             CAsiFloat &operator/= (const CAsiDouble &);
  2614.             CAsiFloat &operator/= (const smallint);
  2615.             CAsiFloat &operator/= (const integer);
  2616.             CAsiFloat &operator/= (const real);
  2617.             CAsiFloat &operator/= (const int);
  2618.  
  2619.             CAsiFloat operator+ (const CAsiSmallInt &) const;
  2620.             CAsiFloat operator+ (const CAsiInt &)      const;
  2621.             CAsiFloat operator+ (const CAsiNumeric &)  const;
  2622.             CAsiFloat operator+ (const CAsiDecimal &)  const;
  2623.             CAsiFloat operator+ (const CAsiFloat &)    const;
  2624.      friend CAsiFloat operator+ (const CAsiSmallInt &, const CAsiFloat &);
  2625.      friend CAsiFloat operator+ (const CAsiInt &, const CAsiFloat &)     ;
  2626.      friend CAsiFloat operator+ (const CAsiNumeric &, const CAsiFloat &) ;
  2627.      friend CAsiFloat operator+ (const CAsiDecimal &, const CAsiFloat &) ;
  2628.             CAsiFloat operator+ (const smallint) const;
  2629.             CAsiFloat operator+ (const integer)  const;
  2630.             CAsiFloat operator+ (const real)     const;
  2631.      friend CAsiFloat operator+ (const smallint, const CAsiFloat &);
  2632.      friend CAsiFloat operator+ (const integer, const CAsiFloat &) ;
  2633.      friend CAsiFloat operator+ (const real, const CAsiFloat &)    ;
  2634.             CAsiFloat operator+ (const int) const;
  2635.      friend CAsiFloat operator+ (const int, const CAsiFloat &);
  2636.  
  2637.             CAsiFloat operator- (const CAsiSmallInt &) const;
  2638.             CAsiFloat operator- (const CAsiInt &)      const;
  2639.             CAsiFloat operator- (const CAsiNumeric &)  const;
  2640.             CAsiFloat operator- (const CAsiDecimal &)  const;
  2641.             CAsiFloat operator- (const CAsiFloat &)    const;
  2642.      friend CAsiFloat operator- (const CAsiSmallInt &, const CAsiFloat &);
  2643.      friend CAsiFloat operator- (const CAsiInt &, const CAsiFloat &);
  2644.      friend CAsiFloat operator- (const CAsiNumeric &, const CAsiFloat &);
  2645.      friend CAsiFloat operator- (const CAsiDecimal &, const CAsiFloat &);
  2646.             CAsiFloat operator- (const smallint) const;
  2647.             CAsiFloat operator- (const integer)  const;
  2648.             CAsiFloat operator- (const real)     const;
  2649.      friend CAsiFloat operator- (const smallint, const CAsiFloat &);
  2650.      friend CAsiFloat operator- (const integer, const CAsiFloat &);
  2651.      friend CAsiFloat operator- (const real, const CAsiFloat &);
  2652.             CAsiFloat operator- (const int) const;
  2653.      friend CAsiFloat operator- (const int, const CAsiFloat &);
  2654.  
  2655.             CAsiFloat operator* (const CAsiSmallInt &) const;
  2656.             CAsiFloat operator* (const CAsiInt &)      const;
  2657.             CAsiFloat operator* (const CAsiNumeric &)  const;
  2658.             CAsiFloat operator* (const CAsiDecimal &)  const;
  2659.             CAsiFloat operator* (const CAsiFloat &)    const;
  2660.      friend CAsiFloat operator* (const CAsiSmallInt &, const CAsiFloat &);
  2661.      friend CAsiFloat operator* (const CAsiInt &, const CAsiFloat &);
  2662.      friend CAsiFloat operator* (const CAsiNumeric &, const CAsiFloat &);
  2663.      friend CAsiFloat operator* (const CAsiDecimal &, const CAsiFloat &);
  2664.             CAsiFloat operator* (const smallint) const;
  2665.             CAsiFloat operator* (const integer)  const;
  2666.             CAsiFloat operator* (const real)     const;
  2667.      friend CAsiFloat operator* (const smallint, const CAsiFloat &);
  2668.      friend CAsiFloat operator* (const integer, const CAsiFloat &);
  2669.      friend CAsiFloat operator* (const real, const CAsiFloat &);
  2670.             CAsiFloat operator* (const int) const;
  2671.      friend CAsiFloat operator* (const int, const CAsiFloat &);
  2672.  
  2673.             CAsiFloat operator/ (const CAsiSmallInt &) const;
  2674.             CAsiFloat operator/ (const CAsiInt &)      const;
  2675.             CAsiFloat operator/ (const CAsiNumeric &)  const;
  2676.             CAsiFloat operator/ (const CAsiDecimal &)  const;
  2677.             CAsiFloat operator/ (const CAsiFloat &)    const;
  2678.      friend CAsiFloat operator/ (const CAsiSmallInt &, const CAsiFloat &);
  2679.      friend CAsiFloat operator/ (const CAsiInt &, const CAsiFloat &);
  2680.      friend CAsiFloat operator/ (const CAsiNumeric &, const CAsiFloat &);
  2681.      friend CAsiFloat operator/ (const CAsiDecimal &, const CAsiFloat &);
  2682.             CAsiFloat operator/ (const smallint) const;
  2683.             CAsiFloat operator/ (const integer)  const;
  2684.             CAsiFloat operator/ (const real)     const;
  2685.      friend CAsiFloat operator/ (const smallint, const CAsiFloat &);
  2686.      friend CAsiFloat operator/ (const integer, const CAsiFloat &);
  2687.      friend CAsiFloat operator/ (const real, const CAsiFloat &)   ;
  2688.             CAsiFloat operator/ (const int) const;
  2689.      friend CAsiFloat operator/ (const int, const CAsiFloat &);
  2690.  
  2691.             CAsiFloat &operator++ (void);
  2692.             CAsiFloat &operator-- (void);
  2693.             CAsiFloat &operator- (void);
  2694.  
  2695. private:
  2696.     real fvalue;
  2697. };
  2698.  
  2699.  
  2700.  
  2701. ////////////////////////////////////////////////
  2702. //
  2703. //
  2704. class CAsiReal: public CAsiApproxNum
  2705. //
  2706. // REAL
  2707. //
  2708. // This class introduces functionality of the SQL REAL data.
  2709. // It redefines all arithmetic and comparision operators in which 
  2710. // real number can be involved in SQL. Memeber functions also allow 
  2711. // to set and retrieve value of the internal real number in double and
  2712. // integer formats.
  2713.  
  2714. {
  2715. public:
  2716.             CAsiReal (void);
  2717.             CAsiReal (const CAsiReal &);
  2718.     virtual ~CAsiReal (void);
  2719.  
  2720.     //  Get data descriptor
  2721.     //
  2722.     virtual EAsiDataType Type      (void) const;
  2723.     virtual uint         ReturnLength (void) const;
  2724.  
  2725.     // Store Data value
  2726.     //
  2727.     virtual EAsiBoolean   storeValue (real);
  2728.     virtual EAsiBoolean   storeValue (integer);
  2729.     virtual EAsiBoolean   storeValue (smallint);
  2730.     virtual EAsiBoolean   storeValue (char *, uint);
  2731.     virtual EAsiBoolean   storeValue (const CAsiUcStr &);
  2732.     virtual EAsiBoolean   storeValue (const CAsiData &);
  2733.  
  2734.     virtual EAsiBoolean   SQLType    (CAsiUcStr *) const;        // SQL data type as string
  2735.     virtual EAsiBoolean   SQLLiteral (CAsiUcStr *) const;        // SQL compatible literal
  2736.  
  2737.     //  Get data value 
  2738.     //
  2739.     virtual integer       intValue  (void) const;
  2740.     virtual real          realValue (void) const;
  2741.  
  2742.     virtual EAsiBoolean   getValue (real *) const;
  2743.     virtual EAsiBoolean   getValue (integer *) const;
  2744.     virtual EAsiBoolean   getValue (smallint *) const;
  2745.     virtual EAsiBoolean   getValue (char *, uint) const;
  2746.     virtual EAsiBoolean   getValue (CAsiUcStr *) const;
  2747.  
  2748.     // ASI application/DBMS driver data exchange
  2749.     //
  2750.     virtual long          read           (char *, long, long) const;
  2751.     virtual long          size           (void) const;
  2752.  
  2753.     // Runtime class iteraction functions
  2754.     //
  2755.     virtual unsigned long packSize   (void) const;
  2756.     virtual unsigned long packTo     (void*) const;
  2757.     virtual EAsiBoolean   unpackFrom (void*);
  2758.  
  2759.     // Duplicate itself
  2760.     //
  2761.     virtual CAsiObject   *duplicate (void) const;
  2762.  
  2763.     // Operators
  2764.     //
  2765.             // Assignment
  2766.             CAsiReal &operator= (const CAsiSmallInt &);
  2767.             CAsiReal &operator= (const CAsiInt &);
  2768.             CAsiReal &operator= (const CAsiNumeric &);
  2769.             CAsiReal &operator= (const CAsiDecimal &);
  2770.             CAsiReal &operator= (const CAsiFloat &);
  2771.             CAsiReal &operator= (const CAsiReal &);
  2772.             CAsiReal &operator= (const CAsiDouble &);
  2773.             CAsiReal &operator= (const smallint);
  2774.             CAsiReal &operator= (const integer);
  2775.             CAsiReal &operator= (const real);
  2776.             CAsiReal &operator= (const int);
  2777.  
  2778.             // Arithmetic operators
  2779.             CAsiReal &operator+= (const CAsiSmallInt &);
  2780.             CAsiReal &operator+= (const CAsiInt &);
  2781.             CAsiReal &operator+= (const CAsiNumeric &);
  2782.             CAsiReal &operator+= (const CAsiDecimal &);
  2783.             CAsiReal &operator+= (const CAsiFloat &);
  2784.             CAsiReal &operator+= (const CAsiReal &);
  2785.             CAsiReal &operator+= (const CAsiDouble &);
  2786.             CAsiReal &operator+= (const smallint);
  2787.             CAsiReal &operator+= (const integer);
  2788.             CAsiReal &operator+= (const real);
  2789.             CAsiReal &operator+= (const int);
  2790.  
  2791.             CAsiReal &operator-= (const CAsiSmallInt &);
  2792.             CAsiReal &operator-= (const CAsiInt &);
  2793.             CAsiReal &operator-= (const CAsiNumeric &);
  2794.             CAsiReal &operator-= (const CAsiDecimal &);
  2795.             CAsiReal &operator-= (const CAsiFloat &);
  2796.             CAsiReal &operator-= (const CAsiReal &);
  2797.             CAsiReal &operator-= (const CAsiDouble &);
  2798.             CAsiReal &operator-= (const smallint);
  2799.             CAsiReal &operator-= (const integer);
  2800.             CAsiReal &operator-= (const real);
  2801.             CAsiReal &operator-= (const int);
  2802.  
  2803.             CAsiReal &operator*= (const CAsiSmallInt &);
  2804.             CAsiReal &operator*= (const CAsiInt &);
  2805.             CAsiReal &operator*= (const CAsiNumeric &);
  2806.             CAsiReal &operator*= (const CAsiDecimal &);
  2807.             CAsiReal &operator*= (const CAsiFloat &);
  2808.             CAsiReal &operator*= (const CAsiReal &);
  2809.             CAsiReal &operator*= (const CAsiDouble &);
  2810.             CAsiReal &operator*= (const smallint);
  2811.             CAsiReal &operator*= (const integer);
  2812.             CAsiReal &operator*= (const real);
  2813.             CAsiReal &operator*= (const int);
  2814.  
  2815.             CAsiReal &operator/= (const CAsiSmallInt &);
  2816.             CAsiReal &operator/= (const CAsiInt &);
  2817.             CAsiReal &operator/= (const CAsiNumeric &);
  2818.             CAsiReal &operator/= (const CAsiDecimal &);
  2819.             CAsiReal &operator/= (const CAsiFloat &);
  2820.             CAsiReal &operator/= (const CAsiReal &);
  2821.             CAsiReal &operator/= (const CAsiDouble &);
  2822.             CAsiReal &operator/= (const smallint);
  2823.             CAsiReal &operator/= (const integer);
  2824.             CAsiReal &operator/= (const real);
  2825.             CAsiReal &operator/= (const int);
  2826.  
  2827.             CAsiReal operator+ (const CAsiSmallInt &) const;
  2828.             CAsiReal operator+ (const CAsiInt &)      const;
  2829.             CAsiReal operator+ (const CAsiNumeric &)  const;
  2830.             CAsiReal operator+ (const CAsiDecimal &)  const;
  2831.             CAsiReal operator+ (const CAsiFloat &)    const;
  2832.             CAsiReal operator+ (const CAsiReal &)     const;
  2833.      friend CAsiReal operator+ (const CAsiSmallInt &, const CAsiReal &);
  2834.      friend CAsiReal operator+ (const CAsiInt &, const CAsiReal &);
  2835.      friend CAsiReal operator+ (const CAsiNumeric &, const CAsiReal &);
  2836.      friend CAsiReal operator+ (const CAsiDecimal &, const CAsiReal &);
  2837.      friend CAsiReal operator+ (const CAsiFloat &, const CAsiReal &)  ;
  2838.             CAsiReal operator+ (const smallint) const;
  2839.             CAsiReal operator+ (const integer)  const;
  2840.             CAsiReal operator+ (const real)     const;
  2841.      friend CAsiReal operator+ (const smallint, const CAsiReal &);
  2842.      friend CAsiReal operator+ (const integer, const CAsiReal &) ;
  2843.      friend CAsiReal operator+ (const real, const CAsiReal &)    ;
  2844.             CAsiReal operator+ (const int) const;
  2845.      friend CAsiReal operator+ (const int, const CAsiReal &);
  2846.  
  2847.             CAsiReal operator- (const CAsiSmallInt &) const;
  2848.             CAsiReal operator- (const CAsiInt &)      const;
  2849.             CAsiReal operator- (const CAsiNumeric &)  const;
  2850.             CAsiReal operator- (const CAsiDecimal &)  const;
  2851.             CAsiReal operator- (const CAsiFloat &)    const;
  2852.             CAsiReal operator- (const CAsiReal &)     const;
  2853.      friend CAsiReal operator- (const CAsiSmallInt &, const CAsiReal &);
  2854.      friend CAsiReal operator- (const CAsiInt &, const CAsiReal &);
  2855.      friend CAsiReal operator- (const CAsiNumeric &, const CAsiReal &);
  2856.      friend CAsiReal operator- (const CAsiDecimal &, const CAsiReal &);
  2857.      friend CAsiReal operator- (const CAsiFloat &, const CAsiReal &)  ;
  2858.             CAsiReal operator- (const smallint) const;
  2859.             CAsiReal operator- (const integer)  const;
  2860.             CAsiReal operator- (const real)     const;
  2861.      friend CAsiReal operator- (const smallint, const CAsiReal &);
  2862.      friend CAsiReal operator- (const integer, const CAsiReal &);
  2863.      friend CAsiReal operator- (const real, const CAsiReal &);
  2864.             CAsiReal operator- (const int) const;
  2865.      friend CAsiReal operator- (const int, const CAsiReal &);
  2866.  
  2867.             CAsiReal operator* (const CAsiSmallInt &) const;
  2868.             CAsiReal operator* (const CAsiInt &)      const;
  2869.             CAsiReal operator* (const CAsiNumeric &)  const;
  2870.             CAsiReal operator* (const CAsiDecimal &)  const;
  2871.             CAsiReal operator* (const CAsiFloat &)    const;
  2872.             CAsiReal operator* (const CAsiReal &)     const;
  2873.      friend CAsiReal operator* (const CAsiSmallInt &, const CAsiReal &);
  2874.      friend CAsiReal operator* (const CAsiInt &, const CAsiReal &);
  2875.      friend CAsiReal operator* (const CAsiNumeric &, const CAsiReal &);
  2876.      friend CAsiReal operator* (const CAsiDecimal &, const CAsiReal &);
  2877.      friend CAsiReal operator* (const CAsiFloat &, const CAsiReal &)  ;
  2878.             CAsiReal operator* (const smallint) const;
  2879.             CAsiReal operator* (const integer)  const;
  2880.             CAsiReal operator* (const real)     const;
  2881.      friend CAsiReal operator* (const smallint, const CAsiReal &);
  2882.      friend CAsiReal operator* (const integer, const CAsiReal &) ;
  2883.      friend CAsiReal operator* (const real, const CAsiReal &)    ;
  2884.             CAsiReal operator* (const int) const;
  2885.      friend CAsiReal operator* (const int, const CAsiReal &);
  2886.  
  2887.             CAsiReal operator/ (const CAsiSmallInt &) const;
  2888.             CAsiReal operator/ (const CAsiInt &)      const;
  2889.             CAsiReal operator/ (const CAsiNumeric &)  const;
  2890.             CAsiReal operator/ (const CAsiDecimal &)  const;
  2891.             CAsiReal operator/ (const CAsiFloat &)    const;
  2892.             CAsiReal operator/ (const CAsiReal &)     const;
  2893.      friend CAsiReal operator/ (const CAsiSmallInt &, const CAsiReal &);
  2894.      friend CAsiReal operator/ (const CAsiInt &, const CAsiReal &);
  2895.      friend CAsiReal operator/ (const CAsiNumeric &, const CAsiReal &);
  2896.      friend CAsiReal operator/ (const CAsiDecimal &, const CAsiReal &);
  2897.      friend CAsiReal operator/ (const CAsiFloat &, const CAsiReal &)  ;
  2898.             CAsiReal operator/ (const smallint) const;
  2899.             CAsiReal operator/ (const integer)  const;
  2900.             CAsiReal operator/ (const real)     const;
  2901.      friend CAsiReal operator/ (const smallint, const CAsiReal &);
  2902.      friend CAsiReal operator/ (const integer, const CAsiReal &) ;
  2903.      friend CAsiReal operator/ (const real, const CAsiReal &);
  2904.             CAsiReal operator/ (const int) const;
  2905.      friend CAsiReal operator/ (const int, const CAsiReal &);
  2906.  
  2907.             CAsiReal &operator++ (void);
  2908.             CAsiReal &operator-- (void);
  2909.             CAsiReal &operator- (void);
  2910.  
  2911. private:
  2912.     real rvalue;
  2913. };
  2914.  
  2915.  
  2916. ////////////////////////////////////////////////
  2917. //
  2918. //
  2919. class CAsiDouble: public CAsiApproxNum
  2920. //
  2921. // DOUBLE PRECISION
  2922. //
  2923. {
  2924. public:
  2925.             CAsiDouble (void);
  2926.             CAsiDouble (const CAsiDouble &);
  2927.     virtual ~CAsiDouble (void);
  2928.  
  2929.     //  Get data descriptor
  2930.     //
  2931.     virtual EAsiDataType Type      (void) const;
  2932.     virtual uint         ReturnLength (void) const;
  2933.  
  2934.     // Store Data value
  2935.     //
  2936.     virtual EAsiBoolean   storeValue (real);
  2937.     virtual EAsiBoolean   storeValue (integer);
  2938.     virtual EAsiBoolean   storeValue (smallint);
  2939.     virtual EAsiBoolean   storeValue (char *, uint);
  2940.     virtual EAsiBoolean   storeValue (const CAsiUcStr &);
  2941.     virtual EAsiBoolean   storeValue (const CAsiData &);
  2942.  
  2943.     //  Get data value 
  2944.     //
  2945.     virtual integer       intValue  (void) const;
  2946.     virtual real          realValue (void) const;
  2947.  
  2948.     virtual EAsiBoolean   getValue (real *) const;
  2949.     virtual EAsiBoolean   getValue (integer *) const;
  2950.     virtual EAsiBoolean   getValue (smallint *) const;
  2951.     virtual EAsiBoolean   getValue (char *, uint) const;
  2952.     virtual EAsiBoolean   getValue (CAsiUcStr *) const;
  2953.  
  2954.     virtual EAsiBoolean   SQLType    (CAsiUcStr *) const;        // SQL data type as string
  2955.     virtual EAsiBoolean   SQLLiteral (CAsiUcStr *) const;        // SQL compatible literal
  2956.  
  2957.     // ASI application/DBMS driver data exchange
  2958.     //
  2959.     virtual long          read           (char *, long, long) const;
  2960.     virtual long          size           (void) const;
  2961.  
  2962.     // Runtime class iteraction functions
  2963.     //
  2964.     virtual unsigned long packSize   (void) const;
  2965.     virtual unsigned long packTo     (void*) const;
  2966.     virtual EAsiBoolean   unpackFrom (void*);
  2967.  
  2968.     // Duplicate itself
  2969.     //
  2970.     virtual CAsiObject   *duplicate (void) const;
  2971.  
  2972.     // Operators
  2973.     //
  2974.             // Assignment
  2975.             CAsiDouble &operator= (const CAsiSmallInt &);
  2976.             CAsiDouble &operator= (const CAsiInt &);
  2977.             CAsiDouble &operator= (const CAsiNumeric &);
  2978.             CAsiDouble &operator= (const CAsiDecimal &);
  2979.             CAsiDouble &operator= (const CAsiFloat &);
  2980.             CAsiDouble &operator= (const CAsiReal &);
  2981.             CAsiDouble &operator= (const CAsiDouble &);
  2982.             CAsiDouble &operator= (const smallint);
  2983.             CAsiDouble &operator= (const integer);
  2984.             CAsiDouble &operator= (const real);
  2985.             CAsiDouble &operator= (const int);
  2986.  
  2987.             // Arithmetic operators
  2988.             CAsiDouble &operator+= (const CAsiSmallInt &);
  2989.             CAsiDouble &operator+= (const CAsiInt &);
  2990.             CAsiDouble &operator+= (const CAsiNumeric &);
  2991.             CAsiDouble &operator+= (const CAsiDecimal &);
  2992.             CAsiDouble &operator+= (const CAsiFloat &);
  2993.             CAsiDouble &operator+= (const CAsiReal &);
  2994.             CAsiDouble &operator+= (const CAsiDouble &);
  2995.             CAsiDouble &operator+= (const smallint);
  2996.             CAsiDouble &operator+= (const integer);
  2997.             CAsiDouble &operator+= (const real);
  2998.             CAsiDouble &operator+= (const int);
  2999.  
  3000.             CAsiDouble &operator-= (const CAsiSmallInt &);
  3001.             CAsiDouble &operator-= (const CAsiInt &);
  3002.             CAsiDouble &operator-= (const CAsiNumeric &);
  3003.             CAsiDouble &operator-= (const CAsiDecimal &);
  3004.             CAsiDouble &operator-= (const CAsiFloat &);
  3005.             CAsiDouble &operator-= (const CAsiReal &);
  3006.             CAsiDouble &operator-= (const CAsiDouble &);
  3007.             CAsiDouble &operator-= (const smallint);
  3008.             CAsiDouble &operator-= (const integer);
  3009.             CAsiDouble &operator-= (const real);
  3010.             CAsiDouble &operator-= (const int);
  3011.  
  3012.             CAsiDouble &operator*= (const CAsiSmallInt &);
  3013.             CAsiDouble &operator*= (const CAsiInt &);
  3014.             CAsiDouble &operator*= (const CAsiNumeric &);
  3015.             CAsiDouble &operator*= (const CAsiDecimal &);
  3016.             CAsiDouble &operator*= (const CAsiFloat &);
  3017.             CAsiDouble &operator*= (const CAsiReal &);
  3018.             CAsiDouble &operator*= (const CAsiDouble &);
  3019.             CAsiDouble &operator*= (const smallint);
  3020.             CAsiDouble &operator*= (const integer);
  3021.             CAsiDouble &operator*= (const real);
  3022.             CAsiDouble &operator*= (const int);
  3023.  
  3024.             CAsiDouble &operator/= (const CAsiSmallInt &);
  3025.             CAsiDouble &operator/= (const CAsiInt &);
  3026.             CAsiDouble &operator/= (const CAsiNumeric &);
  3027.             CAsiDouble &operator/= (const CAsiDecimal &);
  3028.             CAsiDouble &operator/= (const CAsiFloat &);
  3029.             CAsiDouble &operator/= (const CAsiReal &);
  3030.             CAsiDouble &operator/= (const CAsiDouble &);
  3031.             CAsiDouble &operator/= (const smallint);
  3032.             CAsiDouble &operator/= (const integer);
  3033.             CAsiDouble &operator/= (const real);
  3034.             CAsiDouble &operator/= (const int);
  3035.  
  3036.             CAsiDouble operator+ (const CAsiSmallInt &) const;
  3037.             CAsiDouble operator+ (const CAsiInt &)      const;
  3038.             CAsiDouble operator+ (const CAsiNumeric &)  const;
  3039.             CAsiDouble operator+ (const CAsiDecimal &)  const;
  3040.             CAsiDouble operator+ (const CAsiFloat &)    const;
  3041.             CAsiDouble operator+ (const CAsiReal &)     const;
  3042.             CAsiDouble operator+ (const CAsiDouble &)   const;
  3043.      friend CAsiDouble operator+ (const CAsiSmallInt &, const CAsiDouble &);
  3044.      friend CAsiDouble operator+ (const CAsiInt &, const CAsiDouble &);
  3045.      friend CAsiDouble operator+ (const CAsiNumeric &, const CAsiDouble &);
  3046.      friend CAsiDouble operator+ (const CAsiDecimal &, const CAsiDouble &);
  3047.      friend CAsiDouble operator+ (const CAsiFloat &, const CAsiDouble &);
  3048.      friend CAsiDouble operator+ (const CAsiReal &, const CAsiDouble &);
  3049.             CAsiDouble operator+ (const smallint) const;
  3050.             CAsiDouble operator+ (const integer)  const;
  3051.             CAsiDouble operator+ (const real)     const;
  3052.      friend CAsiDouble operator+ (const smallint, const CAsiDouble &);
  3053.      friend CAsiDouble operator+ (const integer, const CAsiDouble &) ;
  3054.      friend CAsiDouble operator+ (const real, const CAsiDouble &)    ;
  3055.             CAsiDouble operator+ (const int) const;
  3056.      friend CAsiDouble operator+ (const int, const CAsiDouble &);
  3057.  
  3058.             CAsiDouble operator- (const CAsiSmallInt &) const;
  3059.             CAsiDouble operator- (const CAsiInt &)      const;
  3060.             CAsiDouble operator- (const CAsiNumeric &)  const;
  3061.             CAsiDouble operator- (const CAsiDecimal &)  const;
  3062.             CAsiDouble operator- (const CAsiFloat &)    const;
  3063.             CAsiDouble operator- (const CAsiReal &)     const;
  3064.             CAsiDouble operator- (const CAsiDouble &)   const;
  3065.      friend CAsiDouble operator- (const CAsiSmallInt &, const CAsiDouble &);
  3066.      friend CAsiDouble operator- (const CAsiInt &, const CAsiDouble &);
  3067.      friend CAsiDouble operator- (const CAsiNumeric &, const CAsiDouble &);
  3068.      friend CAsiDouble operator- (const CAsiDecimal &, const CAsiDouble &);
  3069.      friend CAsiDouble operator- (const CAsiFloat &, const CAsiDouble &)  ;
  3070.      friend CAsiDouble operator- (const CAsiReal &, const CAsiDouble &);
  3071.             CAsiDouble operator- (const smallint) const;
  3072.             CAsiDouble operator- (const integer)  const;
  3073.             CAsiDouble operator- (const real)     const;
  3074.      friend CAsiDouble operator- (const smallint, const CAsiDouble &);
  3075.      friend CAsiDouble operator- (const integer, const CAsiDouble &);
  3076.      friend CAsiDouble operator- (const real, const CAsiDouble &);
  3077.             CAsiDouble operator- (const int) const;
  3078.      friend CAsiDouble operator- (const int, const CAsiDouble &);
  3079.  
  3080.             CAsiDouble operator* (const CAsiSmallInt &) const;
  3081.             CAsiDouble operator* (const CAsiInt &)      const;
  3082.             CAsiDouble operator* (const CAsiNumeric &)  const;
  3083.             CAsiDouble operator* (const CAsiDecimal &)  const;
  3084.             CAsiDouble operator* (const CAsiFloat &)    const;
  3085.             CAsiDouble operator* (const CAsiReal &)     const;
  3086.             CAsiDouble operator* (const CAsiDouble &)   const;
  3087.      friend CAsiDouble operator* (const CAsiSmallInt &, const CAsiDouble &);
  3088.      friend CAsiDouble operator* (const CAsiInt &, const CAsiDouble &);
  3089.      friend CAsiDouble operator* (const CAsiNumeric &, const CAsiDouble &);
  3090.      friend CAsiDouble operator* (const CAsiDecimal &, const CAsiDouble &);
  3091.      friend CAsiDouble operator* (const CAsiFloat &, const CAsiDouble &);
  3092.      friend CAsiDouble operator* (const CAsiReal &, const CAsiDouble &);
  3093.             CAsiDouble operator* (const smallint) const;
  3094.             CAsiDouble operator* (const integer) const;
  3095.             CAsiDouble operator* (const real) const;
  3096.      friend CAsiDouble operator* (const smallint, const CAsiDouble &);
  3097.      friend CAsiDouble operator* (const integer, const CAsiDouble &);
  3098.      friend CAsiDouble operator* (const real, const CAsiDouble &);
  3099.             CAsiDouble operator* (const int) const;
  3100.      friend CAsiDouble operator* (const int, const CAsiDouble &);
  3101.  
  3102.             CAsiDouble operator/ (const CAsiSmallInt &) const;
  3103.             CAsiDouble operator/ (const CAsiInt &)      const;
  3104.             CAsiDouble operator/ (const CAsiNumeric &)  const;
  3105.             CAsiDouble operator/ (const CAsiDecimal &)  const;
  3106.             CAsiDouble operator/ (const CAsiFloat &)    const;
  3107.             CAsiDouble operator/ (const CAsiReal &)     const;
  3108.             CAsiDouble operator/ (const CAsiDouble &)   const;
  3109.      friend CAsiDouble operator/ (const CAsiSmallInt &, const CAsiDouble &);
  3110.      friend CAsiDouble operator/ (const CAsiInt &, const CAsiDouble &);
  3111.      friend CAsiDouble operator/ (const CAsiNumeric &, const CAsiDouble &);
  3112.      friend CAsiDouble operator/ (const CAsiDecimal &, const CAsiDouble &);
  3113.      friend CAsiDouble operator/ (const CAsiFloat &, const CAsiDouble &);
  3114.      friend CAsiDouble operator/ (const CAsiReal &, const CAsiDouble &);
  3115.             CAsiDouble operator/ (const smallint) const;
  3116.             CAsiDouble operator/ (const integer)  const;
  3117.             CAsiDouble operator/ (const real)     const;
  3118.      friend CAsiDouble operator/ (const smallint, const CAsiDouble &);
  3119.      friend CAsiDouble operator/ (const integer, const CAsiDouble &);
  3120.      friend CAsiDouble operator/ (const real, const CAsiDouble &);
  3121.             CAsiDouble operator/ (const int) const;
  3122.      friend CAsiDouble operator/ (const int, const CAsiDouble &);
  3123.  
  3124.             CAsiDouble &operator++ (void);
  3125.             CAsiDouble &operator-- (void);
  3126.             CAsiDouble &operator- (void);
  3127.  
  3128.  
  3129. private:
  3130.     real dvalue;
  3131. };
  3132.  
  3133.  
  3134. ////////////////////////////////////////////////
  3135. //
  3136. //
  3137. class CAsiChar: public CAsiData
  3138. //
  3139. // CHARACTER
  3140. //
  3141. {
  3142. friend class CAsiTempTable;
  3143. public:
  3144.     // Construction/Destruction
  3145.     //
  3146.             CAsiChar ();
  3147.             CAsiChar (uint);
  3148.             CAsiChar (const CAsiChar &);
  3149.     virtual ~CAsiChar ();
  3150.  
  3151.  
  3152.     // Set Varying, National, Character set name, and Collation
  3153.            void           setVarying    (void);
  3154.            void           setNational   (void);
  3155.            void           setCharSet    (const CAsiUcStr &);
  3156.            void           setDefCharSet (void);
  3157.            void           setCollName   (const CAsiUcStr &);
  3158.            void           setCollIdent  (AsiUcIdCLT);
  3159.            void           setCoerc      (EAsiCAttr);
  3160.  
  3161.     // Get data descriptor
  3162.     //
  3163.     virtual EAsiDataType    Type         (void) const;
  3164.     virtual uint            Length       (void) const;
  3165.     virtual uint            ReturnLength (void) const;
  3166.             uint            ByteSize     (void) const;
  3167.       const CAsiUcStr   &   CollName     (void) const;      
  3168.       const CAsiUcStr   &   CharSetName  (void) const;
  3169.             AsiUcIdCLT      CollIdent    (void) const;
  3170.             AsiUcIdCCT      CharSetIdent (void) const;
  3171.             EAsiCAttr       Coercibility (void) const;
  3172.  
  3173.     //  is_ functions
  3174.     //
  3175.     virtual EAsiBoolean   is_character  (void) const;
  3176.     virtual EAsiBoolean   is_comparable (const CAsiData *) const;
  3177.     virtual EAsiBoolean   is_storable   (const CAsiData *) const;
  3178.     virtual EAsiBoolean   is_castable   (const CAsiData *) const;
  3179.             EAsiBoolean   is_national   (void) const;
  3180.  
  3181.     virtual CAsiData *    checkCat      (const CAsiData *) const;
  3182.  
  3183.     // Store Data value
  3184.     //
  3185.     virtual EAsiBoolean   storeValue (real);
  3186.     virtual EAsiBoolean   storeValue (integer);
  3187.     virtual EAsiBoolean   storeValue (smallint);
  3188.     virtual EAsiBoolean   storeValue (char *, uint);
  3189.             EAsiBoolean   storeValue (char *, uint, AsiUcIdCCT);
  3190.     virtual EAsiBoolean   storeValue (const CAsiUcStr &);
  3191.     virtual EAsiBoolean   storeValue (const CAsiData &);
  3192.     virtual EAsiBoolean   storeValue (const AsiUcStr);
  3193.  
  3194.     //  Get data value
  3195.     //
  3196.         const CAsiUcStr  &charValue (void) const;   // Reference to string
  3197.  
  3198.     virtual EAsiBoolean   getValue (real *) const;
  3199.     virtual EAsiBoolean   getValue (integer *) const;
  3200.     virtual EAsiBoolean   getValue (smallint *) const;
  3201.     virtual EAsiBoolean   getValue (char *, uint) const;
  3202.     virtual EAsiBoolean   getValue (CAsiUcStr *) const;
  3203.  
  3204.     virtual EAsiBoolean   SQLType    (CAsiUcStr *) const;        // SQL data type as string
  3205.     virtual EAsiBoolean   SQLLiteral (CAsiUcStr *) const;        // SQL compatible literal
  3206.  
  3207.     // ASI application/DBMS driver data exchange
  3208.     //
  3209.     virtual long          read           (char *, long, long) const;
  3210.     virtual long          size           (void) const;
  3211.  
  3212.     // Runtime class iteraction functions
  3213.     //
  3214.     virtual unsigned long packSize   (void) const;
  3215.     virtual unsigned long packTo     (void*) const;
  3216.     virtual EAsiBoolean   unpackFrom (void*);
  3217.  
  3218.     // Duplicate itself
  3219.     //
  3220.     virtual CAsiObject   *duplicate (void) const;
  3221.  
  3222.     // Nullify all members
  3223.  
  3224.     virtual void          Clear     (void);
  3225.  
  3226.     // Like predicate and string functions
  3227.     //
  3228.     EAsiBoolean Like       (const CAsiChar &, const CAsiChar &) const;
  3229.     CAsiChar    Substring  (uint) const;
  3230.     CAsiChar    Substring  (uint, uint) const;
  3231.     CAsiChar    Upper      (void) const;
  3232.     CAsiChar    Lower      (void) const;
  3233.     CAsiChar    Trim       (EAsiTrimSpec, const CAsiChar &) const;
  3234.     CAsiNumeric Position   (const CAsiChar &) const;
  3235.    
  3236.  
  3237.     // Operators
  3238.     //
  3239.             // Assignment
  3240.             CAsiChar  & operator=  (const CAsiChar &);
  3241.             CAsiChar  & operator=  (const CAsiUcStr &);
  3242.  
  3243.             // Cancatenation
  3244.             CAsiChar    operator+  (const CAsiChar &) const;
  3245.             CAsiChar    operator+  (const CAsiUcStr &) const;
  3246.  
  3247.             // Comparision
  3248.             int         operator>  (const CAsiChar &) const;
  3249.             int         operator>  (const CAsiUcStr &) const;
  3250.      friend int         operator>  (const CAsiUcStr &, const CAsiChar &);
  3251.  
  3252.             int         operator>=  (const CAsiChar &) const;
  3253.             int         operator>=  (const CAsiUcStr &) const;
  3254.      friend int         operator>=  (const CAsiUcStr &, const CAsiChar &);
  3255.  
  3256.             int         operator==  (const CAsiChar &) const;
  3257.             int         operator==  (const CAsiUcStr &) const;
  3258.      friend int         operator==  (const CAsiUcStr &, const CAsiChar &);
  3259.  
  3260.             int         operator<=  (const CAsiChar &) const;
  3261.             int         operator<=  (const CAsiUcStr &) const;
  3262.      friend int         operator<=  (const CAsiUcStr &, const CAsiChar &);
  3263.  
  3264.             int         operator<  (const CAsiChar &) const;
  3265.             int         operator<  (const CAsiUcStr &) const;
  3266.      friend int         operator<  (const CAsiUcStr &, const CAsiChar &);
  3267.  
  3268.             int         operator!=  (const CAsiChar &) const;
  3269.             int         operator!=  (const CAsiUcStr &) const;
  3270.      friend int         operator!=  (const CAsiUcStr &, const CAsiChar &);
  3271.  
  3272. private:
  3273.  
  3274.     EAsiBoolean     isCompColSet(const AsiUcIdCLT, EAsiCAttr) const;
  3275.     AsiUcIdCLT      CompColSet(const AsiUcIdCLT, EAsiCAttr) const;
  3276.     EAsiBoolean     isDyadicOpColSet(const AsiUcIdCLT, EAsiCAttr) const;
  3277.     AsiUcIdCLT      DyadicOpColSet(const AsiUcIdCLT, EAsiCAttr *, EAsiCAttr) const;
  3278.  
  3279. private:
  3280.  
  3281.     uint      maxlength; // Length of character data
  3282.     uint      retlength; // Length of the stored data
  3283.     CAsiUcStr chvalue;   // Value
  3284.  
  3285.     short           mod;         // Type modifiers
  3286.     AsiUcIdCCT      CharSetId;   // Character set identifier
  3287.     CAsiUcStr       CharSet;     // Character set name
  3288.     AsiUcIdCLT      ColId;       // Collation identifier
  3289.     CAsiUcStr       CName;       // Collation name
  3290.     EAsiCAttr       coercibility;// Coercibility attribute
  3291. };
  3292.  
  3293.  
  3294. ////////////////////////////////////////////////
  3295. //
  3296. //
  3297. class CAsiBinary: public CAsiData
  3298. //
  3299. // BINARY
  3300. //
  3301. // This class introduces functionality of the internal binary data. 
  3302. // It defines assignment and binary concatenation operations which are
  3303. // associated with = and + operators.
  3304. //
  3305. //
  3306. {
  3307. friend class CAsiTempTable;
  3308. public:
  3309.     // Construction/Destruction
  3310.     //
  3311.             CAsiBinary  ();
  3312.             CAsiBinary  (uint);
  3313.             CAsiBinary  (const CAsiBinary &);
  3314.     virtual ~CAsiBinary ();
  3315.  
  3316.  
  3317.     // Set Varying
  3318.            void          setVarying    (void);
  3319.  
  3320.     // Get data descriptor
  3321.     //
  3322.     virtual EAsiDataType Type         (void) const;
  3323.     virtual uint         Length       (void) const; // Binary length
  3324.     virtual uint         ReturnLength (void) const;
  3325.  
  3326.  
  3327.     //  is_ functions
  3328.     //
  3329.     virtual EAsiBoolean   is_binary     (void) const;
  3330.     virtual EAsiBoolean   is_comparable (const CAsiData *) const;
  3331.     virtual EAsiBoolean   is_storable   (const CAsiData *) const;
  3332.     virtual EAsiBoolean   is_castable   (const CAsiData *) const;
  3333.  
  3334.     virtual CAsiData *    checkCat (const CAsiData *) const;
  3335.  
  3336.     // Store Data value
  3337.     //
  3338.             EAsiBoolean   storeHexValue (char *, uint, uint *);
  3339.             EAsiBoolean   storeHexValue (const CAsiUcStr &);
  3340.             EAsiBoolean   storeBinValue (char *, uint, uint *);
  3341.             EAsiBoolean   storeBinValue (const CAsiUcStr &);
  3342.     virtual EAsiBoolean   storeValue    (char *, uint);
  3343.     virtual EAsiBoolean   storeValue    (char *, uint, uint *);
  3344.     virtual EAsiBoolean   storeValue    (const CAsiData &);
  3345.  
  3346.     //  Get data value
  3347.     //
  3348.             EAsiBoolean   getHexValue (char *, uint, uint *) const;
  3349.             EAsiBoolean   getHexValue (CAsiUcStr *) const;
  3350.             EAsiBoolean   getBinValue (char *, uint, uint *) const;
  3351.             EAsiBoolean   getBinValue (CAsiUcStr *) const;
  3352.     virtual EAsiBoolean   getValue    (char *, uint) const;
  3353.     virtual EAsiBoolean   getValue    (char *, uint, uint *) const;
  3354.  
  3355.     virtual EAsiBoolean   SQLType    (CAsiUcStr *) const;        // SQL data type as string
  3356.     virtual EAsiBoolean   SQLLiteral (CAsiUcStr *) const;        // SQL compatible literal
  3357.  
  3358.     // ASI application/DBMS driver data exchange
  3359.     //
  3360.     virtual long          read           (char *, long, long) const;
  3361.     virtual long          size           (void) const;
  3362.  
  3363.     // Runtime class iteraction functions
  3364.     //
  3365.     virtual unsigned long packSize   (void) const;
  3366.     virtual unsigned long packTo     (void*) const;
  3367.     virtual EAsiBoolean   unpackFrom (void*);
  3368.  
  3369.     // Duplicate itself
  3370.     //
  3371.     virtual CAsiObject   *duplicate(void) const;
  3372.  
  3373.     // Nullify all members
  3374.  
  3375.     virtual void          Clear     (void);
  3376.  
  3377.     // Utility 
  3378.     //
  3379.     CAsiBinary Substring(uint);
  3380.     CAsiBinary Substring(uint,uint);
  3381.  
  3382.     // Operators
  3383.     //
  3384.             // Assignment
  3385.             CAsiBinary   &operator= (const CAsiBinary &);
  3386.  
  3387.             // Cancatenation
  3388.             CAsiBinary  operator+  (const CAsiBinary &) const;
  3389.  
  3390.             // Comparision
  3391.             int         operator>  (const CAsiBinary &) const;
  3392.             int         operator>= (const CAsiBinary &) const;
  3393.             int         operator== (const CAsiBinary &) const;
  3394.             int         operator<= (const CAsiBinary &) const;
  3395.             int         operator<  (const CAsiBinary &) const;
  3396.             int         operator!= (const CAsiBinary &) const;
  3397.  
  3398.  
  3399. private:
  3400.     uint       blength;   // Length of binary data
  3401.     uint       alength;   // Actual length
  3402.     uint       buflen;    // Allocated length
  3403.     uchar    * value;     // Value
  3404.     short      mod;       // Modifier
  3405. };
  3406.  
  3407.  
  3408. /////////////////////////////////////////////////////////////////////////////
  3409. class CAsiIQualifier : public CAsiData
  3410. //
  3411. // Interval Qualifier
  3412. //
  3413. {
  3414. friend class CAsiInterval;
  3415. friend class CAsiDatetime;
  3416.  
  3417. public:
  3418.     // Construction/Destruction
  3419.     //
  3420.                CAsiIQualifier (void);        
  3421.                CAsiIQualifier (EAsiIType);        
  3422.                CAsiIQualifier (EAsiIType, uint);
  3423.                CAsiIQualifier (EAsiIType, uint, uint);
  3424.                CAsiIQualifier (const CAsiIQualifier &);
  3425.     virtual   ~CAsiIQualifier (void);
  3426.  
  3427.     // Set Interval qualifier type and characteristics
  3428.     //
  3429.     virtual EAsiBoolean  setIType         (EAsiIType);    // Set interval type
  3430.             void         setLeadFieldPrec (uint);         // Set Leading field precision
  3431.             void         setFracSecPrec   (uint);         // Set Fractional sec prec
  3432.  
  3433.     // Get access to interval characteristics
  3434.     //
  3435.     virtual EAsiDataType Type          (void) const;
  3436.     virtual EAsiIType    IntervalType  (void) const;
  3437.     virtual uint         LeadFieldPrec (void) const;
  3438.     virtual uint         FracSecPrec   (void) const;
  3439.     virtual uint         ReturnLength  (void) const;
  3440.  
  3441.     // ASI application/DBMS driver data exchange
  3442.     //
  3443.     virtual long          read           (char *, long, long) const;
  3444.     virtual long          size           (void) const;
  3445.  
  3446.     // Return interval type
  3447.     virtual EAsiBoolean  is_interval     (void) const;
  3448.     virtual EAsiBoolean  is_yminterval   (void) const;
  3449.     virtual EAsiBoolean  is_dtinterval   (void) const;
  3450.     virtual EAsiBoolean  is_storable     (const CAsiData *) const;
  3451.     virtual EAsiBoolean  is_comparable   (const CAsiData *) const;
  3452.             EAsiBoolean  is_moreaccurate (const CAsiIQualifier *) const;
  3453.  
  3454.     virtual EAsiBoolean  SQLType       (CAsiUcStr *) const;        // SQL data type as string
  3455.  
  3456. private:
  3457.     virtual EAsiBoolean  SQLLiteral    (CAsiUcStr *) const;    // SQL compatible literal
  3458.  
  3459. public:
  3460.     // Assignment operator
  3461.             CAsiIQualifier &operator= (const CAsiIQualifier &);
  3462.  
  3463.     // Runtime class iteraction functions
  3464.     //
  3465.     virtual unsigned long packSize   (void) const;
  3466.     virtual unsigned long packTo     (void*) const;
  3467.     virtual EAsiBoolean   unpackFrom (void*);
  3468.  
  3469.     // Duplicate itself
  3470.     //
  3471.     virtual CAsiObject   *duplicate(void) const;
  3472.  
  3473. protected:
  3474.     EAsiIType itype;                 // Interval type
  3475.     uint lfp;                        // Leading field precision
  3476.     uint fsp;                        // Fractional second precision
  3477. };
  3478.  
  3479.  
  3480.  
  3481. ////////////////////////////////////////////////
  3482. //
  3483. //
  3484. class CAsiInterval : public CAsiIQualifier
  3485. //
  3486. // INTERVAL
  3487. //
  3488. //  This is a base class for datetime intervals. The basic functionality 
  3489. //  for class includes setting and retrieving interval sign.
  3490.  
  3491. {
  3492. friend class CAsiDate;
  3493. friend class CAsiTime;
  3494. friend class CAsiTimeStamp;
  3495.  
  3496. public:
  3497.     // Constructors/Destructors
  3498.     //
  3499.             CAsiInterval ();
  3500.     virtual ~CAsiInterval ();
  3501.  
  3502.     virtual EAsiBoolean   SQLType  (CAsiUcStr *)      const;
  3503.  
  3504.     virtual CAsiData *    checkAdd (const CAsiData *) const;
  3505.     virtual CAsiData *    checkSub (const CAsiData *) const;
  3506.     virtual CAsiData *    checkMul (const CAsiData *) const;
  3507.     virtual CAsiData *    checkDiv (const CAsiData *) const;
  3508.  
  3509.     //  Set/get interval sign
  3510.     //
  3511.              void          setSign  (EAsiBoolean);
  3512.             EAsiBoolean   Sign     (void)             const;
  3513.  
  3514.  
  3515. protected:
  3516.     EAsiBoolean sign;     // Interval sign
  3517. };
  3518.  
  3519.  
  3520. ////////////////////////////////////////////////
  3521. //
  3522. //
  3523. class CAsiYM : public CAsiInterval
  3524. //
  3525. // Year Month Intervals
  3526. //
  3527. // Constructors/Destructor
  3528. //
  3529. // CAsiYM ()
  3530. // CAsiYM (
  3531. //   EAsiIType itype)                  // Year Month Interval type
  3532. // CAsiYM (
  3533. //   EAsiIType itype,                  // Year Month Interval type
  3534. //   uint lprec                        // Leading fields precision
  3535. //   )                  
  3536. //
  3537. // Different forms of constructor allow to specify interval type, and leading
  3538. // field precision
  3539. // Interval type shall be a valid Year Month interval type.
  3540. // If invalid interval type was specified, interval will be set to kAsiIUnknown.
  3541. //
  3542. //  EAsiBoolean set (
  3543. //    EAsiBoolean sign,                // Interval sign kAsiFalse (+), kAsiTrue (-)
  3544. //    uint years,                     // Years
  3545. //    uint months)                    // Months
  3546. //
  3547. //  EAsiBoolean setYears (
  3548. //    uint years)                     // Years
  3549. //
  3550. //  EAsiBoolean setMonths (
  3551. //    uint months)                    // Months
  3552. //
  3553. //  Interval fields set functions allow to set interval. They return
  3554. //  boolean value, because they must validate input.
  3555. //
  3556. //
  3557. //  Get interval fields
  3558. //
  3559. //  void get (
  3560. //    EAsiBoolean *sign,               // Interval sign kAsiFalse (+), kAsiTrue (-)
  3561. //    uint *years,                    // Years
  3562. //    uint *months) const             // Months
  3563. //
  3564. //  EAsiBoolean getYears (
  3565. //    uint *years) const              // Years
  3566. //
  3567. //  EAsiBoolean getMonths (
  3568. //    uint *months) const             // Months
  3569. //
  3570. //  The functions above retrieve interval fields. Return kAsiTrue if 
  3571. //  specified interval field present in interval and kAsiFalse otherwise.
  3572. //
  3573. //
  3574. //  Operators
  3575. //
  3576. //  Operators overload interval arithmetics operations like +, -, /, *, and 
  3577. //  unary minus. Besides them all boolean operators are redefined.
  3578. //
  3579. //
  3580.  
  3581. {
  3582.         
  3583. friend class CAsiDate;
  3584. friend class CAsiTime;
  3585. friend class CAsiTimeStamp;
  3586. friend class CAsiTempTable;
  3587.  
  3588. public:
  3589.     // Construction/Destruction
  3590.     //
  3591.             CAsiYM (void);
  3592.             CAsiYM (EAsiIType);
  3593.             CAsiYM (EAsiIType, uint);
  3594.             CAsiYM (const CAsiYM &);
  3595.     virtual ~CAsiYM (void);
  3596.  
  3597.     virtual EAsiBoolean   setIType      (EAsiIType);    // Set interval type
  3598.  
  3599.     virtual EAsiBoolean   is_castable   (const CAsiData *) const;
  3600.  
  3601.     // Store Data value
  3602.     //
  3603.     virtual EAsiBoolean   storeValue (integer);
  3604.     virtual EAsiBoolean   storeValue (smallint);
  3605.     virtual EAsiBoolean   storeValue (char *, uint);
  3606.     virtual EAsiBoolean   storeValue (const CAsiUcStr &);
  3607.     virtual EAsiBoolean   storeValue (const CAsiData &);
  3608.  
  3609.     // Set data value
  3610.     //
  3611.        EAsiBoolean   set       (ASI_IYEAR *);
  3612.        EAsiBoolean   set       (ASI_IYEARTOMONTH *);
  3613.        EAsiBoolean   set       (ASI_IMONTH *);
  3614.         EAsiBoolean   set       (EAsiBoolean, uint, uint);
  3615.         EAsiBoolean   setYears  (uint);
  3616.         EAsiBoolean   setMonths (uint);
  3617.  
  3618.     //  Get data value in the Unicode character string format
  3619.     //
  3620.     virtual EAsiBoolean   getValue (integer *) const;
  3621.     virtual EAsiBoolean   getValue (smallint *) const;
  3622.     virtual EAsiBoolean   getValue (char *, uint) const;
  3623.     virtual EAsiBoolean   getValue (CAsiUcStr *) const;
  3624.  
  3625.     virtual EAsiBoolean   SQLLiteral (CAsiUcStr *) const;        // SQL compatible literal
  3626.  
  3627.        EAsiBoolean   get       (ASI_IYEAR *)        const;
  3628.        EAsiBoolean   get       (ASI_IYEARTOMONTH *) const;
  3629.        EAsiBoolean   get       (ASI_IMONTH *)       const;
  3630.         EAsiBoolean   get       (EAsiBoolean *, uint *, uint *) const;
  3631.         EAsiBoolean   getYears  (uint *) const;
  3632.         EAsiBoolean   getMonths (uint *) const;
  3633.  
  3634.     // ASI application/DBMS driver data exchange
  3635.     //
  3636.     virtual long          read           (char *, long, long) const;
  3637.     virtual long          size           (void) const;
  3638.  
  3639.     // Runtime class iteraction functions
  3640.     //
  3641.     virtual unsigned long packSize   (void) const;
  3642.     virtual unsigned long packTo     (void*) const;
  3643.     virtual EAsiBoolean   unpackFrom (void*);
  3644.  
  3645.     // Duplicate itself
  3646.     //
  3647.     virtual CAsiObject   *duplicate (void) const;
  3648.  
  3649.     // Operators
  3650.         CAsiYM       &operator=  (const CAsiYM &);
  3651.         CAsiYM       &operator=  (const CAsiSmallInt &);
  3652.         CAsiYM       &operator=  (const CAsiInt &);
  3653.         CAsiYM       &operator=  (const CAsiNumeric &);
  3654.         CAsiYM       &operator=  (const CAsiDecimal &);
  3655.         CAsiYM       &operator=  (integer);
  3656.  
  3657.         CAsiYM       operator+  (const CAsiYM &) const;
  3658. friend CAsiDate     operator+  (const CAsiYM &, const CAsiDate &);
  3659.         CAsiYM       operator-  (const CAsiYM &) const;
  3660.  
  3661.        CAsiYM       operator*  (const CAsiSmallInt &) const;
  3662.         CAsiYM       operator*  (const CAsiInt &) const;
  3663.         CAsiYM       operator*  (const CAsiNumeric &) const;
  3664.         CAsiYM       operator*  (const CAsiDecimal &) const;
  3665.         CAsiYM       operator*  (integer) const;
  3666. friend CAsiYM       operator*  (const CAsiSmallInt &,const CAsiYM &);
  3667. friend CAsiYM       operator*  (const CAsiInt &,     const CAsiYM &);
  3668. friend CAsiYM       operator*  (const CAsiNumeric &, const CAsiYM &);
  3669. friend CAsiYM       operator*  (const CAsiDecimal &, const CAsiYM &);
  3670. friend CAsiYM       operator*  (integer,             const CAsiYM &);
  3671.  
  3672.         CAsiYM       operator/  (const CAsiSmallInt &) const;
  3673.         CAsiYM       operator/  (const CAsiInt &)      const;
  3674.         CAsiYM       operator/  (const CAsiNumeric &)  const;
  3675.         CAsiYM       operator/  (const CAsiDecimal &)  const;
  3676.         CAsiYM       operator/  (integer)              const;
  3677.  
  3678.         CAsiYM       &operator-  (void);
  3679.  
  3680.     // Comparision predicates
  3681.     //
  3682.        int           operator>  (const CAsiYM &) const;
  3683.         int           operator>= (const CAsiYM &) const;
  3684.         int           operator== (const CAsiYM &) const;
  3685.         int           operator<= (const CAsiYM &) const;
  3686.         int           operator<  (const CAsiYM &) const;
  3687.         int           operator!= (const CAsiYM &) const;
  3688. private:
  3689.        char *        getYMString (char *) const;
  3690.  
  3691. protected:
  3692.     ulong ivalue;         // Interval value in months
  3693.  
  3694. };
  3695.  
  3696.  
  3697. ////////////////////////////////////////////////
  3698. //
  3699. //
  3700. class CAsiDT : public CAsiInterval
  3701. //
  3702. // Day Time Intervals
  3703. //
  3704. // This class introduces functionality of the Day Time intervals.
  3705. // 
  3706. // MEMBER FUNCTIONS
  3707. // ----------------
  3708. // Constructors/Destructor
  3709. //
  3710. // CAsiDT ()
  3711. // CAsiDT (
  3712. //   EAsiIType itype                   // Interval type
  3713. //  )
  3714. // CAsiDT (
  3715. //   EAsiIType itype,                  // Interval type
  3716. //   uint lprec                        // Leading fields precision
  3717. //  )
  3718. // CAsiDT (
  3719. //   EAsiIType itype                   // Interval type
  3720. //   uint lprec,                       // Leading fields precision
  3721. //   uint fprec                        // Fractional second precision
  3722. //  )
  3723.  
  3724. // Constructors allow to set interval type, leading field precision and fractional
  3725. // seconds precision
  3726. // Interval type shall specify valid day time interval type.
  3727. // If invalid interval type was specified, interval will be set to kAsiIUnknown.
  3728. //
  3729. //
  3730. //  EAsiBoolean set (
  3731. //    EAsiBoolean sign,                 // Interval sign kAsiFalse (+), kAsiTrue (-)
  3732. //    uint days,                        // Days
  3733. //    uint hours,                       // Hours
  3734. //    uint minutes,                     // Minutes
  3735. //    double seconds)                   // Seconds
  3736. //
  3737. //  EAsiBoolean setDays (
  3738. //    uint days)                        // Days
  3739. //
  3740. //  EAsiBoolean setHours (
  3741. //    uint hours)                       // Hours
  3742. //
  3743. //  EAsiBoolean setMinutes (
  3744. //    uint minutes)                     // Minutes
  3745. //
  3746. //  EAsiBoolean getSeconds (
  3747. //    double seconds)                   // Seconds
  3748. //
  3749. //  Interval fields set functions allow to set interval. They return
  3750. //  boolean value, because they must validate input.
  3751. //
  3752. //
  3753. //  Get interval fields
  3754. //
  3755. //  void get (
  3756. //    EAsiBoolean *sign,               // Interval sign kAsiFalse (+), kAsiTrue (-)
  3757. //    uint *days,                       // Days
  3758. //    uint *hours,                      // Hours
  3759. //    uint *minutes,                    // Minutes
  3760. //    double *seconds) const            // Seconds with fraction
  3761. //
  3762. //  EAsiBoolean getDays (
  3763. //    uint *days                       // Days
  3764. //   ) const
  3765. //
  3766. //  EAsiBoolean getHours (
  3767. //    uint *hours                      // Hours
  3768. //   ) const;
  3769. //
  3770. //  EAsiBoolean getMinutes (
  3771. //     uint *minutes                    // Minutes
  3772. //   ) const;
  3773. //
  3774. //  EAsiBoolean getSeconds (
  3775. //    double *seconds) const;           // Seconds with fraction
  3776. //
  3777. //  The functions above retrieve interval fields
  3778. //
  3779. //
  3780. //  Operators
  3781. //
  3782. //  Operators overload interval arithmetics operations like +, -, /, *, and 
  3783. //  unary minus. Besides them all boolean operators are redefined.
  3784. //
  3785. //
  3786.  
  3787. {
  3788.     // Friend classes
  3789. friend class CAsiDate;
  3790. friend class CAsiTime;
  3791. friend class CAsiTimeStamp;
  3792. friend class CAsiTempTable;
  3793.  
  3794. private:
  3795.     // private helpers
  3796.  
  3797.                 void        ChkMul     (real);
  3798.                 void        ChkDiv     (real);
  3799.                 int         cmpDTI     (const CAsiDT&) const;
  3800.                 EAsiBoolean ChkSet     (double);
  3801.                 void        ChkSet2    (double);
  3802.                 double      LocalToUTC (double) const;
  3803.                 double      UTCToLocal (double) const;
  3804.  
  3805. public:
  3806.  
  3807.     // Constructors/Destructors
  3808.     //
  3809.             CAsiDT (void);
  3810.             CAsiDT (EAsiIType);
  3811.             CAsiDT (EAsiIType, uint);
  3812.             CAsiDT (EAsiIType, uint, uint);
  3813.             CAsiDT (const CAsiDT &);
  3814.     virtual ~CAsiDT (void);
  3815.  
  3816.     virtual EAsiBoolean   setIType      (EAsiIType);    // Set interval type
  3817.  
  3818.     virtual EAsiBoolean   is_castable   (const CAsiData *) const;
  3819.  
  3820.     // Store Data value
  3821.     //
  3822.     virtual EAsiBoolean   storeValue (integer);
  3823.     virtual EAsiBoolean   storeValue (smallint);
  3824.     virtual EAsiBoolean   storeValue (char *, uint);
  3825.     virtual EAsiBoolean   storeValue (const CAsiUcStr &);
  3826.     virtual EAsiBoolean   storeValue (const CAsiData &);
  3827.  
  3828.     // Set data value
  3829.     //
  3830.             EAsiBoolean   set        (ASI_IDAY *);
  3831.             EAsiBoolean   set        (ASI_IHOUR *);
  3832.             EAsiBoolean   set        (ASI_IMINUTE *);
  3833.             EAsiBoolean   set        (ASI_ISECOND *);
  3834.             EAsiBoolean   set        (ASI_IDAYTOHOUR *);
  3835.             EAsiBoolean   set        (ASI_IDAYTOMINUTE *);
  3836.             EAsiBoolean   set        (ASI_IDAYTOSECOND *);
  3837.             EAsiBoolean   set        (ASI_IHOURTOMINUTE *);
  3838.             EAsiBoolean   set        (ASI_IHOURTOSECOND *);
  3839.             EAsiBoolean   set        (ASI_IMINUTETOSECOND *);
  3840.             EAsiBoolean   set        (EAsiBoolean, uint, uint, uint, double);
  3841.             EAsiBoolean   setDays    (uint);
  3842.             EAsiBoolean   setHours   (uint);
  3843.             EAsiBoolean   setMinutes (uint);
  3844.             EAsiBoolean   setSeconds (double);
  3845.  
  3846.     //  Get data value in the Unicode character string format
  3847.     //
  3848.     virtual EAsiBoolean   getValue   (integer *)      const;
  3849.     virtual EAsiBoolean   getValue   (smallint *)     const;
  3850.     virtual EAsiBoolean   getValue   (char *, uint)   const;
  3851.     virtual EAsiBoolean   getValue   (CAsiUcStr *)    const;
  3852.  
  3853.     virtual EAsiBoolean   SQLLiteral (CAsiUcStr *) const;        // SQL compatible literal
  3854.  
  3855.             EAsiBoolean   get        (ASI_IDAY *)            const;
  3856.             EAsiBoolean   get        (ASI_IHOUR *)           const;
  3857.             EAsiBoolean   get        (ASI_IMINUTE *)         const;
  3858.             EAsiBoolean   get        (ASI_ISECOND *)         const;
  3859.             EAsiBoolean   get        (ASI_IDAYTOHOUR *)      const;
  3860.             EAsiBoolean   get        (ASI_IDAYTOMINUTE *)    const;
  3861.             EAsiBoolean   get        (ASI_IDAYTOSECOND *)    const;
  3862.             EAsiBoolean   get        (ASI_IHOURTOMINUTE *)   const;
  3863.             EAsiBoolean   get        (ASI_IHOURTOSECOND *)   const;
  3864.             EAsiBoolean   get        (ASI_IMINUTETOSECOND *) const;
  3865.             EAsiBoolean   get        (EAsiBoolean *, uint *, uint *, uint *,
  3866.                                       double *) const;
  3867.             EAsiBoolean   getDays    (uint *) const;
  3868.             EAsiBoolean   getHours   (uint *) const;
  3869.             EAsiBoolean   getMinutes (uint *) const;
  3870.             EAsiBoolean   getSeconds (double *) const;
  3871.  
  3872.     // ASI application/DBMS driver data exchange
  3873.     //
  3874.     virtual long          read           (char *, long, long) const;
  3875.     virtual long          size           (void) const;
  3876.  
  3877.     // Runtime class iteraction functions
  3878.     //
  3879.     virtual unsigned long packSize   (void) const;
  3880.     virtual unsigned long packTo     (void*) const;
  3881.     virtual EAsiBoolean   unpackFrom (void*);
  3882.  
  3883.     // Duplicate itself
  3884.     //
  3885.     virtual CAsiObject   *duplicate (void) const;
  3886.  
  3887.     // Operators
  3888.             CAsiDT       &operator=  (const CAsiDT &);
  3889.  
  3890.             CAsiDT       &operator=  (const CAsiSmallInt &);
  3891.             CAsiDT       &operator=  (const CAsiInt &);
  3892.             CAsiDT       &operator=  (const CAsiNumeric &);
  3893.             CAsiDT       &operator=  (const CAsiDecimal &);
  3894.             CAsiDT       &operator=  (integer);
  3895.  
  3896.             CAsiDT       operator+  (const CAsiDT &) const;
  3897.             CAsiDT       operator-  (const CAsiDT &) const;
  3898.             CAsiDT       operator*  (const CAsiSmallInt &) const;
  3899.             CAsiDT       operator*  (const CAsiInt &)      const;
  3900.             CAsiDT       operator*  (const CAsiNumeric &)  const;
  3901.             CAsiDT       operator*  (const CAsiDecimal &)  const;
  3902.             CAsiDT       operator*  (integer)              const;
  3903.      friend CAsiDT       operator*  (const CAsiSmallInt &,const CAsiDT &);
  3904.      friend CAsiDT       operator*  (const CAsiInt &,     const CAsiDT &);
  3905.      friend CAsiDT       operator*  (const CAsiNumeric &, const CAsiDT &);
  3906.      friend CAsiDT       operator*  (const CAsiDecimal &, const CAsiDT &);
  3907.      friend CAsiDT       operator*  (integer,             const CAsiDT &);
  3908.  
  3909.             CAsiDT       operator/  (const CAsiSmallInt &) const;
  3910.             CAsiDT       operator/  (const CAsiInt &)      const;
  3911.             CAsiDT       operator/  (const CAsiNumeric &)  const;
  3912.             CAsiDT       operator/  (const CAsiDecimal &)  const;
  3913.             CAsiDT       operator/  (integer)              const;
  3914.  
  3915.             CAsiDT       &operator-  (void);
  3916.  
  3917.     // Comparision predicates
  3918.     //
  3919.             int           operator>  (const CAsiDT &) const;
  3920.             int           operator>= (const CAsiDT &) const;
  3921.             int           operator== (const CAsiDT &) const;
  3922.             int           operator<= (const CAsiDT &) const;
  3923.             int           operator<  (const CAsiDT &) const;
  3924.             int           operator!= (const CAsiDT &) const;
  3925.  
  3926. private:
  3927.             char        * getDTString (char *) const;
  3928.  
  3929.  
  3930. protected:
  3931.     double ivalue;        // Interval value in seconds with fraction
  3932.  
  3933. };
  3934.  
  3935.  
  3936. ////////////////////////////////////////////////
  3937. //
  3938. //
  3939. class CAsiDatetime : public CAsiData
  3940. //
  3941. //  Datetime 
  3942. //
  3943. {
  3944. public:
  3945.     // Construction/Destruction
  3946.     //
  3947.             CAsiDatetime ();
  3948.     virtual ~CAsiDatetime ();
  3949.  
  3950.     // Get data descriptor
  3951.     //
  3952.     virtual EAsiDataType Type          (void) const;
  3953.  
  3954.     //  is_ functions
  3955.     //
  3956.     virtual EAsiBoolean   is_datetime   (void) const;
  3957.     virtual EAsiBoolean   is_comparable (const CAsiData *) const;
  3958.  
  3959.     virtual CAsiData *    checkAdd (const CAsiData *) const;
  3960.     virtual CAsiData *    checkSub (const CAsiData *) const;
  3961.  
  3962.     //  Get datetime field value
  3963.     //
  3964.     virtual ushort Year      (void) const = 0;
  3965.     virtual ushort Month     (void) const = 0;
  3966.     virtual ushort Day       (void) const = 0;
  3967.     virtual ushort Hour      (void) const = 0;
  3968.     virtual ushort Minute    (void) const = 0;
  3969.     virtual double Second    (void) const = 0;
  3970.  
  3971. protected:
  3972.  
  3973. };
  3974.  
  3975.  
  3976. ////////////////////////////////////////////////
  3977. //
  3978. //
  3979. class CAsiDate: public CAsiDatetime
  3980. //
  3981. // DATE
  3982. //
  3983. {
  3984. friend class CAsiTimeStamp;
  3985. friend class CAsiTempTable;
  3986.  
  3987. public:
  3988.  
  3989.     // Construction/Destruction
  3990.     //
  3991.             CAsiDate ();
  3992.             CAsiDate (const CAsiDate &);
  3993.     virtual ~CAsiDate (void);
  3994.  
  3995.     // Get data descriptor
  3996.     //
  3997.     virtual EAsiDTType   DateTimeType  (void) const;
  3998.     virtual uint         ReturnLength  (void) const;
  3999.  
  4000.     // Check storable
  4001.     virtual EAsiBoolean  is_storable   (const CAsiData *) const;
  4002.     virtual EAsiBoolean  is_castable   (const CAsiData *) const;
  4003.  
  4004.     // Store Data value
  4005.     //
  4006.     virtual EAsiBoolean  storeValue (char *, uint);
  4007.     virtual EAsiBoolean  storeValue (const CAsiUcStr &);
  4008.     virtual EAsiBoolean  storeValue (const CAsiData &);
  4009.  
  4010.     // Set date fields
  4011.     //
  4012.             EAsiBoolean  set      (ASI_DTDATE *);
  4013.             EAsiBoolean  set      (ushort, ushort, ushort);
  4014.             EAsiBoolean  setYear  (ushort);
  4015.             EAsiBoolean  setMonth (ushort);
  4016.             EAsiBoolean  setDay   (ushort);
  4017.  
  4018.     //  Get data value
  4019.     //
  4020.             EAsiBoolean  get      (ASI_DTDATE *)  const;
  4021.     virtual EAsiBoolean  getValue (char *, uint)  const;
  4022.     virtual EAsiBoolean  getValue (CAsiUcStr *)   const;
  4023.  
  4024.     virtual EAsiBoolean  SQLType    (CAsiUcStr *) const;        // SQL data type as string
  4025.     virtual EAsiBoolean  SQLLiteral (CAsiUcStr *) const;        // SQL compatible literal
  4026.  
  4027.     virtual ushort       Year      (void) const;
  4028.     virtual ushort       Month     (void) const;
  4029.     virtual ushort       Day       (void) const;
  4030.     virtual ushort       Hour      (void) const;
  4031.     virtual ushort       Minute    (void) const;
  4032.     virtual double       Second    (void) const;
  4033.  
  4034.     // ASI application/DBMS driver data exchange
  4035.     //
  4036.     virtual long          read           (char *, long, long) const;
  4037.     virtual long          size           (void) const;
  4038.  
  4039.     // Runtime class iteraction functions
  4040.     //
  4041.     virtual unsigned long packSize   (void) const;
  4042.     virtual unsigned long packTo     (void*) const;
  4043.     virtual EAsiBoolean   unpackFrom (void*);
  4044.  
  4045.     // Duplicate itself
  4046.     //
  4047.     virtual CAsiObject   *duplicate (void) const;
  4048.  
  4049.     // Operators
  4050.     //
  4051.      // Assignments
  4052.             CAsiDate    &operator=     (const CAsiDate &);
  4053.  
  4054.      // Arithmatics
  4055.             CAsiDate     operator+     (const CAsiYM &) const;
  4056.             CAsiDate     operator+     (const CAsiDT &) const;
  4057.      friend CAsiDate     operator+     (const CAsiYM &, const CAsiDate &);
  4058.      friend CAsiDate     operator+     (const CAsiDT &, const CAsiDate &);
  4059.  
  4060.             CAsiDate     operator-     (const CAsiYM &) const;
  4061.             CAsiDate     operator-     (const CAsiDT &) const;
  4062.  
  4063.             //   Dates difference , result corresponds with EAsiType value
  4064.  
  4065.             CAsiYM YMDiff (const CAsiDate &, const CAsiYM &)   const;
  4066.             CAsiDT DTDiff (const CAsiDate &, const CAsiDT &)   const;
  4067.  
  4068.      // Comparision
  4069.             int          operator>     (const CAsiDate &)      const;
  4070.             int          operator>=    (const CAsiDate &)      const;
  4071.             int          operator==    (const CAsiDate &)      const;
  4072.             int          operator<=    (const CAsiDate &)      const;
  4073.             int          operator<     (const CAsiDate &)      const;
  4074.             int          operator!=    (const CAsiDate &)      const;
  4075.  
  4076.  
  4077. protected:
  4078.     ulong month;      // Months since 00-00-00
  4079.     ushort day;       // Day of the month
  4080.  
  4081. };
  4082.  
  4083. ///////////////////////////////////////////
  4084. //
  4085. //
  4086. class CAsiTime : public CAsiDatetime
  4087. //
  4088. // TIME
  4089. //
  4090. {
  4091. friend class CAsiTimeStamp;
  4092. friend class CAsiTempTable;
  4093.  
  4094. public:
  4095.  
  4096.     // Construction/Destruction
  4097.     //
  4098.             CAsiTime  (void);
  4099.             CAsiTime  (const CAsiDT&);
  4100.             CAsiTime  (uint);
  4101.             CAsiTime  (uint, const CAsiDT&);
  4102.             CAsiTime  (const CAsiTime &);
  4103.     virtual ~CAsiTime (void);
  4104.  
  4105.  
  4106.             void         setWithTimeZone (EAsiBoolean f = kAsiTrue );
  4107.  
  4108.     // Get data descriptor
  4109.     //
  4110.     virtual EAsiDTType   DateTimeType  (void) const;
  4111.     virtual uint         TimePrec      (void) const;
  4112.     virtual uint         ReturnLength  (void) const;
  4113.  
  4114.     // Check storable
  4115.     virtual EAsiBoolean  is_storable   (const CAsiData *) const;
  4116.     virtual EAsiBoolean  is_castable   (const CAsiData *) const;
  4117.  
  4118.     // Store Data value
  4119.     //
  4120.     virtual EAsiBoolean  storeValue   (char *, uint);
  4121.     virtual EAsiBoolean  storeValue   (const CAsiUcStr &);
  4122.     virtual EAsiBoolean  storeValue   (const CAsiData &);
  4123.  
  4124.  
  4125.     // Set date value
  4126.     //
  4127.             EAsiBoolean  set           (ASI_DTTIME *);
  4128.             EAsiBoolean  set           (ushort, ushort, double);
  4129.             EAsiBoolean  setHour       (ushort);
  4130.             EAsiBoolean  setMinute     (ushort);
  4131.             EAsiBoolean  setSecond     (double);
  4132.             EAsiBoolean  setTimeZone   (const CAsiDT &);
  4133.  
  4134.     //  Get data value
  4135.     //
  4136.             EAsiBoolean  get          (ASI_DTTIME *) const;
  4137.     virtual EAsiBoolean  getValue     (char *, uint) const;
  4138.     virtual EAsiBoolean  getValue     (CAsiUcStr *)  const;
  4139.  
  4140.     virtual EAsiBoolean  SQLType      (CAsiUcStr *) const;        // SQL data type as string
  4141.     virtual EAsiBoolean  SQLLiteral   (CAsiUcStr *) const;        // SQL compatible literal
  4142.  
  4143.     virtual ushort       Year         (void) const {return 0;};
  4144.     virtual ushort       Month        (void) const {return 0;};
  4145.     virtual ushort       Day          (void) const {return 0;};
  4146.     virtual ushort       Hour         (void) const;
  4147.     virtual ushort       Minute       (void) const;
  4148.     virtual double       Second       (void) const;
  4149.       const CAsiDT      &TimeZone     (void) const;
  4150.  
  4151.     // ASI application/DBMS driver data exchange
  4152.     //
  4153.     virtual long          read           (char *, long, long) const;
  4154.     virtual long          size           (void) const;
  4155.  
  4156.     // Runtime class iteraction functions
  4157.     //
  4158.     virtual unsigned long packSize   (void) const;
  4159.     virtual unsigned long packTo     (void*) const;
  4160.     virtual EAsiBoolean   unpackFrom (void*);
  4161.  
  4162.     // Duplicate itself
  4163.     //
  4164.     virtual CAsiObject  *duplicate (void) const;
  4165.  
  4166.     // Operators
  4167.     //
  4168.             // Assignments
  4169.             CAsiTime    &operator=     (const CAsiTime &);
  4170.  
  4171.             // Arithmatics
  4172.             CAsiTime     operator+     (const CAsiDT &) const;
  4173.      friend CAsiTime     operator+     (const CAsiDT &, const CAsiTime &);
  4174.             CAsiTime     operator-     (const CAsiDT &) const;
  4175.  
  4176.             // Difference
  4177.             CAsiDT       DTDiff        (const CAsiTime &,const CAsiDT &) const;
  4178.  
  4179.             // Comparision
  4180.             int          operator>     (const CAsiTime &) const;
  4181.             int          operator>=    (const CAsiTime &) const;
  4182.             int          operator==    (const CAsiTime &) const;
  4183.             int          operator<=    (const CAsiTime &) const;
  4184.             int          operator<     (const CAsiTime &) const;
  4185.             int          operator!=    (const CAsiTime &) const;
  4186.  
  4187.  
  4188. private:
  4189.  
  4190.     ushort timeprec;   // Time precision
  4191.     double seconds;    // Seconds since 0:0 AM with fraction
  4192.     short  mod;        // Modifiyer
  4193.     CAsiDT timezone;
  4194. };
  4195.  
  4196. ///////////////////////////////////////////
  4197. //
  4198. //
  4199. class CAsiTimeStamp: public CAsiDatetime
  4200. //
  4201. // TIMESTAMP
  4202. //
  4203.  
  4204. // This class introduces functionality of the TIMESTAMP SQL data type
  4205. //
  4206. // MEMBER FUNCTIONS
  4207. // ----------------
  4208. // Constructors/Destructor
  4209. //
  4210. //  CAsiTimeStamp ()
  4211. //  CAsiTimeStamp (
  4212. //    uint tprec)           // Timestamp precision
  4213. //
  4214. // Two forms of constructor are provided. The second form allows to define 
  4215. // timestamp precision. If the first form of constructor
  4216. // is used, timestamp precision is set to 0.
  4217. //
  4218. //
  4219. // Set Timestamp fields
  4220. //   
  4221. // EAsiBoolean set (
  4222. //    ushort year,             // Year
  4223. //    ushort month,            // Month
  4224. //    ushort day,              // Day
  4225. //    ushort hour,             // Hour
  4226. //    ushort minute,           // Minute
  4227. //    double second)           // Second with fraction
  4228. //
  4229. // EAsiBoolean setYear (
  4230. //    ushort year)             // Year
  4231. //
  4232. // EAsiBoolean setMonth (
  4233. //    ushort month)            // Month
  4234. //
  4235. // EAsiBoolean setDay (
  4236. //    ushort day)              // Day
  4237. //
  4238. // EAsiBoolean setHour (
  4239. //    ushort hour)             // Hour
  4240. //
  4241. // EAsiBoolean setMinute (
  4242. //    ushort minute)           // Minute
  4243. //
  4244. // EAsiBoolean setSecond (
  4245. //    double second)           // Second with fraction
  4246. //
  4247. // These fiunctions are used to set datetime type and datetime fields.
  4248. //
  4249. // Year shall be greater or equal than 0;
  4250. // Month >= 1 and <= 12;
  4251. // Day >= 1 and <= actual number of days for each month;
  4252. // Hour >= 0 and <= 23
  4253. // Minute >= 0 and <= 59
  4254. // Second >= 0 and <= 59
  4255. // Second fraction is an unsigned short number that holds second fraction.
  4256. //
  4257. // Most of functions return boolean value bacause they must validate
  4258. // input arguments. For example, seconds can't be stored to the DATE or 
  4259. // month can be greater than 12. 
  4260. // 
  4261. //
  4262. // void get (
  4263. //    ushort *year,             // Year
  4264. //    ushort *month,            // Month
  4265. //    ushort *day,              // Day
  4266. //    ushort *hour,             // Hour
  4267. //    ushort *minute,           // Minute
  4268. //    double *second)           // Second with fraction
  4269. //
  4270. // ushort  Year ()
  4271. //
  4272. // ushort  Month ()
  4273. //
  4274. // ushort  Day ()
  4275. //
  4276. // ushort  Hour ()
  4277. //
  4278. // ushort  Minute ()
  4279. //
  4280. // double  Second ()
  4281. //
  4282. // The functions above extracts all or specified datetime fields.
  4283. //
  4284. //
  4285. // Operators
  4286. //
  4287. // All meaningful arithmetic and comparision operators are redefined by 
  4288. // this class. Description of them can be found in SQL/ISO standard (6.14). 
  4289. // Besides them special datetime operations are defined for the datetime 
  4290. // data.
  4291. // 
  4292. // CAsiIDateTime & at_time_zone (
  4293. //   CAsiDT &tz)         // Time zone value
  4294. //
  4295. // This function translate TIME or TIMESTAMP datetime according to the 
  4296. // time zone value specified as a internal hour or hour to minute day time 
  4297. // interval (see 6.14 SQL/ISO). Interval value shall be between -'12:59 and 
  4298. // +'13:00'. If wrong interval type was passed or 
  4299.  
  4300. {
  4301. friend class CAsiDate;
  4302. friend class CAsiTime;
  4303. friend class CAsiTempTable;
  4304. public:
  4305.  
  4306.     // Construction/Destruction
  4307.     //
  4308.             CAsiTimeStamp ();
  4309.             CAsiTimeStamp (uint);
  4310.             CAsiTimeStamp (const CAsiDT &);
  4311.             CAsiTimeStamp (uint, const CAsiDT &);
  4312.             CAsiTimeStamp (const CAsiTimeStamp &);
  4313.     virtual ~CAsiTimeStamp (void);
  4314.  
  4315.             void         setWithTimeZone (EAsiBoolean f = kAsiTrue );
  4316.  
  4317.     // Get data descriptor
  4318.     //
  4319.     virtual EAsiDTType   DateTimeType  (void) const;
  4320.     virtual uint         TimeStampPrec (void) const;
  4321.     virtual uint         ReturnLength  (void) const;
  4322.  
  4323.     // Check storable
  4324.     virtual EAsiBoolean  is_storable   (const CAsiData *) const;
  4325.     virtual EAsiBoolean  is_castable   (const CAsiData *) const;
  4326.  
  4327.     // Store Data value
  4328.     //
  4329.     virtual EAsiBoolean  storeValue  (char *, uint);
  4330.     virtual EAsiBoolean  storeValue  (const CAsiUcStr &);
  4331.     virtual EAsiBoolean  storeValue  (const CAsiData &);
  4332.  
  4333.  
  4334.     // Set timestamp fields
  4335.     //
  4336.             EAsiBoolean  set         (ASI_DTTIMESTAMP *);
  4337.             EAsiBoolean  set         (const CAsiDate &, const CAsiTime &);
  4338.             EAsiBoolean  set         (ushort, ushort, ushort, ushort,
  4339.                                       ushort, double);
  4340.             EAsiBoolean  setYear     (ushort);
  4341.             EAsiBoolean  setMonth    (ushort);
  4342.             EAsiBoolean  setDay      (ushort);
  4343.             EAsiBoolean  setHour     (ushort);
  4344.             EAsiBoolean  setMinute   (ushort);
  4345.             EAsiBoolean  setSecond   (double);
  4346.             EAsiBoolean  setTimeZone (const CAsiDT &);
  4347.  
  4348.     //  Get data value
  4349.     //
  4350.             EAsiBoolean  get           (ASI_DTTIMESTAMP *) const;
  4351.     virtual EAsiBoolean  getValue      (char *, uint)      const;
  4352.     virtual EAsiBoolean  getValue      (CAsiUcStr *)       const;
  4353.  
  4354.     virtual EAsiBoolean  SQLType       (CAsiUcStr *) const;        // SQL data type as string
  4355.     virtual EAsiBoolean  SQLLiteral    (CAsiUcStr *) const;        // SQL compatible literal
  4356.  
  4357.     virtual ushort       Year          (void) const;
  4358.     virtual ushort       Month         (void) const;
  4359.     virtual ushort       Day           (void) const;
  4360.     virtual ushort       Hour          (void) const;
  4361.     virtual ushort       Minute        (void) const;
  4362.     virtual double       Second        (void) const;
  4363.       const CAsiDT      &TimeZone      (void) const;
  4364.  
  4365.     // ASI application/DBMS driver data exchange
  4366.     //
  4367.     virtual long          read           (char *, long, long) const;
  4368.     virtual long          size           (void) const;
  4369.  
  4370.     // Runtime class iteraction functions
  4371.     //
  4372.     virtual unsigned long packSize   (void) const;
  4373.     virtual unsigned long packTo     (void*) const;
  4374.     virtual EAsiBoolean   unpackFrom (void*);
  4375.  
  4376.     // Duplicate itself
  4377.     //
  4378.     virtual CAsiObject  *duplicate (void) const;
  4379.  
  4380.     // Operators
  4381.     //
  4382.             // Assignments
  4383.             CAsiTimeStamp    &operator=     (const CAsiTimeStamp &);
  4384.             CAsiTimeStamp    &operator=     (const CAsiDate &);
  4385.             CAsiTimeStamp    &operator=     (const CAsiTime &);
  4386.  
  4387.             // Arithmatics
  4388.             CAsiTimeStamp    operator+     (const CAsiYM &) const;
  4389.             CAsiTimeStamp    operator+     (const CAsiDT &) const;
  4390.      friend CAsiTimeStamp    operator+     (const CAsiYM &, CAsiTimeStamp &);
  4391.      friend CAsiTimeStamp    operator+     (const CAsiDT &, CAsiTimeStamp &);
  4392.  
  4393.             CAsiTimeStamp    operator-     (const CAsiYM &) const;
  4394.             CAsiTimeStamp    operator-     (const CAsiDT &) const;
  4395.  
  4396.             //  Difference between timestamps
  4397.             CAsiYM    YMDiff (const CAsiTimeStamp &, const CAsiYM &) const;
  4398.             CAsiDT    DTDiff (const CAsiTimeStamp &, const CAsiDT &) const;
  4399.  
  4400.             // Comparision
  4401.             int               operator>     (const CAsiTimeStamp &) const;
  4402.             int               operator>=    (const CAsiTimeStamp &) const;
  4403.             int               operator==    (const CAsiTimeStamp &) const;
  4404.             int               operator<=    (const CAsiTimeStamp &) const;
  4405.             int               operator<     (const CAsiTimeStamp &) const;
  4406.             int               operator!=    (const CAsiTimeStamp &) const;
  4407.  
  4408.  
  4409.  
  4410. private:
  4411.     CAsiTime time;
  4412.     CAsiDate date;
  4413. };
  4414.  
  4415.  
  4416. class CAsiImplDef: public CAsiData
  4417. //
  4418. // Implementation defined data
  4419. //
  4420. // This class is supposed to be a superclass for all user-defined data.
  4421. // ASI provides facility for exchanging data in the generic format between
  4422. // application and driver.
  4423. //
  4424. // MEMBER FUNCTIONS
  4425. // -----------------
  4426. //
  4427. //  void  setType (
  4428. //   int type         // Implementation type
  4429. //  )
  4430. //
  4431. // Set implementation defined type.
  4432. //
  4433. {
  4434. public:
  4435.     //  Construction destruction
  4436.     //
  4437.             CAsiImplDef  (void);
  4438.     virtual ~CAsiImplDef (void);
  4439.  
  4440.     //  Get data descriptor
  4441.     //
  4442.     virtual EAsiDataType  Type          (void) const;
  4443.     virtual int           ImplDataType  (void) const;
  4444.  
  4445.     // Set implementation data type
  4446.     //
  4447.             void          setType       (int);
  4448.             void          setName       (const CAsiUcStr &);
  4449.  
  4450.     //  is_ functions
  4451.     //                                
  4452.     virtual EAsiBoolean   is_implement  (void) const;
  4453.  
  4454.  
  4455.     virtual EAsiBoolean   SQLType    (CAsiUcStr *) const;
  4456.     virtual EAsiBoolean   SQLLiteral (CAsiUcStr *) const;
  4457.  
  4458.     // ASI application/DBMS driver data exchange
  4459.     //
  4460.     virtual long          read           (char *, long, long) const;
  4461.     virtual long          size           (void) const;
  4462.  
  4463.     // Store Data value
  4464.     //
  4465.     virtual EAsiBoolean   storeValue     (const CAsiData &);
  4466.  
  4467.     // Runtime class iteraction functions
  4468.     //
  4469.     virtual unsigned long packSize   (void) const;
  4470.     virtual unsigned long packTo     (void*) const;
  4471.     virtual EAsiBoolean   unpackFrom (void*);
  4472.  
  4473.     // Duplicate itself
  4474.     //
  4475.     virtual CAsiObject   *duplicate (void) const;
  4476.  
  4477.     // Nullify all members
  4478.  
  4479.     virtual void          Clear     (void);
  4480.  
  4481. protected:
  4482.     int impltype;          // Implementation data type
  4483.     CAsiUcStr iname;       // Implemantation defined type name
  4484.  
  4485. };
  4486.  
  4487.  
  4488.  
  4489.  
  4490. ////////////////////////////////////////////////
  4491. //
  4492. //
  4493. class CAsiColumn : public CAsiObject
  4494. // This class introduces functionality of a table column. It holds a 
  4495. // column descriptor and column data. Column descriptor includes the 
  4496. // folowing issues, that can be set and retrieved by the CAsiColumn services:
  4497. // 
  4498. //  - Column name;
  4499. //  - Whether column name is an implementation defined;
  4500. //  - Domain, if column is based on it;
  4501. //  - Data type descriptor ;
  4502. //  - Collation name, if any;
  4503. //  - Value of the default option
  4504. //  - Nullability characteristics
  4505. //  - Ordinal position of column within table
  4506. //
  4507. //
  4508.  
  4509.  
  4510. {
  4511. public:
  4512.             CAsiColumn (void);
  4513.             CAsiColumn (const CAsiIdent &);
  4514.             CAsiColumn (const CAsiIdent &, const CAsiSmallInt &);
  4515.             CAsiColumn (const CAsiIdent &, const CAsiInt &);
  4516.             CAsiColumn (const CAsiIdent &, const CAsiNumeric &);
  4517.             CAsiColumn (const CAsiIdent &, const CAsiDecimal &);
  4518.             CAsiColumn (const CAsiIdent &, const CAsiFloat &);
  4519.             CAsiColumn (const CAsiIdent &, const CAsiReal &);
  4520.             CAsiColumn (const CAsiIdent &, const CAsiDouble &);
  4521.             CAsiColumn (const CAsiIdent &, const CAsiChar &);
  4522.             CAsiColumn (const CAsiIdent &, const CAsiBinary &);
  4523.             CAsiColumn (const CAsiIdent &, const CAsiDate &);
  4524.             CAsiColumn (const CAsiIdent &, const CAsiTime &);
  4525.             CAsiColumn (const CAsiIdent &, const CAsiTimeStamp &);
  4526.             CAsiColumn (const CAsiIdent &, const CAsiYM &);
  4527.             CAsiColumn (const CAsiIdent &, const CAsiDT &);
  4528.             CAsiColumn (const CAsiIdent &, const CAsiIdent &); // By domain name
  4529.             CAsiColumn (const CAsiIdent &, CAsiData *);        // By generic data
  4530.             CAsiColumn (const CAsiColumn &);                   // copy constructor
  4531.  
  4532.     virtual ~CAsiColumn ();
  4533.     // Setting Column Descriptor
  4534.     //                                             
  4535.             void          setName      (const CAsiIdent &);  // Set column name
  4536.             void          setNullable  (EAsiBoolean);        // Set nullability
  4537.             void          setNative    (EAsiBoolean);        // Set native flag
  4538.             void          setCollation (const CAsiUcStr &);  // Set collation name
  4539.             void          setDefault   (CAsiData *);         // Set Default data
  4540.             void          setDomain    (const CAsiIdent &);  // Set Domain name
  4541.             void          setDataDsc   (CAsiData *);         // Set data descriptor
  4542.             void          setOffset    (uint);               // Set Ordinal position
  4543.  
  4544.     // Read Column Descriptor
  4545.     //
  4546.       const CAsiIdent   & Name         (void) const;         // Get column name
  4547.             EAsiBoolean   Nullable     (void) const;         // Get nullability
  4548.             EAsiBoolean   Native       (void) const;         // Get native flag
  4549.       const CAsiUcStr   * Collation    (void) const;         // Get collation name
  4550.             CAsiData    * Default      (void) const;         // Get Default data
  4551.       const CAsiIdent   & Domain       (void) const;         // Get Domain name
  4552.             uint          Offset       (void) const;         // Get Ordinal position
  4553.  
  4554.     // Get Access to Column Data Descriptor and Data
  4555.     //
  4556.             CAsiData    * getData (void) const;
  4557.  
  4558.     // Overloaded operators
  4559.             
  4560.             CAsiColumn  & operator= (const CAsiColumn &);
  4561.             CAsiColumn  & operator= (CAsiData *);
  4562.  
  4563.     // Runtime class iteraction functions
  4564.     //
  4565.     virtual unsigned long packSize   (void) const;
  4566.     virtual unsigned long packTo     (void*) const;
  4567.     virtual EAsiBoolean   unpackFrom (void*);
  4568.  
  4569.     // Duplicate column
  4570.     //
  4571.     virtual CAsiObject *duplicate    (void) const;
  4572.  
  4573.     // Nullify all members
  4574.  
  4575.     virtual void        Clear        (void);  
  4576.  
  4577. protected:
  4578.     CAsiIdent    name;        // Column name
  4579.     CAsiData   * data;        // Column data descriptor and data
  4580.     
  4581.     EAsiBoolean  nullable;    // Nullability
  4582.     EAsiBoolean  native;      // Is native 
  4583.     CAsiData   * defval;      // Default value
  4584.     CAsiIdent    domain;      // Domain name
  4585.     uint         offset;      // Offset within table
  4586. };
  4587.  
  4588.  
  4589.  
  4590. ////////////////////////////////////////////////
  4591. //
  4592. //
  4593. class CAsiRow : public CAsiObject
  4594. //
  4595. //  This class introduces functionality of a column collection
  4596. //  
  4597. {
  4598. public:
  4599.             CAsiRow (int ColNum);
  4600.             CAsiRow (const CAsiRow &);
  4601.     virtual ~CAsiRow ();
  4602.  
  4603.             int          ColNum      (void) const;
  4604.             CAsiColumn & operator [] (int) const;
  4605.             int          findCol     (const CAsiIdent &) const;
  4606.             EAsiBoolean  isDistinct  (void) const;
  4607.     virtual CAsiObject * duplicate   (void) const;
  4608.     // Nullify all members
  4609.     virtual void         Clear        (void);  
  4610.  
  4611. private:
  4612.     CAsiColumn *columns;    // Columns data
  4613.     int         colnum;     // Number of columns in row 
  4614. };
  4615.  
  4616.  
  4617.  
  4618. ////////////////////////////////////////////////
  4619. //
  4620. //
  4621. class CAsiHostBuffer: public CAsiObject
  4622. //
  4623. // This class holds information about host variable buffer. Host variable
  4624. // buffer has a dual usage in ASI: it is either as a source for dynamic 
  4625. // parameters input or a destination for column value output.
  4626. // CAsiHostBuffer is a base class for CAsiParameter class, designating the
  4627. // fact that parameter has to be linked with the host variable buffer.
  4628. //
  4629. //  virtual EAsiBoolean setBind (
  4630. //    CAsiData *pData        // Pointer to host buffer
  4631. //   )
  4632. //  Bind parameter with data buffer in the host program. Host buffer
  4633. //  is represented as a CAsiData object.
  4634. //  Function returns kAsiTrue if succeeded and kAsiFalse otherwise.
  4635. //
  4636. //
  4637. //
  4638. //  virtual EAsiBoolean getBind (
  4639. //    CAsiData  **ppData         // Storage of pointer to host buffer
  4640. //   )
  4641. //
  4642. //  This function stores pointer to the host memory buffer into provided 
  4643. //  memory location.
  4644. //  kAsiFalse is returned if parameter was not bound with host buffer, or 
  4645. //  other abnormal situation occured.
  4646. //
  4647. {
  4648. friend class CAsiCsr;
  4649. friend class CAsiStm;
  4650.  
  4651. public:
  4652.     // Construction/descriptor
  4653.     //
  4654.              CAsiHostBuffer ();
  4655.     virtual ~CAsiHostBuffer ();
  4656.  
  4657.     // Getting bound variable address
  4658.     //
  4659.     virtual EAsiBoolean getBind (CAsiData **) const;
  4660.  
  4661.     // Runtime class iteraction functions
  4662.     //
  4663.     virtual unsigned long packSize   (void) const = 0;
  4664.     virtual unsigned long packTo     (void*) const = 0;
  4665.     virtual EAsiBoolean   unpackFrom (void*) = 0;
  4666.  
  4667. protected:
  4668.     // Binding parameter with host variable buffer
  4669.     //
  4670.     virtual EAsiBoolean setBind (CAsiData *);
  4671.  
  4672.  
  4673. protected:
  4674.     CAsiData *pData;      // Pointer to data
  4675. };
  4676.  
  4677.  
  4678. ////////////////////////////////////////////////
  4679. //
  4680. //
  4681. class CAsiParameter: public CAsiHostBuffer
  4682. //
  4683. // This class describes dynamic parameter or variable reference in the SQL 
  4684. // statement and its link with the host program buffer. It inherits 
  4685. // functionality of the CAsiHostBuffer supercalss and reloads setBind()
  4686. // member function.
  4687. //
  4688. //  EAsiBoolean setBind (
  4689. //    CAsiData *pData,            // Pointer to host buffer
  4690. //    )
  4691. //
  4692. //  Bind parameter with the host program buffer. Function also checks
  4693. //  whether the host variable type matches the parameter type. Return
  4694. //  kAsiTrue if succeded, and kAsiFalse otherwise. Can set and push
  4695. //  complition in DDA if types mismatch error was detected.
  4696. //
  4697. {
  4698. // Friend classes
  4699. //
  4700. friend class CAsiParser;
  4701. friend class CAsiStm;
  4702. friend class CAsiDDAParams;
  4703. friend class CAsiHostLink;
  4704. friend class CAsiInterDBCursor;
  4705. friend class CAsiEmulCursor;
  4706. friend class CAsiEmulTable;
  4707.  
  4708. public:
  4709.     // Construction/descriptor
  4710.     //
  4711.     CAsiParameter ();
  4712.     virtual ~CAsiParameter ();
  4713.  
  4714. protected:
  4715.     // Bind parameter with host buffer
  4716.     //
  4717.     virtual EAsiBoolean setBind     (CAsiData *);
  4718.  
  4719. public:
  4720.     // Setting parameter characteristics
  4721.     //
  4722.             void        setName     (const CAsiIdent &);  // name
  4723.             void        setNullable (EAsiBoolean);        // nullability characteristics
  4724.             void        setDsc      (CAsiData*);          // data descriptor
  4725.  
  4726.     // Getting parameter characteristics
  4727.     //
  4728.       const CAsiIdent  &Name        (void) const;  // name
  4729.             EAsiBoolean isNullable  (void) const;  // nullability characteristics
  4730.             CAsiData   *Dsc         (void) const;  // data descriptor
  4731.  
  4732.     // Runtime class iteraction functions
  4733.     //
  4734.     virtual unsigned long packSize   (void) const;
  4735.     virtual unsigned long packTo     (void*) const;
  4736.     virtual EAsiBoolean   unpackFrom (void*);
  4737. private:
  4738.     virtual CAsiObject * duplicate   (void) const;
  4739.     // Nullify all members
  4740.     virtual void        Clear        (void);  
  4741.  
  4742. private:
  4743.     CAsiIdent ucParName;       // Parameter name
  4744.     CAsiData *pDataDescriptor; // Parameter data descriptor
  4745.     EAsiBoolean eNul;          // Nullability characteristics
  4746. };
  4747.  
  4748.  
  4749. ////////////////////////////////////////////////
  4750. //  Extern function prototypes
  4751. //
  4752. extern "C" {
  4753. void                      AsiExceptionThrow (CAsiException*);
  4754. }
  4755.  
  4756.  
  4757. #endif /* ASI_ASICLASS_HH */
  4758. /*EOF*/
  4759.