Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

dbobjgetstreamer.cpp

Go to the documentation of this file.
00001 //============================================================================= 
00002 //
00003 // XDFLengine library
00004 //
00005 //----------------------------------------------------------------------------- 
00006 //  DBOBJGetStreamer.CPP
00007 //----------------------------------------------------------------------------- 
00013 //_____________________________________________________________________________
00014 //
00015 //  Copyright (C) 2003 Guillaume Baurand. All Rights Reserved.
00016 //
00017 //  This file is part of the XDFLengine project.
00018 //
00019 //  The XDFLengine is free software; you can redistribute it and/or modify
00020 //  it under the terms of the GNU General Public License as published by
00021 //  the Free Software Foundation; either version 2 of the License, or
00022 //  (at your option) any later version.
00023 //
00024 //  This program is distributed in the hope that it will be useful,
00025 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
00026 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00027 //  GNU General Public License for more details.
00028 //
00029 //  You should have received a copy of the GNU General Public License
00030 //  along with this program; if not, write to the Free Software
00031 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
00032 //  USA.
00033 //
00034 //  For more information, 
00035 //      contact  : guillaume@baurand.net 
00036 //      or visit : http://xdflengine.sourceforge.net
00037 //
00038 //=============================================================================
00039 
00040 #   include "dbobjgetstreamer.hpp"
00041 #   include "processor/xmlflowcontext.hpp"
00042 #   include "streamers/db/dbobject/dbobjdefinition.hpp"
00043 #   include "streamers/db/dbobject/dbget/dbobjgetstatement.hpp"
00044 
00045 BEGIN_XDFLENGINE_NS
00046 
00047 //============================================================================= 
00048 //  CLASS DBOBJGetStreamer
00049 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
00050 
00051     //_____________________________________________________________________
00052     //  DBOBJGetStreamer
00053     //---------------------------------------------------------------------
00054     DBOBJGetStreamer::DBOBJGetStreamer( const XMLStreamerFactory* p_pParent, StreamerParams* p_pParameters, XMLFlowContext* p_pContext, XMLStreamConsumer* p_pOutput, ContentHandler* p_pHandler,const DBOBJDefinitionNode* p_pDBOBJDefinitionRoot,  DBOBJDefinitionNode* p_pDBOBJOwnedDefinitionRoot)
00055     :SaxStreamer( p_pParent, p_pParameters, p_pContext, p_pOutput, p_pHandler, false)
00056     {
00057         m_pDBOBJDefinitionRoot = p_pDBOBJDefinitionRoot;
00058         m_pDBOBJOwnedDefinitionRoot = p_pDBOBJOwnedDefinitionRoot;
00059         DEBUG_CREATE(AutodescStreamer)
00060     }
00061     
00062     //_____________________________________________________________________
00063     //  ~DBOBJGetStreamer
00064     //---------------------------------------------------------------------     
00065     DBOBJGetStreamer::~DBOBJGetStreamer()
00066     {
00067         while (!m_vaStatements.empty()) releaseCharBuffer( m_vaStatements.pop());
00068         while (!m_vaNamedData.empty())
00069         {
00070             delStream( m_vaNamedData.pop());
00071         }
00072 
00073         delete m_pDBOBJOwnedDefinitionRoot;
00074 
00075         // release connection
00076         if(m_pConnection) ((DBStreamerFactory*) m_pParent)->releaseConnection(m_pszConnName, m_pContext->getThreadId());
00077 
00078         m_pszConnName = releaseCharBuffer(m_pszConnName);
00079         m_pszMaxItems = releaseCharBuffer( m_pszMaxItems);
00080 
00081 
00082         DEBUG_DEL(AutodescStreamer)
00083     }
00084 
00085     //_____________________________________________________________________
00086     //  COMMITSTREAM
00087     //---------------------------------------------------------------------
00088     bool DBOBJGetStreamer::commitStream(bool p_fFinal)
00089     {
00090         //---------------------------------------------------------------------
00091         bool                    l_fOK;
00092         //---------------------------------------------------------------------
00093 
00094         PREP_CATCH_XML_FLOW_ERROR;
00095 
00096         DEBUG_IN(DBOBJGetStreamer::commitStream)
00097 
00098         l_fOK = SaxStreamer::commitStream( p_fFinal);
00099 
00100         if(l_fOK && p_fFinal)
00101         {   
00102             // get definition
00103             WATCH_XML_FLOW_ERROR
00104             {
00105 
00106                 // get request parameters
00107                 m_boolFlat=false;
00108                 if ( strcmp( XMLStreamer::getParamValue( m_pParameters, DBOBJGETSTREAMER_FLAT, DBOBJGETSTREAMER_FLAT_DEF ) , REQ_TRUE ) == 0 ) m_boolFlat=true;
00109                 m_pszMaxItems = importCharBuffer(0, XMLStreamer::getParamValue( m_pParameters,  DBOBJGETSTREAMER_MAXITEMS,  DBOBJGETSTREAMER_MAXITEMS_DEF ));
00110                 if ( strcmp( m_pszMaxItems, "0") != 0 ) m_boolFlat=true;
00111                 m_intBufSize =  atoi( XMLStreamer::getParamValue( m_pParameters,  DBOBJGETSTREAMER_OTL_BUFFER,  DBOBJGETSTREAMER_OTL_BUFFER_DEF ));
00112                 m_uiStreamObjects= atoi( XMLStreamer::getParamValue( m_pParameters, DBOBJGETSTREAMER_STREAMOBJECTS,DBOBJGETSTREAMER_STREAMOBJECTS_DEF));
00113 
00114 
00115                 // get statement object tree
00116                 m_pDBOBJGetStatementRoot=((DBOBJGetStatementSAXBuilder*)m_pHandler)->getStatementRoot();
00117 
00118                 // get connection                
00119                 m_pszConnName = importCharBuffer( 0, getParamValue(m_pParameters, DBOBJGETSTREAMER_CONNECTION));
00120                 m_pConnection = ((DBStreamerFactory*) m_pParent)->getConnection(m_pszConnName, m_pContext->getThreadId()  );
00121 
00122                 // Build SQL
00123                 buildSELECTStatement( m_pDBOBJDefinitionRoot, m_pDBOBJGetStatementRoot, 0, 0, 0, 0, 0);
00124 
00125                 // execute SQL
00126                 executeSQL();
00127 
00128                 // build XML
00129                 makeXML();
00130 
00131 
00132             } 
00133             CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN ;
00134             
00135         }
00136 
00137     RELEASE_AND_RETURN:
00138         
00139 
00140         ON_XML_FLOW_ERROR_DO l_fOK = false;
00141 
00142         DEBUG_OUT(DBOBJGetStreamer::commitStream)
00143 
00144         ON_XML_FLOW_ERROR_THROW;            
00145         return l_fOK;
00146     }
00147 
00148     //_________________________________________________________________________
00149     //  BUILDSELECTSTATEMENT
00150     //-------------------------------------------------------------------------
00151     void DBOBJGetStreamer::buildSELECTStatement( const DBOBJDefinitionNode* p_pDBOBJDefNode,
00152                                                 DBOBJGetStatementNode*  p_pDBOBJStmtNode,
00153                                                 unsigned int            p_uiDepth,
00154                                                 const char*             p_pszParentFROM,
00155                                                 const char*             p_pszParentJOIN,
00156                                                 const char*             p_pszParentWHERE,
00157                                                 const char*             p_pszParentORDER)
00158     {
00159         //---------------------------------------------------------------------
00160         DBOBJDefinitionNode*    l_pSAXDB_defSubNode;
00161         DBOBJGetStatementNode*  l_pSAXDB_stmtSubNode;
00162 
00163         const char*             l_pszNodeName = 0;
00164 
00165         char*                   l_pszSELECT = 0;
00166         char*                   l_pszFROM = 0;
00167         char*                   l_pszJOIN = 0;
00168         char*                   l_pszWHERE = 0;
00169         char*                   l_pszJOINORDER = 0;
00170         char*                   l_pszORDER = 0;
00171         char*                   l_pszSQLStmt = 0;
00172         const char*             l_pszWHERESEP = 0;
00173         const char*             l_pszORDERSEP = 0;
00174 
00175         unsigned int            l_uiSubNodesCount;
00176         unsigned int            i;
00177         //---------------------------------------------------------------------
00178 
00179         DEBUG_IN(DBOBJGetStreamer::buildSQLStatement)
00180         PREP_CATCH_XML_FLOW_ERROR;
00181         
00182         WATCH_XML_FLOW_ERROR { 
00183 
00184             l_pszNodeName = p_pDBOBJDefNode->getName();
00185 
00186             // make SELECT clause
00187             l_pszSELECT = buildSQLSELECT( p_pDBOBJDefNode, p_uiDepth);
00188             // make FROM clause
00189             l_pszFROM = buildSQLFROM( p_pDBOBJDefNode, p_uiDepth, p_pszParentFROM);
00190             // make JOIN clause
00191             l_pszJOIN =  buildSQLJOIN( p_pDBOBJDefNode, p_uiDepth, p_pszParentJOIN);
00192             // make WHERE clause
00193             l_pszWHERE = buildSQLWHERE( p_pDBOBJDefNode, p_pDBOBJStmtNode, p_uiDepth, p_pszParentWHERE);
00194             // make ORDER clause
00195             l_pszORDER = buildSQLORDER( p_pDBOBJDefNode, p_pDBOBJStmtNode, p_uiDepth, p_pszParentORDER);
00196             // make JOIN ORDER clause
00197             l_pszJOINORDER = buildSQLJOINORDER( p_pDBOBJDefNode, p_uiDepth, l_pszORDER ); 
00198 
00199             l_pszWHERESEP="";
00200             if(l_pszJOIN && l_pszWHERE) if( ( strlen( l_pszJOIN) > 0 ) && ( strlen( l_pszWHERE) > 0 ) ) l_pszWHERESEP=" AND ";
00201             l_pszORDERSEP="";
00202             if(l_pszJOINORDER && l_pszORDER) l_pszORDERSEP=" , ";  
00203 
00204             // complete statement ...
00205             l_pszSQLStmt = copyCharBuffer( l_pszNodeName);
00206             l_pszSQLStmt = concatCharBuffer( l_pszSQLStmt, DBOBJGETSTREAMER_SQLSEP);
00207 
00208             // SELECT
00209             l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, "SELECT ");
00210 
00211             if( p_pDBOBJDefNode->isDistinct() ) l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, "DISTINCT ");
00212 
00213             if (g_uiSQLSyntax==SQL_SYNTAX_MSSQL)
00214             {
00215                 // MAXITEMS (SQL SERVER)
00216                 if( m_boolFlat && (p_uiDepth == 0) && ( strcmp( m_pszMaxItems,"0" ) != 0 ) )
00217                 {
00218                     l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, " TOP ");
00219                     l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, m_pszMaxItems);
00220                     l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, " ");
00221                 }
00222             }
00223 
00224             l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, l_pszSELECT);
00225 
00226             // FROM
00227             l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt," FROM ");
00228             l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, l_pszFROM);
00229 
00230             // WHERE
00231             l_pszWHERESEP=" WHERE ";
00232             if(l_pszJOIN)
00233             {
00234                 l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, " WHERE ");
00235                 l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, l_pszJOIN);
00236                 if(l_pszWHERE)
00237                 {
00238                     l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, " AND ");
00239                     l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, l_pszWHERE);
00240                 }
00241                 l_pszWHERESEP=" AND ";
00242             }
00243             else
00244             {
00245                 if(l_pszWHERE)
00246                 {
00247                     l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, " WHERE ");
00248                     l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, l_pszWHERE);
00249                     l_pszWHERESEP=" AND ";
00250                 }
00251             }
00252             
00253             if (DBStreamerFactory::getSQLSyntax()==SQL_SYNTAX_ORA)
00254             {
00255                 // MAXITEMS (ORA)
00256                 if( m_boolFlat && (p_uiDepth == 0) && ( strcmp( m_pszMaxItems,"0" ) != 0 ) )
00257                 {
00258                     l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, l_pszWHERESEP);
00259                     l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, " ROWNUM <=");
00260                     l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, m_pszMaxItems);
00261                 }
00262             }
00263 
00264             // ORDER BY
00265             if( l_pszJOINORDER )
00266             {
00267                 l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, " ORDER BY "            );
00268                 l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, l_pszJOINORDER );
00269                 l_pszSQLStmt =  concatCharBuffer( l_pszSQLStmt, "\n");
00270             }
00271 
00272             // ... and store it for further use
00273             //logout << "\n>" << l_pszSQLStmt << "\n";
00274             pushSQLStatement( l_pszSQLStmt);
00275 
00276             // RECURSE
00277             if( !m_boolFlat )
00278             {
00279                 l_uiSubNodesCount = p_pDBOBJDefNode->getChildNodesCount();
00280                 for( i=0 ; i< l_uiSubNodesCount ; i++)
00281                 {
00282                     l_pSAXDB_defSubNode = p_pDBOBJDefNode->getChildNode(i);
00283 
00284                     if(p_pDBOBJStmtNode) l_pSAXDB_stmtSubNode = p_pDBOBJStmtNode->getChildNode( l_pSAXDB_defSubNode->getName());
00285                     else l_pSAXDB_stmtSubNode=0;
00286 
00287                     buildSELECTStatement( l_pSAXDB_defSubNode, l_pSAXDB_stmtSubNode, p_uiDepth+1, l_pszFROM, l_pszJOIN, l_pszWHERE, l_pszJOINORDER);
00288                 }
00289             }
00290 
00291         } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  
00292 
00293     RELEASE_AND_RETURN: 
00294 
00295         releaseCharBuffer( l_pszSELECT);
00296         releaseCharBuffer( l_pszFROM);
00297         releaseCharBuffer( l_pszJOIN);
00298         releaseCharBuffer( l_pszWHERE);
00299         releaseCharBuffer( l_pszJOINORDER);
00300         releaseCharBuffer( l_pszORDER);
00301         releaseCharBuffer( l_pszSQLStmt);
00302 
00303         DEBUG_OUT(DBOBJGetStreamer::buildSQLStatement)
00304         ON_XML_FLOW_ERROR_THROW;    
00305     }
00306 
00307     //_________________________________________________________________________
00308     //  BUILDSQLSELECT
00309     //-------------------------------------------------------------------------
00310     char* DBOBJGetStreamer::buildSQLSELECT( const DBOBJDefinitionNode*  p_pDBOBJDefNode,
00311                                             unsigned int            p_uiDepth) const
00312     {
00313         //---------------------------------------------------------------------
00314         char                    l_cTmp[50];
00315         char*                   l_pszSQL = 0;
00316         
00317         DBOBJDefinitionField*   l_pSAXDB_defField;
00318         const DBOBJDefinitionNode*  l_pSAXDB_defParent;
00319 
00320         unsigned int            i;
00321         unsigned int            j;
00322         unsigned int            l_uiFieldsCount;
00323 
00324         const char*             l_pszNodeName = 0;
00325         const char*             l_pszFieldAlias = 0;
00326         const char*             l_pszFieldDBName = 0;
00327         const char*             l_pszParentName = 0;
00328         const char*             l_pszParentKey = 0;
00329         const char*             l_pszSep = 0;
00330         const char*             l_pszMap = 0;
00331         const char*             l_pszDateFormat = 0;
00332         //---------------------------------------------------------------------
00333 
00334         DEBUG_IN(DBOBJGetStreamer::buildSQLSELECT)
00335         PREP_CATCH_XML_FLOW_ERROR;
00336         
00337         WATCH_XML_FLOW_ERROR { 
00338 
00339             l_pszNodeName = p_pDBOBJDefNode->getName();
00340             l_pszSep=" ";
00341             // add the parent keys for tree linking
00342             if( p_uiDepth>0 )
00343             {   
00344                 l_pSAXDB_defParent = p_pDBOBJDefNode;
00345                 for( i=0 ; i < p_uiDepth ; i++)
00346                 {   
00347                     // for all the ancestors
00348                     l_pSAXDB_defParent =    l_pSAXDB_defParent->getParent();
00349                     l_pszParentName =       l_pSAXDB_defParent->getName();
00350                     l_uiFieldsCount =       l_pSAXDB_defParent->getPkeysCount();
00351             
00352                     
00353                     for( j=0 ; j < l_uiFieldsCount ; j++)
00354                     {   
00355                         // for each key of the parent
00356                         l_pszParentKey = l_pSAXDB_defParent->getPkey(j)->getDBField();
00357 
00358                         l_pszSQL = concatCharBuffer( l_pszSQL, l_pszSep);
00359                         l_pszSQL = concatCharBuffer( l_pszSQL, l_pszParentName );
00360                         l_pszSQL = concatCharBuffer( l_pszSQL, ".");
00361                         l_pszSQL = concatCharBuffer( l_pszSQL, l_pszParentKey );
00362                         l_pszSQL = concatCharBuffer( l_pszSQL, " AS "         );
00363                         l_pszSQL = concatCharBuffer( l_pszSQL, DBOBJGETSTREAMER_PARPKEY);
00364 
00365                         sprintf( (char*)  &l_cTmp, "%d", (p_uiDepth-i-1));
00366                         l_pszSQL = concatCharBuffer( l_pszSQL, l_cTmp);
00367                         l_pszSQL = concatCharBuffer( l_pszSQL, "_");
00368 
00369                         sprintf( (char*)  &l_cTmp, "%d", (j));
00370                         l_pszSQL = concatCharBuffer( l_pszSQL, l_cTmp);
00371 
00372                         l_pszSep=", ";
00373                     }
00374                 }
00375             }
00376 
00377             // walk on node's fields
00378             l_uiFieldsCount = p_pDBOBJDefNode->getFieldsCount();
00379             for( i=0 ; i < l_uiFieldsCount; i++ )
00380             {
00381                 l_pSAXDB_defField = p_pDBOBJDefNode->getField(i);
00382                 // get field name
00383                 l_pszFieldAlias = l_pSAXDB_defField->getDBAlias();
00384                 // get DB field name
00385                 l_pszFieldDBName = l_pSAXDB_defField->getDBField();
00386                 //get reduced data type
00387                 l_pszMap = l_pSAXDB_defField->getMap();
00388                 // get Date format
00389                 if( strcmp( l_pszMap, DBOBJDEFFIELD_MAP_DATE) == 0 )  l_pszDateFormat = l_pSAXDB_defField->getDateFormat();
00390 
00391                 
00392                 if ( !l_pSAXDB_defField->isHidden() )
00393                 {   // if not hidden, select it      
00394                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszSep);   
00395                     if (DBStreamerFactory::getSQLSyntax()==SQL_SYNTAX_ORA)
00396                     {                                   
00397                         if( strcmp( l_pszMap, DBOBJDEFFIELD_MAP_DATE) == 0 )
00398                         {
00399                             l_pszSQL = concatCharBuffer( l_pszSQL, "TO_CHAR(");
00400                         }
00401                     }
00402                     else if (DBStreamerFactory::getSQLSyntax()==SQL_SYNTAX_MSSQL)   
00403                     {                               
00404                         if( strcmp( l_pszMap, DBOBJDEFFIELD_MAP_DATE) == 0 )
00405                         {
00406                             l_pszSQL = concatCharBuffer( l_pszSQL, "CONVERT(varchar(29),");
00407                         }
00408                     }                       
00409                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszNodeName);
00410                     l_pszSQL = concatCharBuffer( l_pszSQL, "."); 
00411                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszFieldDBName);
00412                     if (DBStreamerFactory::getSQLSyntax()==SQL_SYNTAX_ORA)      
00413                     {
00414                         if( strcmp( l_pszMap, DBOBJDEFFIELD_MAP_DATE) == 0 )
00415                         {
00416                             l_pszSQL = concatCharBuffer( l_pszSQL, ",'"); 
00417                             l_pszSQL = concatCharBuffer( l_pszSQL, l_pszDateFormat);
00418                             l_pszSQL = concatCharBuffer( l_pszSQL, "')"); 
00419                         }
00420                     }
00421                     else if (DBStreamerFactory::getSQLSyntax()==SQL_SYNTAX_MSSQL)
00422                     {                                   
00423                         if( strcmp( l_pszMap, DBOBJDEFFIELD_MAP_DATE) == 0 )
00424                         {
00425                             l_pszSQL = concatCharBuffer( l_pszSQL, ","); 
00426                             l_pszSQL = concatCharBuffer( l_pszSQL, l_pszDateFormat);
00427                             l_pszSQL = concatCharBuffer( l_pszSQL, ")"); 
00428                         }
00429                     }                   
00430                     l_pszSQL = concatCharBuffer( l_pszSQL, " AS ");
00431                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszFieldAlias);
00432                 }
00433                 else
00434                 {   // else select as NULL        
00435                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszSep);
00436                     l_pszSQL = concatCharBuffer( l_pszSQL, " NULL AS ");
00437                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszFieldAlias);
00438                 }
00439                 l_pszSep=", ";
00440             }
00441 
00442 
00443             // add keys to transmit to children for parent / child linking
00444             if(!m_boolFlat)
00445             {
00446                 l_uiFieldsCount = p_pDBOBJDefNode -> getPkeysCount();
00447                 for( i=0 ; i<l_uiFieldsCount ; i++)
00448                 {   // for each key of current node ...
00449 
00450                     sprintf( (char*)  &l_cTmp, "%d", (i));
00451 
00452                     l_pszFieldDBName = p_pDBOBJDefNode->getPkey(i)->getDBField();    
00453                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszSep);
00454                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszNodeName);
00455                     l_pszSQL = concatCharBuffer( l_pszSQL, "."); 
00456                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszFieldDBName);
00457                     l_pszSQL = concatCharBuffer( l_pszSQL, " AS ");
00458                     l_pszSQL = concatCharBuffer( l_pszSQL, DBOBJGETSTREAMER_SELFPKEY);     
00459                     l_pszSQL = concatCharBuffer( l_pszSQL, l_cTmp );  
00460                     l_pszSep=", ";
00461                 }
00462             }
00463 
00464         } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  
00465 
00466     RELEASE_AND_RETURN: 
00467 
00468         DEBUG_OUT(DBOBJGetStreamer::buildSQLSELECT)
00469         ON_XML_FLOW_ERROR_DO
00470         {
00471             releaseCharBuffer( l_pszSQL);
00472             l_pszSQL=0;
00473         }
00474 
00475         ON_XML_FLOW_ERROR_THROW;    
00476         return l_pszSQL;
00477     }
00478 
00479     //_________________________________________________________________________
00480     //  BUILDSQLFROM
00481     //-------------------------------------------------------------------------
00482     char* DBOBJGetStreamer::buildSQLFROM(   const DBOBJDefinitionNode*  p_pDBOBJDefNode,
00483                                             unsigned int            p_uiDepth,
00484                                             const char*             p_pszParentFROM ) const
00485     {
00486         //---------------------------------------------------------------------
00487         char*           l_pszOut = 0;
00488         const char*     l_pszNodeName = 0;
00489         const char*     l_pszNodeTable = 0;
00490         //---------------------------------------------------------------------
00491 
00492         DEBUG_IN(DBOBJGetStreamer::buildSQLFROM)
00493         PREP_CATCH_XML_FLOW_ERROR;
00494         
00495         WATCH_XML_FLOW_ERROR { 
00496 
00497             l_pszNodeName = p_pDBOBJDefNode->getName();
00498             l_pszNodeTable = p_pDBOBJDefNode->getDBTable();
00499 
00500             // if not root, add parents tables
00501             l_pszOut = copyCharBuffer( p_pszParentFROM);
00502             if( p_uiDepth > 0) l_pszOut = concatCharBuffer( l_pszOut, ", ");
00503             l_pszOut = concatCharBuffer( l_pszOut, l_pszNodeTable );
00504             l_pszOut = concatCharBuffer( l_pszOut, " "          );
00505             l_pszOut = concatCharBuffer( l_pszOut, l_pszNodeName  );
00506 
00507         } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  
00508 
00509     RELEASE_AND_RETURN: 
00510 
00511         DEBUG_OUT(DBOBJGetStreamer::buildSQLFROM)
00512         ON_XML_FLOW_ERROR_DO
00513         {
00514             releaseCharBuffer( l_pszOut);
00515             l_pszOut=0;
00516         }
00517 
00518         ON_XML_FLOW_ERROR_THROW;
00519         return l_pszOut;
00520     }
00521 
00522 
00523     //_________________________________________________________________________
00524     //  buildSQLJOIN
00525     //-------------------------------------------------------------------------
00526     char* DBOBJGetStreamer::buildSQLJOIN(  const DBOBJDefinitionNode*   p_pDBOBJDefNode,
00527                                             unsigned int            p_uiDepth,
00528                                             const char*             p_pszParentJOIN) const
00529     {
00530 
00531         //---------------------------------------------------------------------
00532         char*       l_pszSQL = 0;
00533         const char* l_pszRestrict = 0;
00534         const char* l_pszNodeName = 0;
00535         const char* l_pszParentName = 0;
00536         const char* l_pszInKey = 0;
00537         const char* l_pszOutKey = 0;
00538         unsigned int l_uiKeyLinksCount;
00539         unsigned int i;
00540         const char* l_pszSep = 0;
00541         //---------------------------------------------------------------------
00542 
00543         // if root level, then generate SQL according to the XML selection request
00544         DEBUG_IN(MLHandlerDBGET::buildSQLJOIN)
00545         PREP_CATCH_XML_FLOW_ERROR;
00546         
00547         WATCH_XML_FLOW_ERROR { 
00548         
00549             l_pszSQL = copyCharBuffer( p_pszParentJOIN);
00550 
00551             if( p_uiDepth >0)
00552             {
00553                 l_pszSep="";
00554                 if( l_pszSQL) l_pszSep=" AND ";
00555 
00556                 l_pszNodeName = p_pDBOBJDefNode->getName();
00557                 l_pszParentName = p_pDBOBJDefNode->getParent()->getName();
00558                 l_uiKeyLinksCount = p_pDBOBJDefNode->getKeyLinksCount();
00559 
00560                 for( i=0 ; i<l_uiKeyLinksCount ; i++)
00561                 {   // for all inkeys & outkeys of the parent
00562                     l_pszInKey = p_pDBOBJDefNode->getKeyLink(i)->first->getDBField();
00563                     l_pszOutKey = p_pDBOBJDefNode->getKeyLink(i)->second->getDBField();
00564                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszSep );
00565                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszNodeName);
00566                     l_pszSQL = concatCharBuffer( l_pszSQL, ".");
00567                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszInKey    );
00568                     l_pszSQL = concatCharBuffer( l_pszSQL, "=");
00569                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszParentName);
00570                     l_pszSQL = concatCharBuffer( l_pszSQL, ".");
00571                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszOutKey);
00572                     l_pszSep=" AND ";
00573                 }   
00574             }
00575 
00576             l_pszRestrict= p_pDBOBJDefNode->getRestrict();
00577             if( strlen(l_pszRestrict) > 0 )
00578             {
00579                 l_pszSQL = concatCharBuffer( l_pszSQL, l_pszSep);
00580                 l_pszSQL = concatCharBuffer( l_pszSQL, l_pszRestrict);
00581             }
00582 
00583         } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  
00584 
00585     RELEASE_AND_RETURN: 
00586 
00587         DEBUG_OUT(MLHandlerDBGET::buildSQLJOIN)
00588         ON_XML_FLOW_ERROR_DO
00589         {
00590             releaseCharBuffer( l_pszSQL);
00591             l_pszSQL=0;
00592         }
00593         ON_XML_FLOW_ERROR_THROW;    
00594         return l_pszSQL;
00595     }
00596 
00597     //_________________________________________________________________________
00598     //  buildSQLWHERE
00599     //-------------------------------------------------------------------------
00600     char* DBOBJGetStreamer::buildSQLWHERE(  const DBOBJDefinitionNode*  p_pDBOBJDefNode, 
00601                                             DBOBJGetStatementNode*  p_pDBOBJStmtNode, 
00602                                             unsigned int            p_uiDepth,
00603                                             const char *            p_pszParentWHERE ) const
00604     {
00605         //---------------------------------------------------------------------
00606         const DBOBJDefinitionField*     l_pSAXDB_filterDef;
00607         const DBOBJGetStatementClause*  l_pSAXDB_filter;
00608 
00609         char*           l_pszSQL = 0;
00610         const char*     l_pszNodeName = 0;
00611         const char*     l_pszDBFieldName = 0;
00612         const char*     l_pszFilterOp = 0;
00613         const char*     l_pszMap = 0;
00614         char*           l_pszFilterValue = 0;
00615         const char*     l_pszSep = 0;
00616         const char*     l_pszQuote = 0;
00617         const char*     l_pszWild1 = 0;
00618         const char*     l_pszWild2 = 0;
00619 
00620         unsigned int    l_uiCount;
00621         unsigned int    i;
00622 
00623         bool            l_fUpperField;
00624         //---------------------------------------------------------------------
00625 
00626         DEBUG_IN(DBOBJGetStreamer::buildSQLWHERE)
00627         PREP_CATCH_XML_FLOW_ERROR;
00628         
00629         WATCH_XML_FLOW_ERROR { 
00630 
00631             l_pszSQL = copyCharBuffer( p_pszParentWHERE);
00632 
00633             if(p_pDBOBJStmtNode)
00634             {   
00635                 l_pszSep = "";
00636                 if(l_pszSQL) l_pszSep=" AND ";
00637 
00638                 l_pszNodeName = p_pDBOBJDefNode->getName();
00639 
00640                 l_uiCount = p_pDBOBJStmtNode->getFiltersCount();
00641                 for( i=0 ; i < l_uiCount ; i++)
00642                 { 
00643                     // for each filter in request
00644                     l_pSAXDB_filter = p_pDBOBJStmtNode->getFilter( i);
00645 
00646                     //defaults
00647                     l_pszQuote = "";
00648                     l_pszWild1 = "";
00649                     l_pszWild2 = "";
00650                     l_fUpperField = false;
00651 
00652                     // get filter      
00653                     l_pszFilterOp = l_pSAXDB_filter->m_pszOp;
00654                     l_pszFilterValue = copyCharBuffer( l_pSAXDB_filter->m_pszValue); //TODO:correctSQLValue
00655                     l_pSAXDB_filterDef = l_pSAXDB_filter->m_pFieldDefinition;
00656 
00657                     // get field props
00658                     l_pszDBFieldName = l_pSAXDB_filterDef->getDBField();
00659                     l_pszMap = l_pSAXDB_filterDef->getMap();
00660                 
00661                     if ( strcmp(l_pszMap, DBOBJDEFFIELD_MAP_STRING) == 0 )
00662                     {
00663                         l_pszQuote="'";
00664                         if( strcmp( l_pszFilterOp,DBOBJGETSTMT_FILTEROPSEARCH) == 0 )
00665                         {   // SEARCH : UPPER(FIELD) LIKE 'UPPERED%'
00666                             l_pszWild2 = "%";
00667                             upperize( l_pszFilterValue);
00668                             l_fUpperField = true;
00669                             l_pszFilterOp = DBOBJGETSTMT_FILTEROPLIKE;
00670                         }
00671                         if( strcmp( l_pszFilterOp,DBOBJGETSTMT_FILTEROPFIND) == 0 )
00672                         {   // FIND : UPPER(FIELD) LIKE '%UPPERED%'
00673                             l_pszWild1 = "%";
00674                             l_pszWild2 = "%";
00675                             l_fUpperField = true;
00676                             upperize( l_pszFilterValue);
00677                             l_pszFilterOp = DBOBJGETSTMT_FILTEROPLIKE;
00678                         }
00679                     }
00680                     if( strcmp(l_pszFilterOp,DBOBJGETSTMT_FILTEROPIN)==0 ) l_pszQuote="";
00681 
00682                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszSep);
00683                     if ( l_fUpperField) l_pszSQL = concatCharBuffer( l_pszSQL, "UPPER(" );
00684                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszNodeName);
00685                     l_pszSQL = concatCharBuffer( l_pszSQL, ".");
00686                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszDBFieldName);
00687                     if ( l_fUpperField) l_pszSQL = concatCharBuffer( l_pszSQL, ")");
00688                     l_pszSQL = concatCharBuffer( l_pszSQL, " ");
00689                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszFilterOp);
00690                     l_pszSQL = concatCharBuffer( l_pszSQL, " ");
00691                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszQuote);
00692                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszWild1);
00693                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszFilterValue);
00694                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszWild2);
00695                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszQuote);
00696 
00697                     l_pszSep=" AND ";
00698                     releaseCharBuffer( l_pszFilterValue);
00699                     l_pszFilterValue = 0;
00700                 }
00701             }
00702 
00703         } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  
00704 
00705     RELEASE_AND_RETURN: 
00706 
00707         DEBUG_OUT(DBOBJGetStreamer::buildSQLWHERE)
00708         
00709         releaseCharBuffer( l_pszFilterValue);
00710         ON_XML_FLOW_ERROR_DO
00711         {
00712             releaseCharBuffer( l_pszSQL);
00713             l_pszSQL=0;
00714         }
00715         ON_XML_FLOW_ERROR_THROW;    
00716         return l_pszSQL;
00717     }
00718 
00719     //_________________________________________________________________________
00720     //  BUILDSQLJOINORDER
00721     //-------------------------------------------------------------------------
00722     char* DBOBJGetStreamer::buildSQLJOINORDER(  const DBOBJDefinitionNode*  p_pDBOBJDefNode,
00723                                                 unsigned int            p_uiDepth,
00724                                                 const char*             p_pszParentJOINORDER ) const
00725     {
00726         //---------------------------------------------------------------------
00727         char*           l_pszSQL = 0;
00728         const char*     l_pszNodeName = 0;
00729         const char*     l_pszPkey = 0;
00730         const char*     l_pszSep = 0;
00731 
00732         unsigned int    l_uiPkeysCount;
00733         unsigned int    i;
00734         //---------------------------------------------------------------------
00735 
00736         DEBUG_IN(DBOBJGetStreamer::buildSQLJOINORDER)
00737         PREP_CATCH_XML_FLOW_ERROR;
00738         
00739         WATCH_XML_FLOW_ERROR { 
00740         
00741             l_pszSQL = copyCharBuffer( p_pszParentJOINORDER);
00742             l_pszSep="";
00743 
00744             if( l_pszSQL) l_pszSep=", ";
00745 
00746             l_pszNodeName = p_pDBOBJDefNode->getName();
00747         
00748             // insert pkeys as order clause
00749             l_uiPkeysCount = p_pDBOBJDefNode->getPkeysCount();
00750             for( i=0 ; i < l_uiPkeysCount ; i++)
00751             {
00752                 l_pszPkey = p_pDBOBJDefNode->getPkey(i)->getDBField();
00753 
00754                 l_pszSQL = concatCharBuffer( l_pszSQL, l_pszSep);
00755                 l_pszSQL = concatCharBuffer( l_pszSQL, l_pszNodeName);
00756                 l_pszSQL = concatCharBuffer( l_pszSQL, ".");
00757                 l_pszSQL = concatCharBuffer( l_pszSQL, l_pszPkey);
00758 
00759                 l_pszSep = ", ";
00760             }
00761 
00762         } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  
00763 
00764     RELEASE_AND_RETURN: 
00765 
00766         DEBUG_OUT(DBOBJGetStreamer::buildSQLJOINORDER)
00767         ON_XML_FLOW_ERROR_DO
00768         {
00769             releaseCharBuffer( l_pszSQL);
00770             l_pszSQL=0;
00771         }
00772         ON_XML_FLOW_ERROR_THROW;    
00773         return l_pszSQL;
00774     }
00775 
00776     //_________________________________________________________________________
00777     //  BUILDSQLORDER
00778     //-------------------------------------------------------------------------
00779     char* DBOBJGetStreamer::buildSQLORDER(  const DBOBJDefinitionNode*      p_pDBOBJDefNode,
00780                                              DBOBJGetStatementNode* p_pDBOBJStmtNode, 
00781                                              unsigned int           p_uiDepth,
00782                                              const char*            p_pszParentORDER) const
00783     {
00784         //---------------------------------------------------------------------
00785         const DBOBJDefinitionField*     l_pSAXDB_orderDef;
00786         const DBOBJGetStatementClause*  l_pSAXDB_order;
00787 
00788         char*           l_pszSQL = 0;
00789         const char*     l_pszNodeName = 0;
00790         const char*     l_pszFieldName = 0;
00791         const char*     l_pszOrderOp = 0;
00792         const char*     l_pszSep = 0;
00793 
00794         unsigned int    l_uiCount;
00795         unsigned int    i;
00796         //---------------------------------------------------------------------
00797 
00798         DEBUG_IN(DBOBJGetStreamer::buildSQLORDER)
00799         PREP_CATCH_XML_FLOW_ERROR;
00800         
00801         WATCH_XML_FLOW_ERROR { 
00802 
00803             l_pszSQL = copyCharBuffer( p_pszParentORDER);
00804 
00805             if( p_pDBOBJStmtNode)
00806             {
00807                 l_pszSep="";
00808                 if( l_pszSQL) l_pszSep=", ";
00809 
00810                 l_pszNodeName = p_pDBOBJDefNode->getName();
00811 
00812 
00813                 l_uiCount = p_pDBOBJStmtNode->getOrdersCount();
00814                 for( i=0 ; i<l_uiCount ; i++)
00815                 {
00816                     l_pSAXDB_order=p_pDBOBJStmtNode->getOrder(i);
00817 
00818                     l_pSAXDB_orderDef = l_pSAXDB_order->m_pFieldDefinition;
00819                     l_pszFieldName = l_pSAXDB_orderDef->getDBField();
00820                     l_pszOrderOp = l_pSAXDB_order->m_pszOp;
00821 
00822                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszSep);
00823                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszNodeName);
00824                     l_pszSQL = concatCharBuffer( l_pszSQL, ".");
00825                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszFieldName);
00826                     l_pszSQL = concatCharBuffer( l_pszSQL, " ");
00827                     l_pszSQL = concatCharBuffer( l_pszSQL, l_pszOrderOp);
00828 
00829                     l_pszSep=", ";
00830                 }
00831             }
00832 
00833         } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  
00834 
00835     RELEASE_AND_RETURN: 
00836 
00837         DEBUG_OUT(DBOBJGetStreamer::buildSQLORDER)
00838         ON_XML_FLOW_ERROR_DO
00839         {
00840             releaseCharBuffer( l_pszSQL);
00841             l_pszSQL=0;
00842         }
00843         ON_XML_FLOW_ERROR_THROW;    
00844         return l_pszSQL;
00845     }
00846 
00847     //_________________________________________________________________________
00848     //  EXECUTESQL
00849     //-------------------------------------------------------------------------
00850     void DBOBJGetStreamer::executeSQL()
00851     {
00852         //---------------------------------------------------------------------
00853         otl_stream*         l_rsData;
00854         otl_stream_peek*    l_rsDataPeek;
00855 
00856         char*               l_pszSQLStmt;
00857         char*               l_pszLabel;
00858         
00859         unsigned int        l_uiStatementsCount;
00860         unsigned int        i=0;
00861         //---------------------------------------------------------------------
00862 
00863         DEBUG_IN(DBOBJGetStreamer::executeSQL)
00864         PREP_CATCH_XML_FLOW_ERROR;
00865         
00866         WATCH_XML_FLOW_ERROR { 
00867 
00868             l_uiStatementsCount = m_vaStatements.size();
00869             DEBUG_ECHO << "found "<< l_uiStatementsCount << " statements.\n";
00870 
00871             while( !m_vaStatements.empty() )
00872             {           
00873                 //extract SQL and label
00874                 l_pszLabel = m_vaStatements.dequeue();
00875                 l_pszSQLStmt = strstr( l_pszLabel ,DBOBJGETSTREAMER_SQLSEP);
00876                 l_pszSQLStmt[0]='\0';
00877                 l_pszSQLStmt ++;
00878 
00879                 logout << "\t" << DBOBJGETSTREAMER_TAGNAME << "   :   " << "select " << l_pszLabel << "s";
00880 
00881                 logout << "executing node " << l_pszLabel << "-->\n" << l_pszSQLStmt << "\n";
00882                 try
00883                 {
00884                     //execute SQL
00885                     l_rsData=new otl_stream();
00886                     logout << ".";
00887                     l_rsData->set_all_column_types(otl_all_num2str | otl_all_date2str);  // set all columns to strings
00888                     l_rsData->open( m_intBufSize, l_pszSQLStmt, *m_pConnection );
00889                     logout << ".";
00890                     //l_rsData->rewind(); //  force execution
00891                     logout << ".";
00892 
00893                 }
00894                 catch(otl_exception& p)
00895                 { // intercept OTL exceptions
00896                     MAKE_XMLFLOW_EXCEPTION ( ERRCODE_LOC_DBOBJGETREQUEST + ERRCODE_CAUSE_DATAACCESS ,  (char*) &(p.msg), "", "DBOBJGetStreamer::executeSQL", "", false );
00897                     p.~otl_tmpl_exception();
00898                     delete l_rsData;
00899                     goto RELEASE_AND_RETURN;
00900                 }
00901                 logout << "ok\n";
00902 
00903 
00904                 l_rsDataPeek=new otl_stream_peek;
00905                 l_rsDataPeek->pOTLStream=l_rsData;
00906                 l_rsDataPeek->pos=0;
00907                 m_vaNamedData.add(l_rsDataPeek, l_pszLabel);
00908 
00909                 releaseCharBuffer( l_pszLabel);
00910 
00911                 i++;
00912             }
00913 
00914         } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  
00915 
00916     RELEASE_AND_RETURN: 
00917 
00918         DEBUG_OUT(DBOBJGetStreamer::executeSQL)
00919         ON_XML_FLOW_ERROR_THROW;    
00920     }
00921 
00922 
00923     //_________________________________________________________________________
00924     //  PUSHSQLSTATEMENT
00925     //-------------------------------------------------------------------------
00926     void DBOBJGetStreamer::pushSQLStatement(const char* p_pszSQL)
00927     {
00928         DEBUG_FUNC(DBOBJRequest::addSQLStatement)
00929 
00930         if ( strlen( p_pszSQL) > 0 ) m_vaStatements.enqueue( importCharBuffer( 0, p_pszSQL) );
00931 
00932     }
00933 
00934     //_________________________________________________________________________
00935     //  GETDATASTREAM
00936     //-------------------------------------------------------------------------
00937     otl_stream* DBOBJGetStreamer::getDataStream(const char* p_pszName) const
00938     {
00939         otl_stream_peek*    l_rsDataPeek;
00940 
00941         DEBUG_FUNC(DBOBJGetStreamer::getDataStream)
00942 
00943         l_rsDataPeek = m_vaNamedData.get(p_pszName);
00944     
00945         // ERRCHECK : data stream present
00946         if( ! p_pszName) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_DBOBJGETREQUEST + ERRCODE_CAUSE_MISSINGREF , "Unable to find data stream.", "", "DBOBJGetStreamer::getDataStream", "", false );
00947 
00948         return l_rsDataPeek->pOTLStream;
00949     }
00950 
00951     //_________________________________________________________________________
00952     //  PEEKDATA
00953     //-------------------------------------------------------------------------
00954     const char* DBOBJGetStreamer::peekData(const char* p_pszName)
00955     {
00956         //---------------------------------------------------------------------
00957         otl_stream_peek*    l_rsDataPeek;
00958         char*                   l_pszValue=0;
00959         int                     l_iSize=0;
00960         //---------------------------------------------------------------------
00961 
00962         DEBUG_FUNC(DBOBJGetStreamer::peekData)
00963         PREP_CATCH_XML_FLOW_ERROR;
00964         
00965         WATCH_XML_FLOW_ERROR { 
00966 
00967             l_rsDataPeek=m_vaNamedData.get( p_pszName);
00968 
00969             if( l_rsDataPeek->vaPeeks.size() > l_rsDataPeek->pos)
00970             {
00971                 l_pszValue = l_rsDataPeek->vaPeeks.get(l_rsDataPeek->pos);
00972                 l_rsDataPeek->pos++;
00973             }
00974             else
00975             {
00976                 l_iSize = l_rsDataPeek->pOTLStream->describe_next_out_var()->elem_size;
00977                 l_pszValue = allocCharBuffer(l_iSize+1);
00978                 (* l_rsDataPeek->pOTLStream) >> l_pszValue;
00979                 l_rsDataPeek->vaPeeks.push(l_pszValue);
00980                 l_rsDataPeek->pos++;
00981             }
00982 
00983         } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  
00984 
00985     RELEASE_AND_RETURN: 
00986 
00987         ON_XML_FLOW_ERROR_THROW;    
00988         return exportCharBuffer( l_pszValue);
00989     }
00990 
00991     //_________________________________________________________________________
00992     //  REWINDPEEKEDDATA
00993     //-------------------------------------------------------------------------
00994     void DBOBJGetStreamer::rewindPeekedData(const char* p_pszName)
00995     {
00996         //---------------------------------------------------------------------
00997         otl_stream_peek*    l_rsDataPeek;
00998         //---------------------------------------------------------------------
00999 
01000         DEBUG_FUNC(DBOBJGetStreamer::rewindPeekedData)
01001 
01002         l_rsDataPeek=m_vaNamedData.get( p_pszName);
01003         l_rsDataPeek->pos=0;
01004     }
01005 
01006     //_________________________________________________________________________
01007     //  FLUSHPEEKEDDATA
01008     //-------------------------------------------------------------------------
01009     void DBOBJGetStreamer::flushPeekedData(const char* p_pszName)
01010     {
01011         //---------------------------------------------------------------------
01012         otl_stream_peek*    l_rsDataPeek;
01013         //---------------------------------------------------------------------
01014 
01015         DEBUG_FUNC(DBOBJGetStreamer::flushPeekedData)
01016 
01017         l_rsDataPeek=m_vaNamedData.get( p_pszName);
01018         while( ! l_rsDataPeek->vaPeeks.empty()) releaseCharBuffer( l_rsDataPeek->vaPeeks.pop());
01019         l_rsDataPeek->pos=0;
01020     }
01021 
01022     //_________________________________________________________________________
01023     //  REMDATASTREAM
01024     //-------------------------------------------------------------------------
01025     void DBOBJGetStreamer::delStream(otl_stream_peek* p_rsDataPeek) 
01026     {
01027         //---------------------------------------------------------------------     
01028         otl_stream*         l_rsData;
01029         //---------------------------------------------------------------------
01030 
01031         DEBUG_FUNC(DBOBJGetStreamer::delStream)
01032     
01033         l_rsData=p_rsDataPeek->pOTLStream;
01034         while( ! p_rsDataPeek->vaPeeks.empty()) releaseCharBuffer( p_rsDataPeek->vaPeeks.pop());
01035         l_rsData->clean();
01036         l_rsData->close();
01037         delete(l_rsData);
01038         delete(p_rsDataPeek);
01039     }
01040 
01041     //_________________________________________________________________________
01042     //  makeXML
01043     //-------------------------------------------------------------------------
01044     void DBOBJGetStreamer::makeXML()
01045     {
01046         DEBUG_FUNC(SAXDBSelectBuilder::getXML)
01047 
01048         logout << "\t" << DBOBJGETSTREAMER_TAGNAME << "   :   " << "build objects' xml\n";
01049         m_uiToStream = 0;
01050         makeXML( m_pDBOBJDefinitionRoot, 0, 0);
01051         while(!m_vaNamedData.empty() ) delStream(m_vaNamedData.pop());
01052     }
01053 
01054     //_________________________________________________________________________
01055     //  MAKEXML
01056     //-------------------------------------------------------------------------
01057     void DBOBJGetStreamer::makeXML(const DBOBJDefinitionNode*  p_pDBOBJDefNode,
01058                                   const char*           p_pszParentKeysValues,
01059                                   unsigned int          p_uiDepth) 
01060     {
01061         //---------------------------------------------------------------------
01062         otl_stream*             l_prsData;
01063         const DBOBJDefinitionNode*  l_pSAXDB_defParent;
01064         const DBOBJDefinitionNode*  l_pSAXDB_defChild;
01065 
01066         char*                   l_pszTmp1 = 0;
01067         char*                   l_pszTmp2 = 0;
01068 
01069         const char*             l_pszNodeName = 0;
01070         char*                   l_pszKeys = 0;
01071 
01072         char*                   l_pszDBValue=0;
01073         int                     l_iSize=0;
01074         int                     l_iSize2=0;
01075         const char*             l_pszParentKeyDBValue = 0;
01076         char*                   l_pszParentKeyPassedValue = 0;
01077 
01078         bool                    l_fParentChanged;
01079         
01080         unsigned int            l_uiFieldsCount;
01081         unsigned int            l_uiChildNodesCount;
01082         unsigned int            i;  
01083         unsigned int            j;
01084         //---------------------------------------------------------------------
01085 
01086         DEBUG_IN(DBOBJGetStreamer::makeXML)
01087         PREP_CATCH_XML_FLOW_ERROR;
01088         
01089         WATCH_XML_FLOW_ERROR { 
01090         
01091             l_pszNodeName = p_pDBOBJDefNode->getName();
01092             l_prsData = getDataStream( l_pszNodeName);
01093             l_fParentChanged =false;
01094             if( l_prsData )
01095             {
01096                 if( !l_prsData->eof() )
01097                 {   
01098                     
01099                     while( ( !l_fParentChanged ) && ( !l_prsData->eof() ))
01100                     {
01101                         DEBUG_ECHO << "vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv\n";
01102                         DEBUG_ECHO << l_pszNodeName << "\n";
01103 
01104                         if ( p_uiDepth == 0)
01105                         {
01106                             if(m_uiToStream ==0) logout << "\t" << DBOBJGETSTREAMER_TAGNAME << "   :   " << "output objects";
01107                             logout << ".";
01108                         }
01109 
01110                         // ANCESTORS CHECK
01111                         if( p_uiDepth > 0 )
01112                         {              
01113                             DEBUG_ECHO << "keys passed:" << p_pszParentKeysValues << "\n";
01114 
01115                             // ...check parents keys values
01116                             l_fParentChanged = false;
01117                             l_pSAXDB_defParent = p_pDBOBJDefNode;
01118                             l_pszParentKeyPassedValue = copyCharBuffer( p_pszParentKeysValues);
01119                             l_pszTmp1 = l_pszParentKeyPassedValue;
01120 
01121                             for( i=0 ; ( i < p_uiDepth ) && ( !l_fParentChanged ) ; i++)
01122                             {   // For all the ancestors...
01123                                 
01124                                 l_pSAXDB_defParent = l_pSAXDB_defParent->getParent();
01125                                 l_uiFieldsCount =  l_pSAXDB_defParent->getPkeysCount();
01126 
01127                                 for( j=0 ; ( j < l_uiFieldsCount )  && (! l_fParentChanged ) ; j++)
01128                                 {   // For each key...
01129 
01130                                     // get Value from DB
01131                                     l_pszParentKeyDBValue= peekData( l_pszNodeName);
01132 
01133                                     // get value from parents
01134                                     l_pszTmp2 = strstr( l_pszTmp1, DBOBJGETSTREAMER_LISTKEYCOLSEP);
01135                                     if( l_pszTmp2)  l_pszTmp2[0]='\0';
01136 
01137                                     DEBUG_ECHO << ":" << l_pszParentKeyDBValue << "(db)~(par)" << l_pszTmp1 << "\n";
01138 
01139                                     // compare
01140                                     if( strcmp( l_pszTmp1, l_pszParentKeyDBValue) != 0 ) 
01141                                     {
01142                                         l_fParentChanged=true;
01143                                         DEBUG_ECHO << "Parents changed\n";
01144                                     }
01145                                     l_pszTmp1 = l_pszTmp2+strlen(DBOBJGETSTREAMER_LISTKEYCOLSEP);
01146                                 }
01147                             }
01148 
01149                             l_pszParentKeyPassedValue = releaseCharBuffer( l_pszParentKeyPassedValue); 
01150                         }
01151 
01152                         if (! l_fParentChanged)
01153                         {
01154                             flushPeekedData(l_pszNodeName); 
01155                         }
01156                         else
01157                         {
01158                             rewindPeekedData(l_pszNodeName);
01159                             break;
01160                         }
01161 
01162                         // OPEN NODE
01163                         openXMLNode(p_pDBOBJDefNode);
01164 
01165                         // RECURSE TO CHILDREN              
01166                         if(!m_boolFlat)
01167                         {               
01168 
01169                             // Make parent keys list                
01170                             l_uiFieldsCount = p_pDBOBJDefNode -> getPkeysCount();
01171                             //logout << "\t\t";
01172                             //for( j=0 ; j < p_uiDepth ; j++) logout << "\t";
01173                             //logout << l_pszNodeName ;
01174 
01175                             l_pszKeys = 0;
01176                             for( j=0 ; j<l_uiFieldsCount ; j++)
01177                             { 
01178                                 // for each key of current node ...
01179                                 l_iSize = l_prsData->describe_next_out_var()->elem_size;
01180                                 if(l_iSize>l_iSize2) l_pszDBValue = (char*) realloc( l_pszDBValue, l_iSize+1);
01181                                 (*l_prsData) >> l_pszDBValue;
01182                                 l_iSize2=l_iSize;
01183 
01184                                 l_pszKeys = concatCharBuffer( l_pszKeys, l_pszDBValue);
01185                                 l_pszKeys = concatCharBuffer( l_pszKeys, DBOBJGETSTREAMER_LISTKEYCOLSEP);                 
01186                             }
01187                             
01188                             //logout << " " << l_pszKeys;
01189                             //logout << "\n";
01190 
01191                             l_pszKeys = concatCharBuffer( l_pszKeys, p_pszParentKeysValues);
01192 
01193                             // recurse to children
01194                             l_uiChildNodesCount = p_pDBOBJDefNode->getChildNodesCount();
01195                             for( j=0; j< l_uiChildNodesCount; j++ )
01196                             {
01197                                 // for each child
01198                                 l_pSAXDB_defChild = p_pDBOBJDefNode->getChildNode(j);
01199                                 makeXML( l_pSAXDB_defChild, l_pszKeys, p_uiDepth+1);                                  
01200                             }
01201 
01202                             releaseCharBuffer( l_pszKeys);
01203                             l_pszKeys=0;
01204                         }                   
01205 
01206                         // CLOSE NODE
01207                         closeXMLNode(p_pDBOBJDefNode);
01208 
01209                         // LOOP
01210                         DEBUG_ECHO << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
01211 
01212 
01213                         if ( p_uiDepth == 0)
01214                         {
01215                             m_uiToStream++;
01216                             if((m_uiToStream >= m_uiStreamObjects)||(l_prsData->eof())) 
01217                             {
01218                                 logout << "ok " << "( " << m_uiToStream << " objects)\n";
01219                                 m_pOutput->commitStream(false);
01220                                 m_uiToStream = 0;
01221                             }
01222                         }
01223                     
01224                     }
01225 
01226                     if ( l_prsData->eof() ) {
01227                         DEBUG_ECHO << l_pszNodeName << "::EOD!!\n";
01228                         //remDataStream(l_pszNodeName);
01229                     }
01230                 }
01231             }
01232 
01233         } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  
01234 
01235     RELEASE_AND_RETURN: 
01236 
01237         free( l_pszDBValue);
01238         releaseCharBuffer( l_pszKeys);
01239         releaseCharBuffer( l_pszParentKeyPassedValue);
01240 
01241         DEBUG_OUT(DBOBJGetStreamer::makeXML)
01242         ON_XML_FLOW_ERROR_THROW;    
01243 
01244     }
01245 
01246     //_________________________________________________________________________
01247     //  OPENXMLNODE
01248     //-------------------------------------------------------------------------
01249     void DBOBJGetStreamer::openXMLNode(const DBOBJDefinitionNode* p_pDBOBJDefNode) 
01250     {
01251         //---------------------------------------------------------------------
01252         
01253         otl_stream*             l_prsData;
01254         DBOBJDefinitionField*   l_pSAXDB_defField;  
01255 
01256         char*                   l_pszChildren = 0;
01257         const char*             l_pszNodeName = 0;
01258         const char*             l_pszFieldName = 0;
01259         char*                   l_pszValue=0;
01260         const char*                 l_pszXMLValue=0;
01261         int                     l_iSize=0;
01262         int                     l_iSize2=0;
01263 
01264         unsigned int            l_uiFieldsCount;
01265         unsigned int            i;
01266         //---------------------------------------------------------------------
01267 
01268         DEBUG_IN(DBOBJGetStreamer::openXMLNode)
01269         PREP_CATCH_XML_FLOW_ERROR;
01270         
01271         WATCH_XML_FLOW_ERROR { 
01272 
01273             l_pszNodeName = p_pDBOBJDefNode->getName();
01274             l_prsData = getDataStream(l_pszNodeName);
01275 
01276             (*m_pOutput) << "\n<" << l_pszNodeName;
01277 
01278             l_uiFieldsCount = p_pDBOBJDefNode->getFieldsCount();
01279             l_pszChildren = 0;
01280             for(i=0; i<l_uiFieldsCount ; i++)
01281             {
01282                 l_pSAXDB_defField = p_pDBOBJDefNode->getField(i);
01283                 l_pszFieldName =  l_pSAXDB_defField->getName();
01284 
01285                 l_iSize = l_prsData->describe_next_out_var()->elem_size;
01286                 if(l_iSize>l_iSize2) l_pszValue = (char*) realloc( l_pszValue, l_iSize+1);
01287                 (*l_prsData) >> l_pszValue; 
01288                 l_iSize2 = l_iSize;
01289 
01290                 if(!l_prsData->is_null()) l_pszXMLValue = l_pszValue;
01291                 else l_pszXMLValue = REQ_NULL;
01292 
01293                 DEBUG_ECHO << l_pszNodeName << "." << l_pszFieldName << "=" << l_pszXMLValue << "\n";
01294 
01295                 if ( l_pSAXDB_defField->isAttribute() )
01296                 {   // attribute, offset name and stream directly  
01297                     (*m_pOutput) <<  " " << (l_pszFieldName+1) << "=\"" << l_pszXMLValue << "\"";
01298                 }
01299                 else
01300                 {   // child node
01301                     l_pszChildren = concatCharBuffer( l_pszChildren, "\t<");
01302                     l_pszChildren = concatCharBuffer( l_pszChildren, l_pszFieldName);
01303                     l_pszChildren = concatCharBuffer( l_pszChildren, "><![CDATA[");
01304                     l_pszChildren = concatCharBuffer( l_pszChildren, l_pszXMLValue);
01305                     l_pszChildren = concatCharBuffer( l_pszChildren, "]]></");
01306                     l_pszChildren = concatCharBuffer( l_pszChildren, l_pszFieldName);
01307                     l_pszChildren = concatCharBuffer( l_pszChildren, ">\n");
01308                 }
01309                 
01310             }
01311             l_pszValue = releaseCharBuffer( l_pszValue);
01312             
01313             (*m_pOutput) <<  " >";
01314             if(l_pszChildren) (*m_pOutput) << "\n" << l_pszChildren;
01315 
01316         } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  
01317 
01318     RELEASE_AND_RETURN: 
01319 
01320         l_pszChildren = releaseCharBuffer(l_pszChildren);
01321 
01322         DEBUG_OUT(DBOBJGetStreamer::openXMLNode)
01323         ON_XML_FLOW_ERROR_THROW;    
01324     }
01325 
01326 
01327     //_________________________________________________________________________
01328     //  closeXMLNode
01329     //-------------------------------------------------------------------------
01330     void DBOBJGetStreamer::closeXMLNode(const DBOBJDefinitionNode* p_pDBOBJDefNode ) 
01331     {
01332         DEBUG_IN(DBOBJGetStreamer::closeXMLNode)
01333         PREP_CATCH_XML_FLOW_ERROR;
01334         
01335         WATCH_XML_FLOW_ERROR { 
01336 
01337             (*m_pOutput) << "</" << p_pDBOBJDefNode->getName() << ">\n";
01338 
01339         } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  
01340 
01341     RELEASE_AND_RETURN: 
01342 
01343         DEBUG_OUT(DBOBJGetStreamer::closeXMLNode)
01344         ON_XML_FLOW_ERROR_THROW;    
01345     }
01346 
01347 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
01348 //=============================================================================
01349 
01350 
01351 
01352 //=============================================================================
01353 //  CLASS DBOBJGetStreamerFactory
01354 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
01355 
01356     XMLStreamer* DBOBJGetStreamerFactory::getStreamer( StreamerParams* p_pParameters, XMLFlowContext* p_pStreamContext, XMLStreamConsumer* p_pStreamConsumer) const
01357     {
01358         const char*                     l_pszDefinitionName=0;
01359         XMLStreamBuffer*                l_pszDefinitionBuffer=0;
01360         const DBOBJDefinitionNode*      l_pDefinitionRoot=0;
01361         DBOBJDefinitionNode*            l_pOwnedDefinitionRoot=0;
01362         DBOBJGetStatementSAXBuilder*    l_pSAXStatementBuilder = 0; 
01363 
01364         l_pszDefinitionName = XMLStreamer::getParamValue(p_pParameters, DBOBJGETSTREAMER_TARGET, "");
01365         l_pDefinitionRoot = getCachedDefinition(l_pszDefinitionName, p_pStreamContext);
01366         if(!l_pDefinitionRoot)
01367         {
01368             l_pOwnedDefinitionRoot = buildDefinition(l_pszDefinitionName, p_pStreamContext);
01369             l_pDefinitionRoot = l_pOwnedDefinitionRoot;
01370         }
01371 
01372     
01373 
01374         l_pSAXStatementBuilder = new DBOBJGetStatementSAXBuilder(p_pStreamContext, l_pDefinitionRoot);
01375 
01376         return (XMLStreamer*) new DBOBJGetStreamer( this, p_pParameters, p_pStreamContext, p_pStreamConsumer, l_pSAXStatementBuilder, l_pDefinitionRoot, l_pOwnedDefinitionRoot);
01377     }
01378 
01379 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
01380 //=============================================================================
01381 
01382 END_XDFLENGINE_NS
01383 
01384 

Generated on Sat Oct 4 13:19:57 2003 for XDFLengine by doxygen1.3-rc2