IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 3242


Ignore:
Timestamp:
Feb 15, 2005, 4:08:33 PM (21 years ago)
Author:
jhoblitt
Message:

add psDBPTypeToSQL() & psDBPTypeToMySQL()
rename psDBGetPSToSQLTable() to psDBGetPTypeToSQLTable()
rename psDBPSToSQLTableCleanup() to psDBPTypeToSQLTableCleanup()
rename psDBGetSQLToPSTable() to psDBGetSQLToPTypeTable()
rename psDBSQLToPSTableCleanup() to psDBSQLToPTypeTableCleanup()
rename psDBGetPSToMySQLTable() to psDBGetPTypeToMySQLTable()
rename psDBPSToMySQLTableCleanup() to psDBPTypeToMySQLTableCleanup()

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/archive/psdb/psDB.c

    r3236 r3242  
    88 *  @author Joshua Hoblitt
    99 *
    10  *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2005-02-16 00:45:11 $
     10 *  @version $Revision: 1.29 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2005-02-16 02:08:33 $
    1212 *
    1313 *  Copyright 2005 Joshua Hoblitt, University of Hawaii
    … …  
    4545// lookup table functions
    4646static psElemType psDBMySQLToPType(enum enum_field_types type, unsigned int flags);
    47 
    48 static psHash  *psDBGetPSToSQLTable(void);
    49 static void     psDBPSToSQLTableCleanup(void);
    50 
    51 static psHash  *psDBGetSQLToPSTable(void);
    52 static void     psDBSQLToPSTableCleanup(void);
     47static char    *psDBPTypeToSQL(psElemType pType);
     48static mysqlType *psDBPTypeToMySQL(psElemType pType);
     49
     50static psHash  *psDBGetPTypeToSQLTable(void);
     51static void     psDBPTypeToSQLTableCleanup(void);
     52
     53static psHash  *psDBGetSQLToPTypeTable(void);
     54static void     psDBSQLToPTypeTableCleanup(void);
    5355
    5456static psHash  *psDBGetMySQLToSQLTable(void);
    5557static void     psDBMySQLToSQLTableCleanup(void);
    5658
    57 static psHash  *psDBGetPSToMySQLTable(void);
    58 static void     psDBPSToMySQLTableCleanup(void);
     59static psHash  *psDBGetPTypeToMySQLTable(void);
     60static void     psDBPTypeToMySQLTableCleanup(void);
    5961
    6062static psPtr    psDBMySQLTypeAlloc(enum enum_field_types type, bool isUnsigned);
    … …  
    113115    // one or more are still open
    114116    psDBMySQLToSQLTableCleanup();
    115     psDBPSToSQLTableCleanup();
    116     psDBSQLToPSTableCleanup();
    117     psDBPSToMySQLTableCleanup();
     117    psDBPTypeToSQLTableCleanup();
     118    psDBSQLToPTypeTableCleanup();
     119    psDBPTypeToMySQLTableCleanup();
    118120}
    119121
    … …  
    353355    int             i;                  // field index
    354356    psMetadata      *md;                // a row
    355     psHash          *mysqlToSQLTable;   // type lookup table
    356     psHash          *sqlToPSTable;      // type lookup table
    357     char            *key;               // hash tmp value
    358     char            *value;             // hash tmp value
    359357    psU32           pType;              // psElemType of a field
    360358    psU32           type;               // psMetadataType of a a field
    361     char            *sqlType;           // copy of lookup table result
    362359    psPtr           data;               // copy of result field
    363360
    … …  
    402399    fieldCount = mysql_num_fields(result);
    403400
    404     mysqlToSQLTable = psDBGetMySQLToSQLTable();
    405     sqlToPSTable = psDBGetSQLToPSTable();
    406 
    407401    while ((row = mysql_fetch_row(result))) {
    408402        // allocate new psMetadata to represent a row
    … …  
    413407        for (i = 0; i < fieldCount; i++) {
    414408            // lookup MySQL column type
    415             key = psDBIntToString((psU64)field[i].type);
    416             value = psHashLookup(mysqlToSQLTable, key);
    417             sqlType = psStringCopy(value);
    418             psFree(key);
    419 
    420             // MySQL column types can not be directly translated to PS
    421             // types as the the mysql types do not tell you if the value is
    422             // signed or unsigned.  The result is this ugly conversion from
    423             // mysql -> ascii -> ptype
    424             if (field[i].flags & UNSIGNED_FLAG) {
    425                 psStringPrepend(&sqlType, "UNSIGNED ");
    426             }
    427 
    428             // convert MySQL type to PS type
    429             value = psHashLookup(sqlToPSTable, sqlType);
    430             pType = (psU32)atol(value);
    431             psFree(sqlType);
     409            pType = psDBMySQLToPType(field[i].type, field[i].flags);
    432410
    433411            // copy field data and convert NULLs to the appropriate NaN value
    … …  
    455433        psArrayAdd(resultSet, 0, md);
    456434    }
    457 
    458     psFree(mysqlToSQLTable);
    459     psFree(sqlToPSTable);
    460435
    461436    mysql_free_result(result);
    … …  
    751726    psListIterator  *cursor;            // row iterator
    752727    psMetadataItem  *item;              // field in row
    753     psHash          *mysqlFieldType;    // type lookup table
    754728    mysqlType       *mType;             // type tmp variable
    755729    static bool     isNull = true;      // used in a MYSQL_BIND to indicate NULL,
    756730                                        // this will be used outside of this func
    757     char            *key;               // hash tmp variable
    758731    psU32           i;                  // field index
    759732
    … …  
    761734
    762735    cursor = psListIteratorAlloc(values->list, 0);
    763 
    764     mysqlFieldType = psDBGetPSToMySQLTable();
    765736
    766737    // loop over fields
    … …  
    768739    while ((item = psListGetNext(cursor))) {
    769740        // lookup pType -> mysql type
    770         key = psDBIntToString((psU64)item->pType);
    771         mType = psHashLookup(mysqlFieldType, key);
    772         psFree(key);
     741        mType = psDBPTypeToMySQL(item->pType);
    773742
    774743        // input data length is determined by the MYSQL_TYPE_* unless it's a string
    … …  
    776745        bind[i].buffer_type = mType->type;
    777746        bind[i].is_unsigned = mType->isUnsigned;
     747
     748        psFree(mType);
    778749
    779750        // convert NaNs to NULL and set the buffer_length for strings
    … …  
    789760                // error, not a pointer to a string
    790761                psFree(cursor);
    791                 psFree(mysqlFieldType);
    792762
    793763                return false;
    … …  
    805775
    806776    psFree(cursor);
    807     psFree(mysqlFieldType);
    808777
    809778    return true;
    … …  
    819788    psMetadataItem  *item;              // column description
    820789    psListIterator  *cursor;            // column iterator
    821     psHash          *colType;           // type lookup table
    822     char            *key;               // hash tmp variable
    823     char            *value;             // hash tmp variable
     790    char            *colType;           // type lookup table
    824791
    825792    if (!table) {
    … …  
    829796    // + _ + tableName + _ + (
    830797    psStringAppend(&query, "CREATE TABLE %s (", tableName);
    831 
    832     colType = psDBGetPSToSQLTable();
    833798
    834799    cursor = psListIteratorAlloc(table->list, 0);
    … …  
    837802    while ((item = psListGetNext(cursor))) {
    838803        if (item->type == PS_META_PRIMITIVE) {
    839             // lookup SQL column type
    840             key = psDBIntToString((psU64)item->pType);
    841             value = psHashLookup(colType, key);
    842             psFree(key);
    843 
    844804            // + column name + _ + column type
    845             psStringAppend(&query, "%s %s", item->name, value);
     805            colType = psDBPTypeToSQL(item->pType);
     806            psStringAppend(&query, "%s %s", item->name, colType);
     807            psFree(colType);
    846808        } else if ((item->type == PS_META_STR) && (item->pType == PS_TYPE_PTR)) {
    847809            // + column name + _ + varchar( + length + )
    … …  
    860822        }
    861823    }
    862 
    863     psFree(colType);
    864824
    865825    psListIteratorSet(cursor, 0);
    … …  
    10961056
    10971057    mysqlToSQLTable = psDBGetMySQLToSQLTable();
    1098     sqlToPSTable    = psDBGetSQLToPSTable();
     1058    sqlToPSTable    = psDBGetSQLToPTypeTable();
    10991059
    11001060    // lookup MySQL column type
    … …  
    11221082}
    11231083
    1124 static psHash *psDBGetPSToSQLTable(void)
     1084static char *psDBPTypeToSQL(psElemType pType)
     1085{
     1086    psHash          *pTypeToSQLTable;   // type lookup table
     1087    char            *key;               // hash tmp value
     1088    char            *sqlType;             // hash tmp value
     1089
     1090    pTypeToSQLTable = psDBGetPTypeToSQLTable();
     1091
     1092    key = psDBIntToString((psU64)pType);
     1093    sqlType = psHashLookup(pTypeToSQLTable, key);
     1094    psFree(key);
     1095
     1096    psFree(pTypeToSQLTable);
     1097
     1098    psMemIncrRefCounter(sqlType);
     1099
     1100    return sqlType;
     1101}
     1102
     1103static mysqlType *psDBPTypeToMySQL(psElemType pType)
     1104{
     1105    psHash          *pTypeToMySQLTable; // type lookup table
     1106    char            *key;               // hash tmp value
     1107    mysqlType       *mType;             // mysqlType struct to return
     1108   
     1109    pTypeToMySQLTable = psDBGetPTypeToMySQLTable();
     1110
     1111    key = psDBIntToString((psU64)pType);
     1112    mType = psHashLookup(pTypeToMySQLTable, key);
     1113    psFree(key);
     1114
     1115    psFree(pTypeToMySQLTable);
     1116
     1117    psMemIncrRefCounter(mType);
     1118
     1119    return mType;
     1120}
     1121
     1122static psHash *psDBGetPTypeToSQLTable(void)
    11251123{
    11261124    static psHash   *lookupTable = NULL;
    … …  
    11521150}
    11531151
    1154 static void psDBPSToSQLTableCleanup(void)
     1152static void psDBPTypeToSQLTableCleanup(void)
    11551153{
    11561154    psHash          *lookupTable;
    11571155
    1158     lookupTable = psDBGetPSToSQLTable();
     1156    lookupTable = psDBGetPTypeToSQLTable();
    11591157
    11601158    psMemDecrRefCounter(lookupTable);
    … …  
    11621160}
    11631161
    1164 static psHash *psDBGetSQLToPSTable(void)
     1162static psHash *psDBGetSQLToPTypeTable(void)
    11651163{
    11661164    static psHash   *lookupTable = NULL;
    … …  
    11731171    if (!lookupTable) {
    11741172        // invert the PSToSQL table
    1175         psToSQLTable = psDBGetPSToSQLTable();
     1173        psToSQLTable = psDBGetPTypeToSQLTable();
    11761174        lookupTable = psHashAlloc(psToSQLTable->nbucket);
    11771175
    … …  
    11961194}
    11971195
    1198 static void psDBSQLToPSTableCleanup(void)
     1196static void psDBSQLToPTypeTableCleanup(void)
    11991197{
    12001198    psHash          *lookupTable;
    12011199
    1202     lookupTable = psDBGetSQLToPSTable();
     1200    lookupTable = psDBGetSQLToPTypeTable();
    12031201
    12041202    psMemDecrRefCounter(lookupTable);
    … …  
    12511249}
    12521250
    1253 static psHash *psDBGetPSToMySQLTable(void)
     1251static psHash *psDBGetPTypeToMySQLTable(void)
    12541252{
    12551253    static psHash   *lookupTable = NULL;
    … …  
    12821280}
    12831281
    1284 static void psDBPSToMySQLTableCleanup(void)
     1282static void psDBPTypeToMySQLTableCleanup(void)
    12851283{
    12861284    psHash          *lookupTable;
    12871285
    1288     lookupTable = psDBGetPSToMySQLTable();
     1286    lookupTable = psDBGetPTypeToMySQLTable();
    12891287
    12901288    psMemDecrRefCounter(lookupTable);
Note: See TracChangeset for help on using the changeset viewer.