---

dbobjgetstatement.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//-----------------------------------------------------------------------------
//  DBOBJGETSTATEMENT.CPP
//----------------------------------------------------------------------------- 
//_____________________________________________________________________________
//
//  Copyright (C) 2003 Guillaume Baurand. All Rights Reserved.
//
//  This file is part of the XDFLengine project.
//
//  The XDFLengine is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
//  USA.
//
//  For more information, 
//      contact  : guillaume@baurand.net 
//      or visit : http://xdflengine.sourceforge.net
//
//=============================================================================

#   include "dbobjgetstatement.hpp"  
#   include "flow/consumers/streamsax2parser.hpp"

BEGIN_XDFLENGINE_NS



//============================================================================= 
//  CLASS DBOBJGetStatementNode
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    //_________________________________________________________________________
    //  DBOBJGETSTATEMENTNODE
    //-------------------------------------------------------------------------
    DBOBJGetStatementNode::DBOBJGetStatementNode(const DBOBJDefinitionNode* p_pDBOBJDefNode )
    {
        m_pDBObjectNodeDefinition = p_pDBOBJDefNode;
        m_pszName = importCharBuffer(0, m_pDBObjectNodeDefinition->getName());

        DEBUG_CREATE(DBOBJGetStatementNode)
    }

    //_________________________________________________________________________
    //  ~DBOBJGETSTATEMENTNODE
    //------------------------------------------------------------------------- 
    DBOBJGetStatementNode::~DBOBJGetStatementNode() 
    {
        DEBUG_DEL(DBOBJGetStatementNode)

        releaseCharBuffer(m_pszName);
        deleteTree();

    }

    //_________________________________________________________________________
    //  SETPARENT
    //------------------------------------------------------------------------- 
    void DBOBJGetStatementNode::setParent( DBOBJGetStatementNode* p_pDBOBJParentStmtNode)
    {
        DEBUG_FUNC(DBOBJGetStatementNode::setParent)
        m_pSAXStatementParent =  p_pDBOBJParentStmtNode;
    }
    
    // GETTERS  

    //_________________________________________________________________________
    //  GETNAME
    //-------------------------------------------------------------------------     
    const char* DBOBJGetStatementNode::getName() const
    {
        DEBUG_FUNC(SAXDBObjectNode::getName)
        return exportCharBuffer( m_pszName);
    }

    //_________________________________________________________________________
    //  GETPARENT
    //-------------------------------------------------------------------------     
    DBOBJGetStatementNode* DBOBJGetStatementNode::getParent() const
    {
        DEBUG_FUNC(DBOBJGetStatementNode::getParent)
        return m_pSAXStatementParent; 
    }

    //_________________________________________________________________________
    //  GETDEFINITION
    //-------------------------------------------------------------------------     
    const DBOBJDefinitionNode* DBOBJGetStatementNode::getDefinition() const
    {
        DEBUG_FUNC(SAXDBObjectNode::getDefinition)
        return m_pDBObjectNodeDefinition;
    }
    
    // CHILDREN COLLECTION BUILDER & ACCESSORS
    
    //_________________________________________________________________________
    //  APPENDCHILD
    //-------------------------------------------------------------------------     
    void DBOBJGetStatementNode::appendChild( DBOBJGetStatementNode* p_pSAXStatementChild)
    {
        DEBUG_FUNC(DBOBJGetStatementNode::appendChild)
        m_vaChildren.add( p_pSAXStatementChild, p_pSAXStatementChild->getName());
    }

    //_________________________________________________________________________
    //  GETCHILDNODESCOUNT
    //-------------------------------------------------------------------------     
    unsigned int DBOBJGetStatementNode::getChildNodesCount() const
    {
        DEBUG_FUNC(DBOBJGetStatementNode::getChildNodesCount)
        return m_vaChildren.size(); 
    }

    //_________________________________________________________________________
    //  GETCHILDNODE
    //-------------------------------------------------------------------------     
    DBOBJGetStatementNode* DBOBJGetStatementNode::getChildNode(unsigned int p_uiIndex) const
    {
        DEBUG_FUNC(DBOBJGetStatementNode::getChildNode)
        return m_vaChildren.get(p_uiIndex);
    }

    //_________________________________________________________________________
    //  GETCHILDNODE
    //-------------------------------------------------------------------------     
    DBOBJGetStatementNode* DBOBJGetStatementNode::getChildNode( const char* p_pszName, unsigned int p_uiIndex) const
    {
        DEBUG_FUNC(DBOBJGetStatementNode::getChildNode)
        return m_vaChildren.get(p_pszName,p_uiIndex);
    }
    
    // FILTERS COLLECTION BUILDER & ACCESSORS   

    //_________________________________________________________________________
    //  APPENDFILTER
    //-------------------------------------------------------------------------     
    void DBOBJGetStatementNode::appendFilter( DBOBJGetStatementClause* p_pDBOBJGetStatementClause)
    {
        DEBUG_FUNC(DBOBJGetStatementNode::appendFilter)

        // translate operator
        if( strcmp( p_pDBOBJGetStatementClause->m_pszOp, DBOBJGETSTMT_FILTEROPGT ) == 0)    p_pDBOBJGetStatementClause->m_pszOp = importCharBuffer( p_pDBOBJGetStatementClause->m_pszOp, ">" );
        if( strcmp( p_pDBOBJGetStatementClause->m_pszOp, DBOBJGETSTMT_FILTEROPLT ) == 0)    p_pDBOBJGetStatementClause->m_pszOp = importCharBuffer( p_pDBOBJGetStatementClause->m_pszOp, "<" );
        if( strcmp( p_pDBOBJGetStatementClause->m_pszOp, DBOBJGETSTMT_FILTEROPGTE ) == 0)   p_pDBOBJGetStatementClause->m_pszOp = importCharBuffer( p_pDBOBJGetStatementClause->m_pszOp, ">=");
        if( strcmp( p_pDBOBJGetStatementClause->m_pszOp, DBOBJGETSTMT_FILTEROPLTE ) ==0)    p_pDBOBJGetStatementClause->m_pszOp = importCharBuffer( p_pDBOBJGetStatementClause->m_pszOp, "<=");
        if( strcmp( p_pDBOBJGetStatementClause->m_pszOp, DBOBJGETSTMT_FILTEROPEQ ) == 0)    p_pDBOBJGetStatementClause->m_pszOp = importCharBuffer( p_pDBOBJGetStatementClause->m_pszOp, "=" );
        if( strcmp( p_pDBOBJGetStatementClause->m_pszOp, DBOBJGETSTMT_FILTEROPNE ) == 0)    p_pDBOBJGetStatementClause->m_pszOp = importCharBuffer( p_pDBOBJGetStatementClause->m_pszOp, "<>");

        m_vaFilters.add( p_pDBOBJGetStatementClause, p_pDBOBJGetStatementClause->m_pFieldDefinition->getName());
    }

    //_________________________________________________________________________
    //  GETFILTERSCOUNT
    //-------------------------------------------------------------------------     
    unsigned int DBOBJGetStatementNode::getFiltersCount() const
    {
        DEBUG_FUNC(DBOBJGetStatementNode::getFiltersCount)
        return m_vaFilters.size();
    }

    //_________________________________________________________________________
    //  GETFILTER
    //-------------------------------------------------------------------------     
    DBOBJGetStatementClause* DBOBJGetStatementNode::getFilter(unsigned int p_uiIndex) const
    {
        DEBUG_FUNC(DBOBJGetStatementNode::getFilter)
        
        return m_vaFilters.get(p_uiIndex);
    }

    //_________________________________________________________________________
    //  GETFILTER
    //-------------------------------------------------------------------------     
    DBOBJGetStatementClause* DBOBJGetStatementNode::getFilter(const char* p_pszName, unsigned int p_uiIndex) const
    {
        DEBUG_FUNC(DBOBJGetStatementNode::getFilter)
        
        return m_vaFilters.get(p_pszName,p_uiIndex);
    }
    
    // ORDERS COLLECTION BUILDER & ACCESSORS
    
    //_________________________________________________________________________
    //  APPENDORDER
    //-------------------------------------------------------------------------     
    void DBOBJGetStatementNode::appendOrder( DBOBJGetStatementClause* p_pDBOBJGetStatementClause)
    {
        DEBUG_FUNC(DBOBJGetStatementNode::appendOrder)

        m_vaOrders.add( p_pDBOBJGetStatementClause, p_pDBOBJGetStatementClause->m_pFieldDefinition->getName());
    }

    //_________________________________________________________________________
    //  GETORDERSCOUNT
    //-------------------------------------------------------------------------     
    unsigned int DBOBJGetStatementNode::getOrdersCount() const
    {
        DEBUG_FUNC(DBOBJGetStatementNode::getOrdersCount)
        return m_vaOrders.size();
    }

    //_________________________________________________________________________
    //  GETORDER
    //-------------------------------------------------------------------------     
    DBOBJGetStatementClause* DBOBJGetStatementNode::getOrder(unsigned int p_uiIndex) const
    {
        DEBUG_FUNC(DBOBJGetStatementNode::getOrder)
        
        return m_vaOrders.get(p_uiIndex);
    }

    //_________________________________________________________________________
    //  GETORDER
    //-------------------------------------------------------------------------     
    DBOBJGetStatementClause* DBOBJGetStatementNode::getOrder(const char* p_pszName, unsigned int p_uiIndex) const
    {
        DEBUG_FUNC(DBOBJGetStatementNode::getOrder)
        
        return m_vaOrders.get(p_pszName, p_uiIndex);
    }
    
    // PRIVATES
    
    //_________________________________________________________________________
    //  DELETETREE
    //-------------------------------------------------------------------------     
    void DBOBJGetStatementNode::deleteTree()    
    {       
        //---------------------------------------------------------------------
        DBOBJGetStatementClause*   l_pSAXDB_clause = 0;
        DBOBJGetStatementNode*     l_pSAXDB_node = 0;
        //---------------------------------------------------------------------

        DEBUG_IN(DBOBJGetStatementNode::deleteTree)

        // kill chidren
        while( ! m_vaChildren.empty()) delete m_vaChildren.pop();

        // kill filters
        while(! m_vaFilters.empty()) 
        {      
            l_pSAXDB_clause = m_vaFilters.pop();
            l_pSAXDB_clause->m_pszOp=releaseCharBuffer(l_pSAXDB_clause->m_pszOp);
            l_pSAXDB_clause->m_pszValue=releaseCharBuffer(l_pSAXDB_clause->m_pszValue);
            delete l_pSAXDB_clause;
            
        }   

        // kill orders
        while(! m_vaOrders.empty()) 
        {      
            l_pSAXDB_clause = m_vaOrders.pop();
            l_pSAXDB_clause->m_pszOp=releaseCharBuffer(l_pSAXDB_clause->m_pszOp);
            l_pSAXDB_clause->m_pszValue=releaseCharBuffer(l_pSAXDB_clause->m_pszValue);
            delete l_pSAXDB_clause;
            
        }   
  
        DEBUG_OUT(DBOBJGetStatementNode::deleteTree)
    }

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//=============================================================================





//============================================================================= 
//  CLASS SAXDBSELECTBUILDER
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    //_________________________________________________________________________
    //  BUILDDBOBJGETSTATEMENT
    //-------------------------------------------------------------------------
    DBOBJGetStatementNode* DBOBJGetStatementSAXBuilder::buildDBOBJGetStatement(XMLFlowContext* p_pContext,  XMLStreamProvider* p_pInput,const  DBOBJDefinitionNode* p_pDBOBJDefNode)
    {
        //---------------------------------------------------------------------
        DBOBJGetStatementSAXBuilder*            l_pDBOBJGetStmtBuilder=0;
        DBOBJGetStatementNode*                  l_pDBOBJGetStatementRoot=0;
        XDFLSaxErrorReporter*               l_pErrReporter=0;
        StreamSAX2Parser*                       l_pStreamParser=0;
        //---------------------------------------------------------------------

        DEBUG_IN(SAXDBObjectBuilder::buildSAXDBObject);
        PREP_CATCH_XML_FLOW_ERROR;
        
        WATCH_XML_FLOW_ERROR { 

            //  Create our SAX handler and error reporter objects.
            l_pDBOBJGetStmtBuilder=new DBOBJGetStatementSAXBuilder(p_pContext, p_pDBOBJDefNode);
            l_pErrReporter= new XDFLSaxErrorReporter("DBOBJGetStatementSAXBuilder::buildDBOBJGetStatement");

            // create parser
            l_pStreamParser = new StreamSAX2Parser(l_pDBOBJGetStmtBuilder, l_pErrReporter);

            // Parse !
            (*p_pInput) >> (*l_pStreamParser);
            l_pStreamParser->commitStream(true);            

            l_pDBOBJGetStatementRoot = l_pDBOBJGetStmtBuilder->getStatementRoot();

        } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  

    RELEASE_AND_RETURN: 

        delete l_pStreamParser;
        delete l_pDBOBJGetStmtBuilder;
        delete l_pErrReporter;

        DEBUG_OUT(SAXDBObjectBuilder::buildSAXDBObject);
        ON_XML_FLOW_ERROR_DO delete l_pDBOBJGetStmtBuilder->getStatementRoot();
        ON_XML_FLOW_ERROR_THROW;    

        return l_pDBOBJGetStatementRoot;
    }

    //  CONSTRUCTORS AND DESTRUCTOR  

    //_________________________________________________________________________
    //  DBOBJGetStatementSAXBuilder
    //-------------------------------------------------------------------------
    DBOBJGetStatementSAXBuilder::DBOBJGetStatementSAXBuilder(XMLFlowContext* p_pContext, const DBOBJDefinitionNode* p_pDBOBJDefNode)
    {
        m_pSAXDB_curClause=0;
        m_pSAXDB_objectDef=p_pDBOBJDefNode; 
        m_pSAXDB_StatementRoot=0; 
        m_pContext = p_pContext;

        DEBUG_CREATE(DBOBJGetStatementSAXBuilder)
    }

    //_________________________________________________________________________
    //  ~DBOBJGetStatementSAXBuilder
    //-------------------------------------------------------------------------
    DBOBJGetStatementSAXBuilder::~DBOBJGetStatementSAXBuilder()
    {
        DEBUG_DEL(DBOBJGetStatementSAXBuilder)

        m_pSAXDB_curClause=0;
        m_pSAXDB_objectDef=0;   
        m_pSAXDB_StatementRoot=0; 

    }

    //  GETTERS  

    //_________________________________________________________________________
    //  GETSTATEMENTROOT
    //-------------------------------------------------------------------------
    DBOBJGetStatementNode* DBOBJGetStatementSAXBuilder::getStatementRoot()
    {
        DEBUG_FUNC(DBOBJGetStatementSAXBuilder::getStatementRoot) 

        return m_pSAXDB_StatementRoot;
    }

    //  CONTENTHANDLER  

    //_________________________________________________________________________
    //  STARTELEMENT
    //-------------------------------------------------------------------------
    void DBOBJGetStatementSAXBuilder::startElement( const XMLCh* const uri, 
                                                    const XMLCh* const localname, 
                                                    const XMLCh* const qname, 
                                                    const Attributes& attrs)
    {
        //---------------------------------------------------------------------
        const DBOBJDefinitionNode*      l_pSAXDB_nodeDef;
        const DBOBJDefinitionField*     l_pDBObjectFieldDef;
        DBOBJGetStatementNode*      l_pSAXDB_node=0;

        char                        l_szTagName[XMLPROCESSOR_MAX_TAG_SIZE];
        char                        l_szFieldName[XMLPROCESSOR_MAX_ATTRVAL_SIZE];
        char                        l_szOp[XMLPROCESSOR_MAX_ATTRVAL_SIZE];

        bool                        l_fRoot;
        unsigned int                l_uiType;
        //---------------------------------------------------------------------

        DEBUG_IN(DBOBJGetStatementSAXBuilder::startElement);
        PREP_CATCH_XML_FLOW_ERROR;
        
        WATCH_XML_FLOW_ERROR { 

            XSTR(m_pContext->getTranscoder(), localname, (char*)&l_szTagName);

            logout << l_szTagName << "\n";

            // get node or field definition
            if( m_vaNodes.empty() )
            {
                // root node ?
                if( strcmp( m_pSAXDB_objectDef->getName(), (char*) &l_szTagName) == 0) 
                {
                    l_fRoot = true;
                    l_uiType = 0; // node
                    l_pSAXDB_nodeDef = m_pSAXDB_objectDef;
                }
                else
                {
                    l_uiType=-1; // ignore
                }
            }
            else
            {
                // not a root node
                l_fRoot = false;
                l_uiType = 0; // node

                if( strcmp( (char*) &l_szTagName, DBOBJGETSTMT_FILTER) == 0 ) l_uiType=DBOBJGETSTMT_TYPE_FILTER;    // filter
                if( strcmp( (char*) &l_szTagName, DBOBJGETSTMT_ORDER) == 0 )  l_uiType=DBOBJGETSTMT_TYPE_ORDER; // order

                if( l_uiType>0) // create clause
                {
                    // get field name from clause
                     SAX_getAttrValue( attrs, DBOBJGETSTMT_FIELD,"", (char*)&l_szFieldName);
                    l_pDBObjectFieldDef = m_vaNodes.top()->getDefinition()->getField( (char*) &l_szFieldName);

                    // ERRCHECK : def field exists
                    if( l_pDBObjectFieldDef == 0 ) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_DBOBJGETREQUEST + ERRCODE_CAUSE_MISSINGREF , "Unable to find field definition.", "", "DBOBJGetStatementSAXBuilder::startElement", "The provided field name does not exists in object's node.", false );

                    if(l_pDBObjectFieldDef) // definition found, continue
                    {
                        if( l_uiType == DBOBJGETSTMT_TYPE_FILTER) SAX_getAttrValue(attrs, DBOBJGETSTMT_OP, DBOBJGETSTMT_FILTEROPDEF, (char*)&l_szOp);
                        if( l_uiType == DBOBJGETSTMT_TYPE_ORDER)  SAX_getAttrValue(attrs, DBOBJGETSTMT_OP, DBOBJGETSTMT_ORDEROPDEF, (char*)&l_szOp);

                        // create clause object
                        m_pSAXDB_curClause=new DBOBJGetStatementClause;
                        m_pSAXDB_curClause->m_pFieldDefinition  =l_pDBObjectFieldDef;
                        m_pSAXDB_curClause->m_uiType            =l_uiType;
                        m_pSAXDB_curClause->m_pszOp             =importCharBuffer( 0, (char*) &l_szOp);
                        m_pSAXDB_curClause->m_pszValue          =0; 
                    }
                }
                else
                {
                    l_pSAXDB_nodeDef = m_vaNodes.top()->getDefinition()->getChildNode( (char*) &l_szTagName);
                    // ERRCHECK : def child exists
                    if( l_pSAXDB_nodeDef == 0 ) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_DBOBJGETREQUEST + ERRCODE_CAUSE_MISSINGREF , "Unable to find child node definition. ", "", "DBOBJGetStatementSAXBuilder::startElement", "The statement node's tag name does not match to a definition node.", false );
                }
            }
            
            // build node
            if(l_uiType==0)
            {
                m_pSAXDB_curClause=0;

                if(l_pSAXDB_nodeDef)
                {
                    l_pSAXDB_node = new DBOBJGetStatementNode( l_pSAXDB_nodeDef);

                    if( !l_fRoot)
                    {
                        l_pSAXDB_node->setParent( m_vaNodes.top());
                        m_vaNodes.top()->appendChild( l_pSAXDB_node);
                    }

                    //stack node
                    m_vaNodes.push( l_pSAXDB_node);
                }
            }

        } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  

    RELEASE_AND_RETURN:         

        logout << "/" << l_szTagName << "\n";

        DEBUG_OUT(DBOBJGetStatementSAXBuilder::startElement)
        ON_XML_FLOW_ERROR_DO  delStackedNodes();
        ON_XML_FLOW_ERROR_DO delete m_pSAXDB_curClause;
        ON_XML_FLOW_ERROR_THROW;    
    }

    //_________________________________________________________________________
    //  ENDELEMENT
    //-------------------------------------------------------------------------
    void DBOBJGetStatementSAXBuilder::endElement(   const XMLCh* const uri,
                                                    const XMLCh* const localname,
                                                    const XMLCh* const qname)
    {
        
        DEBUG_IN(DBOBJGetStatementSAXBuilder::endElement)
        PREP_CATCH_XML_FLOW_ERROR;
        
        WATCH_XML_FLOW_ERROR { 
        
            if( m_pSAXDB_curClause )
            {  
                if( m_pSAXDB_curClause->m_uiType == DBOBJGETSTMT_TYPE_FILTER) m_vaNodes.top()->appendFilter( m_pSAXDB_curClause);
                if( m_pSAXDB_curClause->m_uiType == DBOBJGETSTMT_TYPE_ORDER) m_vaNodes.top()->appendOrder( m_pSAXDB_curClause);
                m_pSAXDB_curClause=0;
            }
            else
            {
                // pop top stacked node and adds its to the previous one's children collection    
                if(! m_vaNodes.empty())
                {
                    m_pSAXDB_StatementRoot=m_vaNodes.pop();
                }
            }

        } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  

    RELEASE_AND_RETURN: 

        DEBUG_OUT(DBOBJGetStatementSAXBuilder::endElement)
        ON_XML_FLOW_ERROR_THROW;    
    }

    //_________________________________________________________________________
    //  CHARACTERS
    //-------------------------------------------------------------------------
    void DBOBJGetStatementSAXBuilder::characters(   const XMLCh* const chars , 
                                                    const unsigned int length)
    {
        //---------------------------------------------------------------------
        char*   l_pszChars;
        char*   l_pszTrimmedChars;
        //---------------------------------------------------------------------
        DEBUG_IN(DBOBJGetStatementSAXBuilder::characters)
        PREP_CATCH_XML_FLOW_ERROR;

        WATCH_XML_FLOW_ERROR { 

            // if there's a current field, store value
            if( m_pSAXDB_curClause )
            { 
                l_pszChars= XSTR(m_pContext->getTranscoder(), chars, length);
                l_pszTrimmedChars = trimCharBuffer( l_pszChars);
                releaseCharBuffer( l_pszChars);
                m_pSAXDB_curClause->m_pszValue = concatCharBuffer( m_pSAXDB_curClause->m_pszValue, l_pszTrimmedChars);
                releaseCharBuffer( l_pszTrimmedChars);
            }

        } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;  

    RELEASE_AND_RETURN: 
           
        DEBUG_OUT(DBOBJGetStatementSAXBuilder::characters)
        ON_XML_FLOW_ERROR_THROW;               
    }



    //_________________________________________________________________________
    //  DELSTACKEDNODES
    //-------------------------------------------------------------------------
    void DBOBJGetStatementSAXBuilder::delStackedNodes()
    {
        DEBUG_FUNC(DBOBJGetStatementSAXBuilder::delStackedNode)

        while(!m_vaNodes.empty()) delete m_vaNodes.pop();
    }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//=============================================================================

END_XDFLENGINE_NS

---