/trunk/source/PostGISGDO/PGSRecordset.cpp

Large files files are truncated, but you can click here to view the full file

// Copyright 2011 Intergraph Corporation

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.



#include "PGSRecordset.hpp"

#include "../Common/LogFiles.hpp"

#include "../Common/PGtoGDOmaps.hpp"

#include "../Common/VarUtils.hpp"

#include "../Common/GDOtoEWKB.hpp"

#include "../Common/pg_const.h"

#include <stdio.h>

#include "PostGISGDO.hpp"

#include "PostGIS.rh"



LPWSTR GetTableName(LPWSTR sSQL)

{

    LPWSTR sRes = NULL;

    if(!wcschr(sSQL, ' '))

    {

        sRes = (LPWSTR)malloc((wcslen(sSQL) + 1)*sizeof(wchar_t));

        wcscpy(sRes, sSQL);

    }

    else

    {

        LPWSTR sFrom = wcsstr(sSQL, L" FROM ");

        if(!sFrom) sFrom = wcsstr(sSQL, L" from ");

        if(!sFrom) sFrom = wcsstr(sSQL, L" From ");

        if(sFrom)

        {

            sFrom += 6;

            while((sFrom[0] == ' ') && (sFrom[0] != 0))

            {

                sFrom++;

            }

            int slen = wcslen(sFrom);



            LPWSTR sSpace = wcschr(sFrom, ' ');

            LPWSTR sFirstDblQ = wcschr(sFrom, '\"');



            bool bDoubleQuoted = false;

            if(sFirstDblQ)

            {

                if(sSpace)

                {

                    if(sFirstDblQ < sSpace) bDoubleQuoted = true;

                    else slen = sSpace - sFrom;

                }

                else bDoubleQuoted = true;

            }

            else if(sSpace) slen = sSpace - sFrom;



            if(bDoubleQuoted)

            {

                LPWSTR sNextDblQ = wcschr(sFirstDblQ + 1, '\"');

                LPWSTR sDot = wcschr(sFrom, '.');

                if(sDot)

                {

                    if(sDot < sFirstDblQ)

                    {

                        if(sNextDblQ) slen = sNextDblQ - sFrom + 1;

                    }

                    else if(sNextDblQ)

                    {

                        if(sDot == sNextDblQ + 1)

                        {

                            sDot++;

                            if(sDot[0] == '\"')

                            {

                                sDot++;

                                sNextDblQ = wcschr(sDot, '\"');

                                if(sNextDblQ) slen = sNextDblQ - sFrom + 1;

                            }

                            else

                            {

                                sSpace = wcschr(sDot, ' ');

                                if(sSpace) slen = sSpace - sFrom;

                            }

                        }

                        else slen = sNextDblQ - sFrom + 1;

                    }

                }

                else

                {

                    if(sNextDblQ) slen = sNextDblQ - sFrom + 1;

                }

            }



            sRes = (LPWSTR)malloc((slen + 1)*sizeof(wchar_t));

            wcsncpy(sRes, sFrom, slen);

            sRes[slen] = 0;

#if DBGLEVEL > 2

            WriteMallocReport(1, slen, wcslen(sRes));

#endif

        }

        else

        {

            // the table name contains space(s}. If it is correctly enclosed

            // double quotes, then it should work

            sRes = (LPWSTR)malloc((wcslen(sSQL) + 1)*sizeof(wchar_t));

            wcscpy(sRes, sSQL);

        }

    }

    return(sRes);

}



bool IsMetatable(PConnStruct pConnStruct, LPSTR sName)

{

    if(stricmp(pConnStruct->sGAlias, sName) == 0) return(true);



    bool bTrans = (pConnStruct->iSysTrans | pConnStruct->iGdoTrans);



    int iLen = 40 + strlen(pConnStruct->sGAlias) + strlen(sName);

    LPSTR sSql = (LPSTR)malloc(iLen*sizeof(char));

    sprintf(sSql, "select * from %s where tablename = '%s'",

        pConnStruct->sGAlias, sName);

#if DBGLEVEL > 2

    WriteMallocReport(2, iLen - 1, strlen(sSql));

#endif



    SetSP(pConnStruct->pConn, bTrans);

    //LPSTR lsCmd = GetSaveSQL(sSql, bTrans);

    PGresult *res = PQexec(pConnStruct->pConn, sSql);

    //free(lsCmd);

    free(sSql);



    if(PQresultStatus(res) != PGRES_TUPLES_OK)

    {

        PQclear(res);

        RollbackSP(pConnStruct->pConn, bTrans);

        return(false);

    }



    long nrows = PQntuples(res);

    PQclear(res);

    ReleaseSP(pConnStruct->pConn, bTrans);



    return(nrows > 0);



    /*if(stricmp(pConnStruct->sGFeatures, sName) == 0) return(true);

    if(stricmp(pConnStruct->sFieldLookup, sName) == 0) return(true);

    if(stricmp(pConnStruct->sAttributeProperties, sName) == 0) return(true);

    if(stricmp(pConnStruct->sGeometryProperties, sName) == 0) return(true);

    if(stricmp(pConnStruct->sCoordSystems, sName) == 0) return(true);

    if(stricmp(pConnStruct->sModTables, sName) == 0) return(true);

    if(stricmp(pConnStruct->sModLog, sName) == 0) return(true);

    if(stricmp(pConnStruct->sPickLists, sName) == 0) return(true);

    return(false);*/

}





//  FldExtendedPropertySet



FldExtendedPropertySet::FldExtendedPropertySet(IUnknown *pUnkOuter, ITypeLib *ALib) :

    CCOMDispatch(pUnkOuter, ALib, 0)

{

#if DBGLEVEL > 1

    WriteLogFile("FldExtendedPropertySet::FldExtendedPropertySet-1\r\n", true);

#endif // DBGLEVEL

    m_lSinglePass = 0;

    m_lCache = 0;

    m_pField = NULL;

}



FldExtendedPropertySet::FldExtendedPropertySet(IUnknown *pUnkOuter, ITypeLib *ALib,

    int iIndex) : CCOMDispatch(pUnkOuter, ALib, iIndex)

{

#if DBGLEVEL > 1

    WriteLogFile("FldExtendedPropertySet::FldExtendedPropertySet-2\r\n", true);

#endif // DBGLEVEL

    m_lSinglePass = 0;

    m_lCache = 0;

    m_pField = NULL;

}



FldExtendedPropertySet::~FldExtendedPropertySet()

{

#if DBGLEVEL > 1

    WriteLogFile("FldExtendedPropertySet::~FldExtendedPropertySet\r\n", true);

#endif // DBGLEVEL

}



HRESULT FldExtendedPropertySet::QueryInterface(REFIID iid, void **ppvObject)

{

#if DBGLEVEL > 2

    WriteLogFile("FldExtendedPropertySet::QueryInterface\r\n", true);

#endif // DBGLEVEL

    HRESULT hres = CCOMDispatch::QueryInterface(iid, ppvObject);

    if(hres != S_OK)

    {

        if(IsEqualIID(iid, DIID_ExtendedPropertySet))

        {

            hres = S_OK;

            *ppvObject = this;

            ((IUnknown*)*ppvObject)->AddRef();

        }

        else

        {

            hres = E_NOINTERFACE;

#if DBGLEVEL > 2

            char buf[128];

            FormatGuid(buf, "Unknown Interface: ", "\r\n", iid);

            WriteLogFile(buf, true);

#endif // DBGLEVEL

        }

    }

    return(hres);

}



ULONG FldExtendedPropertySet::Release()

{

    ULONG lRest;

    IUnknown *pUnkOuter = m_pUnkOuter;

    if(pUnkOuter) lRest = pUnkOuter->Release();

    else lRest = --m_lRefCount;

#if DBGLEVEL > 2

    char buf[64];

    if(pUnkOuter) sprintf(buf, "FldExtendedPropertySet::Release (aggregated) - %d\r\n", lRest);

    else sprintf(buf, "FldExtendedPropertySet::Release - %d\r\n", lRest);

    WriteLogFile(buf, true);

#endif // DBGLEVEL

    if(pUnkOuter || (lRest > 0)) return lRest;

    delete(this);

    return(0);

}



HRESULT FldExtendedPropertySet::GetValue(BSTR PropertyName, VARIANT *Value)

{

#if DBGLEVEL > 0

    WriteLogFile("FldExtendedPropertySet::GetValue\r\n  ", true);

    WriteLogFile("Name: ", false);

    WriteLogFile(PropertyName, false);

    WriteLogFile("\r\n", false);

    if(m_pField)

    {

        WriteLogFile("  Field Name: ", false);

        WriteLogFile(m_pField->GetNamePtr(), false);

        WriteLogFile("\r\n", false);

        WriteLogFile("  Field Table Name: ", false);

        WriteLogFile(m_pField->GetTblNamePtr(), false);

        WriteLogFile("\r\n", false);

    }

#endif // DBGLEVEL

    if(!Value) return(E_POINTER);

    if(wcsicmp(PropertyName, L"Single Pass") == 0)

    {

        VariantClear(Value);

        Value->vt = VT_I4;

        Value->lVal = m_lSinglePass;

        return(S_OK);

    }

    else if(wcsicmp(PropertyName, L"Cache") == 0)

    {

        VariantClear(Value);

        Value->vt = VT_I4;

        Value->lVal = m_lCache;

        return(S_OK);

    }

    else if(wcsicmp(PropertyName, L"Key") == 0)

    {

        VariantClear(Value);

        if(m_pField)

        {

            Value->vt = VT_BOOL;

            if(m_pField->IsKeyField()) Value->boolVal = VARIANT_TRUE;

            else Value->boolVal = VARIANT_FALSE;

            return(S_OK);

        }

    }

    /*else if(wcsicmp(PropertyName, L"Description") == 0)

    {

        Value->vt = VT_BSTR;

        Value->bstrVal = SysAllocString(L"Desc");

        return(S_OK);

    }

    else if(wcsicmp(PropertyName, L"GeometryType") == 0)

    {

        if(m_pField)

        {

            Value->vt = VT_I4;

            Value->lVal = m_pField->GetGeomType();

            return(S_OK);

        }

    }

    else if(wcsicmp(PropertyName, L"PrimaryGeometryFlag") == 0)

    {

        if(m_pField)

        {

            Value->vt = VT_BOOL;

            Value->boolVal = VARIANT_FALSE;

            return(S_OK);

        }

    }

    else if(wcsicmp(PropertyName, L"GCoordSystemGUID") == 0)

    {

        if(m_pField)

        {

            return(m_pField->get_CoordSystemGUID(Value));

        }

    }

    else if(wcsicmp(PropertyName, L"Locatable") == 0)

    {

        Value->vt = VT_BOOL;

        Value->boolVal = VARIANT_TRUE;

        return(S_OK);

    }

    else if(wcsicmp(PropertyName, L"Type") == 0)

    {

        if(m_pField)

        {

            Value->vt = VT_I2;

            Value->iVal = m_pField->GetType();

            return(S_OK);

        }

    }

    else if(wcsicmp(PropertyName, L"Displayable") == 0)

    {

        Value->vt = VT_BOOL;

        Value->boolVal = VARIANT_TRUE;

        return(S_OK);

    }

    else if(wcsicmp(PropertyName, L"Format") == 0)

    {

        Value->vt = VT_BSTR;

        Value->bstrVal = SysAllocString(L"general");

        return(S_OK);

    }

    else if(wcsicmp(PropertyName, L"Precision") == 0)

    {

        if((m_pField->GetType() == 7) || m_pField->GetType() == 8))

        {

            Value->vt = VT_I4;

            Value->lVal = 8;

            return(S_OK);

        }

    }*/

    Value->vt = VT_NULL;

    //return(S_OK);

    return(E_NOTIMPL);

}



HRESULT FldExtendedPropertySet::SetValue(BSTR PropertyName, VARIANT Value, long *Status)

{

#if DBGLEVEL > 0

    WriteLogFile("FldExtendedPropertySet::SetValue\r\n  ", true);

    WriteLogFile("Name: ", false);

    WriteLogFile(PropertyName, false);

    WriteLogFile("\r\n", false);

#endif // DBGLEVEL

    if(wcsicmp(PropertyName, L"Single Pass") == 0)

    {

        m_lSinglePass = VarToLong(Value);

        *Status = S_OK;

        return(S_OK);

    }

    else if(wcsicmp(PropertyName, L"Cache") == 0)

    {

        m_lCache = VarToLong(Value);

        *Status = S_OK;

        return(S_OK);

    }

    return(E_NOTIMPL);

}



void FldExtendedPropertySet::SetTDField(GTDField *pField)

{

    m_pField = pField;

    return;

}





//  GField



GField::GField(IUnknown *pUnkOuter, ITypeLib *ALib) : CCOMDispatch(pUnkOuter, ALib, 20)

{

#if DBGLEVEL > 1

    WriteLogFile("GField::GField-1\r\n", true);

#endif // DBGLEVEL

    m_sOrigName = NULL;

    m_wsName = NULL;

    m_pConnStruct = NULL;

    m_pExt = NULL;

    m_pLitConv = NULL;

    m_sNewIdCmd = NULL;

    m_sGenIdCmd = NULL;

    m_pvBuffer = NULL;

    InitFldAttrs(&m_cAttrs);

    VariantInit(&m_vNewVal);

    m_vNewVal.vt = VT_EMPTY;

    m_iSpecType = 0;

    m_iSpecField = 0;

    m_pSpecField = NULL;

    m_bIsMetatable = false;

}



GField::GField(IUnknown *pUnkOuter, ITypeLib *ALib, int iIndex) :

    CCOMDispatch(pUnkOuter, ALib, iIndex)

{

#if DBGLEVEL > 1

    WriteLogFile("GField::GField-2\r\n", true);

#endif // DBGLEVEL

    m_sOrigName = NULL;

    m_wsName = NULL;

    m_pConnStruct = NULL;

    m_pExt = NULL;

    m_pLitConv = NULL;

    m_sNewIdCmd = NULL;

    m_sGenIdCmd = NULL;

    m_pvBuffer = NULL;

    InitFldAttrs(&m_cAttrs);

    VariantInit(&m_vNewVal);

    m_vNewVal.vt = VT_EMPTY;

    m_iSpecType = 0;

    m_iSpecField = 0;

    m_pSpecField = NULL;

    m_bIsMetatable = false;

}



GField::~GField()

{

#if DBGLEVEL > 1

    WriteLogFile("GField::~GField\r\n", true);

#endif // DBGLEVEL

    if(m_pSpecField) m_pSpecField->Release();

    VariantClear(&m_vNewVal);

    ClearFldAttrs(&m_cAttrs);

    if(m_sGenIdCmd) free(m_sGenIdCmd);

    if(m_sNewIdCmd) free(m_sNewIdCmd);

    if(m_pExt) m_pExt->SetOuter(NULL);

    if(m_pLitConv) m_pLitConv->SetOuter(NULL);

    if(m_wsName) free(m_wsName);

    if(m_sOrigName) free(m_sOrigName);

}



HRESULT GField::QueryInterface(REFIID iid, void **ppvObject)

{

#if DBGLEVEL > 2

    WriteLogFile("GField::QueryInterface\r\n", true);

#endif // DBGLEVEL

    HRESULT hres = CCOMDispatch::QueryInterface(iid, ppvObject);

    if(hres != S_OK)

    {

        if(IsEqualIID(iid, DIID_GField))

        {

            hres = S_OK;

            *ppvObject = this;

            ((IUnknown*)*ppvObject)->AddRef();

        }

        else

        {

            hres = E_NOINTERFACE;

#if DBGLEVEL > 2

            char buf[128];

            FormatGuid(buf, "Unknown Interface: ", "\r\n", iid);

            WriteLogFile(buf, true);

#endif // DBGLEVEL

        }

    }

    return(hres);

}



ULONG GField::Release()

{

    ULONG lRest;

    IUnknown *pUnkOuter = m_pUnkOuter;

    if(pUnkOuter) lRest = pUnkOuter->Release();

    else lRest = --m_lRefCount;

#if DBGLEVEL > 2

    char buf[64];

    if(pUnkOuter) sprintf(buf, "GField::Release (aggregated) - %d\r\n", lRest);

    else sprintf(buf, "GField::Release - %d\r\n", lRest);

    WriteLogFile(buf, true);

#endif // DBGLEVEL

    if(pUnkOuter || (lRest > 0)) return lRest;

    delete(this);

    return(0);

}



HRESULT GField::get_Value(VARIANT *pValue)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_Value (", true);

    WriteLogFile(m_wsName, false);

    WriteLogFile(")\r\n", false);

    GFields *pFlds = (GFields*)m_pUnkOuter;

    GRecordset *pRS = pFlds->GetParentRecordset();

    WriteLogFile("    Recordset (", false);

    WriteLogFile(pRS->GetNamePtr(), false);

    WriteLogFile(")\r\n", false);

#endif // DBGLEVEL

    if(m_iSpecField == 1)

    {

        HRESULT hres = m_pSpecField->get_Value(pValue);

        if(pValue->vt > VT_NULL) return(hres);

    }



    if(!pValue) return(E_POINTER);

    //if(!m_pvBuffer) return(E_POINTER);



    // It looks like GeoMedia is able to pass an uninitialized VARIANT into

    // this method. When the vt is somehow od (e.g. 83 in our case),

    // the system does not know how to clear it and refuses to copy into it

    // So we try to clear it and if it fails, we simply set the vt to empty

    //VariantClear(pValue);

    pValue->vt = VT_EMPTY;

    // end of hack

    if(m_vNewVal.vt > VT_EMPTY) VariantCopy(pValue, &m_vNewVal);

    else if(m_pvBuffer) VariantCopy(pValue, m_pvBuffer);

/*WriteVariantToLogFile(L"  Value: ", *pValue);

char buf[32];

sprintf(buf, "  VType: %d\r\n", pValue->vt);

WriteLogFile(buf, false);*/

    return(S_OK);

}



HRESULT GField::set_Value(VARIANT pValue)

{

    ValidateVariant(&pValue);



#if DBGLEVEL > 0

    WriteLogFile("GField::set_Value\r\n", true);

    WriteLogFile("  Field name: ", false);

    WriteLogFile(m_wsName, false);

    WriteVariantToLogFile(L"\r\n  Value: ", pValue);

    char buf[32];

    sprintf(buf, "  VType: %d\r\n", pValue.vt);

    WriteLogFile(buf, false);

#endif // DBGLEVEL

    if(m_iSpecField > 0) m_pSpecField->set_Value(pValue);



    // hack for G/I Toolkit

    if((pValue.vt == VT_BSTR) && (m_cAttrs.iType < 8))

    {

        int iVal;

        float fltVal;



        switch(m_cAttrs.iType)

        {

        case 1:

            VariantClear(&m_vNewVal);

            m_vNewVal.vt = VT_BOOL;

            m_vNewVal.boolVal = (wcslen(pValue.bstrVal) > 0) &&

                ((pValue.bstrVal[0] == 'T') || (pValue.bstrVal[0] == 't'));

            return(S_OK);

        case 2:

            VariantClear(&m_vNewVal);

            if(swscanf(pValue.bstrVal, L"%d", &iVal) == 1)

            {

                m_vNewVal.vt = VT_UI1;

                m_vNewVal.bVal = (BYTE)iVal;

            }

            return(S_OK);

        case 3:

            VariantClear(&m_vNewVal);

            if(swscanf(pValue.bstrVal, L"%d", &iVal) == 1)

            {

                m_vNewVal.vt = VT_I2;

                m_vNewVal.iVal = iVal;

            }

            return(S_OK);

        case 4:

            VariantClear(&m_vNewVal);

            if(swscanf(pValue.bstrVal, L"%d", &iVal) == 1)

            {

                m_vNewVal.vt = VT_I4;

                m_vNewVal.lVal = iVal;

            }

            return(S_OK);

        case 5:

            VariantClear(&m_vNewVal);

            m_vNewVal.vt = VT_CY;

            m_vNewVal.cyVal.int64 = CurrencyFromBSTR(pValue.bstrVal, m_pConnStruct->sDecSep);

            return(S_OK);

        case 6:

            VariantClear(&m_vNewVal);

            if(swscanf(pValue.bstrVal, L"%f", &fltVal) == 1)

            {

                m_vNewVal.vt = VT_R4;

                m_vNewVal.fltVal = fltVal;

            }

            return(S_OK);

        case 7:

            VariantClear(&m_vNewVal);

            if(swscanf(pValue.bstrVal, L"%f", &fltVal) == 1)

            {

                m_vNewVal.vt = VT_R8;

                m_vNewVal.dblVal = fltVal;

            }

            return(S_OK);

        }

    }

    // end of hack



    VariantCopy(&m_vNewVal, &pValue);

    return(S_OK);

}



HRESULT GField::get_AllowZeroLength(VARIANT_BOOL *pAllow)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_AllowZeroLength\r\n", true);

#endif // DBGLEVEL

    if(!pAllow) return(E_POINTER);

/*if((m_iSpecType == 2) && (wcsicmp(m_wsName, L"csguid") == 0))

{

    *pAllow = VARIANT_FALSE;

    return(S_OK);

}*/

    *pAllow = VARIANT_TRUE;

    return(S_OK);

}



HRESULT GField::set_AllowZeroLength(VARIANT_BOOL pAllow)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::set_AllowZeroLength\r\n", true);

#endif // DBGLEVEL

    return(E_NOTIMPL);

}



HRESULT GField::get_Attributes(long *pAttr)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_Attributes\r\n", true);

#endif // DBGLEVEL

    if(!pAttr) return(E_POINTER);

    *pAttr = m_cAttrs.lAttr;

    return(S_OK);

}



HRESULT GField::set_Attributes(long pAttr)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::set_Attributes\r\n", true);

#endif // DBGLEVEL

    return(E_NOTIMPL);

}



HRESULT GField::get_CollatingOrder(long *pOrder)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_CollatingOrder\r\n", true);

#endif // DBGLEVEL

    if(!pOrder) return(E_POINTER);

    *pOrder = 0;

    return(S_OK);

}



HRESULT GField::get_CoordSystemGUID(VARIANT *CSGuid)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_CoordSystemGUID\r\n", true);

#endif // DBGLEVEL

    if(!CSGuid) return(E_POINTER);

    if((m_cAttrs.ulSrid == 0) && (!m_cAttrs.sCSGuid[0])) return(E_FAIL);



    VariantClear(CSGuid);



    if(m_cAttrs.sCSGuid[0])

    {

        CSGuid->vt = VT_BSTR;

        CSGuid->bstrVal = SysAllocString(m_cAttrs.sCSGuid);

    }

    else

    {

        VARIANT *pRow = FindCSTableRow(&m_pConnStruct->cCSTable,

            m_cAttrs.ulSrid);

        if(pRow) VariantCopy(CSGuid, &pRow[1]);

        else CSGuid->vt = VT_NULL;

    }

#if DBGLEVEL > 0

    WriteVariantToLogFile(L"CS GUID: ", *CSGuid);

#endif // DBGLEVEL

    return(S_OK);

}



HRESULT GField::set_CoordSystemGUID(VARIANT CSGuid)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::set_CoordSystemGUID\r\n", true);

#endif // DBGLEVEL

    return(E_NOTIMPL);

}



HRESULT GField::get_DataUpdatable(VARIANT_BOOL *pUpdatable)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_DataUpdatable\r\n", true);

#endif // DBGLEVEL

    if(!pUpdatable) return(E_POINTER);

    if(m_cAttrs.bUpdatable) *pUpdatable = VARIANT_TRUE;

    else *pUpdatable = VARIANT_FALSE;

    return(S_OK);

}



HRESULT GField::set_DefaultValue(BSTR pValue)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::set_DefaultValue\r\n", true);

#endif // DBGLEVEL

    return(E_NOTIMPL);

}



HRESULT GField::get_DefaultValue(BSTR *pValue)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_DefaultValue\r\n", true);

#endif // DBGLEVEL

    if(!pValue) return(E_POINTER);

    //if(*pValue) SysFreeString(*pValue);

    *pValue = NULL;

    if(m_cAttrs.wsDefVal) *pValue = SysAllocString(m_cAttrs.wsDefVal);

    else *pValue = SysAllocString(L"");

    return(S_OK);

}



HRESULT GField::get_Name(BSTR *pName)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_Name\r\n", true);

#if DBGLEVEL > 2

    WriteLogFile("  FieldName: ", false);

    WriteLogFile(m_wsName, false);

    if(m_cAttrs.wsTblName)

    {

        WriteLogFile("\r\n  TableName: ", false);

        WriteLogFile(m_cAttrs.wsTblName, false);

    }

    WriteLogFile("\r\n", false);

#endif // DBGLEVEL

#endif // DBGLEVEL

    if(!pName) return(E_POINTER);

    //if(*pName) SysFreeString(*pName);



    // Hack for GCoordSystem table

    // at some point, GeoMedia requires that the GCoordSystem table fields

    // are in uppercase

    if(m_iSpecType == 2)

    {

        if(m_wsName)

        {

            wchar_t wsbuf[64];

            wcscpy(wsbuf, m_wsName);

            _wcsupr(wsbuf);

            *pName = SysAllocString(wsbuf);

        }

        else *pName = SysAllocString(L"");

        return(S_OK);

    }



    if(m_wsName) *pName = SysAllocString(m_wsName);

    else *pName = SysAllocString(L"");

    return(S_OK);

}



HRESULT GField::set_Name(BSTR pName)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::set_Name\r\n", true);

#endif // DBGLEVEL

    return(E_NOTIMPL);

}



HRESULT GField::get_Required(VARIANT_BOOL *pRequired)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_Required\r\n", true);

#endif // DBGLEVEL

    if(!pRequired) return(E_POINTER);



    if(!m_cAttrs.wsTblName)

    {

        *pRequired = VARIANT_FALSE;

        return(S_OK);

    }



    if((m_iSpecType == 2) && (wcsicmp(m_wsName, L"csguid") == 0))

    {

        *pRequired = VARIANT_TRUE;

        return(S_OK);

    }



    if(m_cAttrs.bRequired) *pRequired = VARIANT_TRUE;

    else *pRequired = VARIANT_FALSE;

    return(S_OK);

}



HRESULT GField::set_Required(VARIANT_BOOL pRequired)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::set_Required\r\n", true);

#endif // DBGLEVEL

    return(E_NOTIMPL);

}



HRESULT GField::get_Size(long *pSize)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_Size\r\n", true);

#endif // DBGLEVEL

    if(!pSize) return(E_POINTER);

    *pSize = m_cAttrs.lSize;

    return(S_OK);

}



HRESULT GField::set_Size(long pSize)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::set_Size\r\n", true);

#endif // DBGLEVEL

    return(E_NOTIMPL);

}



HRESULT GField::get_SourceDatabase(BSTR *pDatabase)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_SourceDatabase\r\n", true);

#endif // DBGLEVEL

    if(!pDatabase) return(E_POINTER);

    //if(*pDatabase) SysFreeString(*pDatabase);

    *pDatabase = NULL;

    if(m_pConnStruct->wsServerName)

        *pDatabase = SysAllocString(m_pConnStruct->wsServerName);

    return(S_OK);

}



HRESULT GField::get_SourceField(BSTR *pField)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_SourceField\r\n", true);

#endif // DBGLEVEL

    if(!pField) return(E_POINTER);

    //if(*pField) SysFreeString(*pField);

    if(m_wsName) *pField = SysAllocString(m_wsName);

    else *pField = SysAllocString(L"");

    return(S_OK);

}



HRESULT GField::get_SourceTable(BSTR *pTable)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_SourceTable\r\n", true);

#endif // DBGLEVEL

    if(!pTable) return(E_POINTER);

    //if(*pTable) SysFreeString(*pTable);

    *pTable = NULL;

    if(m_cAttrs.wsTblName) *pTable = SysAllocString(m_cAttrs.wsTblName);

    return(S_OK);

}



HRESULT GField::get_SubType(long *pGeometryType)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_SubType\r\n", true);

#endif // DBGLEVEL

    if(!pGeometryType) return(E_POINTER);

    *pGeometryType = m_cAttrs.lSubType;

    return(S_OK);

}



HRESULT GField::set_SubType(long pGeometryType)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::set_SubType\r\n", true);

#endif // DBGLEVEL

    return(E_NOTIMPL);

}



HRESULT GField::get_Type(short *pType)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::get_Type\r\n", true);

#if DBGLEVEL > 2

    WriteLogFile("  FieldName: ", false);

    WriteLogFile(m_wsName, false);

    if(m_cAttrs.wsTblName)

    {

        WriteLogFile("\r\n  TableName: ", false);

        WriteLogFile(m_cAttrs.wsTblName, false);

    }

    WriteLogFile("\r\n", false);

#endif // DBGLEVEL

    char buf[32];

    sprintf(buf, "  Type: %d\r\n", m_cAttrs.iType);

    WriteLogFile(buf, false);

#endif // DBGLEVEL

    if(!pType) return(E_POINTER);

    *pType = m_cAttrs.iType;

    return(S_OK);

}



HRESULT GField::set_Type(short pType)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::set_Type\r\n", true);

#endif // DBGLEVEL

    return(E_NOTIMPL);

}



HRESULT GField::AppendChunk(VARIANT Val)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::AppendChunk\r\n", true);

#endif // DBGLEVEL

    return(E_NOTIMPL);

}



HRESULT GField::FieldSize(long *pSize)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::FieldSize\r\n", true);

#endif // DBGLEVEL

    if(!pSize) return(E_POINTER);

    if(!m_pvBuffer) return(S_FALSE);

    *pSize = VarGetSize(*m_pvBuffer);

    return(S_OK);

}



HRESULT GField::GetChunk(long Offset, long Bytes, VARIANT *pChunk)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::GetChunk\r\n", true);

#endif // DBGLEVEL

    if(!pChunk) return(E_POINTER);

    return(E_NOTIMPL);

}



HRESULT GField::GetExtension(BSTR Name, IDispatch * *ppGExtension)

{

#if DBGLEVEL > 0

    WriteLogFile("GField::GetExtension\r\n", true);

    WriteLogFile("  FieldName: ", false);

    WriteLogFile(m_wsName, false);

    if(m_cAttrs.wsTblName)

    {

        WriteLogFile("\r\n  TableName: ", false);

        WriteLogFile(m_cAttrs.wsTblName, false);

    }

    WriteLogFile("\r\n  Name: ", false);

    WriteLogFile(Name, false);

    WriteLogFile("\r\n", false);

#endif // DBGLEVEL

    //if(m_bIsMetatable && (m_iSpecType != 2)) return(E_NOTIMPL);

    if(m_bIsMetatable) return(E_NOTIMPL);



    if(wcsicmp(Name, L"DefaultValueLiteralConversion") == 0)

    {

        //return(E_NOTIMPL);

        if(!m_pLitConv)

        {

            m_pLitConv = new FldLitConvExt(this,

                ((ITypeLib**)m_pConnStruct->ppTypeLibs)[2]);

        }

        if(!ppGExtension) return(E_POINTER);

        if(*ppGExtension) (*ppGExtension)->Release();

        m_pLitConv->AddRef();

        *ppGExtension = m_pLitConv;

        return(S_OK);

    }

    if(wcsicmp(Name, L"ExtendedPropertySet") == 0)

    {

        if(!m_pExt) return(E_NOTIMPL);

        if(!ppGExtension) return(E_POINTER);

        if(*ppGExtension) (*ppGExtension)->Release();

        m_pExt->AddRef();

        *ppGExtension = m_pExt;

        return(S_OK);

    }

    return(E_NOTIMPL);

}



LPWSTR GField::GetNamePtr()

{

    return(m_wsName);

}



LPSTR GField::GetOrigNamePtr()

{

    return(m_sOrigName);

}



Oid GField::GetTableOid()

{

    return(m_cAttrs.lTblOid);

}



void GField::SetAttrs(PConnStruct pConnStruct, PGresult *pRes, int iPos,

    Oid lType, bool bUpdatable, int iSpecType, bool bMetatable)

{

    m_pConnStruct = pConnStruct;

    m_pErrors = (GErrors*)m_pConnStruct->pErrors;

    m_iPos = iPos;

    m_iSpecType = iSpecType;

    m_bIsMetatable = bMetatable;



    if(m_sOrigName) free(m_sOrigName);

    m_sOrigName = NULL;

    if(m_wsName) free(m_wsName);

    m_wsName = NULL;



    LPSTR sVal = PQfname(pRes, iPos);

    if(sVal)

    {

        m_sOrigName = (LPSTR)malloc((strlen(sVal) + 1)*sizeof(char));

        strcpy(m_sOrigName, sVal);

        m_wsName = DBStrToWChar(sVal, m_pConnStruct->lDBEnc);

    }



    //if(!iSpecType)

    {

        m_pExt = new FldExtendedPropertySet(this,

            ((ITypeLib**)pConnStruct->ppTypeLibs)[1]);

    }



    m_cAttrs.lTblOid = PQftable(pRes, iPos);

    m_cAttrs.iTblPos = PQftablecol(pRes, iPos);

    m_cAttrs.bUpdatable = bUpdatable;



    int iMod = PQfmod(pRes, iPos);

    int iSize = PQfsize(pRes, iPos);



    m_cAttrs.lTypeOid = lType;

    m_cAttrs.iType = OidToGdoType(lType, iSize, iMod, &m_cAttrs.lSize);

#if DBGLEVEL > 1

    WriteLogFile("GField::SetAttrs\r\n", true);

    char sbuf[128];

    sprintf(sbuf, "  Name: %s, PG Type: %d, GDO Type: %d\r\n",

        m_sOrigName, lType, m_cAttrs.iType);

    WriteLogFile(sbuf, false);

#endif // DBGLEVEL

    return;

}



int GField::UpdateField(GTableDefs *pGTbls)

{

    GTableDef *ptd = pGTbls->FindByOid(m_cAttrs.lTblOid);

    GTDField *pfld = NULL;

    if(ptd)

    {

        ptd->BuildFromConnection();

        pfld = ptd->GetFieldPtrByTblPos(m_cAttrs.iTblPos);

    }



    if(pfld)

    {

        pfld->CopyAttributes(&m_cAttrs);

        // this was formerly intended for tables without key, however

        // but the oposite way seems to be usually used in GM

        //if(!ptd->GetHasUniqueIndex()) m_pExt->SetTDField(pfld);

        if(m_pExt && ptd->GetHasUniqueIndex()) m_pExt->SetTDField(pfld);

    }



    if(m_cAttrs.sDefValDef)

    {

        LPSTR sEnd = NULL;

        LPSTR sStart = strchr(m_cAttrs.sDefValDef, '\'');

        if(sStart)

        {

            sStart++;

            sEnd = strchr(sStart, '\'');

        }

        if(sEnd)

        {

            m_cAttrs.bUpdatable = false;

            m_cAttrs.lAttr &= ~32;

            m_cAttrs.lAttr |= 16;



            int ilen = sEnd - sStart;

            m_sNewIdCmd = (LPSTR)malloc((ilen + 38)*sizeof(char));

            strcpy(m_sNewIdCmd, "select last_value, is_called from ");

            int icurlen = strlen(m_sNewIdCmd);

            strncat(m_sNewIdCmd, sStart, ilen);

            m_sNewIdCmd[icurlen + ilen] = 0;

#if DBGLEVEL > 2

            WriteMallocReport(4, ilen + 37, strlen(m_sNewIdCmd));

#endif



            m_sGenIdCmd = (LPSTR)malloc((ilen + 22)*sizeof(char));

            strcpy(m_sGenIdCmd, "select nextval('");

            icurlen = strlen(m_sGenIdCmd);

            strncat(m_sGenIdCmd, sStart, ilen);

            m_sGenIdCmd[icurlen + ilen] = 0;

            strcat(m_sGenIdCmd, "')");

#if DBGLEVEL > 2

            WriteMallocReport(5, ilen + 21, strlen(m_sGenIdCmd));

#endif

        }

    }

    else if(m_cAttrs.wsDefVal)

    {

        if(m_cAttrs.iType == gdbGuid)

        {

            if(wcschr(m_cAttrs.wsDefVal, '(') != NULL)

            {

                m_cAttrs.lAttr &= ~32;

                m_cAttrs.bUpdatable = false;

            }

        }

    }



#if DBGLEVEL > 1

    WriteLogFile("GField::UpdateField\r\n", true);

    char sbuf[128];

    sprintf(sbuf, "  Name: %s, GDO Type: %d, SubType: %ld\r\n",

        m_sOrigName, m_cAttrs.iType, m_cAttrs.lSubType);

#if DBGLEVEL > 2

    WriteMallocReport(6, 127, strlen(sbuf));

#endif

    WriteLogFile(sbuf, false);

#endif // DBGLEVEL

    return(m_cAttrs.iGeomDim);

}



void GField::SetNewVal()

{

    VariantClear(&m_vNewVal);

    m_vNewVal.vt = VT_EMPTY;

    if(m_sNewIdCmd)

    {

        bool bTrans = (m_pConnStruct->iSysTrans | m_pConnStruct->iGdoTrans);



        SetSP(m_pConnStruct->pConn, bTrans);

        //LPSTR lsCmd = GetSaveSQL(m_sNewIdCmd, bTrans);

        PGresult *res = PQexecParams(m_pConnStruct->pConn, m_sNewIdCmd, 0,

            NULL, NULL, NULL, NULL, 1);

        //free(lsCmd);

        if(PQresultStatus(res) != PGRES_TUPLES_OK)

        {

            WritePQErrorToLog("Spot 1: ", m_pConnStruct->pConn);

            PQclear(res);

            RollbackSP(m_pConnStruct->pConn, bTrans);

        }

        else

        {

            long nrows = PQntuples(res);

            if(nrows > 0)

            {

                Oid piTypes[2];

                VARIANT vVals[2];

                VariantInit(&vVals[0]);

                VariantInit(&vVals[1]);

                DescribeFieldTypes(res, 2, piTypes);

                GetRecordBin(res, 0, 2, piTypes, vVals,

                    m_pConnStruct->lDBEnc, m_pConnStruct->lGeomOid, NULL, m_pConnStruct->iCurrDigits);

                m_vNewVal.vt = VT_I4;

                if(VarToBool(vVals[1]))

                    m_vNewVal.lVal = VarToLong(vVals[0]) + 1;

                else m_vNewVal.lVal = 1;

            }

            PQclear(res);

            ReleaseSP(m_pConnStruct->pConn, bTrans);

        }

    }

    else if(m_cAttrs.wsDefVal)

    {

        int iVal;

        float fVal;

        SYSTEMTIME sTime;

        switch(m_cAttrs.iType)

        {

        case gdbBoolean:

            m_vNewVal.vt = VT_BOOL;

            m_vNewVal.boolVal = FALSE;

            if((m_cAttrs.wsDefVal[0] == 'T') || (m_cAttrs.wsDefVal[0] == 't'))

                m_vNewVal.boolVal = TRUE;

            break;

        case gdbByte:

            if(swscanf(m_cAttrs.wsDefVal, L"%d", &iVal) == 1)

            {

                m_vNewVal.vt = VT_UI1;

                m_vNewVal.bVal = iVal;

            }

            break;

        case gdbInteger:

            if(swscanf(m_cAttrs.wsDefVal, L"%d", &iVal) == 1)

            {

                m_vNewVal.vt = VT_I2;

                m_vNewVal.iVal = iVal;

            }

            break;

        case gdbLong:

            if(swscanf(m_cAttrs.wsDefVal, L"%d", &iVal) == 1)

            {

                m_vNewVal.vt = VT_I4;

                m_vNewVal.lVal = iVal;

            }

            break;

        case gdbSingle:

            if(swscanf(m_cAttrs.wsDefVal, L"%f", &fVal) == 1)

            {

                m_vNewVal.vt = VT_R4;

                m_vNewVal.fltVal = fVal;

            }

            break;

        case gdbDouble:

            if(swscanf(m_cAttrs.wsDefVal, L"%f", &fVal) == 1)

            {

                m_vNewVal.vt = VT_R8;

                m_vNewVal.dblVal = fVal;

            }

            break;

        case gdbDate:

            if(wcsicmp(m_cAttrs.wsDefVal, L"now()") == 0)

            {

                m_vNewVal.vt = VT_DATE;

                GetLocalTime(&sTime);

                SystemTimeToVariantTime(&sTime, &m_vNewVal.date);

            }

            break;

        default:

            if(wcschr(m_cAttrs.wsDefVal, '(') == NULL)

            {

                m_vNewVal.vt = VT_BSTR;

                m_vNewVal.bstrVal = SysAllocString(m_cAttrs.wsDefVal);

            }

            // else the default value is most likely a function, which result we don't know

        }

    }

    return;

}



void GField::SetBuffer(VARIANT *pBuffer)

{

    m_pvBuffer = pBuffer;

    return;

}



void GField::CancelNewVal()

{

    VariantClear(&m_vNewVal);

    m_vNewVal.vt = VT_EMPTY;

    return;

}



bool GField::Modified()

{

    return(!m_sNewIdCmd && (m_vNewVal.vt > VT_EMPTY));

}



bool GField::HasSeq()

{

    return(m_sNewIdCmd);

}



VARIANT GField::GetModVal()

{

    if(m_vNewVal.vt > VT_EMPTY) return(m_vNewVal);

    if(m_pvBuffer) return(*m_pvBuffer);

    return(m_vNewVal);

}



void GField::UpdateVal(VARIANT *pvVal)

{

    VariantClear(&m_vNewVal);

    m_vNewVal.vt = VT_EMPTY;

    m_pvBuffer = pvVal;

    return;

}



bool GField::GetRequired()

{

    return(m_cAttrs.bRequired);

}



Oid GField::GetTypeOid()

{

    return(m_cAttrs.lTypeOid);

}



LPSTR GField::GetSchemaNamePtr()

{

    return(m_cAttrs.sOrigSchema);

}



LPSTR GField::GetTableNamePtr()

{

    return(m_cAttrs.sOrigTable);

}



void GField::FillGeomInfo(PGeomInfo pgInfo)

{

    pgInfo->iGdoType = m_cAttrs.iType;

    pgInfo->lSubType = m_cAttrs.lSubType;

    pgInfo->iGeomDim = m_cAttrs.iGeomDim;

    pgInfo->ulSrid = m_cAttrs.ulSrid;

    pgInfo->iPsgType = m_cAttrs.iPsgType;

    return;

}



void GField::ChangeCSGuid(LPWSTR wsOldCSGuid, LPWSTR wsNewCSGuid)

{

    if(wcsicmp(m_cAttrs.sCSGuid, wsOldCSGuid) == 0)

        wcscpy(m_cAttrs.sCSGuid, wsNewCSGuid);

    return;

}



void GField::SetSpecField(GField *pSpecFld, int iSpecFld)

{

#if DBGLEVEL > 2

    char buf[64];

    WriteLogFile("GField::SetSpecField\r\n", true);

    WriteLogFile("  Field name: ", false);

    WriteLogFile(m_wsName, false);

    sprintf(buf, "\r\n  SpecType: %d\r\n", iSpecFld, false);

    WriteLogFile(buf, false);

#endif // DBGLEVEL



    m_iSpecField = iSpecFld; // 1 - has INGR field, 2 - has Native field;

    m_pSpecField = pSpecFld;

    m_pSpecField->AddRef();

    return;

}



void GField::SetSpecFldAttrs(unsigned long ulSrid, long iGDOGeomType,

    LPSTR sSchema, LPSTR sTable)

{

#if DBGLEVEL > 2

    char buf[64];

    WriteLogFile("GField::SetSpecFldAttrs\r\n", true);

    WriteLogFile("  Field name: ", false);

    WriteLogFile(m_wsName, false);

    sprintf(buf, "\r\n  GeomType: %d\r\n", iGDOGeomType);

    WriteLogFile(buf, false);

#endif // DBGLEVEL



    m_cAttrs.sOrigSchema = sSchema;

    m_cAttrs.sOrigTable = sTable;

    m_cAttrs.iGeomDim = 2;

    m_cAttrs.ulSrid = ulSrid;

    if(iGDOGeomType == 4) // raster

    {

        m_cAttrs.iType = 32;

        m_cAttrs.lSubType = 2;

        m_cAttrs.iPsgType = 3;

    }

    else if(iGDOGeomType == 5) // text

    {

        m_cAttrs.iType = 32;

        m_cAttrs.lSubType = 10;

        m_cAttrs.iPsgType = 1;

    }

    else

    {

        m_cAttrs.iType = 11;

        m_cAttrs.lSubType = 0;

        m_cAttrs.iPsgType = 0;

        m_cAttrs.iGeomDim = 0;

    }

    return;

}



bool GField::IsThisField(LPSTR sSchema, LPSTR sTable, LPSTR sName)

{

    bool bRes = (strcmp(sTable, m_cAttrs.sOrigTable) == 0) &&

        (strcmp(sName, m_sOrigName) == 0);

    if(sSchema)

    {

        if(m_cAttrs.sOrigSchema)

            bRes &= (strcmp(sSchema, m_cAttrs.sOrigSchema) == 0);

        else bRes = false;

    }

    else bRes &= (m_cAttrs.sOrigSchema == NULL);

    return(bRes);

}





//  GFields



GFields::GFields(IUnknown *pUnkOuter, ITypeLib *ALib) :

    _IGDynaCollection(true, pUnkOuter, ALib, 23)

{

#if DBGLEVEL > 1

    WriteLogFile("GFields::GFields-1\r\n", true);

#endif // DBGLEVEL

    m_pConnStruct = NULL;

    m_pTblDefs = NULL;

    m_iCtidCol = -1;

    m_bIsMetatable = false;

    m_iSpecFields = 0;

    m_piListIndex = NULL;

}



GFields::GFields(IUnknown *pUnkOuter, ITypeLib *ALib, int iIndex) :

    _IGDynaCollection(true, pUnkOuter, ALib, iIndex)

{

#if DBGLEVEL > 1

    WriteLogFile("GFields::GFields-2\r\n", true);

#endif // DBGLEVEL

    m_pConnStruct = NULL;

    m_pTblDefs = NULL;

    m_iCtidCol = -1;

    m_bIsMetatable = false;

    m_iSpecFields = 0;

    m_piListIndex = NULL;

}



GFields::~GFields()

{

#if DBGLEVEL > 1

    WriteLogFile("GFields::~GFields\r\n", true);

#endif // DBGLEVEL

    if(m_piListIndex) free(m_piListIndex);

}



HRESULT GFields::QueryInterface(REFIID iid, void **ppvObject)

{

#if DBGLEVEL > 2

    WriteLogFile("GFields::QueryInterface\r\n", true);

#endif // DBGLEVEL

    HRESULT hres = _IGDynaCollection::QueryInterface(iid, ppvObject);

    if(hres != S_OK)

    {

        if(IsEqualIID(iid, DIID_GFields))

        {

            hres = S_OK;

            *ppvObject = this;

            ((IUnknown*)*ppvObject)->AddRef();

        }

        else

        {

            hres = E_NOINTERFACE;

#if DBGLEVEL > 2

            char buf[128];

            FormatGuid(buf, "Unknown Interface: ", "\r\n", iid);

            WriteLogFile(buf, true);

#endif // DBGLEVEL

        }

    }

    return(hres);

}



ULONG GFields::Release()

{

    ULONG lRest;

    IUnknown *pUnkOuter = m_pUnkOuter;

    if(pUnkOuter) lRest = pUnkOuter->Release();

    else lRest = --m_lRefCount;

#if DBGLEVEL > 2

    char buf[64];

    if(pUnkOuter) sprintf(buf, "GFields::Release (aggregated) - %d\r\n", lRest);

    else sprintf(buf, "GFields::Release - %d\r\n", lRest);

    WriteLogFile(buf, true);

#endif // DBGLEVEL

    if(pUnkOuter || (lRest > 0)) return lRest;

    delete(this);

    return(0);

}



HRESULT GFields::get_Count(short *Count)

{

#if DBGLEVEL > 0

    WriteLogFile("_IGCollection::get_Count\r\n", true);

#endif // DBGLEVEL

    if(!Count) return(E_POINTER);

    *Count = m_iDataLen - m_iSpecFields;

    return(S_OK);

}



HRESULT GFields::_NewEnum(IUnknown * *Enum)

{

#if DBGLEVEL > 0

    WriteLogFile("GFields::_NewEnum\r\n", true);

#endif // DBGLEVEL

    if(!Enum) return(E_POINTER);

    if(*Enum) (*Enum)->Release();

    *Enum = new CEnumGDO(0, m_iDataLen - m_iSpecFields, m_pData);

    (*Enum)->AddRef();

    return(S_OK);

}



HRESULT GFields::Append(IDispatch * Object)

{

#if DBGLEVEL > 0

    WriteLogFile("GFields::Append\r\n", true);

#endif // DBGLEVEL

    return(E_NOTIMPL);

}



HRESULT GFields::Delete(BSTR Name)

{

#if DBGLEVEL > 0

    WriteLogFile("GFields::Delete\r\n", true);

#endif // DBGLEVEL

    return(E_NOTIMPL);

}



HRESULT GFields::get_Item(VARIANT index, GField* *ppGField)

{

    ValidateVariant(&index);



#if DBGLEVEL > 0

    WriteLogFile("GFields::get_Item\r\n", true);

    WriteVariantToLogFile(L"  index: ", index);

#endif // DBGLEVEL

    if(!ppGField) return(E_POINTER);

    // a "get_CollectionItem" method is probably an exception from the COM

    // standards - it can accept uninitialized return values, similary as

    // QueryInterface method

    //if(*ppGField) (*ppGField)->Release();



    *ppGField = NULL;

    GField *pFld = NULL;

    if(index.vt == VT_BSTR) pFld = FindByWName(index.bstrVal);

    else if(index.vt == (VT_BYREF | VT_BSTR))

        pFld = FindByWName(*index.pbstrVal);

    else

    {

        int i = VarToInt(index);

        if(m_piListIndex) i = m_piListIndex[i];

        pFld = (GField*)_IGCollection::GetItem(i);

    }

    if(!pFld) return(ResultFromScode(S_FALSE));



    pFld->AddRef();

    *ppGField = pFld;

    return(S_OK);

}



void GFields::ClearAll()

{

    _IGCollection::ClearAll();

    return;

}



void GFields::BuildFromConn(PConnStruct pConnStruct, PGresult *pRes,

    GTableDefs *pGTbls, int iCtidCol, Oid *plTypes, int iSpecType,

    bool bIsMetatable)

{

    m_pConnStruct = pConnStruct;

    m_pTblDefs = pGTbls;

    m_iCtidCol = iCtidCol;

    m_bIsMetatable = bIsMetatable;



    GField *pFld;

    int ncols = PQnfields(pRes);



    for(int i = 0; i < ncols; i++)

    {

        if(i != m_iCtidCol)

        {

            pFld = new GField(NULL, m_pTypeLib);

            pFld->SetAttrs(pConnStruct, pRes, i, plTypes[i], m_iCtidCol > -1,

                iSpecType, bIsMetatable);

            _IGCollection::AddItem(pFld);

        }

    }

    return;

}



GField* FindBaseField(GField *pSpecFld, int iNameLen, int iSpecPos, int iFields,

    GField **ppFields)

{

    bool bFound = false;

    int i = 0;

    GField *pFld = NULL;

    LPSTR sName = pSpecFld->GetOrigNamePtr();

    while(!bFound && (i < iFields))

    {

        if(i != iSpecPos)

        {

            pFld = ppFields[i++];

            bFound = (strncmp(sName, pFld->GetOrigNamePtr(), iNameLen) == 0);

        }

        else i++;

    }

    return(bFound ? pFld : NULL);

}



void GFields::UpdateFields(int *piGeomDims)

{

    bool bBuildIndex = false;



    CGeomInfo gInfo;

    GField *pFld;

    for(int i = 0; i < m_iDataLen; i++)

    {

        pFld = (GField*)m_pData[i];

        piGeomDims[i] = pFld->UpdateField(m_pTblDefs);

        pFld->FillGeomInfo(&gInfo);

        bBuildIndex |= (gInfo.iGdoType > 31);

    }



    if(bBuildIndex)

    {

        m_piListIndex = (int*)malloc(m_iDataLen*sizeof(int));

        int i = 0;

        int j = 0;

        int iSpecFld, iLen;

        LPSTR sName;

        GField *pBaseFld;

        while(i < m_iDataLen)

        {

            pBaseFld = NULL;

            iSpecFld = 0;

            m_piListIndex[i] = -1;

            m_piListIndex[j] = i;

            pFld = (GField*)m_pData[i++];

            sName = pFld->GetOrigNamePtr();

            iLen = strlen(sName);

            if(iLen > 4)

            {

                iLen -= 4;

                if(strcmp(&sName[iLen], "_igr") == 0) iSpecFld = 1;

                else if(strcmp(&sName[iLen], "_nat") == 0) iSpecFld = 2;

            }

            if(iSpecFld > 0)

                pBaseFld = FindBaseField(pFld, iLen, i - 1, m_iDataLen,

                    (GField**)m_pData);

            if(pBaseFld)

            {

                if(iSpecFld == 1) piGeomDims[i - 1] = 0;

                else piGeomDims[i - 1] = 2;

                pBaseFld->SetSpecField(pFld, iSpecFld);

                pBaseFld->FillGeomInfo(&gInfo);

                pFld->SetSpecFldAttrs(gInfo.ulSrid, gInfo.lSubType,

                    pBaseFld->GetSchemaNamePtr(), pBaseFld->GetTableNamePtr());

                m_iSpecFields++;

            }

            else j++;

        }

    }

    return;

}



/*GField* GFields::FindKeyField()

{

    GField *pFld;

    bool bFound = false;

    int i = 0;

    while(!bFound && (i < GetCount()))

    {

        pFld = (GField*)GetItem(i++);

        bFound = pFld->IsKey();

    }

    return(bFound ? pFld : NULL);

}*/



/*GField* GFields::FindByName(LPSTR sVal)

{

    bool bFound = false;

    GField *pFld = NULL;

    int i = 0;

    while(!bFound && (i < _IGCollection::GetCount()))

    {

        pFld = (GField*)m_pData[i++];

        bFound = (stricmp(pFld->GetNamePtr(), sVal) == 0);

    }

    return(bFound ? pFld : NULL);

}*/



GField* GFields::FindByWName(BSTR bsVal)

{

    bool bFound = false;

    GField *pFld = NULL;

    int i = 0;

    if(m_bIsMetatable)

    {

        while(!bFound && (i < m_iDataLen))

        {

            pFld = (GField*)m_pData[i++];

            bFound = (wcsicmp(pFld->GetNamePtr(), bsVal) == 0);

        }

    }

    else

    {

        while(!bFound && (i < m_iDataLen))

        {

            pFld = (GField*)m_pData[i++];

            bFound = (wcscmp(pFld->GetNamePtr(), bsVal) == 0);

        }

    }

    return(bFound ? pFld : NULL);

}



void GFields::SetNewRow()

{

    GField *pFld;

    for(int i = 0; i < m_iDataLen; i++)

    {

        pFld = (GField*)GetItem(i);

        pFld->SetNewVal();

    }

    return;

}



void GFields::SetBuffer(VARIANT *pBuffer)

{

    GField *pFld;

    if(pBuffer)

    {

        for(int i = 0; i < m_iDataLen; i++)

        {

            pFld = (GField*)GetItem(i);

            pFld->SetBuffer(&pBuffer[i]);

        }

    }

    else

    {

        for(int i = 0; i < m_iDataLen; i++)

        {

            pFld = (GField*)GetItem(i);

            pFld->SetBuffer(NULL);

        }

    }

    return;

}



void GFields::CancelNewRow()

{

    GField *pFld;

    for(int i = 0; i < m_iDataLen; i++)

    {

        pFld = (GField*)GetItem(i);

        pFld->CancelNewVal();

    }

    return;

}



void GFields::UpdateRow(VARIANT *pBuffer)

{

    GField *pFld;

    for(int i = 0; i < m_iDataLen; i++)

    {

        pFld = (GField*)GetItem(i);

        pFld->UpdateVal(&pBuffer[i]);

    }

    return;

}



GTableDefs* GFields::GetTableDefsPtr()

{

    return(m_pTblDefs);

}



void GFields::BroadcastCSChange(LPWSTR wsOldCSGuid, LPWSTR wsNewCSGuid)

{

    GField *pFld;

    for(int i = 0; i < m_iDataLen; i++)

    {

        pFld = (GField*)GetItem(i);

        pFld->ChangeCSGuid(wsOldCSGuid, wsNewCSGuid);

    }

    return;

}



int GFields::HasField(LPSTR sSchema, LPSTR sTable, LPSTR sName)

{

    GField *pFld;

    bool bFound = false;

    int i = 0;

    while(!bFound && (i < m_iDataLen))

    {

        pFld = (GField*)GetItem(i++);

        bFound = pFld->IsThisField(sSchema, sTable, sName);

    }

    return(bFound ? i - 1 : -1);

}



#if DBGLEVEL > 0

GRecordset* GFields::GetParentRecordset()

{

    return (GRecordset*)m_pUnkOuter;

}

#endif





// GFeatureClass



GFeatureClassExt::GFeatureClassExt(IUnknown *pUnkOuter, ITypeLib *ALib) :

    CCOMDispatch(pUnkOuter, ALib, 4)

{

#if DBGLEVEL > 2

    WriteLogFile("GFeatureClassExt::GFeatureClassExt-1\r\n", true);

#endif // DBGLEVEL

    m_wsTblName = NULL;

}



GFeatureClassExt::GFeatureClassExt(IUnknown *pUnkOuter, ITypeLib *ALib,

    int iIndex) : CCOMDispatch(pUnkOuter, ALib, iIndex)

{

#if DBGLEVEL > 2

    WriteLogFile("GFeatureClassExt::GFeatureClassExt-2\r\n", true);

#endif // DBGLEVEL

    m_wsTblName = NULL;

}



GFeatureClassExt::~GFeatureClassExt()

{

#if DBGLEVEL > 2

    WriteLogFile("GFeatureClassExt::~GFeatureClassExt\r\n", true);

#endif // DBGLEVEL

    if(m_wsTblName) free(m_wsTblName);

}



HRESULT GFeatureClassExt::QueryInterface(REFIID iid, void **ppvObject)

{

#if DBGLEVEL > 2

    WriteLogFile("GFeatureClassExt::QueryInterface\r\n", true);

#endif // DBGLEVEL

    HRESULT hres = CCOMDispatch::QueryInterface(iid, ppvObject);

    if(hres != S_OK)

    {

        if(IsEqualIID(iid, DIID__GFeatureClass))

        {

            hres = S_OK;

            *ppvObject = this;

            ((IUnknown*)*ppvObject)->AddRef();

        }

        else

        {

            hres = E_NOINTERFACE;

#if DBGLEVEL > 2

            char buf[128];

            FormatGuid(buf, "Unknown Interface: ", "\r\n", iid);

            WriteLogFile(buf, true);

#endif // DBGLEVEL

        }

    }

    return(hres);

}



ULONG GFeatureClassExt::Release()

{

    ULONG…