IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 3138


Ignore:
Timestamp:
Feb 4, 2005, 3:01:57 PM (21 years ago)
Author:
jhoblitt
Message:

remove all p_ prefixes from function names

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/archive/psdb/psDB.c

    r3137 r3138  
    88 *  @author Joshua Hoblitt
    99 *
    10  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2005-02-05 00:57:49 $
     10 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2005-02-05 01:01:57 $
    1212 *
    1313 *  Copyright 2005 Joshua Hoblitt, University of Hawaii
    … …  
    2929} mysqlType;
    3030
    31 static char *p_psDBIntToString(psU64 n);
    32 static void p_psDBAddToLookupTable(psHash *lookupTable, const psU32 type, const char *string);
    33 static psHash *p_psDBGetMySQLToSQLTable(void);
    34 static void p_psDBMySQLToSQLTableCleanup(void);
    35 static psHash *p_psDBGetPSToSQLTable(void);
    36 static void p_psDBPSToSQLTableCleanup(void);
    37 static psHash *p_psDBGetSQLToPSTable(void);
    38 static void p_psDBSQLToPSTableCleanup(void);
    39 static void p_psDBPSToMySQLTableCleanup(void);
    40 static size_t p_psStringAppend(char **dest, const char *source);
    41 static bool p_psDBRunQuery(psDB *dbh, const char *query);
    42 static char *p_psDBGenerateWhereSQL(psMetadata *where);
    43 static size_t p_psStringPrepend(char **dest, const char *source);
    44 static psPtr p_psDBGetPTypeNull(psElemType pType);
    45 static char *p_psDBGenerateInsertRowSQL(const char *tableName, psMetadata *row);
    46 static char *p_psDBPTypeAsString(psPtr data, psElemType pType);
    47 static char *p_psDBGenerateCreateTableSQL(const char *tableName, psMetadata *where);
    48 static char *p_psDBGenerateSelectColumnSQL(const char *tableName, const char *col, const psU64 limit);
    49 static char *p_psDBGenerateSelectRowsSQL(const char *tableName, psMetadata *where);
    50 static psPtr p_psDBAllocMySQLType(enum enum_field_types type, bool isUnsigned);
     31static char *psDBIntToString(psU64 n);
     32static void psDBAddToLookupTable(psHash *lookupTable, const psU32 type, const char *string);
     33static psHash *psDBGetMySQLToSQLTable(void);
     34static void psDBMySQLToSQLTableCleanup(void);
     35static psHash *psDBGetPSToSQLTable(void);
     36static void psDBPSToSQLTableCleanup(void);
     37static psHash *psDBGetSQLToPSTable(void);
     38static void psDBSQLToPSTableCleanup(void);
     39static void psDBPSToMySQLTableCleanup(void);
     40static size_t psStringAppend(char **dest, const char *source);
     41static bool psDBRunQuery(psDB *dbh, const char *query);
     42static char *psDBGenerateWhereSQL(psMetadata *where);
     43static size_t psStringPrepend(char **dest, const char *source);
     44static psPtr psDBGetPTypeNull(psElemType pType);
     45static char *psDBGenerateInsertRowSQL(const char *tableName, psMetadata *row);
     46static char *psDBPTypeAsString(psPtr data, psElemType pType);
     47static char *psDBGenerateCreateTableSQL(const char *tableName, psMetadata *where);
     48static char *psDBGenerateSelectColumnSQL(const char *tableName, const char *col, const psU64 limit);
     49static char *psDBGenerateSelectRowsSQL(const char *tableName, psMetadata *where);
     50static psPtr psDBAllocMySQLType(enum enum_field_types type, bool isUnsigned);
    5151
    5252psDB *psDBInit(const char *host, const char *user, const char *passwd, const char *dbname)
    … …  
    7777
    7878    // these lookup tables should probably be moved into psDB
    79     p_psDBMySQLToSQLTableCleanup();
    80     p_psDBPSToSQLTableCleanup();
    81     p_psDBSQLToPSTableCleanup();
    82     p_psDBPSToMySQLTableCleanup();
     79    psDBMySQLToSQLTableCleanup();
     80    psDBPSToSQLTableCleanup();
     81    psDBSQLToPSTableCleanup();
     82    psDBPSToMySQLTableCleanup();
    8383}
    8484
    … …  
    9090    // init query with a psMemBlock
    9191    query = psStringCopy("CREATE DATABASE ");
    92     p_psStringAppend(&query, dbname);
     92    psStringAppend(&query, dbname);
    9393
    9494    // the MySQL C API notes that mysql_create_db() is deprecated
    95     status = p_psDBRunQuery(dbh, query);
     95    status = psDBRunQuery(dbh, query);
    9696
    9797    psFree(query);
    … …  
    118118    // init query with a psMemBlock
    119119    query = psStringCopy("DROP DATABASE ");
    120     p_psStringAppend(&query, dbname);
     120    psStringAppend(&query, dbname);
    121121   
    122     // the MySQL C API notes that mysql_drop_db() is deprecated
    123     status = p_psDBRunQuery(dbh, query);
     122    // the MySQL C API notes that mysql_drodb() is deprecated
     123    status = psDBRunQuery(dbh, query);
    124124
    125125    psFree(query);
    … …  
    133133    bool            status;
    134134
    135     query = p_psDBGenerateCreateTableSQL(tableName, md);
     135    query = psDBGenerateCreateTableSQL(tableName, md);
    136136
    137137    fprintf(stderr, "complete query is: %s\n", query);
    138138
    139     status = p_psDBRunQuery(dbh, query);
     139    status = psDBRunQuery(dbh, query);
    140140    psFree(query);
    141141
    … …  
    150150    // init query with a psMemBlock
    151151    query = psStringCopy("DROP TABLE ");
    152     p_psStringAppend(&query, tableName);
    153 
    154     status = p_psDBRunQuery(dbh, query);
     152    psStringAppend(&query, tableName);
     153
     154    status = psDBRunQuery(dbh, query);
    155155
    156156    psFree(query);
    … …  
    170170    psPtr           data;
    171171
    172     query = p_psDBGenerateSelectColumnSQL(tableName, col, limit);
    173 
    174     if (p_psDBRunQuery(dbh, query)) {
     172    query = psDBGenerateSelectColumnSQL(tableName, col, limit);
     173
     174    if (psDBRunQuery(dbh, query)) {
    175175        result = mysql_store_result(dbh->mysql);
    176176    } else {
    … …  
    232232                                                a = (d)(strlen(b->data[i]) \
    233233                                                  ? atoi(b->data[i]) \
    234                                                   : *(d *)p_psDBGetPTypeNull(e)); \
     234                                                  : *(d *)psDBGetPTypeNull(e)); \
    235235                                            }
    236236
    … …  
    326326    psPtr           data;
    327327
    328     query = p_psDBGenerateSelectRowsSQL(tableName, where);
     328    query = psDBGenerateSelectRowsSQL(tableName, where);
    329329
    330330    fprintf(stderr, "complete query is: %s\n", query);
    331331
    332     if (p_psDBRunQuery(dbh, query)) {
     332    if (psDBRunQuery(dbh, query)) {
    333333        result = mysql_store_result(dbh->mysql);
    334334    } else {
    … …  
    351351        fieldCount = mysql_num_fields(result);
    352352
    353         mysqlToSQLTable = p_psDBGetMySQLToSQLTable();
    354         sqlToPSTable = p_psDBGetSQLToPSTable();
     353        mysqlToSQLTable = psDBGetMySQLToSQLTable();
     354        sqlToPSTable = psDBGetSQLToPSTable();
    355355
    356356        while ((row = mysql_fetch_row(result))) {
    … …  
    363363                // as the the mysql types do not tell you if the value is
    364364                // signed or unsigned
    365                 key = p_psDBIntToString((psU64)field[i].type);
     365                key = psDBIntToString((psU64)field[i].type);
    366366                value = psHashLookup(mysqlToSQLTable, key);
    367367                sqlType = psStringCopy(value);
    … …  
    369369
    370370                if (field->flags & UNSIGNED_FLAG) {
    371                     p_psStringPrepend(&sqlType, "UNSIGNED ");
     371                    psStringPrepend(&sqlType, "UNSIGNED ");
    372372                }
    373373
    … …  
    383383                    type = PS_META_STR;
    384384                    data = fieldLength[i] ? psStringNCopy(row[i], fieldLength[i])
    385                                           : p_psDBGetPTypeNull(pType);
     385                                          : psDBGetPTypeNull(pType);
    386386                } else {
    387387                    type = PS_META_PRIMITIVE;
    … …  
    390390                        memcpy(data, row[i], fieldLength[i]);
    391391                    } else {
    392                         data = p_psDBGetPTypeNull(pType);
     392                        data = psDBGetPTypeNull(pType);
    393393                    }
    394394                }
    … …  
    435435    psU32           paramCount;
    436436
    437     query = p_psDBGenerateInsertRowSQL(tableName, row);
     437    query = psDBGenerateInsertRowSQL(tableName, row);
    438438
    439439    fprintf(stderr, "complete query is: %s\n", query);
    … …  
    484484}
    485485
    486 static char *p_psDBGenerateInsertRowSQL(const char *tableName, psMetadata *row)
     486static char *psDBGenerateInsertRowSQL(const char *tableName, psMetadata *row)
    487487{
    488488    char            *query;
    … …  
    492492    // init query with a psMemBlock
    493493    query = psStringCopy("INSERT INTO ");
    494     p_psStringAppend(&query, tableName);
    495     p_psStringAppend(&query, " (");
     494    psStringAppend(&query, tableName);
     495    psStringAppend(&query, " (");
    496496
    497497    cursor = psListIteratorAlloc(row->list, 0);
    … …  
    499499    // get field names
    500500    while ((item = psListGetNext(cursor))) {
    501         p_psStringAppend(&query, item->name);
     501        psStringAppend(&query, item->name);
    502502
    503503        if (!cursor->offEnd) {
    504504            // + , + _
    505             p_psStringAppend(&query, ", ");
    506         }
    507     }
    508 
    509     p_psStringAppend(&query, ") VALUES (");
     505            psStringAppend(&query, ", ");
     506        }
     507    }
     508
     509    psStringAppend(&query, ") VALUES (");
    510510
    511511    psListIteratorSet(cursor, 0);
    … …  
    513513    // create field place holders
    514514    while ((item = psListGetNext(cursor))) {
    515         p_psStringAppend(&query, "?");
     515        psStringAppend(&query, "?");
    516516
    517517        if (!cursor->offEnd) {
    518518            // + , + _
    519             p_psStringAppend(&query, ", ");
     519            psStringAppend(&query, ", ");
    520520        }
    521521    }
    … …  
    523523    psFree(cursor);
    524524
    525     p_psStringAppend(&query, ")");
     525    psStringAppend(&query, ")");
    526526
    527527    return query;
    528528}
    529529
    530 static char *p_psDBGenerateWhereSQL(psMetadata *where)
     530static char *psDBGenerateWhereSQL(psMetadata *where)
    531531{
    532532    char            *query;
    … …  
    545545        if (item->type == PS_META_STR) {
    546546            // + column name + _ + like + _ + ' + value + '
    547             p_psStringAppend(&query, item->name);
     547            psStringAppend(&query, item->name);
    548548            if (*(char *)item->data.V == '\0') {
    549                 p_psStringAppend(&query, " IS NULL");
     549                psStringAppend(&query, " IS NULL");
    550550            } else {
    551                 p_psStringAppend(&query, " LIKE '");
    552                 p_psStringAppend(&query, item->data.V);
    553                 p_psStringAppend(&query, "'");
     551                psStringAppend(&query, " LIKE '");
     552                psStringAppend(&query, item->data.V);
     553                psStringAppend(&query, "'");
    554554            }
    555555        } else {
    … …  
    564564        if (!cursor->offEnd) {
    565565            // + and
    566             p_psStringAppend(&query, " AND ");
     566            psStringAppend(&query, " AND ");
    567567        }
    568568    }
    … …  
    573573}
    574574
    575 static char *p_psDBGenerateCreateTableSQL(const char *tableName, psMetadata *table)
     575static char *psDBGenerateCreateTableSQL(const char *tableName, psMetadata *table)
    576576{
    577577    psMetadataItem  *item;
    … …  
    586586
    587587    // + _ + tableName + _ + (
    588     p_psStringAppend(&query, " ");
    589     p_psStringAppend(&query, tableName);
    590     p_psStringAppend(&query, " (");
     588    psStringAppend(&query, " ");
     589    psStringAppend(&query, tableName);
     590    psStringAppend(&query, " (");
    591591
    592592    // get pType lookup table
    593     colType = p_psDBGetPSToSQLTable();
     593    colType = psDBGetPSToSQLTable();
    594594
    595595    // get Metadata iterator
    … …  
    599599    while ((item = psListGetNext(cursor))) {
    600600        // + column name + _
    601         p_psStringAppend(&query, item->name);
    602         p_psStringAppend(&query, " ");
     601        psStringAppend(&query, item->name);
     602        psStringAppend(&query, " ");
    603603
    604604        if (item->type == PS_META_PRIMITIVE) {
    605605            // lookup SQL column type
    606             key = p_psDBIntToString((psU64)item->pType);
     606            key = psDBIntToString((psU64)item->pType);
    607607            value = psHashLookup(colType, key);
    608608            psFree(key);
    609609
    610610            // + column type
    611             p_psStringAppend(&query, value);
     611            psStringAppend(&query, value);
    612612        } else if (item->type == PS_META_STR) {
    613613            // + varchar( + length + )
    614             p_psStringAppend(&query, "varchar(");
    615             p_psStringAppend(&query, item->data.V);
    616             p_psStringAppend(&query, ")");
     614            psStringAppend(&query, "varchar(");
     615            psStringAppend(&query, item->data.V);
     616            psStringAppend(&query, ")");
    617617        } else {
    618618            // error
    … …  
    622622        if (!cursor->offEnd) {
    623623            // + ,
    624             p_psStringAppend(&query, ", ");
     624            psStringAppend(&query, ", ");
    625625        }
    626626    }
    … …  
    633633    while ((item = psListGetNext(cursor))) {
    634634        if ((strncmp(item->comment, "Primary Key", strlen("Primary Key"))) == 0) {
    635             p_psStringAppend(&query, ", PRIMARY KEY(");
    636             p_psStringAppend(&query, item->name);
    637             p_psStringAppend(&query, ")");
     635            psStringAppend(&query, ", PRIMARY KEY(");
     636            psStringAppend(&query, item->name);
     637            psStringAppend(&query, ")");
    638638        } else if ((strncmp(item->comment, "Key", strlen("Key"))) == 0) {
    639             p_psStringAppend(&query, ", KEY(");
    640             p_psStringAppend(&query, item->name);
    641             p_psStringAppend(&query, ")");
     639            psStringAppend(&query, ", KEY(");
     640            psStringAppend(&query, item->name);
     641            psStringAppend(&query, ")");
    642642        }
    643643    }
    … …  
    646646
    647647    // + ) + _ + ENGINE=innodb;
    648     p_psStringAppend(&query, ") ENGINE=innodb");
     648    psStringAppend(&query, ") ENGINE=innodb");
    649649
    650650    return query;
    651651}
    652652
    653 static char *p_psDBGenerateSelectColumnSQL(const char *tableName, const char *col, const psU64 limit)
     653static char *psDBGenerateSelectColumnSQL(const char *tableName, const char *col, const psU64 limit)
    654654{
    655655    char            *query;
    … …  
    658658    // init query with a psMemBlock
    659659    query = psStringCopy("SELECT ");
    660     p_psStringAppend(&query, col);
    661     p_psStringAppend(&query, " FROM ");
    662     p_psStringAppend(&query, tableName);
     660    psStringAppend(&query, col);
     661    psStringAppend(&query, " FROM ");
     662    psStringAppend(&query, tableName);
    663663
    664664    if (limit) {
    665         p_psStringAppend(&query, " LIMIT ");
    666         limitString = p_psDBIntToString(limit);
    667         p_psStringAppend(&query, limitString);
     665        psStringAppend(&query, " LIMIT ");
     666        limitString = psDBIntToString(limit);
     667        psStringAppend(&query, limitString);
    668668        psFree(limitString);
    669669    }
    … …  
    672672}
    673673
    674 static char *p_psDBGenerateSelectRowsSQL(const char *tableName, psMetadata *where)
     674static char *psDBGenerateSelectRowsSQL(const char *tableName, psMetadata *where)
    675675{
    676676    char            *query;
    … …  
    679679    // init query with a psMemBlock
    680680    query = psStringCopy("SELECT * FROM ");
    681     p_psStringAppend(&query, tableName);
    682     p_psStringAppend(&query, " ");
    683 
    684     string = p_psDBGenerateWhereSQL(where);
     681    psStringAppend(&query, tableName);
     682    psStringAppend(&query, " ");
     683
     684    string = psDBGenerateWhereSQL(where);
    685685    // FIXME check for error
    686     p_psStringAppend(&query, string);
     686    psStringAppend(&query, string);
    687687    psFree(string);
    688688
    … …  
    693693                    *(a *)myNaN = b;
    694694
    695 static psPtr p_psDBGetPTypeNull(psElemType pType)
     695static psPtr psDBGetPTypeNull(psElemType pType)
    696696{
    697697    psPtr           myNaN;
    … …  
    752752                            snprintf(string, length, b, *(a *)data);
    753753
    754 static char *p_psDBPTypeAsString(psPtr data, psElemType pType)
     754static char *psDBPTypeAsString(psPtr data, psElemType pType)
    755755{
    756756    size_t          length;
    … …  
    805805}
    806806
    807 static bool p_psDBRunQuery(psDB *dbh, const char *query)
     807static bool psDBRunQuery(psDB *dbh, const char *query)
    808808{
    809809    if (mysql_real_query(dbh->mysql, query, (unsigned long)strlen(query)) !=0) {
    … …  
    816816}
    817817
    818 static size_t p_psStringAppend(char **dest, const char *source)
     818static size_t psStringAppend(char **dest, const char *source)
    819819{
    820820    size_t          newSize;
    … …  
    830830}
    831831
    832 static size_t p_psStringPrepend(char **dest, const char *source)
     832static size_t psStringPrepend(char **dest, const char *source)
    833833{
    834834    size_t          newSize;
    … …  
    853853}
    854854
    855 static psHash *p_psDBGetPSToSQLTable(void)
     855static psHash *psDBGetPSToSQLTable(void)
    856856{
    857857    static psHash   *lookupTable = NULL;
    … …  
    860860        lookupTable = psHashAlloc(14);
    861861
    862         p_psDBAddToLookupTable(lookupTable, PS_TYPE_S8,  "TINYINT");
    863         p_psDBAddToLookupTable(lookupTable, PS_TYPE_S16, "SMALLINT");
    864         p_psDBAddToLookupTable(lookupTable, PS_TYPE_S32, "INT");
    865         p_psDBAddToLookupTable(lookupTable, PS_TYPE_S64, "BIGINT");
    866         p_psDBAddToLookupTable(lookupTable, PS_TYPE_U8,  "UNSIGNED TINYINT");
    867         p_psDBAddToLookupTable(lookupTable, PS_TYPE_U16, "UNSIGNED SMALLINT");
    868         p_psDBAddToLookupTable(lookupTable, PS_TYPE_U32, "UNSIGNED INT");
    869         p_psDBAddToLookupTable(lookupTable, PS_TYPE_U64, "UNSIGNED BIGINT");
    870         p_psDBAddToLookupTable(lookupTable, PS_TYPE_F32, "FLOAT");
    871         p_psDBAddToLookupTable(lookupTable, PS_TYPE_F64, "DOUBLE");
    872         p_psDBAddToLookupTable(lookupTable, PS_TYPE_C32, "PS_TYPE_C32 is not supported");
    873         p_psDBAddToLookupTable(lookupTable, PS_TYPE_C64, "PS_TYPE_C64 is not supported");
    874         p_psDBAddToLookupTable(lookupTable, PS_TYPE_BOOL,"BOOLEAN");
     862        psDBAddToLookupTable(lookupTable, PS_TYPE_S8,  "TINYINT");
     863        psDBAddToLookupTable(lookupTable, PS_TYPE_S16, "SMALLINT");
     864        psDBAddToLookupTable(lookupTable, PS_TYPE_S32, "INT");
     865        psDBAddToLookupTable(lookupTable, PS_TYPE_S64, "BIGINT");
     866        psDBAddToLookupTable(lookupTable, PS_TYPE_U8,  "UNSIGNED TINYINT");
     867        psDBAddToLookupTable(lookupTable, PS_TYPE_U16, "UNSIGNED SMALLINT");
     868        psDBAddToLookupTable(lookupTable, PS_TYPE_U32, "UNSIGNED INT");
     869        psDBAddToLookupTable(lookupTable, PS_TYPE_U64, "UNSIGNED BIGINT");
     870        psDBAddToLookupTable(lookupTable, PS_TYPE_F32, "FLOAT");
     871        psDBAddToLookupTable(lookupTable, PS_TYPE_F64, "DOUBLE");
     872        psDBAddToLookupTable(lookupTable, PS_TYPE_C32, "PS_TYPE_C32 is not supported");
     873        psDBAddToLookupTable(lookupTable, PS_TYPE_C64, "PS_TYPE_C64 is not supported");
     874        psDBAddToLookupTable(lookupTable, PS_TYPE_BOOL,"BOOLEAN");
    875875        // no support for CHAR, TEXT or GLOB
    876         p_psDBAddToLookupTable(lookupTable, PS_TYPE_PTR, "VARCHAR");
     876        psDBAddToLookupTable(lookupTable, PS_TYPE_PTR, "VARCHAR");
    877877    }
    878878
    … …  
    883883}
    884884
    885 static void p_psDBPSToSQLTableCleanup(void)
     885static void psDBPSToSQLTableCleanup(void)
    886886{
    887887    psHash          *lookupTable;
    888888
    889     lookupTable = p_psDBGetPSToSQLTable();
     889    lookupTable = psDBGetPSToSQLTable();
    890890
    891891    psMemDecrRefCounter(lookupTable);
    … …  
    893893}
    894894
    895 static psHash *p_psDBGetSQLToPSTable(void)
     895static psHash *psDBGetSQLToPSTable(void)
    896896{
    897897    static psHash   *lookupTable = NULL;
    … …  
    904904    if (!lookupTable) {
    905905        // invert the PSToSQL table
    906         psToSQLTable = p_psDBGetPSToSQLTable();
     906        psToSQLTable = psDBGetPSToSQLTable();
    907907        lookupTable = psHashAlloc(psToSQLTable->nbucket);
    908908
    … …  
    927927}
    928928
    929 static void p_psDBSQLToPSTableCleanup(void)
     929static void psDBSQLToPSTableCleanup(void)
    930930{
    931931    psHash          *lookupTable;
    932932
    933     lookupTable = p_psDBGetSQLToPSTable();
     933    lookupTable = psDBGetSQLToPSTable();
    934934
    935935    psMemDecrRefCounter(lookupTable);
    … …  
    937937}
    938938
    939 static psHash *p_psDBGetMySQLToSQLTable(void)
     939static psHash *psDBGetMySQLToSQLTable(void)
    940940{
    941941    static psHash   *lookupTable = NULL;
    … …  
    944944        lookupTable = psHashAlloc(20);
    945945
    946         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_TINY,      "TINYINT");
    947         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_SHORT,     "SMALLINT");
    948         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_LONG,      "INT");
    949         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_INT24,     "MEDIUMINT");
    950         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_LONGLONG,  "BIGINT");
    951         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_DECIMAL,   "DECIMAL");
    952         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_FLOAT,     "FLOAT");
    953         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_DOUBLE,    "DOUBLE");
    954         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_TIMESTAMP, "TIMESTAMP");
    955         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_DATE,      "DATE");
    956         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_TIME,      "TIME");
    957         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_DATETIME,  "DATETIME");
    958         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_YEAR,      "YEAR");
    959         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_STRING,    "CHAR");
    960         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_VAR_STRING,"VARCHAR");
    961         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_BLOB,      "BLOB");
    962         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_SET,       "SET");
    963         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_ENUM,      "ENUM");
    964         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_NULL,      "NULL-type");
    965         p_psDBAddToLookupTable(lookupTable, FIELD_TYPE_CHAR,      "TINYINT");
     946        psDBAddToLookupTable(lookupTable, FIELD_TYPE_TINY,      "TINYINT");
     947        psDBAddToLookupTable(lookupTable, FIELD_TYPE_SHORT,     "SMALLINT");
     948        psDBAddToLookupTable(lookupTable, FIELD_TYPE_LONG,      "INT");
     949        psDBAddToLookupTable(lookupTable, FIELD_TYPE_INT24,     "MEDIUMINT");
     950        psDBAddToLookupTable(lookupTable, FIELD_TYPE_LONGLONG,  "BIGINT");
     951        psDBAddToLookupTable(lookupTable, FIELD_TYPE_DECIMAL,   "DECIMAL");
     952        psDBAddToLookupTable(lookupTable, FIELD_TYPE_FLOAT,     "FLOAT");
     953        psDBAddToLookupTable(lookupTable, FIELD_TYPE_DOUBLE,    "DOUBLE");
     954        psDBAddToLookupTable(lookupTable, FIELD_TYPE_TIMESTAMP, "TIMESTAMP");
     955        psDBAddToLookupTable(lookupTable, FIELD_TYPE_DATE,      "DATE");
     956        psDBAddToLookupTable(lookupTable, FIELD_TYPE_TIME,      "TIME");
     957        psDBAddToLookupTable(lookupTable, FIELD_TYPE_DATETIME,  "DATETIME");
     958        psDBAddToLookupTable(lookupTable, FIELD_TYPE_YEAR,      "YEAR");
     959        psDBAddToLookupTable(lookupTable, FIELD_TYPE_STRING,    "CHAR");
     960        psDBAddToLookupTable(lookupTable, FIELD_TYPE_VAR_STRING,"VARCHAR");
     961        psDBAddToLookupTable(lookupTable, FIELD_TYPE_BLOB,      "BLOB");
     962        psDBAddToLookupTable(lookupTable, FIELD_TYPE_SET,       "SET");
     963        psDBAddToLookupTable(lookupTable, FIELD_TYPE_ENUM,      "ENUM");
     964        psDBAddToLookupTable(lookupTable, FIELD_TYPE_NULL,      "NULL-type");
     965        psDBAddToLookupTable(lookupTable, FIELD_TYPE_CHAR,      "TINYINT");
    966966    }
    967967
    … …  
    972972}
    973973
    974 static void p_psDBMySQLToSQLTableCleanup(void)
     974static void psDBMySQLToSQLTableCleanup(void)
    975975{
    976976    psHash          *lookupTable;
    977977
    978     lookupTable = p_psDBGetMySQLToSQLTable();
     978    lookupTable = psDBGetMySQLToSQLTable();
    979979
    980980    psMemDecrRefCounter(lookupTable);
    … …  
    982982}
    983983
    984 static psHash *p_psDBGetPSToMySQLTable(void)
     984static psHash *psDBGetPSToMySQLTable(void)
    985985{
    986986    static psHash   *lookupTable = NULL;
    … …  
    989989        lookupTable = psHashAlloc(16);
    990990
    991         p_psDBAddToLookupTable(lookupTable, PS_TYPE_S8,     p_psDBAllocMySQLType(MYSQL_TYPE_TINY,       false));
    992         p_psDBAddToLookupTable(lookupTable, PS_TYPE_S16,    p_psDBAllocMySQLType(MYSQL_TYPE_SHORT,      false));
    993         p_psDBAddToLookupTable(lookupTable, PS_TYPE_S32,    p_psDBAllocMySQLType(MYSQL_TYPE_LONG,       false));
    994         p_psDBAddToLookupTable(lookupTable, PS_TYPE_S64,    p_psDBAllocMySQLType(MYSQL_TYPE_LONGLONG,   false));
    995         p_psDBAddToLookupTable(lookupTable, PS_TYPE_U8,     p_psDBAllocMySQLType(MYSQL_TYPE_TINY,       true));
    996         p_psDBAddToLookupTable(lookupTable, PS_TYPE_U16,    p_psDBAllocMySQLType(MYSQL_TYPE_SHORT,      true));
    997         p_psDBAddToLookupTable(lookupTable, PS_TYPE_U32,    p_psDBAllocMySQLType(MYSQL_TYPE_LONG,       true));
    998         p_psDBAddToLookupTable(lookupTable, PS_TYPE_U64,    p_psDBAllocMySQLType(MYSQL_TYPE_LONGLONG,   true));
    999         p_psDBAddToLookupTable(lookupTable, PS_TYPE_F32,    p_psDBAllocMySQLType(MYSQL_TYPE_FLOAT,      false));
    1000         p_psDBAddToLookupTable(lookupTable, PS_TYPE_F64,    p_psDBAllocMySQLType(MYSQL_TYPE_DOUBLE,     false));
    1001         p_psDBAddToLookupTable(lookupTable, PS_TYPE_C32,    NULL);  // unsupported
    1002         p_psDBAddToLookupTable(lookupTable, PS_TYPE_C64,    NULL);  // unsupported
    1003         p_psDBAddToLookupTable(lookupTable, PS_TYPE_BOOL,   p_psDBAllocMySQLType(MYSQL_TYPE_TINY,       true));
    1004         p_psDBAddToLookupTable(lookupTable, PS_TYPE_PTR,    p_psDBAllocMySQLType(MYSQL_TYPE_VAR_STRING, false));
     991        psDBAddToLookupTable(lookupTable, PS_TYPE_S8,     psDBAllocMySQLType(MYSQL_TYPE_TINY,       false));
     992        psDBAddToLookupTable(lookupTable, PS_TYPE_S16,    psDBAllocMySQLType(MYSQL_TYPE_SHORT,      false));
     993        psDBAddToLookupTable(lookupTable, PS_TYPE_S32,    psDBAllocMySQLType(MYSQL_TYPE_LONG,       false));
     994        psDBAddToLookupTable(lookupTable, PS_TYPE_S64,    psDBAllocMySQLType(MYSQL_TYPE_LONGLONG,   false));
     995        psDBAddToLookupTable(lookupTable, PS_TYPE_U8,     psDBAllocMySQLType(MYSQL_TYPE_TINY,       true));
     996        psDBAddToLookupTable(lookupTable, PS_TYPE_U16,    psDBAllocMySQLType(MYSQL_TYPE_SHORT,      true));
     997        psDBAddToLookupTable(lookupTable, PS_TYPE_U32,    psDBAllocMySQLType(MYSQL_TYPE_LONG,       true));
     998        psDBAddToLookupTable(lookupTable, PS_TYPE_U64,    psDBAllocMySQLType(MYSQL_TYPE_LONGLONG,   true));
     999        psDBAddToLookupTable(lookupTable, PS_TYPE_F32,    psDBAllocMySQLType(MYSQL_TYPE_FLOAT,      false));
     1000        psDBAddToLookupTable(lookupTable, PS_TYPE_F64,    psDBAllocMySQLType(MYSQL_TYPE_DOUBLE,     false));
     1001        psDBAddToLookupTable(lookupTable, PS_TYPE_C32,    NULL);  // unsupported
     1002        psDBAddToLookupTable(lookupTable, PS_TYPE_C64,    NULL);  // unsupported
     1003        psDBAddToLookupTable(lookupTable, PS_TYPE_BOOL,   psDBAllocMySQLType(MYSQL_TYPE_TINY,       true));
     1004        psDBAddToLookupTable(lookupTable, PS_TYPE_PTR,    psDBAllocMySQLType(MYSQL_TYPE_VAR_STRING, false));
    10051005    }
    10061006
    … …  
    10111011}
    10121012
    1013 static psPtr p_psDBAllocMySQLType(enum enum_field_types type, bool isUnsigned)
     1013static psPtr psDBAllocMySQLType(enum enum_field_types type, bool isUnsigned)
    10141014{
    10151015    mysqlType       *mType;
    … …  
    10221022}
    10231023
    1024 static void p_psDBPSToMySQLTableCleanup(void)
     1024static void psDBPSToMySQLTableCleanup(void)
    10251025{
    10261026    psHash          *lookupTable;
    10271027
    1028     lookupTable = p_psDBGetPSToMySQLTable();
     1028    lookupTable = psDBGetPSToMySQLTable();
    10291029
    10301030    psMemDecrRefCounter(lookupTable);
    … …  
    10321032}
    10331033
    1034 static void p_psDBAddToLookupTable(psHash *lookupTable, const psU32 type, const char *string)
     1034static void psDBAddToLookupTable(psHash *lookupTable, const psU32 type, const char *string)
    10351035{
    10361036    char            *key;
    10371037    char            *value;
    10381038
    1039     key = p_psDBIntToString((psU64)type);
     1039    key = psDBIntToString((psU64)type);
    10401040    value = psStringCopy(string);
    10411041
    … …  
    10461046}
    10471047
    1048 static char *p_psDBIntToString(psU64 n)
     1048static char *psDBIntToString(psU64 n)
    10491049{
    10501050    char            *string;
Note: See TracChangeset for help on using the changeset viewer.