---

ddlstreamer.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//-----------------------------------------------------------------------------
//  DDLStreamer.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 "ddlstreamer.hpp"
#   include "processor/xmlflowcontext.hpp"
#   include "streamers/db/dbobject/dbobjdefinition.hpp"

BEGIN_XDFLENGINE_NS

//=============================================================================
//  CLASS DDLStreamer
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


    //_____________________________________________________________________
    //  SaxStreamer
    //---------------------------------------------------------------------
    DDLStreamer::DDLStreamer( const XMLStreamerFactory* p_pParent, StreamerParams* p_pParameters, XMLFlowContext* p_pContext, XMLStreamConsumer* p_pOutput, ContentHandler* p_pHandler, bool p_fCopyStreamToOutput)
    :SaxStreamer( p_pParent, p_pParameters, p_pContext, p_pOutput, p_pHandler, p_fCopyStreamToOutput)
    {
        DEBUG_CREATE(DDLStreamer)
    }
    
    //_____________________________________________________________________
    //  ~SaxStreamer
    //---------------------------------------------------------------------     
    DDLStreamer::~DDLStreamer()
    {
        DEBUG_DEL(DDLStreamer)
    }

    //_____________________________________________________________________
    //  COMMITSTREAM
    //---------------------------------------------------------------------
    bool DDLStreamer::commitStream(bool p_fFinal)
    {
        //---------------------------------------------------------------------
        bool                    l_fOK;
        DBOBJDefinitionNode*    l_pDefinitionRoot=0;
        //---------------------------------------------------------------------

        PREP_CATCH_XML_FLOW_ERROR;

        DEBUG_IN(DDLStreamer::writeData)

        l_fOK = SaxStreamer::commitStream( p_fFinal);

        if(l_fOK && p_fFinal)
        {   

            // get definition
            WATCH_XML_FLOW_ERROR
            {
                // retrieve definition
                l_pDefinitionRoot =  ((SAXDBOBJDefinitionBuilder*)m_pHandler)->getDefinition();     
                // process definition completion
                makeNodeDDL( l_pDefinitionRoot, m_pOutput); 
            } 
            CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN ;
        }

    RELEASE_AND_RETURN:
    

        // CACHE DE DEFINITIONS DESACTIVE !!!!
        delete l_pDefinitionRoot;
        
        ON_XML_FLOW_ERROR_DO l_fOK = false;
        ON_XML_FLOW_ERROR_THROW;    

        DEBUG_OUT(DDLStreamer::writeData)

        return l_fOK;

        
    }



   //_________________________________________________________________________
    //  MAKENODEDDL
    //-------------------------------------------------------------------------
    void DDLStreamer::makeNodeDDL( DBOBJDefinitionNode* p_pDefinitionNode, 
                                    XMLStreamConsumer* p_pOutput ) const
    {
        //_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
        DBOBJDefinitionField*   l_pDefinitionField;
        DBOBJDefinitionNode*    l_pDefinitionChild;

        const char*             l_pszTableName = 0;
        const char*             l_pszFieldName = 0;
        char*                   l_pszFieldDBSpec = 0;
        char*                   l_pszFieldDDL = 0;
        const char*             l_pszSep = 0;
        const char*             l_pszOTLType = 0;
        const char*             l_pszDBType = 0;
        const char*             l_pszDBSize = 0;
        const char*             l_pszDBScale = 0;
        const char*             l_pszDBPrec = 0;
        const char*             l_pszDBNullOK = 0;
        char*                   l_pszTmp = 0;
        char*                   l_pszTmp2 = 0;
    
        unsigned int            l_uiFieldsCount;
        unsigned int            l_uiChildrenCount;
        unsigned int            i;
        //_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

        DEBUG_IN(DDLStreamer::makeNodeDDL)

        PREP_CATCH_XML_FLOW_ERROR;

        WATCH_XML_FLOW_ERROR {

            l_pszTableName=p_pDefinitionNode->getDBTable();
            if ( strlen( l_pszTableName) == 0) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_DDLHANDLER + ERRCODE_CAUSE_MISSINGREF , "Table name is missing in definition." , "", "DDLStreamer::makeNodeDDL", "", false);

            (*p_pOutput) << "<" << p_pDefinitionNode->getName() << ">";
            (*p_pOutput) << "\nCREATE TABLE " << l_pszTableName << " ( ";
            
            l_uiFieldsCount = p_pDefinitionNode->getFieldsCount();
            l_pszSep="";
            for(i=0 ; i<l_uiFieldsCount ; i++)
            {
                // Get field props
                l_pDefinitionField = p_pDefinitionNode->getField(i);
                l_pszFieldName = l_pDefinitionField->getDBField();
                if ( strlen( l_pszFieldName) == 0) THROW_XMLFLOW_EXCEPTION ( ERRCODE_LOC_DDLHANDLER + ERRCODE_CAUSE_MISSINGREF , "Field name is missing in definition of table " , l_pszTableName, "DDLStreamer::makeNodeDDL", "", false);
                            
                l_pszFieldDBSpec = copyCharBuffer( l_pDefinitionField->getDBSpecProps());
                l_pszDBNullOK="1";

                // Generate field DDL
                if( strlen( l_pszFieldDBSpec) == 0) l_pszFieldDDL=getColumnDDL_Simple( l_pDefinitionField->getMap());
                else
                {           
                    l_pszFieldDDL = OTL_getColumnDDL( l_pszFieldDBSpec, DBStreamerFactory::getSQLSyntax()); //l_pszOTLType, l_pszDBType, l_pszDBSize, l_pszDBScale, l_pszDBPrec, l_pszDBNullOK);
                    l_pszFieldDBSpec = releaseCharBuffer( l_pszFieldDBSpec);
                }

                (*p_pOutput) <<  l_pszSep << "\n\t" << l_pszFieldName << " " << l_pszFieldDDL;
                if(  strcmp( l_pszDBNullOK, REQ_FALSE) == 0  ) (*p_pOutput) << " NOT NULL ";                    
                l_pszSep=",";
                l_pszFieldDDL = releaseCharBuffer( l_pszFieldDDL);
            }

            (*p_pOutput) << "\n)\n";
            (*p_pOutput) << "</" << p_pDefinitionNode->getName() << ">\n";

            l_uiChildrenCount = p_pDefinitionNode->getChildNodesCount();
            for( i=0 ; i<l_uiChildrenCount ; i++)
            {
                l_pDefinitionChild = p_pDefinitionNode->getChildNode(i);
                makeNodeDDL( l_pDefinitionChild, p_pOutput);
            }

        } CATCH_XML_FLOW_ERROR_RELEASE_AND_RETURN;

    RELEASE_AND_RETURN:

        // release 
        l_pszFieldDBSpec = releaseCharBuffer( l_pszFieldDBSpec);
        l_pszFieldDDL = releaseCharBuffer( l_pszFieldDDL);

        DEBUG_OUT(DDLStreamer::makeNodeDDL)
        ON_XML_FLOW_ERROR_THROW;
    }


    //_________________________________________________________________________
    //  GETCOLUMNDDL_SIMPLE
    //-------------------------------------------------------------------------
    char* DDLStreamer::getColumnDDL_Simple( const char* p_pszReducedType) const
    {
        char* l_pszDDL;

        DEBUG_FUNC(DDLStreamer::getColumnDDL_Simple)
        
        if( strcmp( p_pszReducedType, DBOBJDEFFIELD_MAP_NUM) == 0 )     l_pszDDL = copyCharBuffer( "DOUBLE");
        if( strcmp( p_pszReducedType, DBOBJDEFFIELD_MAP_STRING) == 0 )
        {
            l_pszDDL = copyCharBuffer( "VARCHAR(");
            l_pszDDL = concatCharBuffer( l_pszDDL, DDLSTREAMER_VARCHARSIZE);
            l_pszDDL = concatCharBuffer( l_pszDDL, ")");
        }
        if( strcmp( p_pszReducedType, DBOBJDEFFIELD_MAP_DATE) == 0 ) 
        {
            if (DBStreamerFactory::getSQLSyntax()==SQL_SYNTAX_ORA)
            {
                l_pszDDL= copyCharBuffer( "DATE" );
            }
            else if (DBStreamerFactory::getSQLSyntax()==SQL_SYNTAX_MSSQL)
            {
                l_pszDDL= copyCharBuffer( "TIMESTAMP" );
            }
            else if (DBStreamerFactory::getSQLSyntax()==SQL_SYNTAX_DB2)
            {
                l_pszDDL= copyCharBuffer( "TIMESTAMP" );
            }
                        
        }
        return l_pszDDL;
    }

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


//=============================================================================
//  CLASS DDLStreamerFactory
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    XMLStreamer* DDLStreamerFactory::getStreamer(
        StreamerParams*         p_pParameters, 
        XMLFlowContext* p_pStreamContext, 
        XMLStreamConsumer*      p_pStreamConsumer) const
    {
        SAXDBOBJDefinitionBuilder*  l_pSAXDefinitionBuilder = 0;

        l_pSAXDefinitionBuilder = new SAXDBOBJDefinitionBuilder( p_pStreamContext);
        return (XMLStreamer*) new DDLStreamer( this, p_pParameters, p_pStreamContext, p_pStreamConsumer, l_pSAXDefinitionBuilder, false);
    }

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


END_XDFLENGINE_NS

---