E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeDatabase.h

Go to the documentation of this file.

/************************************************************************************
TerraLib - a library for developing GIS applications.
Copyright � 2001-2007 INPE and Tecgraf/PUC-Rio.

This code is part of the TerraLib library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

You should have received a copy of the GNU Lesser General Public
License along with this library.

The authors reassure the license terms regarding the warranties.
They specifically disclaim any warranties, including, but not limited to,
the implied warranties of merchantability and fitness for a particular purpose.
The library provided hereunder is on an "as is" basis, and the authors have no
obligation to provide maintenance, support, updates, enhancements, or modifications.
In no event shall INPE and Tecgraf / PUC-Rio be held liable to any party for direct,
indirect, special, incidental, or consequential damages arising out of the use
of this library and its documentation.
*************************************************************************************/
#ifndef  __TERRALIB_INTERNAL_DATABASE_H
#define  __TERRALIB_INTERNAL_DATABASE_H

#if defined(_MSC_VER) /* MSVC Compiler */
#pragma warning(disable: 4786)
#endif


#include "TeDefines.h"
#include "TeDataTypes.h"
#include "TeTable.h"
#include "TeGeometry.h"
#include "TeStatistics.h"
#include "TeProject.h"
#include "TeRaster.h"
#include "TeView.h"
#include "TeVisual.h"
#include "TeMetaModelCache.h"
#include "TeSharedPtr.h"
#include "TeDatabaseIndex.h"
#include "TeConnection.h"

class TeLayer;
class TeDatabaseFactoryParams;
class TeRasterParams;
class TeTheme;
class TeTime;
class TeTimeInterval;

#include <set>
#include <string>
//using namespace std;

          
enum TeCursorLocation { TeCLIENTESIDE, TeSERVERSIDE };

enum TeCursorType { TeUNIDIRECTIONAL, TeBIDIRECTIONAL, TeRANDOMACCESS };

enum TeCursorEditType { TeREADONLY, TeREADWRITE };

enum TeCursorDataType { TeBINARYCURSOR, TeTEXTCURSOR };


enum TeSpatialIndexType {TeRTREE, TeQUADTREE};

typedef vector<string>                                            TeKeys;

typedef map<string, double>                            TeKeysToDist;

typedef vector<TeGeometry*> TeGeometryVect;

typedef map<string, TeStatisticsDimensionVect>  TeObjectStatistics;


class TeDatabasePortal;



class TL_DLL TeDatabase 
{
public: 
           TeDatabase();

           virtual ~TeDatabase();

           virtual TeDatabase& operator=(const TeDatabase& other);

           virtual bool operator== (const TeDatabase& other) const
           {          
                      if (dbmsName_ != other.dbmsName_ ||
                                 database_ != other.database_ ||
                                 host_  != other.host_ ||
                                 user_ != other.user_ )
                                 return false;
                      return true;
           }



    virtual void setConnection(TeConnection* c);

    virtual TeConnection* getConnection();



           virtual string errorMessage ()
           { return errorMessage_; }

           virtual int           errorNum ()
           {          return errorNumber_; }

           string     user () 
           { return user_; }

           void user(string value) { user_=value;}

           string     host () 
           { return host_; }

           string     password () 
           { return password_; }

           string     databaseName () 
           { return database_; }
           
           string     dbmsName () 
           { return dbmsName_; }

           int        portNumber () 
           { return portNumber_; }

           TeLayerMap&           layerMap () 
           { return metaModel_->layerMap(); }

           TeViewMap& viewMap () 
           { return metaModel_->viewMap(); }

           TeThemeMap&           themeMap () 
           { return metaModel_->themeMap(); }

           TeThemeMap&           invalidThemeMap() 
           { return metaModel_->invalidThemeMap(); }

           TeProjectMap&  projectMap ()
   { return metaModel_->projectMap(); }

           TeLegendEntryMap& legendMap () 
           { return metaModel_->legendMap(); }

           multiset<int>& relationMSet () 
           { return metaModel_->relationMSet(); }

           virtual void clear();



           virtual bool newDatabase(const string& database, const string& user, const string& password, const string& host, const int &port=-1, bool terralibModel=true, const std::string& characterSet = "") = 0;
           
           virtual bool connect (const string& host, const string& user, const string& password, const string& database, int port = -1) = 0;

           virtual bool showDatabases (const string& /* host */, const string& /* user */, const string& /* password */, vector<string>& /* dbNames */ , int /* port */ = -1)
           { return true; }

           virtual bool connect (const string&  = "") { return false; };

           bool isConnected () 
           { return isConnected_; }

           virtual void close() = 0;

           /*
                      The expected return value is similar to: dbms_server;hostname;portnumber;databasename;user;password
           */
           virtual string getDatabaseDescription();
           
  
  static TeDatabase* DefaultObject( const TeDatabaseFactoryParams& )
  {
    std::cout << std::endl << "TeDatabase::DefaultObject - " <<
      " - Trying to create an invalid TeDatabase default object." <<
      std::endl;
    throw;
      
    return 0;
  };
  


           virtual bool listTables(vector<string>& /* tableList */) { return false; }

           virtual bool listDatabases(std::vector<std::string> & /*databaseList*/) { return false; }

           virtual bool dropDatabase(const std::string & /*databaseName*/) { return false;} 

           virtual bool tableExist(const string& table) = 0;
           
           virtual bool columnExist(const string& table, const string& column, TeAttribute& attr) = 0;

           virtual bool allowEmptyString(const string& /* tableName */, const string& /* column */) { return false; }

           virtual bool validTable (TeTable& table);

           string getTableName(int tableId);

           string getNewTableName(const string& n);


           virtual string getConcatFieldsExpression(const vector<string>& fNamesVec);


           virtual bool createTable(const string& table, TeAttributeList &attr) = 0;

            virtual bool deleteTable (const string& table);


           virtual bool addColumn (const string& table, TeAttributeRep &rep) = 0;


           virtual bool deleteColumn (const string& table, const string& colName);
           

           virtual bool createRelation (const string& relName, const string& table, const string& fieldName, 
                                                                  const string& relatedTable, const string& relatedField, bool cascadeDeletion) = 0;


           virtual TeDBRelationType existRelation(const string& tableName, const string& relName) = 0;


           virtual bool deleteRelation(const string& name, const string& table);

           

           virtual bool execute ( const string &sql) = 0;


           virtual TeDatabasePortal* getPortal () = 0;

           virtual bool inClauseValues(const string& query , const string& attribute, vector<string>& inClauseVector);



           /*
      \param withIntegrity flag that indicates that the referencial integrity should be implemented.
             \param createIndex flag that indicate that the indexes should be created
           */
           virtual bool createConceptualModel(bool withIntegrity = true, bool newDatabase = true, bool createIndex = true);

           virtual bool defineIntegrity(void);

           virtual bool createIndex(const string& tableName, const string& indexName, const string& columnsName);

           virtual bool deleteIndex(const string& tableName, const string& indexName);

           virtual bool getIndexesFromTable(const string& tableName, std::vector<TeDatabaseIndex>& vecIndexes);

           virtual bool createDatabaseTable(); 
           
           virtual bool createDatumTable();

           virtual bool createProjectionTable();

           virtual bool createSRSTable();

           virtual bool createLayerTable ();

           virtual bool createRepresentationTable ();

           virtual bool createViewTable ();

           virtual bool createThemeTable ();

           virtual bool createGroupingTable();

           virtual bool createThemeTablesTable();

           virtual bool createLegendTable ();

           virtual bool createVisualTable();

           virtual bool createVisualRasterTable();

           virtual bool createLayerTableTable();

           virtual bool createTablesRelationTable();

           virtual bool createProjectTable();

           virtual bool createProjectViewTable();


           virtual bool loadProjectSet(); 

           virtual bool loadProject(TeProject* project); 
           
           virtual bool insertProject(TeProject *project) = 0;
           
           virtual bool updateProject(TeProject *project);        

           virtual bool deleteProject(int projectId);  

           virtual bool insertProjectViewRel(int projectId, int viewId);

           virtual bool deleteProjectViewRel(int projectId, int viewId);

           virtual bool projectExist(const string& projectName);


           virtual bool createPolygonGeometry (const string& tableName, const int& epsgCode = -1);

           virtual bool createLineGeometry (const string& tableName, const int& epsgCode = -1);

           virtual bool createPointGeometry (const string& tableName, const int& epsgCode = -1);

           virtual bool createCellGeometry (const string& tableName, const int& epsgCode = -1);
 
           virtual bool createTextGeometry (const string& tableName, const int& epsgCode = -1);

           virtual bool createArcGeometry (const string& tableName, const int& epsgCode = -1);

           virtual bool createNodeGeometry (const string& tableName, const int& epsgCode = -1);

           virtual bool createRasterGeometry(const string& tableName);

           virtual bool createRasterMetadataTable(const string& tableName);
           
           virtual bool createRasterTable (const string& tableName);

           virtual bool createCollectionTable(const string& tableName);


           /*
                      \param atts returning vector of tables information 
                      \param attType type of the tables that are being looked for (optional)
                      \return TRUE if any table was found and FALSE otherwise
           */
           virtual bool getAttrTables(TeAttrTableVector& atts, TeAttrTableType attType = TeAllAttrTypes);

           /*
                      \param tableId table identification (from te_layer_table)
                      \param tField link column name of the static table
                      \param eTable name of the external table
                      \param eField name of the link column of the related table
                      \param relId returns the identification of the relation
           */
           virtual bool insertRelationInfo(const int tableId, const string& tField,
                                                                                                   const string& rTable, const string& rField, int& relId) = 0;

           virtual bool insertTableInfo (int layerId, TeTable &table, const string& user="") = 0;

           virtual bool updateTableInfo (int layerId, TeTable &table, const string user="");

           virtual bool loadTableInfo(TeTable& table);

           virtual bool insertTable(TeTable &table);

           virtual bool alterTable(const string& tableName, TeAttributeRep& rep, const string& oldColName="");

           virtual bool alterTable(const string& oldTableName, const string& newTablename);

           virtual bool insertBlob (const string& tableName, const string& columnBlob, TeAttributeRep& columnId, const string& valueId, unsigned char* data, int size);

           virtual bool insertBlob (const string& tableName, const string& columnBlob, TeAttributeRep& columnId, const string& valueId, const string& fileName);

           virtual bool insertBlob (const string& tableName, const string& columnBlob, const string& whereClause, unsigned char* data, int size) = 0;

           virtual bool insertBlob (const string& tableName, const string& columnBlob, const string& whereClause, const string& fileName);
           
           virtual bool updateTable         (TeTable &table);

           virtual bool loadTable                      (const string& tableName, TeTable &table);

           virtual bool selectTable         (const string& tableName, const string& criteria, TeTable &table);

           virtual bool deleteLayerTable    (int layerId, TeAttrTableType ttype = TeAttrStatic);


           virtual bool insertDatum(const TeDatum& datum);

           virtual bool updateDatum(const TeDatum& datum);

           virtual bool loadDatum(TeDatum& datum);

           virtual void populateDatumTable();

           virtual bool loadDatumSet();



           virtual bool insertProjection(TeProjection* proj) = 0; 

           virtual bool insertSRSId(TeProjection* proj, int srsId);

           virtual bool updateProjection(TeProjection *proj);     

           virtual bool updateSRSId(TeProjection* proj, int srsId);

           virtual TeProjection* loadProjection(int id);

           virtual TeProjection* loadProjectionFromSRSId(int srsid);

           virtual bool deleteProjection(const unsigned int& projId);



           virtual bool insertLayer         (TeLayer *layer) = 0;
           
           virtual bool updateLayer         (TeLayer *layer);     

           /*
                      \param loadAttrList  indicates if the attribute list of each attribute table should be loaded
           */
           virtual bool loadLayerSet        (const bool& loadAttrList = true);

           /*
                      \param layer                     a pointer to a layer that will be loaded from database
                      \param loadAttrList indicates if the attribute list of each attribute table should be loaded
           */
           virtual bool loadLayer                      (TeLayer* layer, const bool& loadAttrList = true);

           /*
                      \param layer                     a pointer to a layer whose attribute table will be loaded from database
                      \param loadAttrList indicates if the attribute list of each attribute table should be loaded
           */
           virtual bool loadLayerTable (TeLayer* layer, const bool& loadAttrList = true);

           virtual bool deleteLayer         (int layerId);

           virtual bool layerExist                     (int id);

           virtual bool layerExist                     (string layerName);


           virtual string getNewLayerName(const string& n);


           virtual bool insertRepresentation (int layerId, TeRepresentation& rep) = 0;  

           virtual bool updateRepresentation (int layerId, TeRepresentation& rep);      

           virtual bool updateLayerBox(TeLayer* layer);




           virtual bool insertRasterGeometry(const string& tableName, TeRasterParams& par, const string& objectId = "");


           virtual bool updateRasterRepresentation(int layerId, TeRasterParams& par, const string& objectId="");


           virtual string getRasterTable(int layerId, const string& objectId);
           

           virtual bool insertRasterMetadata (const string& tableName, int geomId, TeRasterParams& par);


           virtual bool updateRasterMetadata (const string& tableName, int geomId, TeRasterParams& par);


           virtual bool insertView (TeView *view) = 0; 

           virtual bool updateView (TeView *view);     

           /*
                      \param user                                  the user name 
                      \param loadAttrList  indicates if the attribute list of each attribute table should be loaded
                      \param visualClass  identifies which concrete class od visual should be instantiated.
                      The default is TerraLib basic visual.
           */
           virtual bool loadViewSet (const string& user, const bool& loadAttrList = true, const string& visualClass="tevisual");

           /*
                      \param view                                 a pointer to a view that will be loaded from database
                      \param loadAttrList indicates if the attribute list of each attribute table should be loaded
                      \param visualClass  identifies which concrete class od visual should be instantiated.
                      The default is TerraLib basic visual.
           */
           virtual bool loadView (TeView* view, const bool& loadAttrList = true, const string& visualClass="tevisual");

           virtual bool deleteView (int viewId);

           virtual bool insertViewTree (TeViewTree *tree) = 0;    

           /*
                      \param view                                 a pointer to a view that will be loaded from database
                      \param id                        a specific theme or viewtree id of this view that will be loaded from database
                      \param loadAttrList indicates if the attribute list of each attribute table should be loaded
                      \param visualClass  identifies which concrete class od visual should be instantiated.
                      The default is TerraLib basic visual.
           */
           virtual TeViewTree* loadViewTree(TeView* view, int id, const bool& loadAttrList = true, const string& visualClass = "tevisual");

           virtual bool updateViewTree (TeViewTree *tree);
           
           virtual bool viewExist(string viewName);



           virtual bool insertThemeGroup    (TeViewTree* tree) = 0;

           virtual bool insertTheme                    (TeAbstractTheme *theme) = 0;    

           virtual bool updateTheme                    (TeAbstractTheme *theme);

           virtual bool loadTheme                                 (TeAbstractTheme *theme, const bool& loadAttrList = true, const string& visualClass = "tevisual");
           
           virtual bool loadThemes                                (std::vector<TeAbstractTheme*>& vecThemes, const bool& loadAttrList, const std::string& userName, const bool& loadMetadata = true, const string& visualType = "tevisual");

           virtual bool loadExternalThemes  (std::vector<TeAbstractTheme*>& vecExternalThemes);

           virtual bool loadThemeTable                 (TeTheme* theme, const bool& loadAttrList = true);

           virtual bool deleteThemeGroup    (int themeId);

           virtual bool deleteTheme                    (int themeId);

           virtual bool deleteLegend                   (int themeId);
           
           bool insertThemeTable(TeTheme *theme, TeTable& inputTable);

           virtual bool insertThemeTable    (int themeId, int tableId, int relationId, int tableOrder) = 0; 

           virtual bool updateThemeTable    (TeTheme *theme);
           
           bool removeThemeTable(TeTheme *theme, int tableOrder);

           virtual bool insertGrouping (int themeId, const TeGrouping& grouping);

           virtual bool updateGrouping (int themeId, const TeGrouping& grouping);

           virtual bool generateLabelPositions(TeTheme *theme, const std::string& objectId = "");

           virtual bool themeExist(string themeName);
           
           virtual bool themeExist(const std::string &viewName, const std::string &userName, const std::string &themeName);


           virtual string getNewThemeName(const string& n);



           virtual bool insertLegend        (TeLegendEntry *legend) = 0;     
           virtual bool updateLegend        (TeLegendEntry *legend);         

           virtual bool updateLegend   (vector<TeLegendEntry>& legVec);
           virtual bool loadLegend                     (TeAbstractTheme *theme, const string& visualClass = "tevisual");
           virtual bool updateVisual        (TeLegendEntry *legend);
           virtual bool updateVisual   (vector<TeLegendEntry>& legVec);


           virtual bool insertPolygonSet (const string& table, TePolygonSet &ps);       

           virtual bool updatePolygonSet (const string& table, TePolygonSet &ps);       

           virtual bool selectPolygonSet (const string& table, const string& criteria, TePolygonSet &ps);

           virtual bool loadPolygonSet      (TeTheme* theme, TePolygonSet &ps);

           virtual bool loadPolygonSet      (const string& table, const string& geoid, TePolygonSet &ps);

           virtual bool loadPolygonSet      (const string& table, TeBox &box, TePolygonSet &ps);

           /*
                      \return A database portal pointer if there is any polygons inside the box
                      \return A null pointer if there isn't polygons to iterate
                      \note The database portal pointer should be deleted by the application
           */
           virtual TeDatabasePortal* loadPolygonSet(const string& table, TeBox &box);

           virtual bool locatePolygon                  (const string& table, TeCoord2D &pt, TePolygon &polygon, const double& tol = 0.0);

           virtual bool locatePolygonSet   (const string& table, TeCoord2D &pt, double tol, TePolygonSet &polygons);

           virtual bool insertPolygon                  (const string& table, TePolygon &p) = 0;    

           virtual bool updatePolygon                  (const string& table, TePolygon &p) = 0;

           // Accessing/Inserting line geometries into the database
           virtual bool insertLineSet       (const string& table, TeLineSet &ls);       
           virtual bool updateLineSet       (const string& table,TeLineSet &ls);
           virtual bool loadLineSet         (const string& table, const string& geoid, TeLineSet &ls);
    virtual bool loadLineSet     (TeTheme* theme, TeLineSet &ls);
           virtual bool loadLineSet         (const string& table, TeBox &box, TeLineSet &linSet);
           virtual TeDatabasePortal*    loadLineSet (const string& table, TeBox &box);
           virtual bool selectLineSet       (const string& table, const string& criteria, TeLineSet &ls);

    virtual bool insertLine                 (const string& table, TeLine2D &l) = 0;                
           virtual bool updateLine                     (const string& table, TeLine2D &l) = 0;
           virtual bool locateLine                     (const string& table, TeCoord2D &pt, TeLine2D &line, const double& tol = 0.0);
           virtual bool locateLineSet       (const string& table, TeCoord2D &pt, TeLineSet & ls, const double& tol = 0.0);


           // Accessing/Inserting point geometries into the database
           virtual bool insertPointSet      (const string& table, TePointSet &ps);      
    virtual bool updatePointSet (const string& table, TePointSet &ps);
           virtual bool loadPointSet        (const string& table, TeBox &box, TePointSet &ps);
           virtual TeDatabasePortal* loadPointSet      (const string& table, TeBox &box);
           virtual bool loadPointSet        (const string& table, const string& geoid, TePointSet &ps);
           virtual bool loadPointSet        (TeTheme* theme, TePointSet &ps);
           virtual bool selectPointSet (const string& table, const string& criteria, TePointSet &ps);

    virtual bool insertPoint     (const string& table, TePoint &p) = 0;      
           virtual bool updatePoint         (const string& table, TePoint &p);
           virtual bool locatePoint         (const string& table, TeCoord2D &pt, TePoint &point, const double& tol = 0.0);
           virtual bool locatePointSet (const string& table, TeCoord2D &pt, TePointSet &pointSet, const double& tol=0.0);

           // Accessing/Inserting text geometries into the database
           virtual bool insertTextSet       (const string& table, TeTextSet &ts);       
           virtual bool updateTextSet       (const string& table, TeTextSet &ts);       
           virtual bool loadTextSet         (const string& table, const string& geoid, TeTextSet &ts);
           virtual bool selectTextSet       (const string& table, const string& criteria, TeTextSet &ts);

           virtual bool insertText                     (const string& table, TeText &t) = 0;       
           virtual bool updateText                     (const string& table, TeText &t);
           virtual bool locateText                     (const string& table, TeCoord2D &pt, TeText &text, const double& tol = 0.0);
           virtual bool locateTextSet       (const string& table, TeCoord2D &pt, TeTextSet &textSet, const double& tol = 0.0);


           virtual bool insertArcSet        (const string& table, TeArcSet &as);        

           virtual bool updateArcSet        (const string& table, TeArcSet &as);        

           virtual bool loadArcSet                     (const string& table, const string& geoid, TeArcSet &as);

           virtual bool insertArc                      (const string& table,TeArc &arc) = 0;

           virtual bool updateArc                      (const string& table,TeArc &arc);

           // Accessing/Inserting node geometries into the database
           virtual bool insertNodeSet       (const string& table, TeNodeSet &ns);       
           virtual bool updateNodeSet       (const string& table, TeNodeSet &ns);       
           virtual bool loadNodeSet         (const string& table, const string& geoid, TeNodeSet &ps);

           virtual bool insertNode                     (const string& table, TeNode &node) = 0;    
           virtual bool updateNode                     (const string& table, TeNode &node);        

           // Accessing/Inserting cell geometries into the database
           virtual bool insertCellSet       (const string& table, TeCellSet &cs);       
           virtual bool updateCellSet       (const string& table, TeCellSet &cs);       
           virtual bool loadCellSet         (const int& layerId, const string& table, const string& geoid, TeCellSet &cs);
           virtual bool selectCellSet       (const int& layerId, const string& table, const string& criteria, TeCellSet &cs);

           virtual bool insertCell                     (const string& table, TeCell &c) = 0;
           virtual bool updateCell                     (const string& table, TeCell &c);
           virtual bool locateCell                     (const string& table, TeCoord2D &pt, TeCell &c, const double& tol = 0.0);

           virtual bool removeGeometry(const string& tableName, const TeGeomRep& rep, const int& geomId);
           

           virtual    bool insertRasterBlock(const string& table, const string& blockId, const TeCoord2D& ll, const TeCoord2D& ur, unsigned char *buf,unsigned long size, int band=0, unsigned int res=1, unsigned int subband=0) = 0;

           virtual    bool insertVisual (TeLegendEntry *legend);

           virtual bool insertRasterVisual (int themeId , TeRasterVisual* rasterVisual);

           virtual TeRaster* loadLayerRaster(int layerId, const string& objectId="", const char& mode = 'r');

           virtual bool createLUTTable(const string& name);

           virtual bool loadRasterLUT(TeRasterParams* par);

           virtual bool createSpatialIndex(const string& table, const string& columns, TeSpatialIndexType /*type*/ = TeRTREE,short /* level */ =0,short /* tile */ =0);

           virtual bool insertMetadata(const string& /* table */, const string& /* column */, double /* tolx */, double /* toly */,TeBox &/* box */,short /* srid */ =0) { return true; };

           virtual string getSpatialIdxColumn(TeGeomRep rep);

           /*
                      This method gives to the drivers the ability to update box columns, considering precision issues
                      that are particular to the driver. The box should be stored in 4 columns (lower_x, lower_y, upper_x, upper_y)
                      \param tableName table name
                      \param keyColumnName name of the column that is primary key
                      \param idValue key value of the row that should be updated
                      \param box new box value
           */
   virtual bool updateBBox(const string& tableName, const string& keyColumnName, int keyValue, const TeBox& box);  



           virtual bool spatialRelation(const string& actGeomTable, TeGeomRep actRep, TeKeys& actIdsIn, 
                      TeDatabasePortal *portal, int relate, const string& actCollTable="");
           
           virtual bool spatialRelation(const string& actGeomTable, TeGeomRep actRep, TeKeys& actIdsIn, 
                      const string& visGeomTable, TeGeomRep visRep, TeDatabasePortal *portal, 
                      int relate, const string& visCollTable=""); 

           virtual bool spatialRelation(const string& actGeomTable, TeGeomRep actRep, TeGeometry* geom, 
                      TeDatabasePortal *portal, int relate, const string& actCollTable=""); 
                      
           virtual bool spatialRelation(const string& actGeomTable, TeGeomRep actRep, TeKeys& actIdsIn, 
                      TeKeys& actIdsOut, int relate, const string& actCollTable="");

           virtual bool spatialRelation(const string& actGeomTable, TeGeomRep actRep, TeKeys& actIdsIn, 
                      const string& visGeomTable, TeGeomRep visRep, TeKeys& visIdsOut, int relate, 
                      const string& visCollTable="", TeDatabase* = 0); 

           virtual bool spatialRelation(const string& actGeomTable, TeGeomRep actRep, TeGeometry* geom, 
                      TeKeys& actIdsOut, int relate, const string& actCollTable=""); 
           
           virtual bool calculateArea(const string& actGeomTable, TeGeomRep actRep, TeKeys& actIdsIn, double &area);

           virtual bool calculateLength(const string& actGeomTable, TeGeomRep actRep, TeKeys& actIdsIn, double &length);
           
           virtual bool calculateDistance(const string& actGeomTable, TeGeomRep actRep, TeKeys& Ids, double& distance);

           virtual bool calculateDistance(const string& actGeomTable, TeGeomRep actRep, const string& objId1, 
                      const string& visGeomTable, TeGeomRep visRep, const string& objId2, double& distance);

           virtual bool withinDistance(const string& actGeomTable, TeGeomRep actRep, const TeCoord2D& point, 
                      TeKeysToDist& IdsDistOut, const double& max_distance, const string& actCollTable="");


           virtual bool buffer(const string& actGeomTable, TeGeomRep actRep, TeKeys& actIds, TePolygonSet& bufferSet, double dist);

           virtual bool centroid(const string& actGeomTable, TeGeomRep actRep, TePointSet& centroidSet, TeKeys actIds = vector<string>(), const string& actCollTable = "");

           virtual bool convexHull(const string& actGeomTable, TeGeomRep actRep, TeKeys& actIds, TePolygonSet& convexHullSet);

           virtual bool nearestNeighbors(const string& actGeomTable, const string& actCollTable,
                      TeGeomRep actRep, const string& objId1, TeKeys& actIdsOut, int numRes=1);
           
           virtual bool nearestNeighbors(const string& actGeomTable, TeGeomRep actRep, const string& objId1, 
                      const string& visGeomTable, const string& visCollTable, 
                      TeGeomRep visRep, TeKeys& visIdsOut, int numRes=1); 

           virtual bool nearestNeighbors(const string& actGeomTable, const string& actCollTable, 
                      TeGeomRep actRep, const string& objId1, TeDatabasePortal* portal, int numRes=1);

           virtual bool nearestNeighbors(const string& actGeomTable, TeGeomRep actRep, 
                      const string& objId1, const string& visGeomTable, const string& visCollTable, 
                      TeGeomRep visRep, TeDatabasePortal* portal, int numRes=1); 


           virtual bool geomIntersection(const string& actGeomTable, TeGeomRep actRep, TeKeys& actIds, TeGeometryVect& geomVect);

           virtual bool geomIntersection(const string& actGeomTable, TeGeomRep actRep, const string& objId1,
                      const string& visGeomTable, TeGeomRep visRep, const string& objId2, TeGeometryVect& geomVect);

           virtual bool geomDifference(const string& actGeomTable, TeGeomRep actRep, const string& objId1, 
                      const string& objId2, TeGeometryVect& geomVect);

           virtual bool geomDifference(const string& actGeomTable, TeGeomRep actRep, const string& objId1, 
                      const string& visGeomTable, TeGeomRep visRep, const string& objId2, TeGeometryVect& geomVect);

           virtual bool geomUnion(const string& actGeomTable, TeGeomRep actRep, TeKeys& actIds, TeGeometryVect& geomVect);

           virtual bool geomUnion(const string& actGeomTable, TeGeomRep actRep, const string& objId1, 
                      const string& visGeomTable, TeGeomRep visRep, const string& objId2, TeGeometryVect& geomVect);

           virtual bool geomXOr(const string& actGeomTable, TeGeomRep actRep, const string& objId1, 
                      const string& objId2, TeGeometryVect& geomVect);

           virtual bool geomXOr(const string& actGeomTable, TeGeomRep actRep, const string& objId1, 
                      const string& visGeomTable, TeGeomRep visRep, const string& objId2, TeGeometryVect& geomVect);     

           virtual bool zonal(const string& rasterTable, const string& actGeomTable, TeKeys& Ids, TeObjectStatistics& result, const bool &useDummy=true);
           
           virtual bool zonal(const string& rasterTable, const string& actGeomTable, const string& actCollTable, TeObjectStatistics& result, const bool &useDummy=true);
           
           virtual bool zonal(const string& rasterTable, TePolygon& poly, TeStatisticsDimensionVect& result,const bool &useDummy=true);

           virtual bool mask(const string& rasterTable, const string& actGeomTable, const string& objId, const string& nameLayerOut, TeStrategicIterator st);
           
           virtual bool mask(const string& rasterTable, TePolygon& poly, const string& nameLayerOut, TeStrategicIterator st);
           

           virtual string getSQLBoxWhere (const TeBox& box, const TeGeomRep rep, const std::string& tableName);

           virtual string getSQLBoxWhere(const TeBox& box, const TeGeomRep rep, const std::string& tableName, const std::string& columnName);

           virtual string getSQLBoxWhere (const string& table1, const string& table2, TeGeomRep rep2, TeGeomRep rep1 = TePOLYGONS);

           virtual string getSQLBoxSelect (const string& tableName, TeGeomRep rep);

           virtual std::string getSQLOrderBy(const TeGeomRep& rep) const;

           virtual string getSQLStatistics (TeGroupingAttr& attrs);
           
           virtual string getSQLAutoNumber(const string& table);

           virtual string getSQLTemporalWhere (TeTimeInterval& /* timeInterval */, TeTemporalRelation /* timeOperator */, const string& /* initialTime */, const string& /* finalTime */ );

           virtual string getSQLTemporalWhere (const string& temporalRest);
                      
           virtual string getSQLTemporalWhere(int /* time1 */, int /* time2 */, TeChronon /* chr */, TeTemporalRelation /* rel */, const string& /* initialTime */, const string& /* finalTime */);

           virtual string getSQLTime(const TeTime& /* time */) const { return ""; };

           virtual string getSQLTemporalFunction (TeChronon chr, const string& colName);

           virtual bool getMBRGeom(string tableGeom, string object_id, TeBox& box, string colGeom);

           virtual bool getMBRSelectedObjects(string geomTable,string colGeom, string fromClause, 
                      string whereClause, string afterWhereClause, TeGeomRep repType,TeBox &bout, const double& tol = 0.0);

           virtual bool getAttributeList(const string& tableName,TeAttributeList& attList);

           virtual string  escapeSequence(const string& from) = 0;

           virtual TeBox getThemeBox(TeTheme* theme);

           map<int, map<string, string> >& mapThemeAlias() {return metaModel_->mapThemeAlias();}

           virtual string concatValues(vector<string>& values, const string& unionString) = 0;

           virtual string toUpper(const string& value) = 0;

           virtual string leftString(const string& /*name*/, const int& /*length*/){return "";}

           virtual    bool updateVersionStamp(const string& version ); 

           virtual    bool loadVersionStamp( string& version ); 


   virtual bool beginTransaction(); 

   virtual bool commitTransaction();

   virtual bool rollbackTransaction();

   virtual bool dropDBView(const string& dbViewName);
   
   virtual std::string getClientEncoding()
   { return ""; }

   virtual bool setClientEncoding(const std::string& /*characterSet*/)
   { return true; }

   virtual bool getEncodingList(std::vector<std::string>& /*vecEncodingList*/)
   { return true; }

   virtual bool getEncodingList(const std::string& /*host*/, const std::string& /*user*/, const std::string& /*password*/, const int& /*port*/, std::vector<std::string>& /*vecEncodingList*/)
   { return true; }


protected :

           bool                                        isConnected_;                               
std::string                                            host_;                                                 
        std::string                                    user_;                                                 
        std::string                                    password_;                                  
        std::string                                    database_;                                  
           int                                                    portNumber_;                                
           int                                                    errorNumber_;                               
        std::string                                    errorMessage_;                              
        std::string                                    dbmsName_;                                  
           TeSharedPtr<TeMetaModelCache> metaModel_;   

           void alterTableInfoInMemory(const string& updatedTableName, string oldTableName="");

           int               transactionCounter_;

private:

           TeDatabase(const TeDatabase& other);
};


class TL_DLL TeDatabasePortal {
protected:
           

           TeDatabase*                      db_;                             
           TeAttributeList       attList_;             
           int                                         numRows_;             
           int                                         numFields_;                      
           string          errorMessage_;   
           int                                         errorNumber_;         

public :

           TeDatabasePortal ();

           virtual ~TeDatabasePortal ();
           
           TeDatabase* getDatabase()
           { return db_; }

           virtual bool query ( const string &qry, TeCursorLocation l = TeSERVERSIDE, TeCursorType t = TeUNIDIRECTIONAL, TeCursorEditType e = TeREADONLY, TeCursorDataType dt = TeTEXTCURSOR ) = 0;

           virtual bool fetchRow () = 0;

           virtual bool fetchRow (int i) = 0;

           virtual void freeResult () = 0;

           virtual string        errorMessage ()
           { return errorMessage_; }

           virtual int errorNum ()
           { return errorNumber_; }
           
//         virtual bool loadNetwork (TeLayer *layer) = 0;

// specific SQL SELECT command methods

           int numRows () 
           { return numRows_;}

           int numFields () 
           { return numFields_; }

           TeAttributeList& getAttributeList()         
           { return attList_; }

           TeAttribute getAttribute (int i);

           TeAttribute getAttribute (const string& s);

           virtual char* getData (int i) = 0;

           virtual char* getData (const string& s) = 0;

           virtual double getDouble (int i);

           virtual double getDouble (const string& s);

           virtual int getInt (int i);

           virtual int getInt (const string& s);

           virtual bool getBool (const string& s) = 0;

           virtual bool getBool (int i) = 0;

           virtual TeTime getDate (int i) = 0;

           virtual TeTime getDate (const string& s) = 0;

           virtual string getDateAsString(int i) = 0;

           virtual string getDateAsString(const string& s) = 0;

           virtual bool getBlob(const string& s, unsigned char* &data, long& size) = 0;

           int getColumnIndex (const string& s);

           string getColumnName (int i);

           virtual TeViewTree*              getViewTree ();
           virtual TeLegendEntry getLegend();
           virtual void                                getVisual(TeVisual*);
           virtual bool                                getVisual(TeVisual* vis, TeGeomRep& rep, const unsigned int& initIndex);
           virtual bool                                getRasterVisual(TeRasterVisual& vis, const unsigned int& initIndex=0);
           virtual TeColor                             getColor(); 
           virtual bool          getRasterBlock(unsigned long& size, unsigned char* ptData)=0;
           virtual bool          getView(TeView& view, const unsigned int& initIndex=0);
           virtual void          getDatum(TeDatum& datum, const unsigned int& initIndex=0);
           virtual bool          getProjection(TeProjection** proj, const unsigned int& initIndex=0);
           virtual void          getViewNodeParams (TeViewNodeParams& params, const unsigned int& initIndex=0);
           virtual bool          getTheme(TeAbstractTheme& theme, const unsigned int& initIndex=0);
           virtual bool          getGrouping(TeGrouping& group, const unsigned int& initIndex=0);
           virtual bool          getLegend(TeLegendEntry& leg, const unsigned int& initIndex=0);
           virtual bool          getAttrTable(TeTable& table, const unsigned int& initIndex=0);
           virtual bool          getLayer(TeLayer& layer, const unsigned int& initIndex=0);
           virtual bool          getRepresentation(TeRepresentation& rep, const unsigned int& initIndex=0);


           virtual    bool fetchGeometry (TePolygon& geom) = 0;
           virtual    bool fetchGeometry (TePolygon& geom, const unsigned int& initIndex); 
           virtual    bool fetchGeometry (TeLine2D& geom) = 0;
           virtual    bool fetchGeometry (TeLine2D& geom, const unsigned int& initIndex); 
           virtual    bool fetchGeometry (TeNode& geom) = 0;
           virtual    bool fetchGeometry (TeNode& geom, const unsigned int& initIndex);
           virtual    bool fetchGeometry (TePoint& geom) = 0;
           virtual    bool fetchGeometry (TePoint& geom, const unsigned int& initIndex);
           virtual    bool fetchGeometry (TeCell& geom);
           virtual    bool fetchGeometry (TeCell& geom, const unsigned int& initIndex);
           virtual    bool fetchGeometry (TeArc& geom);
           virtual    bool fetchGeometry (TeArc& geom, const unsigned int& initIndex);
           virtual    bool fetchGeometry (TeText& geom);
           virtual    bool fetchGeometry (TeText& geom, const unsigned int& initIndex);
};


/*
           \params begin Iterator that p oints to the beginning of the collection
           \params end Iterator that points to the end of the collection
           \param db pointer to the database where the query expression will be applied
           \param addPlicae flat to indicate that the character ' should enclose each string
*/
template <typename Iterator>
vector<string>
generateInClauses(const Iterator& begin, const Iterator& end, TeDatabase* db, bool addPlicae=true)
{
           int i, chunkSize = 200;
           string inClause;
           vector<string> inClauseVector;

           Iterator temp = begin;
           i = 0;
           while (temp != end)
           {
                      if (i%chunkSize == 0)
                      {
                                 if (!inClause.empty())
                                 {
                                            inClause[inClause.size() - 1] = ')';
                                            inClauseVector.push_back(inClause);
                                            inClause.clear();
                                 }
                                 inClause = "(";
                      }

                      if (addPlicae)
                                 inClause += "'" + db->escapeSequence(*temp) + "',";
                      else
                                 inClause += db->escapeSequence(*temp) + ",";
                      i++;
                      ++temp;
           }
           if (!inClause.empty())
           {
                      inClause[inClause.size() - 1] = ')';
                      inClauseVector.push_back(inClause);
           }
           return inClauseVector;
}


#endif