Index: trunk/archive/psdb/psDB.c =================================================================== --- trunk/archive/psdb/psDB.c (revision 3188) +++ trunk/archive/psdb/psDB.c (revision 3193) @@ -8,6 +8,6 @@ * @author Joshua Hoblitt * - * @version $Revision: 1.10 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-02-10 20:56:41 $ + * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-02-11 21:40:49 $ * * Copyright 2005 Joshua Hoblitt, University of Hawaii @@ -145,5 +145,5 @@ psStringAppend(&query, dbname); - // the MySQL C API notes that mysql_drodb() is deprecated + // the MySQL C API notes that mysql_drop_db() is deprecated status = psDBRunQuery(dbh, query); @@ -209,4 +209,6 @@ } + psFree(query); + result = mysql_store_result(dbh->mysql); if (!result) { @@ -214,11 +216,9 @@ fieldCount = mysql_field_count(dbh->mysql); - // if field count is zero the query should have returned no data. If - // it's non-zero then something bad has happened. + // if field count is zero the query returned no data. If it's non-zero + // then something bad has happened. if (fieldCount != 0) { // error, should have gotten data fprintf(stderr, "Query returned no data. Error: %s\n", mysql_error(dbh->mysql)); - - psFree(query); return NULL; @@ -251,5 +251,4 @@ mysql_free_result(result); - psFree(query); return column; @@ -258,5 +257,5 @@ // dest = assign too, source = source string psArray, conv = conversion function, // type = type to cast to, pType = psElemType -#define STRINGARRAYTOPTYPE(dest, source, conv, type, pType) \ +#define PS_STR_ARRAY_TO_PTYPE(dest, source, conv, type, pType) \ { \ psPtr myNaN; \ @@ -289,41 +288,40 @@ switch (pType) { case PS_TYPE_S8: - STRINGARRAYTOPTYPE(column->data.S8, stringColumn, atoi, psS8, PS_TYPE_S8); + PS_STR_ARRAY_TO_PTYPE(column->data.S8, stringColumn, atoi, psS8, PS_TYPE_S8); break; case PS_TYPE_S16: - STRINGARRAYTOPTYPE(column->data.S16, stringColumn, atoi, psS16, PS_TYPE_S16); + PS_STR_ARRAY_TO_PTYPE(column->data.S16, stringColumn, atoi, psS16, PS_TYPE_S16); break; case PS_TYPE_S32: - STRINGARRAYTOPTYPE(column->data.S32, stringColumn, atoi, psS32, PS_TYPE_S32); + PS_STR_ARRAY_TO_PTYPE(column->data.S32, stringColumn, atoi, psS32, PS_TYPE_S32); break; case PS_TYPE_S64: - STRINGARRAYTOPTYPE(column->data.S64, stringColumn, atoll, psS64, PS_TYPE_S64); + PS_STR_ARRAY_TO_PTYPE(column->data.S64, stringColumn, atoll, psS64, PS_TYPE_S64); break; case PS_TYPE_U8: - // missing from psVector in SDRS - STRINGARRAYTOPTYPE(column->data.U8, stringColumn, atoi, psU8, PS_TYPE_U8); + PS_STR_ARRAY_TO_PTYPE(column->data.U8, stringColumn, atoi, psU8, PS_TYPE_U8); break; case PS_TYPE_U16: - STRINGARRAYTOPTYPE(column->data.U16, stringColumn, atoi, psU16, PS_TYPE_U16); + PS_STR_ARRAY_TO_PTYPE(column->data.U16, stringColumn, atoi, psU16, PS_TYPE_U16); break; case PS_TYPE_U32: - STRINGARRAYTOPTYPE(column->data.U32, stringColumn, atoi, psU32, PS_TYPE_U32); + PS_STR_ARRAY_TO_PTYPE(column->data.U32, stringColumn, atoi, psU32, PS_TYPE_U32); break; case PS_TYPE_U64: - STRINGARRAYTOPTYPE(column->data.U64, stringColumn, atoll, psU64, PS_TYPE_U64); + PS_STR_ARRAY_TO_PTYPE(column->data.U64, stringColumn, atoll, psU64, PS_TYPE_U64); break; case PS_TYPE_F32: - STRINGARRAYTOPTYPE(column->data.F32, stringColumn, atof, psF32, PS_TYPE_F32); + PS_STR_ARRAY_TO_PTYPE(column->data.F32, stringColumn, atof, psF32, PS_TYPE_F32); break; case PS_TYPE_F64: - STRINGARRAYTOPTYPE(column->data.F64, stringColumn, atof, psF64, PS_TYPE_F64); + PS_STR_ARRAY_TO_PTYPE(column->data.F64, stringColumn, atof, psF64, PS_TYPE_F64); break; case PS_TYPE_C32: // this is a bogus SQL type - STRINGARRAYTOPTYPE(column->data.C32, stringColumn, atof, psC32, PS_TYPE_C32); + PS_STR_ARRAY_TO_PTYPE(column->data.C32, stringColumn, atof, psC32, PS_TYPE_C32); break; case PS_TYPE_C64: // this is a bogus SQL type - STRINGARRAYTOPTYPE(column->data.C64, stringColumn, atof, psC64, PS_TYPE_C64); + PS_STR_ARRAY_TO_PTYPE(column->data.C64, stringColumn, atof, psC64, PS_TYPE_C64); break; case PS_TYPE_BOOL: @@ -374,4 +372,6 @@ } + psFree(query); + result = mysql_store_result(dbh->mysql); if (!result) { @@ -384,6 +384,4 @@ // error, should have gotten data fprintf(stderr, "Query returned no data. Error: %s\n", mysql_error(dbh->mysql)); - - psFree(query); return NULL; @@ -462,5 +460,4 @@ mysql_free_result(result); - psFree(query); return resultSet; @@ -1049,8 +1046,11 @@ // select everything if where is NULL - if (where != NULL) { + if (!where) { psStringAppend(&query, " "); + string = psDBGenerateWhereSQL(where); - if (string == NULL) { + if (!string) { + psFree(query); + return NULL; } @@ -1062,5 +1062,5 @@ } -#define MYNAN(dest, type, nan) \ +#define PS_NAN_ALLOC(dest, type, nan) \ dest = psAlloc(sizeof(type)); \ *(type *)dest = nan; @@ -1068,44 +1068,44 @@ static psPtr psDBGetPTypeNaN(psElemType pType) { - psPtr myNaN; + psPtr PS_NAN_ALLOC; switch (pType) { case PS_TYPE_S8: - MYNAN(myNaN, psS8, PS_MAX_S8); + PS_NAN_ALLOC(myNaN, psS8, PS_MAX_S8); break; case PS_TYPE_S16: - MYNAN(myNaN, psS16, PS_MAX_S16); + PS_NAN_ALLOC(myNaN, psS16, PS_MAX_S16); break; case PS_TYPE_S32: - MYNAN(myNaN, psS32, PS_MAX_S32); + PS_NAN_ALLOC(myNaN, psS32, PS_MAX_S32); break; case PS_TYPE_S64: - MYNAN(myNaN, psS64, PS_MAX_S64); + PS_NAN_ALLOC(myNaN, psS64, PS_MAX_S64); break; case PS_TYPE_U8: - MYNAN(myNaN, psU8, PS_MAX_U8); + PS_NAN_ALLOC(myNaN, psU8, PS_MAX_U8); break; case PS_TYPE_U16: - MYNAN(myNaN, psU16, PS_MAX_U16); + PS_NAN_ALLOC(myNaN, psU16, PS_MAX_U16); break; case PS_TYPE_U32: - MYNAN(myNaN, psU32, PS_MAX_U32); + PS_NAN_ALLOC(myNaN, psU32, PS_MAX_U32); break; case PS_TYPE_U64: - MYNAN(myNaN, psU64, PS_MAX_U64); + PS_NAN_ALLOC(myNaN, psU64, PS_MAX_U64); break; case PS_TYPE_F32: - MYNAN(myNaN, psF32, NAN); + PS_NAN_ALLOC(myNaN, psF32, NAN); break; case PS_TYPE_F64: - MYNAN(myNaN, psF64, NAN); + PS_NAN_ALLOC(myNaN, psF64, NAN); break; case PS_TYPE_C32: // this is a bogus SQL type - MYNAN(myNaN, psC32, NAN); + PS_NAN_ALLOC(myNaN, psC32, NAN); break; case PS_TYPE_C64: // this is a bogus SQL type - MYNAN(myNaN, psC64, NAN); + PS_NAN_ALLOC(myNaN, psC64, NAN); break; case PS_TYPE_BOOL: @@ -1113,12 +1113,12 @@ break; case PS_TYPE_PTR: - MYNAN(myNaN, char, '\0'); - break; - } - - return myNaN; -} - -#define ISTYPENAN(type, data, nan) *(type *)data == nan + PS_NAN_ALLOC(myNaN, char, '\0'); + break; + } + + return PS_NAN_ALLOC; +} + +#define PS_IS_NAN(type, data, nan) *(type *)data == nan static bool psDBIsPTypeNaN(psElemType pType, psPtr data) @@ -1128,40 +1128,40 @@ switch (pType) { case PS_TYPE_S8: - isNaN = ISTYPENAN(psS8, data, PS_MAX_S8); + isNaN = PS_IS_NAN(psS8, data, PS_MAX_S8); break; case PS_TYPE_S16: - isNaN = ISTYPENAN(psS16, data, PS_MAX_S16); + isNaN = PS_IS_NAN(psS16, data, PS_MAX_S16); break; case PS_TYPE_S32: - isNaN = ISTYPENAN(psS32, data, PS_MAX_S32); + isNaN = PS_IS_NAN(psS32, data, PS_MAX_S32); break; case PS_TYPE_S64: - isNaN = ISTYPENAN(psS64, data, PS_MAX_S64); + isNaN = PS_IS_NAN(psS64, data, PS_MAX_S64); break; case PS_TYPE_U8: - isNaN = ISTYPENAN(psU8, data, PS_MAX_U8); + isNaN = PS_IS_NAN(psU8, data, PS_MAX_U8); break; case PS_TYPE_U16: - isNaN = ISTYPENAN(psU16, data, PS_MAX_U16); + isNaN = PS_IS_NAN(psU16, data, PS_MAX_U16); break; case PS_TYPE_U32: - isNaN = ISTYPENAN(psU32, data, PS_MAX_U32); + isNaN = PS_IS_NAN(psU32, data, PS_MAX_U32); break; case PS_TYPE_U64: - isNaN = ISTYPENAN(psU64, data, PS_MAX_U64); + isNaN = PS_IS_NAN(psU64, data, PS_MAX_U64); break; case PS_TYPE_F32: - isNaN = ISTYPENAN(psF32, data, NAN); + isNaN = PS_IS_NAN(psF32, data, NAN); break; case PS_TYPE_F64: - isNaN = ISTYPENAN(psF64, data, NAN); + isNaN = PS_IS_NAN(psF64, data, NAN); break; case PS_TYPE_C32: // this is a bogus SQL type - isNaN = ISTYPENAN(psC32, data, NAN); + isNaN = PS_IS_NAN(psC32, data, NAN); break; case PS_TYPE_C64: // this is a bogus SQL type - isNaN = ISTYPENAN(psC64, data, NAN); + isNaN = PS_IS_NAN(psC64, data, NAN); break; case PS_TYPE_BOOL: @@ -1169,5 +1169,5 @@ break; case PS_TYPE_PTR: - isNaN = ISTYPENAN(char, data, '\0'); + isNaN = PS_IS_NAN(char, data, '\0'); break; } @@ -1176,5 +1176,5 @@ } -#define TYPETOSTRING(type, format, data) \ +#define PS_PTYPE_TO_STR(type, format, data) \ (size_t)log10((double)*(type *)data) + 1; \ string = psAlloc(length); \ @@ -1189,32 +1189,32 @@ switch (pType) { case PS_TYPE_S8: - length = TYPETOSTRING(psS8, "%i", data); + length = PS_PTYPE_TO_STR(psS8, "%i", data); break; case PS_TYPE_S16: - length = TYPETOSTRING(psS16, "%i", data); + length = PS_PTYPE_TO_STR(psS16, "%i", data); break; case PS_TYPE_S32: - length = TYPETOSTRING(psS32, "%i", data); + length = PS_PTYPE_TO_STR(psS32, "%i", data); break; case PS_TYPE_S64: - length = TYPETOSTRING(psS64, "%li", data); + length = PS_PTYPE_TO_STR(psS64, "%li", data); break; case PS_TYPE_U8: - length = TYPETOSTRING(psU8, "%u", data); + length = PS_PTYPE_TO_STR(psU8, "%u", data); break; case PS_TYPE_U16: - length = TYPETOSTRING(psU16, "%u", data); + length = PS_PTYPE_TO_STR(psU16, "%u", data); break; case PS_TYPE_U32: - length = TYPETOSTRING(psU32, "%u", data); + length = PS_PTYPE_TO_STR(psU32, "%u", data); break; case PS_TYPE_U64: - length = TYPETOSTRING(psU64, "%lu", data); + length = PS_PTYPE_TO_STR(psU64, "%lu", data); break; case PS_TYPE_F32: - length = TYPETOSTRING(psF32, "%f", data); + length = PS_PTYPE_TO_STR(psF32, "%f", data); break; case PS_TYPE_F64: - length = TYPETOSTRING(psF32, "%f", data); + length = PS_PTYPE_TO_STR(psF32, "%f", data); break; case PS_TYPE_C32: @@ -1225,5 +1225,5 @@ break; case PS_TYPE_BOOL: - length = TYPETOSTRING(bool, "%u", data); + length = PS_PTYPE_TO_STR(bool, "%u", data); break; case PS_TYPE_PTR: