--- /dev/null
+Hello! :)
+
+(Sorry for my english. But if i wrote in portuguese, you wouldn't
+ understand nothing. :])
+
+ I found it's the right place to post this. I'm a newcomer in these
+lists. I hope i did it right. :]
+
+<BOREDOM>
+ When i started using SQL, i started with mSQL. I developed a lot
+of useful apps for me and my job with C, mainly because i loved it's
+elegant, simple api. But for a large project i'm doing in these days, i
+thought is was not enough, because it felt a lot of features i started to
+need, like security and subselects. (and it's not free :))
+ So after looking at the options, choose to start again with
+postgres. It offered everything that i needed, and the documentation is
+really good (remember me to thank the one who wrote'em).
+ But for my little apps, i needed to start porting them to libpq.
+After looking at pq's syntax, i found it was better to write a bridge
+between the mSQL api and libpq. I found that rewriting the libmsql.a
+routines that calls libpq would made things much easier. I guess the
+results are quite good right now.
+</BOREDOM>
+
+ Ok. Lets' summarize it:
+
+ mpgsql.c is the bridge. Acting as a wrapper, it's really good,
+since i could run mSQL. But it's not accurate. Some highlights:
+
+ CONS:
+ * It's not well documented
+ (this post is it's first documentation attempt, in fact);
+ * It doesn't handle field types correctly. I plan to fix it,
+ if people start doing feedbacks;
+ * It's limited to 10 simultaneous connections. I plan to enhance
+ this, i'm just figuring out;
+ * I'd like to make it reentrant/thread safe, although i don't
+ think this could be done without changing the API structure;
+ * Error Management should be better. This is my first priority
+ now;
+ * Some calls are just empty implementations.
+
+ PROS:
+ * the mSQL Monitor runs Okay. :]
+ * It's really cool. :)
+ * Make mSQL-made applications compatible with postgresql just by
+ changing link options.
+ * Uses postgreSQL. :]
+ * the mSQL API it's far easier to use and understand than libpq.
+ Consider this example:
+
+#include "msql.h"
+
+void main(int argc, char **argv, char **envp) {
+ int sid;
+
+ sid = msqlConnect(NULL); /* Connects via unix socket */
+
+ if (sid >= 0) {
+ m_result *rlt;
+ m_row *row;
+ msqlSelectDB(sid, "hosts");
+ if (msqlQuery(sid, "select host_id from hosts")) {
+ rlt = msqlStoreResult();
+ while (row = (m_row*)msqlFetchRow(rlt))
+ printf("hostid: %s\n", row[0]);
+ msqlFreeResult(rlt);
+ }
+ msqlClose(sid);
+ }
+}
+
+ I enclose mpgsql.c inside. I'd like to maintain it, and (maybe, am
+i dreaming) make it as part of the pgsql distribution. I guess it doesn't
+depends on me, but mainly on it's acceptance by its users.
+
+ Hm... i forgot: you'll need a msql.h copy, since it's copyrighted
+by Hughes Technologies Pty Ltd. If you haven't it yes, fetch one
+from www.hughes.com.au.
+
+ I would like to catch users ideas. My next goal is to add better
+error handling, and to make it better documented, and try to let relshow
+run through it. :)
+
+ done. Aldrin Leal <aldrin@americasnet.com>
--- /dev/null
+#include <time.h>
+#include <string.h>
+#include <stdlib.h>
+#include "msql.h"
+#include "libpq-fe.h"
+
+#define HNDMAX 10
+
+PGconn *PGh[HNDMAX] = {
+ NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL
+};
+
+#define E_NOHANDLERS 0
+
+char *msqlErrors[] = {
+ "Out of database handlers."
+};
+
+char msqlErrMsg[BUFSIZ], *tfrom = "dunno";
+PGresult *queryres = NULL;
+
+int msqlConnect (char *host) {
+ int count;
+
+ for (count = 0; count < HNDMAX; count++)
+ if (PGh[count] == NULL) break;
+
+ if (count == HNDMAX) {
+ strncpy(msqlErrMsg, msqlErrors[E_NOHANDLERS], BUFSIZ);
+ return -1;
+ }
+
+ PGh[count] = malloc(sizeof (PGconn));
+ PGh[count]->pghost = host ? strdup(host) : NULL;
+ return count;
+}
+
+int msqlSelectDB(int handle, char *dbname) {
+ char *options = calloc(1, BUFSIZ);
+ char *e = getenv("PG_OPTIONS");
+
+ if (e == NULL)
+ e = "";
+
+ if (PGh[handle]->pghost) {
+ strcat(options, "host=");
+ strncat(options, PGh[handle]->pghost, BUFSIZ);
+ strncat(options, " ", BUFSIZ);
+ free(PGh[handle]->pghost);
+ PGh[handle]->pghost = NULL;
+ }
+ strncat(options, "dbname=", BUFSIZ);
+ strncat(options, dbname, BUFSIZ);
+ strncat(options, " ", BUFSIZ);
+ strncat(options, e, BUFSIZ);
+ free(PGh[handle]);
+ PGh[handle] = PQconnectdb(options);
+ free(options);
+ strncpy(msqlErrMsg, PQerrorMessage(PGh[handle]), BUFSIZ);
+ return (PQstatus(PGh[handle]) == CONNECTION_BAD ? -1 : 0);
+}
+
+int msqlQuery(int handle, char *query) {
+ char *tq = strdup(query);
+ char *p = tq;
+ PGresult *res;
+ PGconn *conn = PGh[handle];
+ ExecStatusType rcode;
+
+ res = PQexec(conn, p);
+
+ rcode = PQresultStatus(res);
+
+ if (rcode == PGRES_TUPLES_OK) {
+ queryres = res;
+ return PQntuples(res);
+ } else if (rcode == PGRES_FATAL_ERROR || rcode == PGRES_NONFATAL_ERROR) {
+ PQclear(res);
+ queryres = NULL;
+ return -1;
+ } else {
+ PQclear(res);
+ queryres = NULL;
+ return 0;
+ }
+}
+
+int msqlCreateDB (int a, char*b) {
+ char tbuf[BUFSIZ];
+ sprintf(tbuf, "create database %s", b);
+ return msqlQuery(a, tbuf) >= 0 ? 0 : -1;
+}
+
+int msqlDropDB (int a, char* b) {
+ char tbuf[BUFSIZ];
+ sprintf(tbuf, "drop database %s", b);
+ return msqlQuery(a, tbuf) >= 0 ? 0 : -1;
+}
+
+int msqlShutdown(int a) {
+}
+
+int msqlGetProtoInfo(void) {
+}
+
+int msqlReloadAcls(int a) {
+}
+
+char *msqlGetServerInfo(void) {
+}
+
+char *msqlGetHostInfo(void) {
+}
+
+char *msqlUnixTimeToDate(time_t date) {
+}
+
+char *msqlUnixTimeToTime(time_t time) {
+}
+
+void msqlClose(int a) {
+ PQfinish(PGh[a]);
+ PGh[a] = NULL;
+ if (queryres) {
+ free(queryres);
+ queryres = NULL;
+ }
+}
+
+void msqlDataSeek(m_result *result, int count) {
+ int c;
+ result->cursor = result->queryData;
+ for (c = 1; c < count; c++)
+ if (result->cursor->next)
+ result->cursor = result->cursor->next;
+}
+
+void msqlFieldSeek(m_result *result, int count) {
+ int c;
+ result->fieldCursor = result->fieldData;
+ for (c = 1; c < count; c++)
+ if (result->fieldCursor->next)
+ result->fieldCursor = result->fieldCursor->next;
+}
+
+void msqlFreeResult(m_result *result) {
+ if (result) {
+ /* Clears fields */
+ free(result->fieldData);
+ result->cursor = result->queryData;
+ while (result->cursor) {
+ int c;
+ m_row m = result->cursor->data;
+
+ for (c = 0; m[c]; c++)
+ free(m[c]);
+
+ result->cursor = result->cursor->next;
+ }
+ free(result->queryData);
+ free(result);
+ }
+}
+
+m_row msqlFetchRow(m_result *row) {
+ m_data *r = row->cursor;
+ if (r) {
+ row->cursor = row->cursor->next;
+ return (m_row)r->data;
+ }
+ return (m_row)NULL;
+}
+
+m_seq *msqlGetSequenceInfo(int a, char *b) {
+}
+
+m_field *msqlFetchField (m_result *mr) {
+ m_field *m = (m_field*)mr->fieldCursor;
+ if (m) {
+ mr->fieldCursor = mr->fieldCursor->next;
+ return m;
+ }
+ return NULL;
+}
+
+m_result *msqlListDBs(int a) {
+ m_result *m;
+ if (msqlQuery(a, "select datname from pg_database") > 0) {
+ m = msqlStoreResult();
+ return m;
+ } else return NULL;
+}
+
+m_result *msqlListTables(int a) {
+ m_result *m;
+ char tbuf[BUFSIZ];
+
+ sprintf(tbuf, "select relname from pg_class where relkind='r' and relowner=%d", getuid());
+ if (msqlQuery(a, tbuf) > 0) {
+ m = msqlStoreResult();
+ return m;
+ } else return NULL;
+}
+
+m_result *msqlListFields(int a, char *b) {
+
+}
+
+m_result *msqlListIndex(int a, char *b, char *c) {
+ m_result *m;
+ char tbuf[BUFSIZ];
+
+ sprintf(tbuf, "select relname from pg_class where relkind='i' and relowner=%d", getuid());
+ if (msqlQuery(a, tbuf) > 0) {
+ m = msqlStoreResult();
+ return m;
+ } else return NULL;
+}
+
+m_result *msqlStoreResult(void) {
+ if (queryres) {
+ m_result *mr = malloc(sizeof(m_result));
+ m_fdata *mf;
+ m_data *md;
+ int count;
+ mr->queryData = mr->cursor = NULL;
+ mr->numRows = PQntuples(queryres);
+ mr->numFields = PQnfields(queryres);
+
+ mf = calloc(PQnfields(queryres), sizeof(m_fdata));
+ for (count = 0; count < PQnfields(queryres); count++) {
+ (m_fdata*)(mf+count)->field.name = strdup(PQfname(queryres, count));
+ (m_fdata*)(mf+count)->field.table = tfrom;
+ (m_fdata*)(mf+count)->field.type = CHAR_TYPE;
+ (m_fdata*)(mf+count)->field.length = PQfsize(queryres, count);
+ (m_fdata*)(mf+count)->next = (m_fdata*)(mf+count+1);
+ }
+ (m_fdata*)(mf+count-1)->next = NULL;
+
+ md = calloc(PQntuples(queryres), sizeof(m_data));
+ for (count = 0; count < PQntuples(queryres); count++) {
+ m_row rows = calloc(PQnfields(queryres)*sizeof(m_row)+1, 1);
+ int c;
+
+ for (c = 0; c < PQnfields(queryres); c++) {
+ rows[c] = strdup(PQgetvalue(queryres, count, c));
+ }
+ (m_data*)(md+count)->data = rows;
+
+ (m_data*)(md+count)->width = PQnfields(queryres);
+ (m_data*)(md+count)->next = (m_data*)(md+count+1);
+ }
+ (m_data*)(md+count-1)->next = NULL;
+
+ mr->queryData = mr->cursor = md;
+ mr->fieldCursor = mr->fieldData = mf;
+
+ return mr;
+ } else return NULL;
+}
+
+time_t msqlDateToUnixTime(char *a) {
+}
+
+time_t msqlTimeToUnixTime(char *b) {
+}
+
+char *msql_tmpnam(void) {
+ return tmpnam("/tmp/msql.XXXXXX");
+}
+
+int msqlLoadConfigFile(char *a) {
+}
+
projects / postgresql / commitdiff