Ticket #106: DropTableDraft.patch

File DropTableDraft.patch, 11.5 KB (added by cwilbur, 9 years ago)

Draft attempt at fix

  • ApplySchemaCommand.cpp

     
    100100    for (FdoInt32 i = 0; i < classesSize; i++)
    101101    {
    102102        FdoPtr<FdoClassDefinition> classDef(featureClasses->GetItem(i));
    103         FdoPtr<FdoPropertyDefinitionCollection> props(classDef->GetProperties());
    104 
    105         if (NULL != props && props->GetCount() > 0)
     103        switch ( classDef->GetElementState() )
    106104        {
    107             std::string sep;
    108             std::string sqlColumns;
     105        case FdoSchemaElementState_Added:
     106            CreateTable(classDef);
     107            break;
     108        case FdoSchemaElementState_Deleted:
     109            DropTable(classDef);
     110            break;
     111        case FdoSchemaElementState_Modified:
     112        case FdoSchemaElementState_Detached:
     113        case FdoSchemaElementState_Unchanged:
     114            break;
     115        }
     116    }
     117}
    109118
    110             //
    111             // Read properties and parse details: name, data type, size.
    112             //
    113             FdoInt32 const propsSize = props->GetCount();
    114             for (FdoInt32 j = 0; j < propsSize; j++)
    115             {
    116                 FdoPtr<FdoPropertyDefinition> propDef(props->GetItem(j));
    117                 if (FdoPropertyType_DataProperty == propDef->GetPropertyType())
    118                 {
    119                     FdoStringP propName(propDef->GetName());
    120                     std::string sqlType(details::PgTypeFromFdoProperty(propDef));
    121                     if (sqlType.empty())
    122                     {
    123                         throw FdoCommandException::Create(L"ApplySchemaCommand::Execute: Unkown data property type");
    124                     }
     119///////////////////////////////////////////////////////////////////////////////
     120// Private operations
     121///////////////////////////////////////////////////////////////////////////////
    125122
    126                     sqlColumns += sep;
    127                     sqlColumns += static_cast<char const*>(propName.Lower());
    128                     sqlColumns += " " + sqlType;
    129                     sep = ",";
    130                 }
    131             }
     123void ApplySchemaCommand::CreateTable(FdoPtr<FdoClassDefinition> classDef) const
     124{
     125    FDOLOG_MARKER("ApplySchemaCommand::-CreateTable");
    132126
    133             //
    134             // Read identity properties used to build PRIMARY KEY
    135             //
    136             sep = "";
    137             std::string sqlPrimaryKey;
    138             FdoPtr<FdoDataPropertyDefinitionCollection> propsIdentity(classDef->GetIdentityProperties());
    139             FdoInt32 const propsIdSize = propsIdentity->GetCount();
    140             for (FdoInt32 j = 0; j < propsIdSize; j++)
     127    FdoPtr<FdoPropertyDefinitionCollection> props(classDef->GetProperties());
     128
     129    if (NULL != props && props->GetCount() > 0)
     130    {
     131        std::string sep;
     132        std::string sqlColumns;
     133
     134        //
     135        // Read properties and parse details: name, data type, size.
     136        //
     137        FdoInt32 const propsSize = props->GetCount();
     138        for (FdoInt32 j = 0; j < propsSize; j++)
     139        {
     140            FdoPtr<FdoPropertyDefinition> propDef(props->GetItem(j));
     141            if (FdoPropertyType_DataProperty == propDef->GetPropertyType())
    141142            {
    142                 FdoPtr<FdoDataPropertyDefinition> propId(propsIdentity->GetItem(j));
    143                 FdoStringP propName(propId->GetName());
    144 
    145                 if (sqlPrimaryKey.empty())
     143                FdoStringP propName(propDef->GetName());
     144                std::string sqlType(details::PgTypeFromFdoProperty(propDef));
     145                if (sqlType.empty())
    146146                {
    147                     sqlPrimaryKey = ", PRIMARY KEY(";
     147                    throw FdoCommandException::Create(L"ApplySchemaCommand::Execute: Unkown data property type");
    148148                }
    149149
    150                 sqlPrimaryKey += sep;
    151                 sqlPrimaryKey += static_cast<char const*>(propName.Lower());
     150                sqlColumns += sep;
     151                sqlColumns += static_cast<char const*>(propName.Lower());
     152                sqlColumns += " " + sqlType;
    152153                sep = ",";
    153154            }
     155        }
    154156
    155             if (!sqlPrimaryKey.empty())
     157        //
     158        // Read identity properties used to build PRIMARY KEY
     159        //
     160        sep = "";
     161        std::string sqlPrimaryKey;
     162        FdoPtr<FdoDataPropertyDefinitionCollection> propsIdentity(classDef->GetIdentityProperties());
     163        FdoInt32 const propsIdSize = propsIdentity->GetCount();
     164        for (FdoInt32 j = 0; j < propsIdSize; j++)
     165        {
     166            FdoPtr<FdoDataPropertyDefinition> propId(propsIdentity->GetItem(j));
     167            FdoStringP propName(propId->GetName());
     168
     169            if (sqlPrimaryKey.empty())
    156170            {
    157                 sqlPrimaryKey += ")";
     171                sqlPrimaryKey = ", PRIMARY KEY(";
    158172            }
    159173
    160             //
    161             // CREATE TABLE command
    162             //
    163             std::string tableName(static_cast<char const*>(FdoStringP(classDef->GetName()).Lower()));
     174            sqlPrimaryKey += sep;
     175            sqlPrimaryKey += static_cast<char const*>(propName.Lower());
     176            sep = ",";
     177        }
    164178
    165             std::string sqlCreate("CREATE TABLE ");
    166             sqlCreate += tableName;
    167             sqlCreate += " ( ";
    168             sqlCreate += sqlColumns;
    169             if (!sqlPrimaryKey.empty())
    170             {
    171                 sqlCreate += sqlPrimaryKey;
    172             }
    173             sqlCreate += " )";
     179        if (!sqlPrimaryKey.empty())
     180        {
     181            sqlPrimaryKey += ")";
     182        }
    174183
    175             FDOLOG_WRITE("SQL:\n\t%s", sqlCreate.c_str());
     184        //
     185        // CREATE TABLE command
     186        //
     187        std::string tableName(static_cast<char const*>(FdoStringP(classDef->GetName()).Lower()));
    176188
    177             mConn->PgExecuteCommand(sqlCreate.c_str());
     189        std::string sqlCreate("CREATE TABLE ");
     190        sqlCreate += tableName;
     191        sqlCreate += " ( ";
     192        sqlCreate += sqlColumns;
     193        if (!sqlPrimaryKey.empty())
     194        {
     195            sqlCreate += sqlPrimaryKey;
     196        }
     197        sqlCreate += " )";
    178198
    179             //
    180             // Register geometric property as PostGIS geometry column
    181             //
    182             if (FdoClassType_FeatureClass == classDef->GetClassType())
    183             {
    184                 FdoFeatureClass* featClass = static_cast<FdoFeatureClass*>(classDef.p);
     199        FDOLOG_WRITE("SQL:\n\t%s", sqlCreate.c_str());
    185200
    186                 AddGeometryColumn(tableName, featClass->GetGeometryProperty());
     201        mConn->PgExecuteCommand(sqlCreate.c_str());
    187202
    188                 // Create GiST index for table-column pair.
    189                 CreateSpatialIndex(tableName, featClass->GetGeometryProperty());
    190             }
     203        //
     204        // Register geometric property as PostGIS geometry column
     205        //
     206        if (FdoClassType_FeatureClass == classDef->GetClassType())
     207        {
     208            FdoFeatureClass* featClass = static_cast<FdoFeatureClass*>(classDef.p);
    191209
    192             //
    193             // CREATE SEQUENCE for single column, integral type PRIMARY KEY
    194             //
    195             if (1 == propsIdSize)
     210            AddGeometryColumn(tableName, featClass->GetGeometryProperty());
     211
     212            // Create GiST index for table-column pair.
     213            CreateSpatialIndex(tableName, featClass->GetGeometryProperty());
     214        }
     215
     216        //
     217        // CREATE SEQUENCE for single column, integral type PRIMARY KEY
     218        //
     219        if (1 == propsIdSize)
     220        {
     221            FdoPtr<FdoDataPropertyDefinition> propId = propsIdentity->GetItem(0);
     222            assert(NULL != propId);
     223
     224            if (propId->GetIsAutoGenerated()
     225                && (FdoDataType_Int16 == propId->GetDataType()
     226                    || FdoDataType_Int32 == propId->GetDataType()
     227                    || FdoDataType_Int64 == propId->GetDataType()))
    196228            {
    197                 FdoPtr<FdoDataPropertyDefinition> propId = propsIdentity->GetItem(0);
    198                 assert(NULL != propId);
    199 
    200                 if (propId->GetIsAutoGenerated()
    201                     && (FdoDataType_Int16 == propId->GetDataType()
    202                         || FdoDataType_Int32 == propId->GetDataType()
    203                         || FdoDataType_Int64 == propId->GetDataType()))
    204                 {
    205                     CreateSequence(tableName, propId);
    206                 }
     229                CreateSequence(tableName, propId);
    207230            }
     231        }
    208232
    209             // TODO: Add class description as a COMMENT
     233        // TODO: Add class description as a COMMENT
    210234
    211235
    212         } // if (NULL != props && props->GetCount() > 0)
     236    } // if (NULL != props && props->GetCount() > 0)
     237}
     238
     239void ApplySchemaCommand::DropTable(FdoPtr<FdoClassDefinition> classDef) const
     240{
     241    FDOLOG_MARKER("ApplySchemaCommand::-DropTable");
     242    //
     243    // DROP TABLE command
     244    //
     245    std::string tableName(static_cast<char const*>(FdoStringP(classDef->GetName()).Lower()));
     246    size_t tildePos = tableName.find("~");
     247    if ( 0 < tildePos )
     248    {
     249        tableName = tableName.substr(tildePos+1);
    213250    }
     251    std::string sqlDrop("DROP TABLE ");
     252    sqlDrop += tableName;
     253
     254    FDOLOG_WRITE("SQL:\n\t%s", sqlDrop.c_str());
     255
     256    mConn->PgExecuteCommand(sqlDrop.c_str());
     257
     258    FdoPtr<FdoDataPropertyDefinitionCollection> propsIdentity(classDef->GetIdentityProperties());
     259    FdoInt32 const propsIdSize = propsIdentity->GetCount();
     260    //
     261    // DROP SEQUENCE for single column, integral type PRIMARY KEY
     262    //
     263    if (1 == propsIdSize)
     264    {
     265        FdoPtr<FdoDataPropertyDefinition> propId = propsIdentity->GetItem(0);
     266        assert(NULL != propId);
     267
     268        if (propId->GetIsAutoGenerated()
     269            && (FdoDataType_Int16 == propId->GetDataType()
     270                || FdoDataType_Int32 == propId->GetDataType()
     271                || FdoDataType_Int64 == propId->GetDataType()))
     272        {
     273            std::string column(static_cast<char const*>(FdoStringP(propId->GetName()).Lower()));
     274            std::string sequence = details::MakeSequenceName(tableName, column);
     275
     276            std::string sql("DROP SEQUENCE " + sequence);
     277            mConn->PgExecuteCommand(sql.c_str());
     278        }
     279    }
    214280}
    215281
    216 ///////////////////////////////////////////////////////////////////////////////
    217 // Private operations
    218 ///////////////////////////////////////////////////////////////////////////////
    219 
    220282void ApplySchemaCommand::AddGeometryColumn(std::string const& table,
    221283                                           FdoPtr<FdoGeometricPropertyDefinition> prop) const
    222284{
  • ApplySchemaCommand.h

     
    134134    //
    135135
    136136
     137    // This function creates a feature table
     138    // It is a simple proxy around SQL command:
     139    // CREATE TABLE <table_name> ( <column_name> <type>, ... [, <primary key>])
     140    // \param
     141    // classDef - definition of feature class
     142    //
     143    void CreateTable(FdoPtr<FdoClassDefinition> classDef) const;
     144
     145
     146    void DropTable(FdoPtr<FdoClassDefinition> classDef) const;
     147
     148
    137149    // This function registers geometry column in PostGIS meta-schema.
    138150    // It is a simple proxy around SQL command:
    139151    // AddGeometryColumn(<schema_name>,<table_name>,<column_name>,<srid>,<type>,<dimension>)