query.h

一个英国人写的GIS查看/编辑工具。支持标准的shapefile地图文件格式和coverage地图文件格式。同时可以编辑相应的dbf文件。

//////////////////////////////////////////////////////
//
// NRDB Pro - Spatial database and mapping application
//
// Copyright (c) 1989-2004 Richard D. Alexander
//
// This program 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.
//
// NRDB Pro is part of the Natural Resources Database Project 
// 
// Homepage: http://www.nrdb.co.uk/
// Users' Forum: http://nrdb.mypalawan.info/
// 

#ifndef _QUERY_H_
#define _QUERY_H_

#include "cdate.h"

class CQueryFeature;
class  CArrayAttrSel;

///////////////////////////////////////////////////////////////////////////////

class CQueryElement 
{
public:
   CQueryElement();
   ~CQueryElement();
   CQueryElement(CQueryElement&);
   CQueryElement& operator=(CQueryElement&);

   int GetDataType() {return m_nDataType;}
   int GetAttrId() {return m_nAttrId;}
   long GetFTypeId() {return m_lFType;}
   CQueryElement* GetNextQuery() {return m_pNext;}
 
   void SetDesc(LPCSTR s) {m_sDesc = s;}
   LPCSTR GetDesc() {return m_sDesc;}

   void SetColName(LPCSTR s) {m_sColName = s;}
   LPCSTR GetColName() {return m_sColName;}

   void SetNextQuery(CQueryElement* p) {m_pNext = p;}
   void SetDataType(int n) {m_nDataType = n;}
   void SetAttrId(int n) {m_nAttrId = n;}
   void SetFTypeId(long l) {m_lFType = l;}

   void SetSelected(BOOL b = TRUE) {m_bSelected = b;}
   BOOL GetSelected() {return m_bSelected;}

   int GetGroupStat() {return m_nStatGroup;}
   void SetGroupStat(int n) {m_nStatGroup = n;}

   int GetGroupBy() {return m_nGroupBy;}
   void SetGroupBy(int n) {m_nGroupBy = n;}

   int GetSortBy() {return m_nSortBy;}
   void SetSortBy(int n) {m_nSortBy = n;}

   int GetCond() {return m_nCond;}
   void SetCond(int nCond) {m_nCond = nCond;}

   double GetCondValue() {return m_dCondValue;}
   void SetCondValue(double d) {m_dCondValue = d;}

   LPCSTR GetCondValueStr() {return m_sCondValue;}
   void SetCondValueStr(LPCSTR s) {m_sCondValue = s;}
   
   static void Delete(CQueryElement*&);

   virtual void Write(FILE* pFile);
   virtual BOOL Read(FILE* pFile);

   enum {none = 0, count, total, mean, min, max, countunique};   
   enum {greater = 1,  less, greaterequal, lessequal, equal, notequal, contains, notcontains, like};
   enum {no = 0, yes = 1, month = 2,  year = 3};

   

protected:
     
   int m_nAttrId;
   int m_nDataType;
   long m_lFType; 
   int m_nStatGroup;
   int m_nGroupBy;   
   BOOL m_nSortBy;
   BOOL m_bSelected;
   CString m_sDesc;
   CString m_sColName;
   int m_nCond;
   double m_dCondValue;
   CString m_sCondValue;
   CQueryElement* m_pNext;
};

///////////////////////////////////////////////////////////////////////////////

struct CQueryDate
{      
   int m_nID;
   char* m_psDescription;   
};

///////////////////////////////////////////////////////////////////////////////

class CQuery : public CQueryElement
{
public:
   CQuery();
   ~CQuery();
   CQuery(CQuery&);
   CQuery(long lFType, CArray <long, long>& alAttr, CArray <long, long>& alFeatures, int nSort = BDFEATURE);
   CQuery(long lFType, CArrayAttrSel& aAttr, CArray <long, long>& alFeatures, int nSort = BDFEATURE);
   CQuery& operator=(CQuery&);
   
   enum {FirstDate, LastDate, FirstDateRange, LastDateRange, AllDatesRange, AllDatesAfter, 
         AllDatesBefore, AllDates};
   static CQueryDate m_aQueryDates[];   
 
   CString DateCondAsString();   

   long GetFType() {return m_lFType;}
   int GetDateCond() {return m_nDateCond;}
   CDateTime GetStartDate() {return m_dtStart;}
   CDateTime GetEndDate() {return m_dtEnd;}
   BOOL IsShowAllFeatures() {return m_bShowAllFeatures;}
   
   void SetStartDate(CDateTime dt) {m_dtStart = dt;}
   void SetEndDate(CDateTime dt) {m_dtEnd = dt;}
   void SetDateCond(int i) {m_nDateCond = i;}
   void SetShowAllFeatures(BOOL b) {m_bShowAllFeatures = b;}
     
   void Initialise(long lFType);

   CString GetQueryName();
   
   virtual void Write(FILE* pFile); 
   virtual BOOL Read(FILE* pFile);

   static CString StripBrackets(CString);

protected:

   void Initialise(long lFType, BOOL& bInitFeatures, BOOL& bInitDates);   

   long m_lFType;
   int m_nDateCond;   
   BOOL m_bShowAllFeatures;
   CDateTime m_dtStart, m_dtEnd;
};

///////////////////////////////////////////////////////////////////////////////

class CQueryLink : public CQueryElement
{
public:
   CQueryLink();
   CQueryLink(long lFType);
   CQueryLink(CQueryLink&);

   virtual void Write(FILE* pFile); 
   virtual BOOL Read(FILE* pFile);
   
   CArray <CQueryFeature, CQueryFeature> m_aFeatures;
};

///////////////////////////////////////////////////////////////////////////////

class CQueryNumber : public CQueryElement
{   
};

///////////////////////////////////////////////////////////////////////////////

class CQueryBoolean : public CQueryLink
{  
public:
   enum {no=0,yes=1};
   
   CQueryBoolean();
};

///////////////////////////////////////////////////////////////////////////////

class CQueryStats : public CQueryElement
{
public:
   enum {add, subtract, divide, multiply, percent, area, length};

   CQueryStats();
   CQueryStats(CQueryStats&);

   int GetAttrId2() {return m_nAttrId2;}
   long GetFTypeId2() {return m_lFType2;}
   void SetAttrId2(int n) {m_nAttrId2 = n;}
   void SetFTypeId2(int l) {m_lFType2 = l;}
   void SetValue1(double d) {m_dValue1 = d;};
   double GetValue1() {ASSERT(m_nAttrId == 0); return m_dValue1;}
   void SetValue2(double d) {m_dValue2 = d;};
   double GetValue2() {ASSERT(m_nAttrId2 == 0); return m_dValue2;}
   int GetStatistic() {return m_nStatistic;}
   void SetStatistic(int n) {m_nStatistic = n;}
   void SetDecPlaces(int n) {m_nDecPlaces = n;}
   int GetDecPlaces() {return m_nDecPlaces;}
   virtual void Write(FILE* pFile); 
   virtual BOOL Read(FILE* pFile);

protected:
   int m_nAttrId2; // Zero if using m_dValue
   long m_lFType2;          
   int m_nStatistic;   
   int m_nDecPlaces;
   double m_dValue1;
   double m_dValue2;
};

///////////////////////////////////////////////////////////////////////////////

class CQueryFeature : public CFeature
{
public:

   CQueryFeature();
   CQueryFeature(CFeature f) : CFeature(f) {};

   void SetSelected(BOOL b = TRUE) {m_bSelected = b;}
   BOOL GetSelected() {return m_bSelected;}

protected:

   BOOL m_bSelected;
};

///////////////////////////////////////////////////////////////////////////////

class CQueryAttrArray : public CAttrArray
{
friend class CQueryResult;

public:
   CQueryAttrArray(LPCSTR sFeature);
   CQueryAttrArray(CQueryAttrArray&);
   ~CQueryAttrArray();
   
   LPCSTR GetFName() {return m_sFeature;}
   void SetFName(LPCSTR s) {m_sFeature = s;}
   BOOL GetCondMet() {return m_bCondMet;}
   
   void SetCondMet(BOOL b = TRUE) {m_bCondMet = b;}

   long GetActiveFeature() {return m_lFeatureActive;}


protected:
   CString m_sFeature;
   CString m_sFeatureActive;
   BOOL m_bCondMet;
   long m_lFeatureActive;
   long m_lParentFeatureActive;
   CDateTime m_dateActive;
};

///////////////////////////////////////////////////////////////////////////////

class CQueryAttrSel
{
public:

   CQueryAttrSel();

   long m_lAttr;
   long m_lFType;
   long m_lDataType;
   int m_nStatGroup;
   int m_nGroupBy;
   BOOL m_nSortBy;

friend CQueryResult;

protected:
};

///////////////////////////////////////////////////////////////////////////////

class  CArrayAttrSel : public CArray <CQueryAttrSel,CQueryAttrSel>
{
public:
    CString GetAttrDesc(CAttrArray& aAttr);    
};

///////////////////////////////////////////////////////////////////////////////

class CQueryResult : public CArray <CQueryAttrArray*, CQueryAttrArray*>
{
public:
      
   CQueryResult();
   ~CQueryResult();

   BOOL Initialise(CQuery*); 
   CArrayAttrSel& GetAttrArray() {return m_aAttrSel;}
   void RemoveAllX();   
   CQueryResult* GetQueryResult() {return m_pQueryResult;}
   
protected:

   enum {Keep, Replace, New};

   CArrayAttrSel m_aAttrSel;
   CQueryResult* m_pQueryResult; // Result prior to stats
   CQuery* m_pQuery;
   BOOL m_bBaseFType;   
   int m_nGroupBy;
  
   BOOL InitFeatures(CQuery*);
   BOOL RetrieveData(CQuery*);
   BOOL LoadDataAll(CQuery*, long lFType);
   
   BOOL CheckConditions(CQuery*, CAttrArray&);
   BOOL CheckValueCond(CQuery*, CAttrArray&);
   int UpdateDates(CQuery*, CAttrArray&, CQueryAttrArray* pAttrArray);
   void RetrieveFeatures(CQuery*, CQueryAttrArray*);
   BOOL RetrieveAttr(CQuery*, CAttrArray&, CQueryAttrArray* pAttrArray);
   BOOL RetrieveMissing(CQuery*, CAttrArray&, CQueryAttrArray* pAttrArray);
   void CalcRowBasedStats();
   void CalcRowBasedStats(CQueryStats* pStats, CQueryAttrArray& aAttr, int iAttr, int nDP);
   BOOL IsFTypeSelected(CQuery*, long lFType);
   int GetDP(CAttribute*);
   CString GetQueryFilter(CQuery*, CAttrArray&);

   //double SetDP(double, int nStat, int nDP);
   double SetDP(double, int nDP);


   enum {no, yes, ftype};

   

   void SortQueryResults();
   int Compare(CQueryAttrArray*, CQueryAttrArray*, int nSortId = 1);
   int Compare(CAttribute*, CAttribute*);

   void CalculateStatistics();
   void CalculateStatistics(CQueryResult& aGroupAttr, CQueryAttrSel& attrselgroup,
                            CQueryAttrSel& attrselstat);
   void DetermineGroup(CQueryResult&, CQueryAttrArray*& paAttrG, CAttribute* pAttrG, 
                       CAttribute* pAttrS, int nStat);
   void UpdateStatistics(CQueryAttrArray*& paAttrG, CAttribute* pAttr, int nStat);   

   void InitNullAttr(CQuery*, CAttrArray& aAttr, CQueryAttrArray* pAttrArray);
  
};

#endif