contrib/mSQL-interface/mpgsql.c

   1 #include <time.h>
   2 #include <string.h>
   3 #include <stdlib.h>
   4 #include "msql.h"
   5 #include "libpq-fe.h"
   6
   7 #define HNDMAX 10
   8
   9 PGconn     *PGh[HNDMAX] = {
  10         NULL, NULL, NULL, NULL, NULL,
  11         NULL, NULL, NULL, NULL, NULL
  12 };
  13
  14 #define E_NOHANDLERS 0
  15
  16 char       *msqlErrors[] = {
  17         "Out of database handlers."
  18 };
  19
  20 char            msqlErrMsg[BUFSIZ],
  21                    *tfrom = "dunno";
  22 PGresult   *queryres = NULL;
  23
  24 int
  25 msqlConnect(char *host)
  26 {
  27         int                     count;
  28
  29         for (count = 0; count < HNDMAX; count++)
  30                 if (PGh[count] == NULL)
  31                         break;
  32
  33         if (count == HNDMAX)
  34         {
  35                 strncpy(msqlErrMsg, msqlErrors[E_NOHANDLERS], BUFSIZ);
  36                 return -1;
  37         }
  38
  39         PGh[count] = malloc(sizeof(PGconn));
  40         PGh[count]->pghost = host ? strdup(host) : NULL;
  41         return count;
  42 }
  43
  44 int
  45 msqlSelectDB(int handle, char *dbname)
  46 {
  47         char       *options = calloc(1, BUFSIZ);
  48         char       *e = getenv("PG_OPTIONS");
  49
  50         if (e == NULL)
  51                 e = "";
  52
  53         if (PGh[handle]->pghost)
  54         {
  55                 strcat(options, "host=");
  56                 strncat(options, PGh[handle]->pghost, BUFSIZ);
  57                 strncat(options, " ", BUFSIZ);
  58                 free(PGh[handle]->pghost);
  59                 PGh[handle]->pghost = NULL;
  60         }
  61         strncat(options, "dbname=", BUFSIZ);
  62         strncat(options, dbname, BUFSIZ);
  63         strncat(options, " ", BUFSIZ);
  64         strncat(options, e, BUFSIZ);
  65         free(PGh[handle]);
  66         PGh[handle] = PQconnectdb(options);
  67         free(options);
  68         strncpy(msqlErrMsg, PQerrorMessage(PGh[handle]), BUFSIZ);
  69         return (PQstatus(PGh[handle]) == CONNECTION_BAD ? -1 : 0);
  70 }
  71
  72 int
  73 msqlQuery(int handle, char *query)
  74 {
  75         char       *tq = strdup(query);
  76         char       *p = tq;
  77         PGresult   *res;
  78         PGconn     *conn = PGh[handle];
  79         ExecStatusType rcode;
  80
  81         res = PQexec(conn, p);
  82
  83         rcode = PQresultStatus(res);
  84
  85         if (rcode == PGRES_TUPLES_OK)
  86         {
  87                 queryres = res;
  88                 return PQntuples(res);
  89         }
  90         else if (rcode == PGRES_FATAL_ERROR || rcode == PGRES_NONFATAL_ERROR)
  91         {
  92                 PQclear(res);
  93                 queryres = NULL;
  94                 return -1;
  95         }
  96         else
  97         {
  98                 PQclear(res);
  99                 queryres = NULL;
 100                 return 0;
 101         }
 102 }
 103
 104 int
 105 msqlCreateDB(int a, char *b)
 106 {
 107         char            tbuf[BUFSIZ];
 108
 109         snprintf(tbuf, BUFSIZ, "create database %s", b);
 110         return msqlQuery(a, tbuf) >= 0 ? 0 : -1;
 111 }
 112
 113 int
 114 msqlDropDB(int a, char *b)
 115 {
 116         char            tbuf[BUFSIZ];
 117
 118         snprintf(tbuf, BUFSIZ, "drop database %s", b);
 119         return msqlQuery(a, tbuf) >= 0 ? 0 : -1;
 120 }
 121
 122 int
 123 msqlShutdown(int a)
 124 {
 125 }
 126
 127 int
 128 msqlGetProtoInfo(void)
 129 {
 130 }
 131
 132 int
 133 msqlReloadAcls(int a)
 134 {
 135 }
 136
 137 char *
 138 msqlGetServerInfo(void)
 139 {
 140 }
 141
 142 char *
 143 msqlGetHostInfo(void)
 144 {
 145 }
 146
 147 char *
 148 msqlUnixTimeToDate(time_t date)
 149 {
 150 }
 151
 152 char *
 153 msqlUnixTimeToTime(time_t time)
 154 {
 155 }
 156
 157 void
 158 msqlClose(int a)
 159 {
 160         PQfinish(PGh[a]);
 161         PGh[a] = NULL;
 162         if (queryres)
 163         {
 164                 free(queryres);
 165                 queryres = NULL;
 166         }
 167 }
 168
 169 void
 170 msqlDataSeek(m_result * result, int count)
 171 {
 172         int                     c;
 173
 174         result->cursor = result->queryData;
 175         for (c = 1; c < count; c++)
 176                 if (result->cursor->next)
 177                         result->cursor = result->cursor->next;
 178 }
 179
 180 void
 181 msqlFieldSeek(m_result * result, int count)
 182 {
 183         int                     c;
 184
 185         result->fieldCursor = result->fieldData;
 186         for (c = 1; c < count; c++)
 187                 if (result->fieldCursor->next)
 188                         result->fieldCursor = result->fieldCursor->next;
 189 }
 190
 191 void
 192 msqlFreeResult(m_result * result)
 193 {
 194         if (result)
 195         {
 196                 /* Clears fields */
 197                 free(result->fieldData);
 198                 result->cursor = result->queryData;
 199                 while (result->cursor)
 200                 {
 201                         int                     c;
 202                         m_row           m = result->cursor->data;
 203
 204                         for (c = 0; m[c]; c++)
 205                                 free(m[c]);
 206
 207                         result->cursor = result->cursor->next;
 208                 }
 209                 free(result->queryData);
 210                 free(result);
 211         }
 212 }
 213
 214 m_row
 215 msqlFetchRow(m_result * row)
 216 {
 217         m_data     *r = row->cursor;
 218
 219         if (r)
 220         {
 221                 row->cursor = row->cursor->next;
 222                 return (m_row) r->data;
 223         }
 224         return (m_row) NULL;
 225 }
 226
 227 m_seq *
 228 msqlGetSequenceInfo(int a, char *b)
 229 {
 230 }
 231
 232 m_field *
 233 msqlFetchField(m_result * mr)
 234 {
 235         m_field    *m = (m_field *) mr->fieldCursor;
 236
 237         if (m)
 238         {
 239                 mr->fieldCursor = mr->fieldCursor->next;
 240                 return m;
 241         }
 242         return NULL;
 243 }
 244
 245 m_result *
 246 msqlListDBs(int a)
 247 {
 248         m_result   *m;
 249
 250         if (msqlQuery(a, "select datname from pg_database") > 0)
 251         {
 252                 m = msqlStoreResult();
 253                 return m;
 254         }
 255         else
 256                 return NULL;
 257 }
 258
 259 m_result *
 260 msqlListTables(int a)
 261 {
 262         m_result   *m;
 263         char            tbuf[BUFSIZ];
 264
 265         snprintf(tbuf, BUFSIZ,
 266                          "select relname from pg_class where relkind='r' and relowner=%d",
 267                          getuid());
 268         if (msqlQuery(a, tbuf) > 0)
 269         {
 270                 m = msqlStoreResult();
 271                 return m;
 272         }
 273         else
 274                 return NULL;
 275 }
 276
 277 m_result *
 278 msqlListFields(int a, char *b)
 279 {
 280
 281 }
 282
 283 m_result *
 284 msqlListIndex(int a, char *b, char *c)
 285 {
 286         m_result   *m;
 287         char            tbuf[BUFSIZ];
 288
 289         snprintf(tbuf, BUFSIZ,
 290                          "select relname from pg_class where relkind='i' and relowner=%d",
 291                          getuid());
 292         if (msqlQuery(a, tbuf) > 0)
 293         {
 294                 m = msqlStoreResult();
 295                 return m;
 296         }
 297         else
 298                 return NULL;
 299 }
 300
 301 m_result *
 302 msqlStoreResult(void)
 303 {
 304         if (queryres)
 305         {
 306                 m_result   *mr = malloc(sizeof(m_result));
 307                 m_fdata    *mf;
 308                 m_data     *md;
 309                 int                     count;
 310
 311                 mr->queryData = mr->cursor = NULL;
 312                 mr->numRows = PQntuples(queryres);
 313                 mr->numFields = PQnfields(queryres);
 314
 315                 mf = calloc(PQnfields(queryres), sizeof(m_fdata));
 316                 for (count = 0; count < PQnfields(queryres); count++)
 317                 {
 318                         (m_fdata *) (mf + count)->field.name = strdup(PQfname(queryres, count));
 319                         (m_fdata *) (mf + count)->field.table = tfrom;
 320                         (m_fdata *) (mf + count)->field.type = CHAR_TYPE;
 321                         (m_fdata *) (mf + count)->field.length = PQfsize(queryres, count);
 322                         (m_fdata *) (mf + count)->next = (m_fdata *) (mf + count + 1);
 323                 }
 324                 (m_fdata *) (mf + count - 1)->next = NULL;
 325
 326                 md = calloc(PQntuples(queryres), sizeof(m_data));
 327                 for (count = 0; count < PQntuples(queryres); count++)
 328                 {
 329                         m_row           rows = calloc(PQnfields(queryres) * sizeof(m_row) + 1, 1);
 330                         int                     c;
 331
 332                         for (c = 0; c < PQnfields(queryres); c++)
 333                                 rows[c] = strdup(PQgetvalue(queryres, count, c));
 334                         (m_data *) (md + count)->data = rows;
 335
 336                         (m_data *) (md + count)->width = PQnfields(queryres);
 337                         (m_data *) (md + count)->next = (m_data *) (md + count + 1);
 338                 }
 339                 (m_data *) (md + count - 1)->next = NULL;
 340
 341                 mr->queryData = mr->cursor = md;
 342                 mr->fieldCursor = mr->fieldData = mf;
 343
 344                 return mr;
 345         }
 346         else
 347                 return NULL;
 348 }
 349
 350 time_t
 351 msqlDateToUnixTime(char *a)
 352 {
 353 }
 354
 355 time_t
 356 msqlTimeToUnixTime(char *b)
 357 {
 358 }
 359
 360 char *
 361 msql_tmpnam(void)
 362 {
 363         return tmpnam("/tmp/msql.XXXXXX");
 364 }
 365
 366 int
 367 msqlLoadConfigFile(char *a)
 368 {
 369 }