IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 7654


Ignore:
Timestamp:
Jun 23, 2006, 11:11:17 AM (20 years ago)
Author:
jhoblitt
Message:

more misc cleanups: assertions & variable declarations

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/db/psDB.c

    r7652 r7654  
    1212 *  @author Joshua Hoblitt
    1313 *
    14  *  @version $Revision: 1.63 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2006-06-23 03:49:16 $
     14 *  @version $Revision: 1.64 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2006-06-23 21:11:17 $
    1616 *
    1717 *  Copyright 2005 Joshua Hoblitt, University of Hawaii
    … …  
    767767                    ...)
    768768{
     769    PS_ASSERT_PTR_NON_NULL(dbh, false);
     770    PS_ASSERT_PTR_NON_NULL(format, false);
     771
     772    char *query = NULL;
     773
     774    // Run query
    769775    va_list argPtr;
    770     char *dest = NULL;
    771 
    772     // Verify database object is not NULL
    773     if(dbh == NULL) {
    774         psError(PS_ERR_BAD_PARAMETER_NULL,true,PS_ERRORTEXT_psDB_INVALID_PSDB);
    775         return false;
    776     }
    777 
    778     // Run query
    779776    va_start(argPtr, format);
    780777    if(argPtr == NULL) {
    781         dest=psStringCopy(format);
     778        query = psStringCopy(format);
    782779    } else {
    783         int destSize = vsnprintf(dest, 0, format, argPtr);
    784         dest = psAlloc(destSize+1);
    785         vsnprintf(dest, destSize+1, format, argPtr);
     780        int destSize = vsnprintf(query, 0, format, argPtr);
     781        query = psAlloc(destSize+1);
     782        vsnprintf(query, destSize+1, format, argPtr);
    786783    }
    787784    va_end(argPtr);
    788     if (mysql_real_query(dbh->mysql, dest, (unsigned long)strlen(dest)) !=0) {
     785    if (mysql_real_query(dbh->mysql, query, (unsigned long)strlen(query)) !=0) {
    789786        //The following if statement was added to standardize outputs between platforms for testing purposes.
    790787        char mysqlTemp[165];
    … …  
    796793            psError(PS_ERR_UNKNOWN, true, PS_ERRORTEXT_psDB_SQL_QUERY_FAIL, mysql_error(dbh->mysql));
    797794        }
    798         psFree(dest);
     795        psFree(query);
    799796        return false;
    800797    }
    801798
    802     psFree(dest);
     799    psFree(query);
     800
    803801    return true;
    804802}
    … …  
    809807                            ...)
    810808{
    811     va_list argPtr;
    812     char *query = NULL;
    813 
    814809    PS_ASSERT_PTR_NON_NULL(dbh, -1);
    815810    PS_ASSERT_PTR_NON_NULL(rowSet, -1);
    816811    PS_ASSERT_PTR_NON_NULL(format, -1);
    817812
     813    char *query = NULL;
     814
    818815    // generate query string
     816    va_list argPtr;
    819817    va_start(argPtr, format);
    820818    if(argPtr == NULL) {
    … …  
    891889psArray *p_psDBFetchResult(psDB *dbh)
    892890{
     891    PS_ASSERT_PTR_NON_NULL(dbh, NULL);
     892
    893893    MYSQL_RES       *result;            // complete db result set
    894894    MYSQL_ROW       row;                // single row of db result set
    … …  
    989989                                    const psMetadata *values)
    990990{
    991     mysqlType       *mType;             // type tmp variable
    992     static bool     isNull = true;      // used in a MYSQL_BIND to indicate NULL,
    993 
    994991    PS_ASSERT_PTR_NON_NULL(mysqlRow, false);
    995992    PS_ASSERT_PTR_NON_NULL(values, false);
     993
     994    mysqlType       *mType;             // type tmp variable
     995    static bool     isNull = true;      // used in a MYSQL_BIND to indicate NULL
    996996
    997997    MYSQL_BIND *bind = mysqlRow->bind;
    … …  
    11181118static void psDBMysqlRowFree(psDBMysqlRow *mysqlRow)
    11191119{
     1120    PS_ASSERT_PTR_NON_NULL(mysqlRow, );
     1121
    11201122    MYSQL_BIND *bind = mysqlRow->bind;
    11211123
    … …  
    11381140                                        const psMetadata *table)
    11391141{
     1142    PS_ASSERT_PTR_NON_NULL(tableName, NULL);
     1143    PS_ASSERT_PTR_NON_NULL(table, NULL);
     1144
    11401145    char            *query = NULL;      // complete query
    11411146    psMetadataItem  *item;              // column description
    11421147    psListIterator  *cursor;            // column iterator
    11431148    char            *colType;           // type lookup table
    1144 
    1145     // Verify input parameters are not null
    1146     if ( (tableName==NULL) || (table==NULL) ) {
    1147         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psDB_TABLE_PARAM_NULL);
    1148         return NULL;
    1149     }
    11501149
    11511150    // Begin to create SQL string to create table
    … …  
    12371236                                      psU64 limit)
    12381237{
     1238    PS_ASSERT_PTR_NON_NULL(tableName, NULL);
     1239    PS_ASSERT_PTR_NON_NULL(col, NULL);
     1240
    12391241    char            *query = NULL;
    12401242    char            *whereSQL;
    … …  
    12751277                                      const psMetadata *row)
    12761278{
     1279    PS_ASSERT_PTR_NON_NULL(tableName, NULL);
     1280    PS_ASSERT_PTR_NON_NULL(row, NULL);
     1281
    12771282    char            *query = NULL;
    12781283    psListIterator  *cursor;
    12791284    psMetadataItem  *item;
    12801285
    1281     // Check if table is NULL
    1282     if(tableName == NULL) {
    1283         psError(PS_ERR_UNEXPECTED_NULL,true,PS_ERRORTEXT_psDB_QUERY_GEN_FAIL);
    1284         return NULL;
    1285     }
    1286 
    1287     // Check if row is NULL
    1288     if(row == NULL) {
    1289         psError(PS_ERR_UNEXPECTED_NULL,true,PS_ERRORTEXT_psDB_QUERY_GEN_FAIL);
    1290         return NULL;
    1291     }
    1292 
    12931286    // Start building query string
    12941287    psStringAppend(&query, "INSERT INTO %s (", tableName);
    … …  
    13331326                                      const psMetadata *values)
    13341327{
     1328    PS_ASSERT_PTR_NON_NULL(tableName, NULL);
     1329    PS_ASSERT_PTR_NON_NULL(values, NULL);
     1330
    13351331    char            *query = NULL;
    13361332    char            *setSQL;
    13371333    char            *whereSQL;
    1338 
    1339     // Verify where and values pointer are not NULL
    1340     if ((!values) || (!where)) {
    1341         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psDB_UPDATE_ROW_FAIL);
    1342         return NULL;
    1343     }
    13441334
    13451335    // Create set SQL substring
    … …  
    13691359                                      unsigned long long limit)
    13701360{
     1361    PS_ASSERT_PTR_NON_NULL(tableName, NULL);
     1362
    13711363    char            *query = NULL;
    13721364    char            *whereSQL;
    … …  
    14021394static char *psDBGenerateWhereSQL(const psMetadata *where)
    14031395{
    1404     char            *query = NULL;
    1405 
    1406     if (!where) {
    1407         psError(PS_ERR_BAD_PARAMETER_NULL, true, "where param may not be NULL.");
    1408         return NULL;
    1409     }
    1410 
    1411     query = psStringCopy("WHERE ");
     1396    PS_ASSERT_PTR_NON_NULL(where, NULL);
     1397
     1398    char *query = psStringCopy("WHERE ");
    14121399
    14131400    // we need to know if an item is 'MULTI' so we have to march through the
    … …  
    14941481                               )
    14951482{
    1496     char            *query = NULL;
    1497     psListIterator  *cursor;
    1498     psMetadataItem  *item;
    1499 
    1500     if (!set
    1501        ) {
    1502         psError(PS_ERR_BAD_PARAMETER_NULL, true, "set param may not be NULL.");
    1503 
    1504         return NULL;
    1505     }
    1506 
    1507     query = psStringCopy("SET ");
    1508 
    1509     cursor = psListIteratorAlloc(set
    1510                                  ->list, 0, false);
     1483    PS_ASSERT_PTR_NON_NULL(set
     1484                           , NULL);
     1485
     1486    char *query = psStringCopy("SET ");
     1487
     1488    psListIterator *cursor = psListIteratorAlloc(set
     1489                             ->list, 0, false);
    15111490
    15121491    // find column name
     1492    psMetadataItem *item = NULL;
    15131493    while ((item = psListGetAndIncrement(cursor))) {
    15141494        // + column name + _ + = + _ + ?
    … …  
    15281508static char *psDBGenerateConditionalSQL(const psMetadataItem *item)
    15291509{
    1530     char            *query = NULL;
    1531 
    15321510    PS_ASSERT_PTR_NON_NULL(item, NULL);
     1511
     1512    char *query = NULL;
    15331513
    15341514    // stringify the psMetadataItem into a SQL search specification
    … …  
    18621842                                bool isUnsigned)
    18631843{
    1864     mysqlType       *mType;
    1865 
    1866     mType = psAlloc(sizeof(mysqlType));
     1844    mysqlType *mType = psAlloc(sizeof(mysqlType));
    18671845    mType->type       = type;
    18681846    mType->isUnsigned = isUnsigned;
    … …  
    18751853                                 const char *string)
    18761854{
    1877     char            *key;
    1878     char            *value;
    1879 
    1880     key = psDBIntToString((psU64)type);
    1881     value = psStringCopy(string);
     1855    PS_ASSERT_PTR_NON_NULL(lookupTable, );
     1856
     1857    char *key = psDBIntToString((psU64)type);
     1858    char *value = psStringCopy(string);
    18821859
    18831860    psHashAdd(lookupTable, key, value);
    … …  
    18911868                                     psPtr value)
    18921869{
    1893     char            *key;
    1894 
    1895     key = psDBIntToString((psU64)type);
     1870    PS_ASSERT_PTR_NON_NULL(lookupTable, );
     1871
     1872    char *key = psDBIntToString((psU64)type);
    18961873
    18971874    psHashAdd(lookupTable, key, value);
    … …  
    20232000static char *psDBIntToString(psU64 n)
    20242001{
    2025     char            *string;
    2026     size_t          length;
    2027 
    20282002    // length of string + \0
    20292003    // if n is 0, length is 1 char + \0
    2030     length = n ? (size_t)log10((double)n) + 1
    2031              : 2;
    2032     string = psAlloc(length);
     2004    size_t length = n ? (size_t)log10((double)n) + 1
     2005                    : 2;
     2006    char *string = psAlloc(length);
    20332007    sprintf(string, "%li", (long int)n);
    20342008
Note: See TracChangeset for help on using the changeset viewer.