Index: /trunk/archive/psdb/psDB.c =================================================================== --- /trunk/archive/psdb/psDB.c (revision 3137) +++ /trunk/archive/psdb/psDB.c (revision 3138) @@ -8,6 +8,6 @@ * @author Joshua Hoblitt * - * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-02-05 00:57:49 $ + * @version $Revision: 1.5 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-02-05 01:01:57 $ * * Copyright 2005 Joshua Hoblitt, University of Hawaii @@ -29,24 +29,24 @@ } mysqlType; -static char *p_psDBIntToString(psU64 n); -static void p_psDBAddToLookupTable(psHash *lookupTable, const psU32 type, const char *string); -static psHash *p_psDBGetMySQLToSQLTable(void); -static void p_psDBMySQLToSQLTableCleanup(void); -static psHash *p_psDBGetPSToSQLTable(void); -static void p_psDBPSToSQLTableCleanup(void); -static psHash *p_psDBGetSQLToPSTable(void); -static void p_psDBSQLToPSTableCleanup(void); -static void p_psDBPSToMySQLTableCleanup(void); -static size_t p_psStringAppend(char **dest, const char *source); -static bool p_psDBRunQuery(psDB *dbh, const char *query); -static char *p_psDBGenerateWhereSQL(psMetadata *where); -static size_t p_psStringPrepend(char **dest, const char *source); -static psPtr p_psDBGetPTypeNull(psElemType pType); -static char *p_psDBGenerateInsertRowSQL(const char *tableName, psMetadata *row); -static char *p_psDBPTypeAsString(psPtr data, psElemType pType); -static char *p_psDBGenerateCreateTableSQL(const char *tableName, psMetadata *where); -static char *p_psDBGenerateSelectColumnSQL(const char *tableName, const char *col, const psU64 limit); -static char *p_psDBGenerateSelectRowsSQL(const char *tableName, psMetadata *where); -static psPtr p_psDBAllocMySQLType(enum enum_field_types type, bool isUnsigned); +static char *psDBIntToString(psU64 n); +static void psDBAddToLookupTable(psHash *lookupTable, const psU32 type, const char *string); +static psHash *psDBGetMySQLToSQLTable(void); +static void psDBMySQLToSQLTableCleanup(void); +static psHash *psDBGetPSToSQLTable(void); +static void psDBPSToSQLTableCleanup(void); +static psHash *psDBGetSQLToPSTable(void); +static void psDBSQLToPSTableCleanup(void); +static void psDBPSToMySQLTableCleanup(void); +static size_t psStringAppend(char **dest, const char *source); +static bool psDBRunQuery(psDB *dbh, const char *query); +static char *psDBGenerateWhereSQL(psMetadata *where); +static size_t psStringPrepend(char **dest, const char *source); +static psPtr psDBGetPTypeNull(psElemType pType); +static char *psDBGenerateInsertRowSQL(const char *tableName, psMetadata *row); +static char *psDBPTypeAsString(psPtr data, psElemType pType); +static char *psDBGenerateCreateTableSQL(const char *tableName, psMetadata *where); +static char *psDBGenerateSelectColumnSQL(const char *tableName, const char *col, const psU64 limit); +static char *psDBGenerateSelectRowsSQL(const char *tableName, psMetadata *where); +static psPtr psDBAllocMySQLType(enum enum_field_types type, bool isUnsigned); psDB *psDBInit(const char *host, const char *user, const char *passwd, const char *dbname) @@ -77,8 +77,8 @@ // these lookup tables should probably be moved into psDB - p_psDBMySQLToSQLTableCleanup(); - p_psDBPSToSQLTableCleanup(); - p_psDBSQLToPSTableCleanup(); - p_psDBPSToMySQLTableCleanup(); + psDBMySQLToSQLTableCleanup(); + psDBPSToSQLTableCleanup(); + psDBSQLToPSTableCleanup(); + psDBPSToMySQLTableCleanup(); } @@ -90,8 +90,8 @@ // init query with a psMemBlock query = psStringCopy("CREATE DATABASE "); - p_psStringAppend(&query, dbname); + psStringAppend(&query, dbname); // the MySQL C API notes that mysql_create_db() is deprecated - status = p_psDBRunQuery(dbh, query); + status = psDBRunQuery(dbh, query); psFree(query); @@ -118,8 +118,8 @@ // init query with a psMemBlock query = psStringCopy("DROP DATABASE "); - p_psStringAppend(&query, dbname); + psStringAppend(&query, dbname); - // the MySQL C API notes that mysql_drop_db() is deprecated - status = p_psDBRunQuery(dbh, query); + // the MySQL C API notes that mysql_drodb() is deprecated + status = psDBRunQuery(dbh, query); psFree(query); @@ -133,9 +133,9 @@ bool status; - query = p_psDBGenerateCreateTableSQL(tableName, md); + query = psDBGenerateCreateTableSQL(tableName, md); fprintf(stderr, "complete query is: %s\n", query); - status = p_psDBRunQuery(dbh, query); + status = psDBRunQuery(dbh, query); psFree(query); @@ -150,7 +150,7 @@ // init query with a psMemBlock query = psStringCopy("DROP TABLE "); - p_psStringAppend(&query, tableName); - - status = p_psDBRunQuery(dbh, query); + psStringAppend(&query, tableName); + + status = psDBRunQuery(dbh, query); psFree(query); @@ -170,7 +170,7 @@ psPtr data; - query = p_psDBGenerateSelectColumnSQL(tableName, col, limit); - - if (p_psDBRunQuery(dbh, query)) { + query = psDBGenerateSelectColumnSQL(tableName, col, limit); + + if (psDBRunQuery(dbh, query)) { result = mysql_store_result(dbh->mysql); } else { @@ -232,5 +232,5 @@ a = (d)(strlen(b->data[i]) \ ? atoi(b->data[i]) \ - : *(d *)p_psDBGetPTypeNull(e)); \ + : *(d *)psDBGetPTypeNull(e)); \ } @@ -326,9 +326,9 @@ psPtr data; - query = p_psDBGenerateSelectRowsSQL(tableName, where); + query = psDBGenerateSelectRowsSQL(tableName, where); fprintf(stderr, "complete query is: %s\n", query); - if (p_psDBRunQuery(dbh, query)) { + if (psDBRunQuery(dbh, query)) { result = mysql_store_result(dbh->mysql); } else { @@ -351,6 +351,6 @@ fieldCount = mysql_num_fields(result); - mysqlToSQLTable = p_psDBGetMySQLToSQLTable(); - sqlToPSTable = p_psDBGetSQLToPSTable(); + mysqlToSQLTable = psDBGetMySQLToSQLTable(); + sqlToPSTable = psDBGetSQLToPSTable(); while ((row = mysql_fetch_row(result))) { @@ -363,5 +363,5 @@ // as the the mysql types do not tell you if the value is // signed or unsigned - key = p_psDBIntToString((psU64)field[i].type); + key = psDBIntToString((psU64)field[i].type); value = psHashLookup(mysqlToSQLTable, key); sqlType = psStringCopy(value); @@ -369,5 +369,5 @@ if (field->flags & UNSIGNED_FLAG) { - p_psStringPrepend(&sqlType, "UNSIGNED "); + psStringPrepend(&sqlType, "UNSIGNED "); } @@ -383,5 +383,5 @@ type = PS_META_STR; data = fieldLength[i] ? psStringNCopy(row[i], fieldLength[i]) - : p_psDBGetPTypeNull(pType); + : psDBGetPTypeNull(pType); } else { type = PS_META_PRIMITIVE; @@ -390,5 +390,5 @@ memcpy(data, row[i], fieldLength[i]); } else { - data = p_psDBGetPTypeNull(pType); + data = psDBGetPTypeNull(pType); } } @@ -435,5 +435,5 @@ psU32 paramCount; - query = p_psDBGenerateInsertRowSQL(tableName, row); + query = psDBGenerateInsertRowSQL(tableName, row); fprintf(stderr, "complete query is: %s\n", query); @@ -484,5 +484,5 @@ } -static char *p_psDBGenerateInsertRowSQL(const char *tableName, psMetadata *row) +static char *psDBGenerateInsertRowSQL(const char *tableName, psMetadata *row) { char *query; @@ -492,6 +492,6 @@ // init query with a psMemBlock query = psStringCopy("INSERT INTO "); - p_psStringAppend(&query, tableName); - p_psStringAppend(&query, " ("); + psStringAppend(&query, tableName); + psStringAppend(&query, " ("); cursor = psListIteratorAlloc(row->list, 0); @@ -499,13 +499,13 @@ // get field names while ((item = psListGetNext(cursor))) { - p_psStringAppend(&query, item->name); + psStringAppend(&query, item->name); if (!cursor->offEnd) { // + , + _ - p_psStringAppend(&query, ", "); - } - } - - p_psStringAppend(&query, ") VALUES ("); + psStringAppend(&query, ", "); + } + } + + psStringAppend(&query, ") VALUES ("); psListIteratorSet(cursor, 0); @@ -513,9 +513,9 @@ // create field place holders while ((item = psListGetNext(cursor))) { - p_psStringAppend(&query, "?"); + psStringAppend(&query, "?"); if (!cursor->offEnd) { // + , + _ - p_psStringAppend(&query, ", "); + psStringAppend(&query, ", "); } } @@ -523,10 +523,10 @@ psFree(cursor); - p_psStringAppend(&query, ")"); + psStringAppend(&query, ")"); return query; } -static char *p_psDBGenerateWhereSQL(psMetadata *where) +static char *psDBGenerateWhereSQL(psMetadata *where) { char *query; @@ -545,11 +545,11 @@ if (item->type == PS_META_STR) { // + column name + _ + like + _ + ' + value + ' - p_psStringAppend(&query, item->name); + psStringAppend(&query, item->name); if (*(char *)item->data.V == '\0') { - p_psStringAppend(&query, " IS NULL"); + psStringAppend(&query, " IS NULL"); } else { - p_psStringAppend(&query, " LIKE '"); - p_psStringAppend(&query, item->data.V); - p_psStringAppend(&query, "'"); + psStringAppend(&query, " LIKE '"); + psStringAppend(&query, item->data.V); + psStringAppend(&query, "'"); } } else { @@ -564,5 +564,5 @@ if (!cursor->offEnd) { // + and - p_psStringAppend(&query, " AND "); + psStringAppend(&query, " AND "); } } @@ -573,5 +573,5 @@ } -static char *p_psDBGenerateCreateTableSQL(const char *tableName, psMetadata *table) +static char *psDBGenerateCreateTableSQL(const char *tableName, psMetadata *table) { psMetadataItem *item; @@ -586,10 +586,10 @@ // + _ + tableName + _ + ( - p_psStringAppend(&query, " "); - p_psStringAppend(&query, tableName); - p_psStringAppend(&query, " ("); + psStringAppend(&query, " "); + psStringAppend(&query, tableName); + psStringAppend(&query, " ("); // get pType lookup table - colType = p_psDBGetPSToSQLTable(); + colType = psDBGetPSToSQLTable(); // get Metadata iterator @@ -599,20 +599,20 @@ while ((item = psListGetNext(cursor))) { // + column name + _ - p_psStringAppend(&query, item->name); - p_psStringAppend(&query, " "); + psStringAppend(&query, item->name); + psStringAppend(&query, " "); if (item->type == PS_META_PRIMITIVE) { // lookup SQL column type - key = p_psDBIntToString((psU64)item->pType); + key = psDBIntToString((psU64)item->pType); value = psHashLookup(colType, key); psFree(key); // + column type - p_psStringAppend(&query, value); + psStringAppend(&query, value); } else if (item->type == PS_META_STR) { // + varchar( + length + ) - p_psStringAppend(&query, "varchar("); - p_psStringAppend(&query, item->data.V); - p_psStringAppend(&query, ")"); + psStringAppend(&query, "varchar("); + psStringAppend(&query, item->data.V); + psStringAppend(&query, ")"); } else { // error @@ -622,5 +622,5 @@ if (!cursor->offEnd) { // + , - p_psStringAppend(&query, ", "); + psStringAppend(&query, ", "); } } @@ -633,11 +633,11 @@ while ((item = psListGetNext(cursor))) { if ((strncmp(item->comment, "Primary Key", strlen("Primary Key"))) == 0) { - p_psStringAppend(&query, ", PRIMARY KEY("); - p_psStringAppend(&query, item->name); - p_psStringAppend(&query, ")"); + psStringAppend(&query, ", PRIMARY KEY("); + psStringAppend(&query, item->name); + psStringAppend(&query, ")"); } else if ((strncmp(item->comment, "Key", strlen("Key"))) == 0) { - p_psStringAppend(&query, ", KEY("); - p_psStringAppend(&query, item->name); - p_psStringAppend(&query, ")"); + psStringAppend(&query, ", KEY("); + psStringAppend(&query, item->name); + psStringAppend(&query, ")"); } } @@ -646,10 +646,10 @@ // + ) + _ + ENGINE=innodb; - p_psStringAppend(&query, ") ENGINE=innodb"); + psStringAppend(&query, ") ENGINE=innodb"); return query; } -static char *p_psDBGenerateSelectColumnSQL(const char *tableName, const char *col, const psU64 limit) +static char *psDBGenerateSelectColumnSQL(const char *tableName, const char *col, const psU64 limit) { char *query; @@ -658,12 +658,12 @@ // init query with a psMemBlock query = psStringCopy("SELECT "); - p_psStringAppend(&query, col); - p_psStringAppend(&query, " FROM "); - p_psStringAppend(&query, tableName); + psStringAppend(&query, col); + psStringAppend(&query, " FROM "); + psStringAppend(&query, tableName); if (limit) { - p_psStringAppend(&query, " LIMIT "); - limitString = p_psDBIntToString(limit); - p_psStringAppend(&query, limitString); + psStringAppend(&query, " LIMIT "); + limitString = psDBIntToString(limit); + psStringAppend(&query, limitString); psFree(limitString); } @@ -672,5 +672,5 @@ } -static char *p_psDBGenerateSelectRowsSQL(const char *tableName, psMetadata *where) +static char *psDBGenerateSelectRowsSQL(const char *tableName, psMetadata *where) { char *query; @@ -679,10 +679,10 @@ // init query with a psMemBlock query = psStringCopy("SELECT * FROM "); - p_psStringAppend(&query, tableName); - p_psStringAppend(&query, " "); - - string = p_psDBGenerateWhereSQL(where); + psStringAppend(&query, tableName); + psStringAppend(&query, " "); + + string = psDBGenerateWhereSQL(where); // FIXME check for error - p_psStringAppend(&query, string); + psStringAppend(&query, string); psFree(string); @@ -693,5 +693,5 @@ *(a *)myNaN = b; -static psPtr p_psDBGetPTypeNull(psElemType pType) +static psPtr psDBGetPTypeNull(psElemType pType) { psPtr myNaN; @@ -752,5 +752,5 @@ snprintf(string, length, b, *(a *)data); -static char *p_psDBPTypeAsString(psPtr data, psElemType pType) +static char *psDBPTypeAsString(psPtr data, psElemType pType) { size_t length; @@ -805,5 +805,5 @@ } -static bool p_psDBRunQuery(psDB *dbh, const char *query) +static bool psDBRunQuery(psDB *dbh, const char *query) { if (mysql_real_query(dbh->mysql, query, (unsigned long)strlen(query)) !=0) { @@ -816,5 +816,5 @@ } -static size_t p_psStringAppend(char **dest, const char *source) +static size_t psStringAppend(char **dest, const char *source) { size_t newSize; @@ -830,5 +830,5 @@ } -static size_t p_psStringPrepend(char **dest, const char *source) +static size_t psStringPrepend(char **dest, const char *source) { size_t newSize; @@ -853,5 +853,5 @@ } -static psHash *p_psDBGetPSToSQLTable(void) +static psHash *psDBGetPSToSQLTable(void) { static psHash *lookupTable = NULL; @@ -860,19 +860,19 @@ lookupTable = psHashAlloc(14); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_S8, "TINYINT"); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_S16, "SMALLINT"); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_S32, "INT"); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_S64, "BIGINT"); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_U8, "UNSIGNED TINYINT"); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_U16, "UNSIGNED SMALLINT"); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_U32, "UNSIGNED INT"); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_U64, "UNSIGNED BIGINT"); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_F32, "FLOAT"); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_F64, "DOUBLE"); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_C32, "PS_TYPE_C32 is not supported"); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_C64, "PS_TYPE_C64 is not supported"); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_BOOL,"BOOLEAN"); + psDBAddToLookupTable(lookupTable, PS_TYPE_S8, "TINYINT"); + psDBAddToLookupTable(lookupTable, PS_TYPE_S16, "SMALLINT"); + psDBAddToLookupTable(lookupTable, PS_TYPE_S32, "INT"); + psDBAddToLookupTable(lookupTable, PS_TYPE_S64, "BIGINT"); + psDBAddToLookupTable(lookupTable, PS_TYPE_U8, "UNSIGNED TINYINT"); + psDBAddToLookupTable(lookupTable, PS_TYPE_U16, "UNSIGNED SMALLINT"); + psDBAddToLookupTable(lookupTable, PS_TYPE_U32, "UNSIGNED INT"); + psDBAddToLookupTable(lookupTable, PS_TYPE_U64, "UNSIGNED BIGINT"); + psDBAddToLookupTable(lookupTable, PS_TYPE_F32, "FLOAT"); + psDBAddToLookupTable(lookupTable, PS_TYPE_F64, "DOUBLE"); + psDBAddToLookupTable(lookupTable, PS_TYPE_C32, "PS_TYPE_C32 is not supported"); + psDBAddToLookupTable(lookupTable, PS_TYPE_C64, "PS_TYPE_C64 is not supported"); + psDBAddToLookupTable(lookupTable, PS_TYPE_BOOL,"BOOLEAN"); // no support for CHAR, TEXT or GLOB - p_psDBAddToLookupTable(lookupTable, PS_TYPE_PTR, "VARCHAR"); + psDBAddToLookupTable(lookupTable, PS_TYPE_PTR, "VARCHAR"); } @@ -883,9 +883,9 @@ } -static void p_psDBPSToSQLTableCleanup(void) +static void psDBPSToSQLTableCleanup(void) { psHash *lookupTable; - lookupTable = p_psDBGetPSToSQLTable(); + lookupTable = psDBGetPSToSQLTable(); psMemDecrRefCounter(lookupTable); @@ -893,5 +893,5 @@ } -static psHash *p_psDBGetSQLToPSTable(void) +static psHash *psDBGetSQLToPSTable(void) { static psHash *lookupTable = NULL; @@ -904,5 +904,5 @@ if (!lookupTable) { // invert the PSToSQL table - psToSQLTable = p_psDBGetPSToSQLTable(); + psToSQLTable = psDBGetPSToSQLTable(); lookupTable = psHashAlloc(psToSQLTable->nbucket); @@ -927,9 +927,9 @@ } -static void p_psDBSQLToPSTableCleanup(void) +static void psDBSQLToPSTableCleanup(void) { psHash *lookupTable; - lookupTable = p_psDBGetSQLToPSTable(); + lookupTable = psDBGetSQLToPSTable(); psMemDecrRefCounter(lookupTable); @@ -937,5 +937,5 @@ } -static psHash *p_psDBGetMySQLToSQLTable(void) +static psHash *psDBGetMySQLToSQLTable(void) { static psHash *lookupTable = NULL; @@ -944,24 +944,24 @@ lookupTable = psHashAlloc(20); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_TINY, "TINYINT"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_SHORT, "SMALLINT"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_LONG, "INT"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_INT24, "MEDIUMINT"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_LONGLONG, "BIGINT"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_DECIMAL, "DECIMAL"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_FLOAT, "FLOAT"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_DOUBLE, "DOUBLE"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_TIMESTAMP, "TIMESTAMP"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_DATE, "DATE"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_TIME, "TIME"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_DATETIME, "DATETIME"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_YEAR, "YEAR"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_STRING, "CHAR"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_VAR_STRING,"VARCHAR"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_BLOB, "BLOB"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_SET, "SET"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_ENUM, "ENUM"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_NULL, "NULL-type"); - p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_CHAR, "TINYINT"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_TINY, "TINYINT"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_SHORT, "SMALLINT"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_LONG, "INT"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_INT24, "MEDIUMINT"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_LONGLONG, "BIGINT"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_DECIMAL, "DECIMAL"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_FLOAT, "FLOAT"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_DOUBLE, "DOUBLE"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_TIMESTAMP, "TIMESTAMP"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_DATE, "DATE"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_TIME, "TIME"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_DATETIME, "DATETIME"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_YEAR, "YEAR"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_STRING, "CHAR"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_VAR_STRING,"VARCHAR"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_BLOB, "BLOB"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_SET, "SET"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_ENUM, "ENUM"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_NULL, "NULL-type"); + psDBAddToLookupTable(lookupTable, FIELD_TYPE_CHAR, "TINYINT"); } @@ -972,9 +972,9 @@ } -static void p_psDBMySQLToSQLTableCleanup(void) +static void psDBMySQLToSQLTableCleanup(void) { psHash *lookupTable; - lookupTable = p_psDBGetMySQLToSQLTable(); + lookupTable = psDBGetMySQLToSQLTable(); psMemDecrRefCounter(lookupTable); @@ -982,5 +982,5 @@ } -static psHash *p_psDBGetPSToMySQLTable(void) +static psHash *psDBGetPSToMySQLTable(void) { static psHash *lookupTable = NULL; @@ -989,18 +989,18 @@ lookupTable = psHashAlloc(16); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_S8, p_psDBAllocMySQLType(MYSQL_TYPE_TINY, false)); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_S16, p_psDBAllocMySQLType(MYSQL_TYPE_SHORT, false)); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_S32, p_psDBAllocMySQLType(MYSQL_TYPE_LONG, false)); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_S64, p_psDBAllocMySQLType(MYSQL_TYPE_LONGLONG, false)); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_U8, p_psDBAllocMySQLType(MYSQL_TYPE_TINY, true)); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_U16, p_psDBAllocMySQLType(MYSQL_TYPE_SHORT, true)); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_U32, p_psDBAllocMySQLType(MYSQL_TYPE_LONG, true)); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_U64, p_psDBAllocMySQLType(MYSQL_TYPE_LONGLONG, true)); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_F32, p_psDBAllocMySQLType(MYSQL_TYPE_FLOAT, false)); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_F64, p_psDBAllocMySQLType(MYSQL_TYPE_DOUBLE, false)); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_C32, NULL); // unsupported - p_psDBAddToLookupTable(lookupTable, PS_TYPE_C64, NULL); // unsupported - p_psDBAddToLookupTable(lookupTable, PS_TYPE_BOOL, p_psDBAllocMySQLType(MYSQL_TYPE_TINY, true)); - p_psDBAddToLookupTable(lookupTable, PS_TYPE_PTR, p_psDBAllocMySQLType(MYSQL_TYPE_VAR_STRING, false)); + psDBAddToLookupTable(lookupTable, PS_TYPE_S8, psDBAllocMySQLType(MYSQL_TYPE_TINY, false)); + psDBAddToLookupTable(lookupTable, PS_TYPE_S16, psDBAllocMySQLType(MYSQL_TYPE_SHORT, false)); + psDBAddToLookupTable(lookupTable, PS_TYPE_S32, psDBAllocMySQLType(MYSQL_TYPE_LONG, false)); + psDBAddToLookupTable(lookupTable, PS_TYPE_S64, psDBAllocMySQLType(MYSQL_TYPE_LONGLONG, false)); + psDBAddToLookupTable(lookupTable, PS_TYPE_U8, psDBAllocMySQLType(MYSQL_TYPE_TINY, true)); + psDBAddToLookupTable(lookupTable, PS_TYPE_U16, psDBAllocMySQLType(MYSQL_TYPE_SHORT, true)); + psDBAddToLookupTable(lookupTable, PS_TYPE_U32, psDBAllocMySQLType(MYSQL_TYPE_LONG, true)); + psDBAddToLookupTable(lookupTable, PS_TYPE_U64, psDBAllocMySQLType(MYSQL_TYPE_LONGLONG, true)); + psDBAddToLookupTable(lookupTable, PS_TYPE_F32, psDBAllocMySQLType(MYSQL_TYPE_FLOAT, false)); + psDBAddToLookupTable(lookupTable, PS_TYPE_F64, psDBAllocMySQLType(MYSQL_TYPE_DOUBLE, false)); + psDBAddToLookupTable(lookupTable, PS_TYPE_C32, NULL); // unsupported + psDBAddToLookupTable(lookupTable, PS_TYPE_C64, NULL); // unsupported + psDBAddToLookupTable(lookupTable, PS_TYPE_BOOL, psDBAllocMySQLType(MYSQL_TYPE_TINY, true)); + psDBAddToLookupTable(lookupTable, PS_TYPE_PTR, psDBAllocMySQLType(MYSQL_TYPE_VAR_STRING, false)); } @@ -1011,5 +1011,5 @@ } -static psPtr p_psDBAllocMySQLType(enum enum_field_types type, bool isUnsigned) +static psPtr psDBAllocMySQLType(enum enum_field_types type, bool isUnsigned) { mysqlType *mType; @@ -1022,9 +1022,9 @@ } -static void p_psDBPSToMySQLTableCleanup(void) +static void psDBPSToMySQLTableCleanup(void) { psHash *lookupTable; - lookupTable = p_psDBGetPSToMySQLTable(); + lookupTable = psDBGetPSToMySQLTable(); psMemDecrRefCounter(lookupTable); @@ -1032,10 +1032,10 @@ } -static void p_psDBAddToLookupTable(psHash *lookupTable, const psU32 type, const char *string) +static void psDBAddToLookupTable(psHash *lookupTable, const psU32 type, const char *string) { char *key; char *value; - key = p_psDBIntToString((psU64)type); + key = psDBIntToString((psU64)type); value = psStringCopy(string); @@ -1046,5 +1046,5 @@ } -static char *p_psDBIntToString(psU64 n) +static char *psDBIntToString(psU64 n) { char *string;