ecbab12008-07-27Stephen R. van den Berg /* * Some pgsql utility functions. * They are kept here to avoid circular references. */
933a762014-11-10Stephen R. van den Berg //! The pgsql backend, shared between all connection instances.
3b31fa2014-11-14Stephen R. van den Berg //! It runs even in non-callback mode in a separate thread and makes sure //! that communication with the database is real-time and event driven //! at all times.
3a881c2014-11-10Stephen R. van den Berg //! //! @note //! Callbacks running from this backend directly determine the latency //! in reacting to communication with the database server; so it //! would be prudent not to block in these callbacks.
933a762014-11-10Stephen R. van den Berg 
ecbab12008-07-27Stephen R. van den Berg #pike __REAL_VERSION__
91e2382014-11-10Stephen R. van den Berg #require constant(Thread.Thread)
ecbab12008-07-27Stephen R. van den Berg  #include "pgsql.h"
7cd0e42017-11-18Stephen R. van den Berg #define PORTALINIT 0 // Portal states #define PARSING 1 #define BOUND 2 #define COMMITTED 3 #define COPYINPROGRESS 4 #define CLOSING 5 #define CLOSED 6 #define PURGED 7 #define NOERROR 0 // Error states networkparser #define PROTOCOLERROR 1 #define PROTOCOLUNSUPPORTED 2 #define LOSTERROR "Database connection lost"
c6d4972018-05-08Stephen R. van den Berg #if PG_DEADLOCK_SENTINEL private multiset mutexes = set_weak_flag((<>), Pike.WEAK); private int deadlockseq; private class MUTEX { inherit Thread.Mutex; private Thread.Thread sentinelthread; private void dump_lockgraph(Thread.Thread curthread) { sleep(PG_DEADLOCK_SENTINEL); String.Buffer buf = String.Buffer(); buf.add("\n{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{\n"); buf.sprintf("Deadlock detected at\n%s\n", describe_backtrace(curthread.backtrace(), -1)); foreach(mutexes; this_program mu; ) if (mu) { Thread.Thread ct; if (ct = mu.current_locking_thread()) buf.sprintf("====================================== Mutex: %O\n%s\n", mu, describe_backtrace(ct.backtrace(), -1)); } buf.add("}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}"); werror(replace(buf.get(), "\n", sprintf("\n%d> ", deadlockseq++)) + "\n"); } Thread.MutexKey lock(void|int type) { Thread.MutexKey key; if (!(key = trylock(type))) { sentinelthread = Thread.Thread(dump_lockgraph, this_thread()); key = ::lock(type); sentinelthread->kill(); } return key; } protected void create() { //::create(); mutexes[this] = 1; } }; #else #define MUTEX Thread.Mutex #endif
3a881c2014-11-10Stephen R. van den Berg //! The instance of the pgsql dedicated backend.
569a922017-12-02Stephen R. van den Berg final Pike.Backend local_backend;
3a881c2014-11-10Stephen R. van den Berg 
569a922017-12-02Stephen R. van den Berg private Pike.Backend cb_backend;
c6d4972018-05-08Stephen R. van den Berg private sql_result qalreadyprinted;
6eb5942014-11-12Stephen R. van den Berg private Thread.Mutex backendmux = Thread.Mutex();
5050652018-12-16Stephen R. van den Berg final multiset(proxy) clients = set_weak_flag((<>), Pike.WEAK);
cff3a32014-09-12Stephen R. van den Berg 
771a162016-10-13Stephen R. van den Berg constant emptyarray = ({});
1c847c2017-06-27Stephen R. van den Berg constant describenodata
e2514a2017-06-28Stephen R. van den Berg  = (["datarowdesc":emptyarray, "datarowtypes":emptyarray, "datatypeoid":emptyarray]);
7cd0e42017-11-18Stephen R. van den Berg private constant censoroptions = (<"use_ssl", "force_ssl", "cache_autoprepared_statements", "reconnect", "text_query", "is_superuser", "server_encoding", "server_version", "integer_datetimes",
652b3c2014-11-19Stephen R. van den Berg  "session_authorization">);
bb4cfe2014-11-26Stephen R. van den Berg  /* Statements matching createprefix cause the prepared statement cache * to be flushed to prevent stale references to (temporary) tables */
7cd0e42017-11-18Stephen R. van den Berg final Regexp createprefix = iregexp("^\a*(CREATE|DROP)\a");
bb4cfe2014-11-26Stephen R. van den Berg  /* Statements matching dontcacheprefix never enter the cache */
7cd0e42017-11-18Stephen R. van den Berg private Regexp dontcacheprefix = iregexp("^\a*(FETCH|COPY)\a");
bb4cfe2014-11-26Stephen R. van den Berg  /* Statements not matching paralleliseprefix will cause the driver * to stall submission until all previously started statements have * run to completion */
02aba92014-11-26Stephen R. van den Berg private Regexp paralleliseprefix
7cd0e42017-11-18Stephen R. van den Berg  = iregexp("^\a*((SELEC|INSER)T|(UPDA|DELE)TE|(FETC|WIT)H)\a");
bb4cfe2014-11-26Stephen R. van den Berg 
bd47ec2017-06-25Stephen R. van den Berg  /* Statements matching transbeginprefix will cause the driver * insert a sync after the statement. * Failure to do so, will result in portal synchronisation errors * in the event of an ErrorResponse. */ final Regexp transbeginprefix
7cd0e42017-11-18Stephen R. van den Berg  = iregexp("^\a*(BEGIN|START)([; \t\f\r\n]|$)");
bd47ec2017-06-25Stephen R. van den Berg  /* Statements matching transendprefix will cause the driver * insert a sync after the statement. * Failure to do so, will result in portal synchronisation errors * in the event of an ErrorResponse. */ final Regexp transendprefix
7cd0e42017-11-18Stephen R. van den Berg  = iregexp("^\a*(COMMIT|ROLLBACK|END)([; \t\f\r\n]|$)");
bd47ec2017-06-25Stephen R. van den Berg 
bb4cfe2014-11-26Stephen R. van den Berg  /* For statements matching execfetchlimit the resultrows will not be
a7d3c22017-07-28Stephen R. van den Berg  * fetched in pieces. This heuristic will be sub-optimal whenever * either an UPDATE/DELETE/INSERT statement is prefixed by WITH, or * if there is a RETURNING with a *lot* of results. In those cases * the portal will be busy until all results have been fetched, and will * not be able to deliver results belonging to other parallel queries * running on the same filedescriptor. * * However, considering that the current heuristic increases query-speed * in the majority of the real-world cases, it would be considered a good * tradeoff.
bb4cfe2014-11-26Stephen R. van den Berg  */
6eb5942014-11-12Stephen R. van den Berg private Regexp execfetchlimit
7cd0e42017-11-18Stephen R. van den Berg  = iregexp("^\a*((UPDA|DELE)TE|INSERT)\a|\aLIMIT\a+[1-9][; \t\f\r\n]*$");
02aba92014-11-26Stephen R. van den Berg 
569a922017-12-02Stephen R. van den Berg private void default_backend_runs() { // Runs as soon as the cb_backend = Pike.DefaultBackend; // DefaultBackend has started } private void create() {
5050652018-12-16Stephen R. van den Berg  atexit(destroy);
569a922017-12-02Stephen R. van den Berg  // Run callbacks from our local_backend until DefaultBackend has started cb_backend = local_backend = Pike.SmallBackend(); call_out(default_backend_runs, 0); }
5050652018-12-16Stephen R. van den Berg private void destroy() { foreach (clients; proxy client; ) destruct(client); }
02aba92014-11-26Stephen R. van den Berg private Regexp iregexp(string expr) {
7cd0e42017-11-18Stephen R. van den Berg  Stdio.Buffer ret = Stdio.Buffer(); foreach (expr; ; int c) if (c >= 'A' && c <= 'Z') ret->add('[', c, c + 'a' - 'A', ']'); else if (c == '\a') // Replace with generic whitespace
02aba92014-11-26Stephen R. van den Berg  ret->add("[ \t\f\r\n]"); else ret->add_int8(c); return Regexp(ret->read()); }
fb8eb42014-10-31Stephen R. van den Berg 
7cd0e42017-11-18Stephen R. van den Berg final void closestatement(bufcon|conxsess plugbuffer, string oldprep) { if (oldprep) { PD("Close statement %s\n", oldprep);
8675b02017-06-03Stephen R. van den Berg  CHAIN(plugbuffer)->add_int8('C')->add_hstring(({'S', oldprep, 0}), 4, 4);
fb8eb42014-10-31Stephen R. van den Berg  } }
6eb5942014-11-12Stephen R. van den Berg private void run_local_backend() {
cff3a32014-09-12Stephen R. van den Berg  Thread.MutexKey lock; int looponce; do {
7cd0e42017-11-18Stephen R. van den Berg  looponce = 0; if (lock = backendmux->trylock()) {
cff3a32014-09-12Stephen R. van den Berg  PD("Starting local backend\n");
5050652018-12-16Stephen R. van den Berg  while (sizeof(clients) // Autoterminate when not needed
09206e2017-11-15Stephen R. van den Berg  || sizeof(local_backend->call_out_info())) {
49143b2016-10-12Stephen R. van den Berg  mixed err; if (err = catch(local_backend(4096.0)))
e340442017-11-30Stephen R. van den Berg  master()->handle_error(err);
49143b2016-10-12Stephen R. van den Berg  }
cff3a32014-09-12Stephen R. van den Berg  PD("Terminating local backend\n");
7cd0e42017-11-18Stephen R. van den Berg  lock = 0;
5050652018-12-16Stephen R. van den Berg  looponce = sizeof(clients);
cff3a32014-09-12Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  } while (looponce);
cff3a32014-09-12Stephen R. van den Berg }
ecbab12008-07-27Stephen R. van den Berg 
3a881c2014-11-10Stephen R. van den Berg //! Registers yourself as a user of this backend. If the backend //! has not been started yet, it will be spawned automatically.
5050652018-12-16Stephen R. van den Berg final void register_backend(proxy client) { int startbackend = !sizeof(clients); clients[client] = 1;
41b4c62017-11-10Stephen R. van den Berg  if (startbackend)
cff3a32014-09-12Stephen R. van den Berg  Thread.Thread(run_local_backend); }
4741cd2008-07-31Stephen R. van den Berg 
7cd0e42017-11-18Stephen R. van den Berg final void throwdelayederror(sql_result|proxy parent) { if (mixed err = parent->delayederror) { if (!objectp(parent->pgsqlsess)) parent->untolderror = 0; else if (parent->pgsqlsess) parent->pgsqlsess->untolderror = 0; parent.delayederror = 0; if (stringp(err)) err = ({err, backtrace()[..<2]});
cff3a32014-09-12Stephen R. van den Berg  throw(err);
ecbab12008-07-27Stephen R. van den Berg  }
cff3a32014-09-12Stephen R. van den Berg }
ecbab12008-07-27Stephen R. van den Berg 
7d9a902017-12-11Stephen R. van den Berg private int readoidformat(int oid) {
7cd0e42017-11-18Stephen R. van den Berg  switch (oid) {
fb8eb42014-10-31Stephen R. van den Berg  case BOOLOID: case BYTEAOID: case CHAROID: case INT8OID: case INT2OID: case INT4OID:
7d9a902017-12-11Stephen R. van den Berg  case FLOAT4OID: #if !constant(__builtin.__SINGLE_PRECISION_FLOAT__) case FLOAT8OID: #endif
b5b0152018-02-05Stephen R. van den Berg  case NUMERICOID:
fb8eb42014-10-31Stephen R. van den Berg  case TEXTOID: case OIDOID: case XMLOID: case MACADDROID: case BPCHAROID: case VARCHAROID: case CTIDOID: case UUIDOID: return 1; //binary } return 0; // text }
7d9a902017-12-11Stephen R. van den Berg private int writeoidformat(int oid, array(string|int) paramValues, array(int) ai) { mixed value = paramValues[ai[0]++]; switch (oid) { case BOOLOID: case BYTEAOID: case CHAROID: case INT8OID: case INT2OID: case INT4OID: case TEXTOID: case OIDOID: case XMLOID: case MACADDROID: case BPCHAROID: case VARCHAROID: case CTIDOID: case UUIDOID: return 1; //binary
b5b0152018-02-05Stephen R. van den Berg  case NUMERICOID:
7d9a902017-12-11Stephen R. van den Berg  case FLOAT4OID: #if !constant(__builtin.__SINGLE_PRECISION_FLOAT__) case FLOAT8OID: #endif if (!stringp(value)) return 1; } return 0; // text }
6eb5942014-11-12Stephen R. van den Berg private inline mixed callout(function(mixed ...:void) f,
7cd0e42017-11-18Stephen R. van den Berg  float|int delay, mixed ... args) {
569a922017-12-02Stephen R. van den Berg  return cb_backend->call_out(f, delay, @args);
0fed8c2014-11-10Stephen R. van den Berg }
933a762014-11-10Stephen R. van den Berg // Some pgsql utility functions
ecbab12008-07-27Stephen R. van den Berg 
3b31fa2014-11-14Stephen R. van den Berg class bufcon {
cff3a32014-09-12Stephen R. van den Berg  inherit Stdio.Buffer;
41b4c62017-11-10Stephen R. van den Berg  private Thread.ResourceCountKey dirty;
ecbab12008-07-27Stephen R. van den Berg 
8675b02017-06-03Stephen R. van den Berg #ifdef PG_DEBUGRACE final bufcon `chain() { return this; } #endif
3b31fa2014-11-14Stephen R. van den Berg  private conxion realbuffer;
ecbab12008-07-27Stephen R. van den Berg 
41b4c62017-11-10Stephen R. van den Berg  private void create(conxion _realbuffer) {
7cd0e42017-11-18Stephen R. van den Berg  realbuffer = _realbuffer;
ecbab12008-07-27Stephen R. van den Berg  }
d432822008-07-31Stephen R. van den Berg 
41b4c62017-11-10Stephen R. van den Berg  final Thread.ResourceCount `stashcount() {
bfa2552016-10-15Stephen R. van den Berg  return realbuffer->stashcount; }
3b31fa2014-11-14Stephen R. van den Berg  final bufcon start(void|int waitforreal) {
41b4c62017-11-10Stephen R. van den Berg  dirty = realbuffer->stashcount->acquire();
cff3a32014-09-12Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  if (waitforreal)
3b31fa2014-11-14Stephen R. van den Berg  error("pgsql.bufcon not allowed here\n");
d432822008-07-31Stephen R. van den Berg #endif
cff3a32014-09-12Stephen R. van den Berg  return this; }
7cd0e42017-11-18Stephen R. van den Berg  final void sendcmd(int mode, void|sql_result portal) { Thread.MutexKey lock = realbuffer->shortmux->lock();
04e6362017-07-03Stephen R. van den Berg  if (portal)
cff3a32014-09-12Stephen R. van den Berg  realbuffer->stashqueue->write(portal);
04e6362017-07-03Stephen R. van den Berg  if (mode == SYNCSEND) { add(PGSYNC); realbuffer->stashqueue->write(1); mode = SENDOUT; // Demote it to prevent an extra SYNC upon stashflush
1c847c2017-06-27Stephen R. van den Berg  }
cff3a32014-09-12Stephen R. van den Berg  realbuffer->stash->add(this);
04e6362017-07-03Stephen R. van den Berg  PD("%d>Stashed mode %d > %d\n",
3f39b52017-07-01Stephen R. van den Berg  realbuffer->socket->query_fd(), mode, realbuffer->stashflushmode); if (mode > realbuffer->stashflushmode) realbuffer->stashflushmode = mode;
4b46bb2018-05-22Stephen R. van den Berg  lock = 0;
41b4c62017-11-10Stephen R. van den Berg  dirty = 0;
cff3a32014-09-12Stephen R. van den Berg  this->clear();
7cd0e42017-11-18Stephen R. van den Berg  if (lock = realbuffer->nostash->trylock(1)) {
8675b02017-06-03Stephen R. van den Berg #ifdef PG_DEBUGRACE conxsess sess = conxsess(realbuffer); realbuffer->started = lock; lock = 0; sess->sendcmd(SENDOUT); #else realbuffer->started = lock; lock = 0;
0e7f332014-11-15Stephen R. van den Berg  realbuffer->sendcmd(SENDOUT);
8675b02017-06-03Stephen R. van den Berg #endif
cff3a32014-09-12Stephen R. van den Berg  }
d432822008-07-31Stephen R. van den Berg  }
74abb02014-11-24Stephen R. van den Berg };
ecbab12008-07-27Stephen R. van den Berg 
c639252014-11-20Stephen R. van den Berg class conxiin {
cff3a32014-09-12Stephen R. van den Berg  inherit Stdio.Buffer:i;
c639252014-11-20Stephen R. van den Berg  final Thread.Condition fillread;
c6d4972018-05-08Stephen R. van den Berg  final MUTEX fillreadmux;
279d842014-12-16Stephen R. van den Berg  final int procmsg;
05b0852014-11-25Stephen R. van den Berg  private int didreadcb;
c639252014-11-20Stephen R. van den Berg 
2ae2702018-05-18Stephen R. van den Berg #if PG_DEBUGHISTORY > 0 final array history = ({}); final int(-1..) input_from(Stdio.Stream stm, void|int(0..) nbytes) { int oldsize = sizeof(this); int ret = i::input_from(stm, nbytes); if (ret) { Stdio.Buffer tb = Stdio.Buffer(this); tb->consume(oldsize); history += ({"<<"+tb->read(ret)}); history = history[<PG_DEBUGHISTORY - 1 ..]; } return ret; } #endif
41b4c62017-11-10Stephen R. van den Berg  protected final bool range_error(int howmuch) {
c639252014-11-20Stephen R. van den Berg #ifdef PG_DEBUG
89dbb52018-05-17Stephen R. van den Berg  if (howmuch < 0) { int available = unread(0); unread(available); error("Out of range %d %O %O\n", howmuch, ((string)this)[.. available-1], ((string)this)[available ..]); }
c639252014-11-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  if (fillread) { Thread.MutexKey lock = fillreadmux->lock(); if (!didreadcb)
2d67a12014-11-25Stephen R. van den Berg  fillread.wait(lock);
7cd0e42017-11-18Stephen R. van den Berg  didreadcb = 0;
c639252014-11-20Stephen R. van den Berg  } else throw(MAGICTERMINATE); return true; }
7cd0e42017-11-18Stephen R. van den Berg  final int read_cb(mixed id, mixed b) {
08505c2017-07-01Stephen R. van den Berg  PD("Read callback %O\n", b && ((string)b)
8551f72016-10-12Stephen R. van den Berg #ifndef PG_DEBUGMORE [..255] #endif );
7cd0e42017-11-18Stephen R. van den Berg  Thread.MutexKey lock = fillreadmux->lock(); if (procmsg && id) procmsg = 0, lock = 0, Thread.Thread(id); else if (fillread) didreadcb = 1, fillread.signal();
c639252014-11-20Stephen R. van den Berg  return 0; }
41b4c62017-11-10Stephen R. van den Berg  private void create() {
c639252014-11-20Stephen R. van den Berg  i::create();
c6d4972018-05-08Stephen R. van den Berg  fillreadmux = MUTEX();
7cd0e42017-11-18Stephen R. van den Berg  fillread = Thread.Condition();
c639252014-11-20Stephen R. van den Berg  }
74abb02014-11-24Stephen R. van den Berg };
c639252014-11-20Stephen R. van den Berg 
57cfc62017-10-29Stephen R. van den Berg class sfile { inherit Stdio.File;
41b4c62017-11-10Stephen R. van den Berg  final int query_fd() {
57cfc62017-10-29Stephen R. van den Berg  return is_open() ? ::query_fd() : -1; } };
c639252014-11-20Stephen R. van den Berg class conxion {
cff3a32014-09-12Stephen R. van den Berg  inherit Stdio.Buffer:o;
c639252014-11-20Stephen R. van den Berg  final conxiin i;
cff3a32014-09-12Stephen R. van den Berg 
6eb5942014-11-12Stephen R. van den Berg  private Thread.Queue qportals;
c6d4972018-05-08Stephen R. van den Berg  final MUTEX shortmux;
fa4c472016-02-27Stephen R. van den Berg  private int closenext;
e7c7322016-02-24Stephen R. van den Berg 
7cd0e42017-11-18Stephen R. van den Berg  final sfile #if constant(SSL.File) |SSL.File #endif socket;
6eb5942014-11-12Stephen R. van den Berg  private int towrite;
7cd0e42017-11-18Stephen R. van den Berg  final multiset(sql_result) runningportals = (<>);
cff3a32014-09-12Stephen R. van den Berg 
c6d4972018-05-08Stephen R. van den Berg  final MUTEX nostash;
a362e32014-11-03Stephen R. van den Berg  final Thread.MutexKey started; final Thread.Queue stashqueue; final Thread.Condition stashavail; final Stdio.Buffer stash;
b52ad52018-01-20Stephen R. van den Berg  //! @ignore final int(KEEP..SYNCSEND) stashflushmode; //! @endignore
41b4c62017-11-10Stephen R. van den Berg  final Thread.ResourceCount stashcount;
a362e32014-11-03Stephen R. van den Berg  final int synctransact;
8675b02017-06-03Stephen R. van den Berg #ifdef PG_DEBUGRACE final mixed nostrack; #endif
cff3a32014-09-12Stephen R. van den Berg #ifdef PG_DEBUG
a362e32014-11-03Stephen R. van den Berg  final int queueoutidx;
7cd0e42017-11-18Stephen R. van den Berg  final int queueinidx = -1;
ecbab12008-07-27Stephen R. van den Berg #endif
2ae2702018-05-18Stephen R. van den Berg #if PG_DEBUGHISTORY > 0 final int(-1..) output_to(Stdio.Stream stm, void|int(0..) nbytes) { Stdio.Buffer tb = Stdio.Buffer(this); int ret = o::output_to(stm, nbytes); if (ret) { i->history += ({">>" + tb->read(ret)}); i->history = i->history[<PG_DEBUGHISTORY - 1 ..]; } return ret; } #endif
3b31fa2014-11-14Stephen R. van den Berg  private inline void queueup(sql_result portal) {
7cd0e42017-11-18Stephen R. van den Berg  qportals->write(portal); portal->_synctransact = synctransact; PD("%d>%O %d %d Queue portal %d bytes\n", socket->query_fd(), portal._portalname, ++queueoutidx, synctransact, sizeof(this));
4ef8a32014-10-29Stephen R. van den Berg  }
8675b02017-06-03Stephen R. van den Berg  final bufcon|conxsess start(void|int waitforreal) {
cff3a32014-09-12Stephen R. van den Berg  Thread.MutexKey lock;
c9ad7b2018-05-07Stephen R. van den Berg #ifdef PG_DEBUGRACE if (nostash->current_locking_thread()) PD("Nostash locked by %s\n", describe_backtrace(nostash->current_locking_thread()->backtrace())); #endif
c3317c2019-11-01Stephen R. van den Berg  while (lock = (waitforreal > 0 ? nostash->lock : nostash->trylock)(1)) {
fa3f9e2018-05-22Stephen R. van den Berg  int mode; if (sizeof(stash) && (mode = getstash(KEEP)) > KEEP)
9c553a2018-05-26Stephen R. van den Berg  sendcmd(mode); // Force out stash to the server
a0a76c2018-06-02Stephen R. van den Berg  if (!stashcount->drained()) { lock = 0; // Unlock while we wait stashcount->wait_till_drained(); continue; // Try again } #ifdef PG_DEBUGRACE conxsess sess = conxsess(this); #endif
9c553a2018-05-26Stephen R. van den Berg  started = lock; // sendcmd() clears started, so delay assignment
8675b02017-06-03Stephen R. van den Berg #ifdef PG_DEBUGRACE return sess; #else
cff3a32014-09-12Stephen R. van den Berg  return this;
8675b02017-06-03Stephen R. van den Berg #endif
cff3a32014-09-12Stephen R. van den Berg  }
c3317c2019-11-01Stephen R. van den Berg  return !waitforreal && bufcon(this)->start();
ecbab12008-07-27Stephen R. van den Berg  }
6eb5942014-11-12Stephen R. van den Berg  private int write_cb() {
b982c02016-10-14Stephen R. van den Berg  Thread.MutexKey lock = shortmux->lock();
5a8c952016-10-15Stephen R. van den Berg  if (this) { // Guard against async destructs towrite -= output_to(socket, towrite); lock = 0; if (!i->fillread && !sizeof(this)) close(); }
cff3a32014-09-12Stephen R. van den Berg  return 0; }
1c847c2017-06-27Stephen R. van den Berg  private int getstash(int mode) {
4b46bb2018-05-22Stephen R. van den Berg  Thread.MutexKey lock = shortmux->lock(); add(stash); stash->clear(); foreach (stashqueue->try_read_array(); ; int|sql_result portal) if (intp(portal)) qportals->write(synctransact++); else queueup(portal); PD("%d>Got stash mode %d > %d\n", socket->query_fd(), stashflushmode, mode); if (stashflushmode > mode) mode = stashflushmode; stashflushmode = KEEP;
1c847c2017-06-27Stephen R. van den Berg  return mode; }
771a162016-10-13Stephen R. van den Berg  final void sendcmd(void|int mode, void|sql_result portal) {
1c847c2017-06-27Stephen R. van den Berg  if (portal) queueup(portal); unfinalised:
6a5bed2014-11-13Stephen R. van den Berg  do {
771a162016-10-13Stephen R. van den Berg  switch (mode) {
6a5bed2014-11-13Stephen R. van den Berg  default:
1c847c2017-06-27Stephen R. van den Berg  break unfinalised;
0e7f332014-11-15Stephen R. van den Berg  case SYNCSEND:
bf75ce2014-11-15Stephen R. van den Berg  PD("%d>Sync %d %d Queue\n",
771a162016-10-13Stephen R. van den Berg  socket->query_fd(), synctransact, ++queueoutidx);
6a5bed2014-11-13Stephen R. van den Berg  add(PGSYNC);
771a162016-10-13Stephen R. van den Berg  mode = SENDOUT;
6a5bed2014-11-13Stephen R. van den Berg  break;
0e7f332014-11-15Stephen R. van den Berg  case FLUSHLOGSEND:
1c847c2017-06-27Stephen R. van den Berg  PD("%d>%O %d Queue simplequery %d bytes\n", socket->query_fd(), portal._portalname, ++queueoutidx, sizeof(this));
771a162016-10-13Stephen R. van den Berg  mode = FLUSHSEND;
6a5bed2014-11-13Stephen R. van den Berg  } qportals->write(synctransact++);
7cd0e42017-11-18Stephen R. van den Berg  } while (0);
4b46bb2018-05-22Stephen R. van den Berg  if (sizeof(stash)) mode = getstash(mode);
a952372018-05-23Stephen R. van den Berg #ifdef PG_DEBUG mixed err; #endif
4b46bb2018-05-22Stephen R. van den Berg  for(;;) {
7cd0e42017-11-18Stephen R. van den Berg #ifdef PG_DEBUG
a952372018-05-23Stephen R. van den Berg  err =
7cd0e42017-11-18Stephen R. van den Berg #endif
4b46bb2018-05-22Stephen R. van den Berg  catch {
4ef8a32014-10-29Stephen R. van den Berg outer:
4b46bb2018-05-22Stephen R. van den Berg  do { switch (mode) { default: PD("%d>Skip flush %d Queue %O\n", socket->query_fd(), mode, (string)this); break outer; case FLUSHSEND: PD("Flush\n"); add(PGFLUSH); case SENDOUT:; } if (towrite = sizeof(this)) { PD("%d>Sendcmd %O\n", socket->query_fd(), ((string)this)[..towrite-1]); towrite -= output_to(socket, towrite); } } while (0); started = 0;
9c553a2018-05-26Stephen R. van den Berg  if (sizeof(stash) && (started = nostash->trylock(2))) {
4b46bb2018-05-22Stephen R. van den Berg #ifdef PG_DEBUGRACE conxsess sess = conxsess(this); sess->sendcmd(SENDOUT); #else mode = getstash(SENDOUT); continue; #endif
a362e32014-11-03Stephen R. van den Berg  }
4b46bb2018-05-22Stephen R. van den Berg  return; }; break; } started = 0;
7cd0e42017-11-18Stephen R. van den Berg  PD("Sendcmd failed %s\n", describe_backtrace(err));
a0525b2017-11-17Stephen R. van den Berg  destruct(this);
ecbab12008-07-27Stephen R. van den Berg  }
cff3a32014-09-12Stephen R. van den Berg  final int close() {
7cd0e42017-11-18Stephen R. van den Berg  if (!closenext && nostash) { closenext = 1;
4d69e02017-11-28Stephen R. van den Berg  { Thread.MutexKey lock = i->fillreadmux->lock(); if (i->fillread) { // Delayed close() after flushing the output buffer i->fillread.signal(); i->fillread = 0; }
0983ca2016-02-17Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  PD("%d>Delayed close, flush write\n", socket->query_fd()); i->read_cb(socket->query_id(), 0);
6c48822016-02-28Stephen R. van den Berg  return 0; } else return -1;
ecbab12008-07-27Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  final void purge() { if (stashcount) { stashcount = 0; PD("%d>Purge conxion %d\n", socket ? socket->query_fd() : -1, !!nostash); int|sql_result portal; if (qportals) // CancelRequest does not use qportals while (portal = qportals->try_read()) if (objectp(portal)) portal->_purgeportal(); if (nostash) { while (sizeof(runningportals)) catch { foreach (runningportals; sql_result result; ) if (!result.datarowtypes) { result.datarowtypes = emptyarray; if (result._state != PURGED && !result.delayederror) result.delayederror = LOSTERROR; result._ddescribe->broadcast(); runningportals[result] = 0; } else destruct(result); };
6c48822016-02-28Stephen R. van den Berg  destruct(nostash);
ccb1172019-05-29Stephen R. van den Berg  if (socket->set_non_blocking) socket->set_non_blocking(); // Drop all callbacks
7cd0e42017-11-18Stephen R. van den Berg  PD("%d>Close socket\n", socket->query_fd()); socket->close(); // This will be an asynchronous close } destruct(this);
6c48822016-02-28Stephen R. van den Berg  }
ecbab12008-07-27Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  private void destroy() { PD("%d>Close conxion %d\n", socket ? socket->query_fd() : -1, !!nostash); catch(purge()); } final void connectloop(proxy pgsqlsess, int nossl) {
966ee82017-11-21Stephen R. van den Berg #ifdef PG_DEBUG mixed err = #endif catch {
7cd0e42017-11-18Stephen R. van den Berg  for (; ; clear()) { socket->connect(pgsqlsess. host, pgsqlsess. port);
fc7f092014-06-01Martin Nilsson #if constant(SSL.File)
7cd0e42017-11-18Stephen R. van den Berg  if (!nossl && !pgsqlsess->nossl && (pgsqlsess.options.use_ssl || pgsqlsess.options.force_ssl)) {
cff3a32014-09-12Stephen R. van den Berg  PD("SSLRequest\n");
7cd0e42017-11-18Stephen R. van den Berg  start()->add_int32(8)->add_int32(PG_PROTOCOL(1234, 5679))
0e7f332014-11-15Stephen R. van den Berg  ->sendcmd(SENDOUT);
7ae3902017-11-21Stephen R. van den Berg  string s = socket.read(1); switch (sizeof(s) && s[0]) {
cff3a32014-09-12Stephen R. van den Berg  case 'S':
7cd0e42017-11-18Stephen R. van den Berg  SSL.File fcon = SSL.File(socket, SSL.Context()); if (fcon->connect()) {
356f7e2017-11-21Stephen R. van den Berg  socket->set_backend(local_backend);
7cd0e42017-11-18Stephen R. van den Berg  socket = fcon;
cff3a32014-09-12Stephen R. van den Berg  break; }
1cb5e72016-12-06Stephen R. van den Berg  default: PD("%d>Close socket short\n", socket->query_fd());
bf75ce2014-11-15Stephen R. van den Berg  socket->close();
7cd0e42017-11-18Stephen R. van den Berg  pgsqlsess.nossl = 1;
cff3a32014-09-12Stephen R. van den Berg  continue; case 'N':
7cd0e42017-11-18Stephen R. van den Berg  if (pgsqlsess.options.force_ssl)
cff3a32014-09-12Stephen R. van den Berg  error("Encryption not supported on connection to %s:%d\n",
7cd0e42017-11-18Stephen R. van den Berg  pgsqlsess.host, pgsqlsess.port);
cff3a32014-09-12Stephen R. van den Berg  } } #else
7cd0e42017-11-18Stephen R. van den Berg  if (pgsqlsess.options.force_ssl)
cff3a32014-09-12Stephen R. van den Berg  error("Encryption library missing," " cannot establish connection to %s:%d\n",
7cd0e42017-11-18Stephen R. van den Berg  pgsqlsess.host, pgsqlsess.port);
cff3a32014-09-12Stephen R. van den Berg #endif break; }
7cd0e42017-11-18Stephen R. van den Berg  if (!socket->is_open()) error(strerror(socket->errno()) + ".\n");
cff3a32014-09-12Stephen R. van den Berg  socket->set_backend(local_backend);
7cd0e42017-11-18Stephen R. van den Berg  socket->set_buffer_mode(i, 0); socket->set_nonblocking(i->read_cb, write_cb, close);
a0525b2017-11-17Stephen R. van den Berg  if (nossl != 2)
7cd0e42017-11-18Stephen R. van den Berg  Thread.Thread(pgsqlsess->processloop, this);
cff3a32014-09-12Stephen R. van den Berg  return; };
966ee82017-11-21Stephen R. van den Berg  PD("Connect error %s\n", describe_backtrace(err));
7cd0e42017-11-18Stephen R. van den Berg  catch(destruct(pgsqlsess->waitforauthready));
a0525b2017-11-17Stephen R. van den Berg  destruct(this);
0d1a5e2014-11-14Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  private string _sprintf(int type) { string res; switch (type) {
0d1a5e2014-11-14Stephen R. van den Berg  case 'O':
7cd0e42017-11-18Stephen R. van den Berg  int fd = -1; if (socket) catch(fd = socket->query_fd()); res = predef::sprintf("conxion fd: %d input queue: %d/%d "
8675b02017-06-03Stephen R. van den Berg  "queued portals: %d output queue: %d/%d\n"
41b4c62017-11-10Stephen R. van den Berg  "started: %d\n",
7cd0e42017-11-18Stephen R. van den Berg  fd, sizeof(i), i->_size_object(),
2434502017-07-01Stephen R. van den Berg  qportals && qportals->size(), sizeof(this), _size_object(),
41b4c62017-11-10Stephen R. van den Berg  !!started);
0d1a5e2014-11-14Stephen R. van den Berg  break; } return res;
cff3a32014-09-12Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  private void create(proxy pgsqlsess, Thread.Queue _qportals, int nossl) {
c639252014-11-20Stephen R. van den Berg  o::create();
cff3a32014-09-12Stephen R. van den Berg  qportals = _qportals;
4ef8a32014-10-29Stephen R. van den Berg  synctransact = 1;
7cd0e42017-11-18Stephen R. van den Berg  socket = sfile(); i = conxiin();
c6d4972018-05-08Stephen R. van den Berg  shortmux = MUTEX(); nostash = MUTEX();
fa4c472016-02-27Stephen R. van den Berg  closenext = 0;
7cd0e42017-11-18Stephen R. van den Berg  stashavail = Thread.Condition(); stashqueue = Thread.Queue(); stash = Stdio.Buffer();
41b4c62017-11-10Stephen R. van den Berg  stashcount = Thread.ResourceCount();
7cd0e42017-11-18Stephen R. van den Berg  Thread.Thread(connectloop, pgsqlsess, nossl);
ecbab12008-07-27Stephen R. van den Berg  }
74abb02014-11-24Stephen R. van den Berg };
ecbab12008-07-27Stephen R. van den Berg 
8675b02017-06-03Stephen R. van den Berg #ifdef PG_DEBUGRACE class conxsess { final conxion chain;
41b4c62017-11-10Stephen R. van den Berg  private void create(conxion parent) {
8675b02017-06-03Stephen R. van den Berg  if (parent->started) werror("Overwriting conxsess %s %s\n", describe_backtrace(({"new ", backtrace()[..<1]})), describe_backtrace(({"old ", parent->nostrack}))); parent->nostrack = backtrace(); chain = parent; }
7cd0e42017-11-18Stephen R. van den Berg  final void sendcmd(int mode, void|sql_result portal) {
8675b02017-06-03Stephen R. van den Berg  chain->sendcmd(mode, portal); chain = 0; }
41b4c62017-11-10Stephen R. van den Berg  private void destroy() {
8675b02017-06-03Stephen R. van den Berg  if (chain) werror("Untransmitted conxsess %s\n", describe_backtrace(({"", backtrace()[..<1]}))); } }; #endif
f4c9d62009-02-15Stephen R. van den Berg //! The result object returned by @[Sql.pgsql()->big_query()], except for
0412962009-01-19Stephen R. van den Berg //! the noted differences it behaves the same as @[Sql.sql_result]. //! //! @seealso
f4c9d62009-02-15Stephen R. van den Berg //! @[Sql.sql_result], @[Sql.pgsql], @[Sql.Sql], @[Sql.pgsql()->big_query()]
3b31fa2014-11-14Stephen R. van den Berg class sql_result {
ecbab12008-07-27Stephen R. van den Berg 
7cd0e42017-11-18Stephen R. van den Berg  private proxy pgsqlsess; private int(0..1) eoffound;
3b31fa2014-11-14Stephen R. van den Berg  private conxion c;
c639252014-11-20Stephen R. van den Berg  private conxiin cr;
36945e2017-11-22Stephen R. van den Berg  final int(0..1) untolderror;
7cd0e42017-11-18Stephen R. van den Berg  final mixed delayederror;
b52ad52018-01-20Stephen R. van den Berg  //! @ignore final int(PORTALINIT..PURGED) _state; //! @endignore
a362e32014-11-03Stephen R. van den Berg  final int _fetchlimit;
7cd0e42017-11-18Stephen R. van den Berg  private int(0..1) alltext; final int(0..1) _forcetext;
f908742017-02-04Stephen R. van den Berg  private int syncparse;
bd47ec2017-06-25Stephen R. van den Berg  private int transtype;
a362e32014-11-03Stephen R. van den Berg  final string _portalname;
383cad2017-11-24Stephen R. van den Berg  private int index;
bf20922014-11-17Stephen R. van den Berg  private int inflight;
7cd0e42017-11-18Stephen R. van den Berg  int portalbuffersize;
c6d4972018-05-08Stephen R. van den Berg  private MUTEX closemux;
bf20922014-11-17Stephen R. van den Berg  private Thread.Queue datarows;
41b4c62017-11-10Stephen R. van den Berg  private Thread.ResourceCountKey stmtifkey, portalsifkey;
15d4e12014-11-18Stephen R. van den Berg  private array(mapping(string:mixed)) datarowdesc;
7cd0e42017-11-18Stephen R. van den Berg  final array(int) datarowtypes; // types from datarowdesc
bf20922014-11-17Stephen R. van den Berg  private string statuscmdcomplete;
15d4e12014-11-18Stephen R. van den Berg  private int bytesreceived;
a362e32014-11-03Stephen R. van den Berg  final int _synctransact; final Thread.Condition _ddescribe;
c6d4972018-05-08Stephen R. van den Berg  final MUTEX _ddescribemux;
7cd0e42017-11-18Stephen R. van den Berg  final Thread.MutexKey _unnamedportalkey, _unnamedstatementkey;
a362e32014-11-03Stephen R. van den Berg  final array _params; final string _query; final string _preparedname; final mapping(string:mixed) _tprepared;
1611e42014-11-28Stephen R. van den Berg  private function(:void) gottimeout; private int timeout;
ecbab12008-07-27Stephen R. van den Berg 
41b4c62017-11-10Stephen R. van den Berg  protected string _sprintf(int type) {
7cd0e42017-11-18Stephen R. van den Berg  string res; switch (type) {
cff3a32014-09-12Stephen R. van den Berg  case 'O':
7cd0e42017-11-18Stephen R. van den Berg  int fd = -1; if (c && c->socket) catch(fd = c->socket->query_fd());
b901be2018-05-26Stephen R. van den Berg  res = sprintf( "sql_result state: %d numrows: %d eof: %d inflight: %d\n" "fd: %O portalname: %O coltypes: %d" " synctransact: %d laststatus: %s\n" "stash: %O\n"
2ae2702018-05-18Stephen R. van den Berg #if PG_DEBUGHISTORY > 0
b901be2018-05-26Stephen R. van den Berg  "history: %O\n"
2ae2702018-05-18Stephen R. van den Berg #endif
b901be2018-05-26Stephen R. van den Berg  "query: %O\n%s\n", _state, index, eoffound, inflight, fd, _portalname, datarowtypes && sizeof(datarowtypes), _synctransact, statuscmdcomplete || (_unnamedstatementkey ? "*parsing*" : ""), qalreadyprinted == this ? 0 : c && (string)c->stash,
2ae2702018-05-18Stephen R. van den Berg #if PG_DEBUGHISTORY > 0
b901be2018-05-26Stephen R. van den Berg  qalreadyprinted == this ? 0 : c && c->i->history,
2ae2702018-05-18Stephen R. van den Berg #endif
b901be2018-05-26Stephen R. van den Berg  qalreadyprinted == this ? "..." : replace(_query, "xxxx\n", "\\n"), qalreadyprinted == this ? "..." : _showbindings()*"\n");
c6d4972018-05-08Stephen R. van den Berg  qalreadyprinted = this;
cff3a32014-09-12Stephen R. van den Berg  break;
11b13b2014-08-16Martin Nilsson  } return res;
ecbab12008-07-27Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  protected void create(proxy _pgsqlsess, conxion _c, string query, int _portalbuffersize, int alltyped, array params, int forcetext,
bd47ec2017-06-25Stephen R. van den Berg  int _timeout, int _syncparse, int _transtype) {
a362e32014-11-03Stephen R. van den Berg  pgsqlsess = _pgsqlsess;
4d69e02017-11-28Stephen R. van den Berg  if (c = _c) cr = c->i; else
09206e2017-11-15Stephen R. van den Berg  losterror();
11b13b2014-08-16Martin Nilsson  _query = query;
bf20922014-11-17Stephen R. van den Berg  datarows = Thread.Queue();
7cd0e42017-11-18Stephen R. van den Berg  _ddescribe = Thread.Condition();
c6d4972018-05-08Stephen R. van den Berg  _ddescribemux = MUTEX(); closemux = MUTEX();
7cd0e42017-11-18Stephen R. van den Berg  portalbuffersize = _portalbuffersize;
15d4e12014-11-18Stephen R. van den Berg  alltext = !alltyped;
11b13b2014-08-16Martin Nilsson  _params = params; _forcetext = forcetext;
0e7f332014-11-15Stephen R. van den Berg  _state = PORTALINIT;
1611e42014-11-28Stephen R. van den Berg  timeout = _timeout;
f908742017-02-04Stephen R. van den Berg  syncparse = _syncparse;
1611e42014-11-28Stephen R. van den Berg  gottimeout = _pgsqlsess->cancelquery;
7cd0e42017-11-18Stephen R. van den Berg  c->runningportals[this] = 1;
bd47ec2017-06-25Stephen R. van den Berg  transtype = _transtype;
11b13b2014-08-16Martin Nilsson  }
ecbab12008-07-27Stephen R. van den Berg 
b901be2018-05-26Stephen R. van den Berg  final array(string) _showbindings() { array(string) msgs = emptyarray; if (_params) { array from, to, paramValues; [from, to, paramValues] = _params; if (sizeof(paramValues)) { int i; string val, fmt = sprintf("%%%ds %%3s %%.61s", max(@map(from, sizeof))); foreach (paramValues; i; val) msgs += ({sprintf(fmt, from[i], to[i], sprintf("%O", val))}); } } return msgs; }
11b13b2014-08-16Martin Nilsson  //! Returns the command-complete status for this query. //!
57c80f2018-05-01Stephen R. van den Berg  //! @note
c6d6612017-11-16Stephen R. van den Berg  //! This function is PostgreSQL-specific.
57c80f2018-05-01Stephen R. van den Berg  //!
046e792018-05-05Stephen R. van den Berg  //! @seealso //! @[affected_rows()]
74abb02014-11-24Stephen R. van den Berg  /*semi*/final string status_command_complete() {
046e792018-05-05Stephen R. van den Berg  if (!statuscmdcomplete) { if (!datarowtypes) waitfordescribe(); { Thread.MutexKey lock = closemux->lock();
c6d4972018-05-08Stephen R. van den Berg  if (_fetchlimit) {
c3317c2019-11-01Stephen R. van den Berg  array reflock = ({ _fetchlimit = 0 }); for (;;) { reflock[0] = lock; lock = 0; if (!_sendexecute(0, reflock)) { lock = closemux->lock(); continue; } }
c6d4972018-05-08Stephen R. van den Berg  } else lock = 0; // Force release before acquiring next
046e792018-05-05Stephen R. van den Berg  lock = _ddescribemux->lock(); if (!statuscmdcomplete) PT(_ddescribe->wait(lock)); } if (this) // If object already destructed, skip the next call trydelayederror(); // since you cannot call functions anymore else error(LOSTERROR); }
bf20922014-11-17Stephen R. van den Berg  return statuscmdcomplete;
11b13b2014-08-16Martin Nilsson  }
ecbab12008-07-27Stephen R. van den Berg 
11b13b2014-08-16Martin Nilsson  //! Returns the number of affected rows by this query. //!
57c80f2018-05-01Stephen R. van den Berg  //! @note
c6d6612017-11-16Stephen R. van den Berg  //! This function is PostgreSQL-specific.
57c80f2018-05-01Stephen R. van den Berg  //! //! @seealso
046e792018-05-05Stephen R. van den Berg  //! @[num_rows()], @[status_command_complete()]
74abb02014-11-24Stephen R. van den Berg  /*semi*/final int affected_rows() {
11b13b2014-08-16Martin Nilsson  int rows;
046e792018-05-05Stephen R. van den Berg  sscanf(status_command_complete() || "", "%*s %d %d", rows, rows);
11b13b2014-08-16Martin Nilsson  return rows; }
ecbab12008-07-27Stephen R. van den Berg 
15d4e12014-11-18Stephen R. van den Berg  final void _storetiming() {
7cd0e42017-11-18Stephen R. van den Berg  if (_tprepared) { _tprepared.trun = gethrtime() - _tprepared.trunstart; m_delete(_tprepared, "trunstart"); _tprepared = 0;
15d4e12014-11-18Stephen R. van den Berg  } }
6eb5942014-11-12Stephen R. van den Berg  private void waitfordescribe() {
4d69e02017-11-28Stephen R. van den Berg  { Thread.MutexKey lock = _ddescribemux->lock(); if (!datarowtypes) PT(_ddescribe->wait(lock)); }
7cd0e42017-11-18Stephen R. van den Berg  if (this) // If object already destructed, skip the next call trydelayederror(); // since you cannot call functions anymore else error(LOSTERROR);
fb8eb42014-10-31Stephen R. van den Berg  }
11b13b2014-08-16Martin Nilsson  //! @seealso //! @[Sql.sql_result()->num_fields()]
74abb02014-11-24Stephen R. van den Berg  /*semi*/final int num_fields() {
7cd0e42017-11-18Stephen R. van den Berg  if (!datarowtypes)
fb8eb42014-10-31Stephen R. van den Berg  waitfordescribe();
192acd2014-11-22Stephen R. van den Berg  return sizeof(datarowtypes);
11b13b2014-08-16Martin Nilsson  }
ecbab12008-07-27Stephen R. van den Berg 
bbb4ce2014-11-24Stephen R. van den Berg  //! @note //! This method returns the number of rows already received from //! the database for the current query. Note that this number //! can still increase between subsequent calls if the results from //! the query are not complete yet. This function is only guaranteed to //! return the correct count after EOF has been reached.
11b13b2014-08-16Martin Nilsson  //! @seealso //! @[Sql.sql_result()->num_rows()]
74abb02014-11-24Stephen R. van den Berg  /*semi*/final int num_rows() {
fb8eb42014-10-31Stephen R. van den Berg  trydelayederror();
7022d62017-11-22Stephen R. van den Berg  return index;
11b13b2014-08-16Martin Nilsson  }
ecbab12008-07-27Stephen R. van den Berg 
09206e2017-11-15Stephen R. van den Berg  private void losterror() { string err; if (pgsqlsess)
7cd0e42017-11-18Stephen R. van den Berg  err = pgsqlsess->geterror(1); error("%s\n", err || LOSTERROR);
09206e2017-11-15Stephen R. van den Berg  } private void trydelayederror() {
7cd0e42017-11-18Stephen R. van den Berg  if (delayederror)
cff3a32014-09-12Stephen R. van den Berg  throwdelayederror(this);
09206e2017-11-15Stephen R. van den Berg  else if (_state == PURGED) losterror();
cff3a32014-09-12Stephen R. van den Berg  }
11b13b2014-08-16Martin Nilsson  //! @seealso //! @[Sql.sql_result()->eof()]
74abb02014-11-24Stephen R. van den Berg  /*semi*/final int eof() {
cff3a32014-09-12Stephen R. van den Berg  trydelayederror();
11b13b2014-08-16Martin Nilsson  return eoffound; }
ecbab12008-07-27Stephen R. van den Berg 
11b13b2014-08-16Martin Nilsson  //! @seealso //! @[Sql.sql_result()->fetch_fields()]
74abb02014-11-24Stephen R. van den Berg  /*semi*/final array(mapping(string:mixed)) fetch_fields() {
7cd0e42017-11-18Stephen R. van den Berg  if (!datarowtypes)
fb8eb42014-10-31Stephen R. van den Berg  waitfordescribe();
7cd0e42017-11-18Stephen R. van den Berg  if (!datarowdesc) error(LOSTERROR); return datarowdesc + emptyarray;
15d4e12014-11-18Stephen R. van den Berg  } #ifdef PG_DEBUG
74abb02014-11-24Stephen R. van den Berg #define INTVOID int
15d4e12014-11-18Stephen R. van den Berg #else
74abb02014-11-24Stephen R. van den Berg #define INTVOID void
15d4e12014-11-18Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  final INTVOID _decodedata(int msglen, string cenc) {
cfa2482017-06-18Stephen R. van den Berg  _storetiming(); _releasestatement();
15d4e12014-11-18Stephen R. van den Berg  string serror;
7cd0e42017-11-18Stephen R. van den Berg  bytesreceived += msglen; int cols = cr->read_int16(); array a = allocate(cols, !alltext && Val.null);
15d4e12014-11-18Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  msglen -= 2 + 4 * cols;
15d4e12014-11-18Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  foreach (datarowtypes; int i; int typ) { int collen = cr->read_sint(4); if (collen > 0) {
15d4e12014-11-18Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  msglen -= collen;
15d4e12014-11-18Stephen R. van den Berg #endif mixed value;
7cd0e42017-11-18Stephen R. van den Berg  switch (typ) {
15d4e12014-11-18Stephen R. van den Berg  case FLOAT4OID:
7d9a902017-12-11Stephen R. van den Berg #if !constant(__builtin.__SINGLE_PRECISION_FLOAT__)
15d4e12014-11-18Stephen R. van den Berg  case FLOAT8OID: #endif
7d9a902017-12-11Stephen R. van den Berg  if (_forcetext) { if (!alltext) { value = (float)cr->read(collen); break; } } else { [ value ] = cr->sscanf(collen == 4 ? "%4F" : "%8F"); if (alltext)
94559c2018-02-01Stephen R. van den Berg  value = sprintf("%.*g", collen == 4 ? 9 : 17, value);
15d4e12014-11-18Stephen R. van den Berg  break; }
7cd0e42017-11-18Stephen R. van den Berg  default:value = cr->read(collen);
15d4e12014-11-18Stephen R. van den Berg  break; case CHAROID:
7cd0e42017-11-18Stephen R. van den Berg  value = alltext ? cr->read(1) : cr->read_int8();
15d4e12014-11-18Stephen R. van den Berg  break;
7cd0e42017-11-18Stephen R. van den Berg  case BOOLOID:value = cr->read_int8(); switch (value) { case 'f':value = 0;
15d4e12014-11-18Stephen R. van den Berg  break;
7cd0e42017-11-18Stephen R. van den Berg  case 't':value = 1;
15d4e12014-11-18Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  if (alltext) value = value ? "t" : "f";
15d4e12014-11-18Stephen R. van den Berg  break; case TEXTOID: case BPCHAROID: case VARCHAROID:
7cd0e42017-11-18Stephen R. van den Berg  value = cr->read(collen); if (cenc == UTF8CHARSET && catch(value = utf8_to_string(value))
15d4e12014-11-18Stephen R. van den Berg  && !serror)
7cd0e42017-11-18Stephen R. van den Berg  serror = SERROR("%O contains non-%s characters\n", value, UTF8CHARSET);
15d4e12014-11-18Stephen R. van den Berg  break;
b5b0152018-02-05Stephen R. van den Berg  case NUMERICOID: if (_forcetext) { value = cr->read(collen); if (!alltext) { value = value/"."; if (sizeof(value) == 1) value = (int)value[0]; else {
e4c30e2018-02-06Stephen R. van den Berg  int i, denom; for (i = sizeof(value[1]), denom = 1; --i >= 0; denom *= 10); i = (int)value[0]; value = (int)value[1]; value = Gmp.mpq(i * denom + (i >= 0 ? value : -value),
b5b0152018-02-05Stephen R. van den Berg  denom); } } } else { int nwords = cr->read_int16(); int magnitude = cr->read_sint(2); int sign = cr->read_int16(); cr->consume(2);
f14f5c2018-03-10Stephen R. van den Berg  if (nwords) { for (value = cr->read_int16(); --nwords; magnitude--) value = value * NUMERIC_MAGSTEP + cr->read_int16(); if (sign) value = -value; if (magnitude > 0) do value *= NUMERIC_MAGSTEP; while (--magnitude); else if (magnitude < 0) { for (sign = NUMERIC_MAGSTEP; ++magnitude; sign *= NUMERIC_MAGSTEP); value = Gmp.mpq(value, sign); } } else value = 0;
e4c30e2018-02-06Stephen R. van den Berg  if (alltext) value = (string)value;
b5b0152018-02-05Stephen R. van den Berg  } break;
15d4e12014-11-18Stephen R. van den Berg  case INT8OID:case INT2OID: case OIDOID:case INT4OID:
7cd0e42017-11-18Stephen R. van den Berg  if (_forcetext) { value = cr->read(collen); if (!alltext) value = (int)value;
15d4e12014-11-18Stephen R. van den Berg  } else {
7cd0e42017-11-18Stephen R. van den Berg  switch (typ) { case INT8OID:value = cr->read_sint(8);
15d4e12014-11-18Stephen R. van den Berg  break;
7cd0e42017-11-18Stephen R. van den Berg  case INT2OID:value = cr->read_sint(2);
15d4e12014-11-18Stephen R. van den Berg  break; case OIDOID:
7cd0e42017-11-18Stephen R. van den Berg  case INT4OID:value = cr->read_sint(4);
15d4e12014-11-18Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  if (alltext) value = (string)value;
15d4e12014-11-18Stephen R. van den Berg  } } a[i]=value;
7cd0e42017-11-18Stephen R. van den Berg  } else if (!collen)
15d4e12014-11-18Stephen R. van den Berg  a[i]=""; } _processdataready(a);
7cd0e42017-11-18Stephen R. van den Berg  if (serror)
15d4e12014-11-18Stephen R. van den Berg  error(serror); #ifdef PG_DEBUG return msglen; #endif
11b13b2014-08-16Martin Nilsson  }
ecbab12008-07-27Stephen R. van den Berg 
a2b20d2014-11-25Stephen R. van den Berg  final void _setrowdesc(array(mapping(string:mixed)) drowdesc, array(int) drowtypes) {
7cd0e42017-11-18Stephen R. van den Berg  Thread.MutexKey lock = _ddescribemux->lock(); datarowdesc = drowdesc; datarowtypes = drowtypes;
fb8eb42014-10-31Stephen R. van den Berg  _ddescribe->broadcast(); }
42fc8c2014-11-03Stephen R. van den Berg  final void _preparebind(array dtoid) {
b901be2018-05-26Stephen R. van den Berg  array(string|int) paramValues = _params ? _params[2] : emptyarray;
7cd0e42017-11-18Stephen R. van den Berg  if (sizeof(dtoid) != sizeof(paramValues))
fb8eb42014-10-31Stephen R. van den Berg  SUSERERROR("Invalid number of bindings, expected %d, got %d\n",
7cd0e42017-11-18Stephen R. van den Berg  sizeof(dtoid), sizeof(paramValues)); Thread.MutexKey lock = _ddescribemux->lock(); if (!_portalname) { _portalname = (_unnamedportalkey = pgsqlsess.unnamedportalmux->trylock(1))
2cdb902014-11-18Stephen R. van den Berg  ? "" : PORTALPREFIX #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  + (string)(c->socket->query_fd()) + "_"
2cdb902014-11-18Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  + String.int2hex(pgsqlsess.pportalcount++); lock = 0;
fb8eb42014-10-31Stephen R. van den Berg #ifdef PG_DEBUGMORE
7cd0e42017-11-18Stephen R. van den Berg  PD("ParamValues to bind: %O\n", paramValues);
fb8eb42014-10-31Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  Stdio.Buffer plugbuffer = Stdio.Buffer(); { array dta = ({sizeof(dtoid)}); plugbuffer->add(_portalname, 0, _preparedname, 0)
7d9a902017-12-11Stephen R. van den Berg  ->add_ints(dta + map(dtoid, writeoidformat, paramValues, ({0})) + dta, 2);
78b2c52014-11-26Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  string cenc = pgsqlsess.runtimeparameter[CLIENT_ENCODING]; foreach (paramValues; int i; mixed value) { if (undefinedp(value) || objectp(value) && value->is_val_null)
2cdb902014-11-18Stephen R. van den Berg  plugbuffer->add_int32(-1); // NULL
7cd0e42017-11-18Stephen R. van den Berg  else if (stringp(value) && !sizeof(value)) { int k = 0; switch (dtoid[i]) {
2cdb902014-11-18Stephen R. van den Berg  default:
7cd0e42017-11-18Stephen R. van den Berg  k = -1; // cast empty strings to NULL for non-string types
2cdb902014-11-18Stephen R. van den Berg  case BYTEAOID: case TEXTOID: case XMLOID: case BPCHAROID: case VARCHAROID:; } plugbuffer->add_int32(k); } else
7cd0e42017-11-18Stephen R. van den Berg  switch (dtoid[i]) {
2cdb902014-11-18Stephen R. van den Berg  case TEXTOID: case BPCHAROID: case VARCHAROID: {
7cd0e42017-11-18Stephen R. van den Berg  if (!value) {
2cdb902014-11-18Stephen R. van den Berg  plugbuffer->add_int32(-1); break; }
7cd0e42017-11-18Stephen R. van den Berg  value = (string)value; switch (cenc) {
2cdb902014-11-18Stephen R. van den Berg  case UTF8CHARSET:
7cd0e42017-11-18Stephen R. van den Berg  value = string_to_utf8(value);
2cdb902014-11-18Stephen R. van den Berg  break; default:
7cd0e42017-11-18Stephen R. van den Berg  if (String.width(value)>8) {
2cdb902014-11-18Stephen R. van den Berg  SUSERERROR("Don't know how to convert %O to %s encoding\n",
7cd0e42017-11-18Stephen R. van den Berg  value, cenc);
2cdb902014-11-18Stephen R. van den Berg  value=""; } }
7cd0e42017-11-18Stephen R. van den Berg  plugbuffer->add_hstring(value, 4);
fb8eb42014-10-31Stephen R. van den Berg  break; }
2cdb902014-11-18Stephen R. van den Berg  default: {
7cd0e42017-11-18Stephen R. van den Berg  if (!value) {
2cdb902014-11-18Stephen R. van den Berg  plugbuffer->add_int32(-1);
fb8eb42014-10-31Stephen R. van den Berg  break;
2cdb902014-11-18Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  if (!objectp(value) || typeof(value) != typeof(Stdio.Buffer())); /* * Like Oracle and SQLite, we accept literal binary values * from single-valued multisets. */ if (multisetp(value) && sizeof(value) == 1) value = indices(value)[0]; else {
d99e6e2017-07-10Stephen R. van den Berg  value = (string)value; if (String.width(value) > 8) if (dtoid[i] == BYTEAOID)
7cd0e42017-11-18Stephen R. van den Berg  /*
d99e6e2017-07-10Stephen R. van den Berg  * FIXME We should throw an error here, it would
7cd0e42017-11-18Stephen R. van den Berg  * have been correct, but for historical reasons and * as a DWIM convenience we autoconvert to UTF8 here.
d99e6e2017-07-10Stephen R. van den Berg  */ value = string_to_utf8(value); else { SUSERERROR(
7cd0e42017-11-18Stephen R. van den Berg  "Wide string %O not supported for type OID %d\n", value, dtoid[i]); value = "";
d99e6e2017-07-10Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  } plugbuffer->add_hstring(value, 4);
fb8eb42014-10-31Stephen R. van den Berg  break; }
f782e92014-11-25Stephen R. van den Berg  case BOOLOID:
2cdb902014-11-18Stephen R. van den Berg  do { int tval;
7cd0e42017-11-18Stephen R. van den Berg  if (stringp(value)) tval = value[0]; else if (!intp(value)) { value = !!value; // cast to boolean
fb8eb42014-10-31Stephen R. van den Berg  break;
2cdb902014-11-18Stephen R. van den Berg  } else
7cd0e42017-11-18Stephen R. van den Berg  tval = value; switch (tval) {
2cdb902014-11-18Stephen R. van den Berg  case 'o':case 'O': catch {
7cd0e42017-11-18Stephen R. van den Berg  tval = value[1]; value = tval == 'n' || tval == 'N';
2cdb902014-11-18Stephen R. van den Berg  };
fb8eb42014-10-31Stephen R. van den Berg  break;
2cdb902014-11-18Stephen R. van den Berg  default:
7cd0e42017-11-18Stephen R. van den Berg  value = 1;
2cdb902014-11-18Stephen R. van den Berg  break; case 0:case '0':case 'f':case 'F':case 'n':case 'N':
7cd0e42017-11-18Stephen R. van den Berg  value = 0;
2cdb902014-11-18Stephen R. van den Berg  break; }
7cd0e42017-11-18Stephen R. van den Berg  } while (0);
0570d52017-12-11Stephen R. van den Berg  plugbuffer->add("\0\0\0\1", value);
2cdb902014-11-18Stephen R. van den Berg  break; case CHAROID:
7cd0e42017-11-18Stephen R. van den Berg  if (intp(value)) plugbuffer->add_hstring(value, 4);
2cdb902014-11-18Stephen R. van den Berg  else {
7cd0e42017-11-18Stephen R. van den Berg  value = (string)value; switch (sizeof(value)) {
2cdb902014-11-18Stephen R. van den Berg  default: SUSERERROR(
7cd0e42017-11-18Stephen R. van den Berg  "\"char\" types must be 1 byte wide, got %O\n", value);
2cdb902014-11-18Stephen R. van den Berg  case 0: plugbuffer->add_int32(-1); // NULL break; case 1:
7cd0e42017-11-18Stephen R. van den Berg  plugbuffer->add_hstring(value[0], 4);
2cdb902014-11-18Stephen R. van den Berg  }
fb8eb42014-10-31Stephen R. van den Berg  }
2cdb902014-11-18Stephen R. van den Berg  break;
b5b0152018-02-05Stephen R. van den Berg  case NUMERICOID: if (stringp(value)) plugbuffer->add_hstring(value, 4); else { int num, den, sign, magnitude = 0; value = Gmp.mpq(value); num = value->num(); den = value->den(); for (value = den; value > NUMERIC_MAGSTEP; value /= NUMERIC_MAGSTEP); if (value > 1) { value = NUMERIC_MAGSTEP / value; num *= value; den *= value; } if (num < 0) sign = 0x4000, num = -num; else sign = 0; array stor = ({}); if (num) { while (!(num % NUMERIC_MAGSTEP)) num /= NUMERIC_MAGSTEP, magnitude++; do stor = ({num % NUMERIC_MAGSTEP}) + stor, magnitude++; while (num /= NUMERIC_MAGSTEP); num = --magnitude << 2; while (den > 1) magnitude--, den /= NUMERIC_MAGSTEP; } plugbuffer->add_int32(4 * 2 + (sizeof(stor) << 1)) ->add_int16(sizeof(stor))->add_int16(magnitude) ->add_int16(sign)->add_int16(num)->add_ints(stor, 2); } break;
7d9a902017-12-11Stephen R. van den Berg  case FLOAT4OID: #if !constant(__builtin.__SINGLE_PRECISION_FLOAT__) case FLOAT8OID: #endif if (stringp(value)) plugbuffer->add_hstring(value, 4); else { int w = dtoid[i] == FLOAT4OID ? 4 : 8; plugbuffer->add_int32(w) ->sprintf(w == 4 ? "%4F" : "%8F", value); } break;
2cdb902014-11-18Stephen R. van den Berg  case INT8OID:
7cd0e42017-11-18Stephen R. van den Berg  plugbuffer->add_int32(8)->add_int((int)value, 8);
2cdb902014-11-18Stephen R. van den Berg  break; case OIDOID: case INT4OID: plugbuffer->add_int32(4)->add_int32((int)value); break; case INT2OID: plugbuffer->add_int32(2)->add_int16((int)value); break; } }
7cd0e42017-11-18Stephen R. van den Berg  if (!datarowtypes) { if (_tprepared && dontcacheprefix->match(_query)) m_delete(pgsqlsess->prepareds, _query), _tprepared = 0;
192acd2014-11-22Stephen R. van den Berg  waitfordescribe();
2cdb902014-11-18Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  if (_state >= CLOSING) lock = _unnamedstatementkey = 0;
192acd2014-11-22Stephen R. van den Berg  else { plugbuffer->add_int16(sizeof(datarowtypes));
c6d4972018-05-08Stephen R. van den Berg  if (sizeof(datarowtypes)) {
7d9a902017-12-11Stephen R. van den Berg  plugbuffer->add_ints(map(datarowtypes, readoidformat), 2);
c6d4972018-05-08Stephen R. van den Berg  lock = 0; } else if (syncparse < 0 && !pgsqlsess->wasparallelisable
7cd0e42017-11-18Stephen R. van den Berg  && !pgsqlsess->statementsinflight->drained(1)) {
c6d4972018-05-08Stephen R. van den Berg  lock = 0;
41b4c62017-11-10Stephen R. van den Berg  PD("Commit waiting for statements to finish\n");
c6d4972018-05-08Stephen R. van den Berg  catch(PT(pgsqlsess->statementsinflight->wait_till_drained(1)));
192acd2014-11-22Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  PD("Bind portal %O statement %O\n", _portalname, _preparedname); _fetchlimit = pgsqlsess->_fetchlimit;
a3a82e2017-06-17Stephen R. van den Berg  _bindportal();
8675b02017-06-03Stephen R. van den Berg  conxsess bindbuffer = c->start();
e340442017-11-30Stephen R. van den Berg  stmtifkey = 0;
8675b02017-06-03Stephen R. van den Berg  CHAIN(bindbuffer)->add_int8('B')->add_hstring(plugbuffer, 4, 4);
7cd0e42017-11-18Stephen R. van den Berg  if (!_tprepared && sizeof(_preparedname))
8675b02017-06-03Stephen R. van den Berg  closestatement(CHAIN(bindbuffer), _preparedname);
192acd2014-11-22Stephen R. van den Berg  _sendexecute(_fetchlimit
bd47ec2017-06-25Stephen R. van den Berg  && !(transtype != NOTRANS
7cd0e42017-11-18Stephen R. van den Berg  || sizeof(_query) >= MINPREPARELENGTH &&
192acd2014-11-22Stephen R. van den Berg  execfetchlimit->match(_query))
7cd0e42017-11-18Stephen R. van den Berg  && _fetchlimit, bindbuffer);
ccb1172019-05-29Stephen R. van den Berg  _unnamedstatementkey = 0;
192acd2014-11-22Stephen R. van den Berg  }
4d69e02017-11-28Stephen R. van den Berg  }
fb8eb42014-10-31Stephen R. van den Berg  }
a2b20d2014-11-25Stephen R. van den Berg  final void _processrowdesc(array(mapping(string:mixed)) datarowdesc, array(int) datarowtypes) {
7cd0e42017-11-18Stephen R. van den Berg  _setrowdesc(datarowdesc, datarowtypes); if (_tprepared) { _tprepared.datarowdesc = datarowdesc; _tprepared.datarowtypes = datarowtypes;
a2b20d2014-11-25Stephen R. van den Berg  }
fb8eb42014-10-31Stephen R. van den Berg  }
a3a82e2017-06-17Stephen R. van den Berg  final void _parseportal() {
4d69e02017-11-28Stephen R. van den Berg  { Thread.MutexKey lock = closemux->lock(); _state = PARSING;
c6d4972018-05-08Stephen R. van den Berg  if (syncparse || syncparse < 0 && pgsqlsess->wasparallelisable) { PD("Commit waiting for statements to finish\n"); catch(PT(pgsqlsess->statementsinflight->wait_till_drained()));
4d69e02017-11-28Stephen R. van den Berg  }
c6d4972018-05-08Stephen R. van den Berg  stmtifkey = pgsqlsess->statementsinflight->acquire();
a3a82e2017-06-17Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  statuscmdcomplete = 0; pgsqlsess->wasparallelisable = paralleliseprefix->match(_query);
a3a82e2017-06-17Stephen R. van den Berg  }
c6d4972018-05-08Stephen R. van den Berg  final void _releasestatement() {
eda1bd2018-05-17Stephen R. van den Berg  Thread.MutexKey lock = closemux->lock();
cfa2482017-06-18Stephen R. van den Berg  if (_state <= BOUND) {
41b4c62017-11-10Stephen R. van den Berg  stmtifkey = 0;
d55f272018-05-30Stephen R. van den Berg  _state = COMMITTED;
cfa2482017-06-18Stephen R. van den Berg  } }
a3a82e2017-06-17Stephen R. van den Berg  final void _bindportal() {
cfa2482017-06-18Stephen R. van den Berg  Thread.MutexKey lock = closemux->lock();
7cd0e42017-11-18Stephen R. van den Berg  _state = BOUND; portalsifkey = pgsqlsess->portalsinflight->acquire();
cff3a32014-09-12Stephen R. van den Berg  }
fb8eb42014-10-31Stephen R. van den Berg  final void _purgeportal() {
a3a82e2017-06-17Stephen R. van den Berg  PD("Purge portal\n");
b4c7e92014-11-18Stephen R. van den Berg  datarows->write(1); // Signal EOF
4d69e02017-11-28Stephen R. van den Berg  { Thread.MutexKey lock = closemux->lock(); _fetchlimit = 0; // disables further Executes
d55f272018-05-30Stephen R. van den Berg  stmtifkey = portalsifkey = 0;
4d69e02017-11-28Stephen R. van den Berg  _state = PURGED;
cfa2482017-06-18Stephen R. van den Berg  }
e302b62014-11-14Stephen R. van den Berg  releaseconditions();
fb8eb42014-10-31Stephen R. van den Berg  }
c6d4972018-05-08Stephen R. van den Berg  final int _closeportal(conxsess cs, array(Thread.MutexKey) reflock) {
7cd0e42017-11-18Stephen R. van den Berg  void|bufcon|conxsess plugbuffer = CHAIN(cs); int retval = KEEP; PD("%O Try Closeportal %d\n", _portalname, _state); _fetchlimit = 0; // disables further Executes
d55f272018-05-30Stephen R. van den Berg  stmtifkey = 0;
7cd0e42017-11-18Stephen R. van den Berg  switch (_state) {
0e7f332014-11-15Stephen R. van den Berg  case PORTALINIT:
cfa2482017-06-18Stephen R. van den Berg  case PARSING:
7cd0e42017-11-18Stephen R. van den Berg  _unnamedstatementkey = 0; _state = CLOSING;
fb8eb42014-10-31Stephen R. van den Berg  break;
0e7f332014-11-15Stephen R. van den Berg  case COPYINPROGRESS:
fb8eb42014-10-31Stephen R. van den Berg  PD("CopyDone\n"); plugbuffer->add("c\0\0\0\4");
cfa2482017-06-18Stephen R. van den Berg  case COMMITTED:
0e7f332014-11-15Stephen R. van den Berg  case BOUND:
7cd0e42017-11-18Stephen R. van den Berg  _state = CLOSING;
c6d4972018-05-08Stephen R. van den Berg  if (reflock) reflock[0] = 0;
7cd0e42017-11-18Stephen R. van den Berg  PD("Close portal %O\n", _portalname);
6172102017-06-21Stephen R. van den Berg  if (_portalname && sizeof(_portalname)) {
7cd0e42017-11-18Stephen R. van den Berg  plugbuffer->add_int8('C') ->add_hstring(({'P', _portalname, 0}), 4, 4); retval = FLUSHSEND;
cff3a32014-09-12Stephen R. van den Berg  } else
7cd0e42017-11-18Stephen R. van den Berg  _unnamedportalkey = 0;
41b4c62017-11-10Stephen R. van den Berg  portalsifkey = 0;
7cd0e42017-11-18Stephen R. van den Berg  if (pgsqlsess->portalsinflight->drained()) {
41b4c62017-11-10Stephen R. van den Berg  if (plugbuffer->stashcount->drained() && transtype != TRANSBEGIN)
bfa2552016-10-15Stephen R. van den Berg  /* * stashcount will be non-zero if a parse request has been queued * before the close was initiated. * It's a bit of a tricky race, but this check should be sufficient. */
7cd0e42017-11-18Stephen R. van den Berg  pgsqlsess->readyforquerycount++, retval = SYNCSEND; pgsqlsess->pportalcount = 0;
cff3a32014-09-12Stephen R. van den Berg  } } return retval; }
042bcd2018-05-05Stephen R. van den Berg  private void replenishrows() {
8bd75e2018-05-24Stephen R. van den Berg  if (_fetchlimit && datarows->size() <= _fetchlimit >> 1 && _state >= COMMITTED) {
c3317c2019-11-01Stephen R. van den Berg  Thread.MutexKey lock; for (;;) { lock = closemux->lock(); if (_fetchlimit) { _fetchlimit = pgsqlsess._fetchlimit; if (bytesreceived) _fetchlimit = min((portalbuffersize >> 1) * index / bytesreceived || 1, _fetchlimit); if (_fetchlimit) if (inflight <= (_fetchlimit - 1) >> 1) { array reflock = ({ lock }); lock = 0; if (!_sendexecute(_fetchlimit, reflock)) continue; } else PD("<%O _fetchlimit %d, inflight %d, skip execute\n", _portalname, _fetchlimit, inflight); } break;
c9ad7b2018-05-07Stephen R. van den Berg  }
ecbab12008-07-27Stephen R. van den Berg  }
cff3a32014-09-12Stephen R. van den Berg  }
042bcd2018-05-05Stephen R. van den Berg  final void _processdataready(array datarow, void|int msglen) { bytesreceived += msglen; inflight--;
a952372018-05-23Stephen R. van den Berg  if (_state < CLOSED)
042bcd2018-05-05Stephen R. van den Berg  datarows->write(datarow); if (++index == 1) PD("<%O _fetchlimit %d=min(%d||1,%d), inflight %d\n", _portalname, _fetchlimit, (portalbuffersize >> 1) * index / bytesreceived, pgsqlsess._fetchlimit, inflight); replenishrows(); }
e302b62014-11-14Stephen R. van den Berg  private void releaseconditions() {
7cd0e42017-11-18Stephen R. van den Berg  _unnamedportalkey = _unnamedstatementkey = 0; if (!datarowtypes) { if (_state != PURGED && !delayederror) delayederror = LOSTERROR; datarowtypes = emptyarray;
5527d02014-11-17Stephen R. van den Berg  _ddescribe->broadcast();
cbe52f2014-11-13Stephen R. van den Berg  }
ccb1172019-05-29Stephen R. van den Berg  if (delayederror && pgsqlsess && !pgsqlsess.delayederror)
37de892018-01-31Stephen R. van den Berg  pgsqlsess.delayederror = delayederror; // Preserve error upstream
7cd0e42017-11-18Stephen R. van den Berg  pgsqlsess = 0;
ecbab12008-07-27Stephen R. van den Berg  }
bf20922014-11-17Stephen R. van den Berg  final void _releasesession(void|string statusccomplete) {
7cd0e42017-11-18Stephen R. van den Berg  c->runningportals[this] = 0;
046e792018-05-05Stephen R. van den Berg  if (statusccomplete && !statuscmdcomplete) { Thread.MutexKey lock = _ddescribemux->lock();
7cd0e42017-11-18Stephen R. van den Berg  statuscmdcomplete = statusccomplete;
046e792018-05-05Stephen R. van den Berg  _ddescribe->broadcast(); }
7cd0e42017-11-18Stephen R. van den Berg  inflight = 0;
8675b02017-06-03Stephen R. van den Berg  conxsess plugbuffer;
c6d4972018-05-08Stephen R. van den Berg  array(Thread.MutexKey) reflock = ({closemux->lock()});
8675b02017-06-03Stephen R. van den Berg  if (!catch(plugbuffer = c->start()))
c6d4972018-05-08Stephen R. van den Berg  plugbuffer->sendcmd(_closeportal(plugbuffer, reflock));
c3317c2019-11-01Stephen R. van den Berg  reflock[0] = 0;
72b75a2018-05-21Stephen R. van den Berg  if (_state < CLOSED) { stmtifkey = 0;
d55f272018-05-30Stephen R. van den Berg  _state = CLOSED;
72b75a2018-05-21Stephen R. van den Berg  }
49e3302017-11-09Stephen R. van den Berg  datarows->write(1); // Signal EOF
e302b62014-11-14Stephen R. van den Berg  releaseconditions(); }
cff3a32014-09-12Stephen R. van den Berg  protected void destroy() { catch { // inside destructors, exceptions don't work
ccb1172019-05-29Stephen R. van den Berg  _releasesession("ABORT");
11b13b2014-08-16Martin Nilsson  }; }
ecbab12008-07-27Stephen R. van den Berg 
c3317c2019-11-01Stephen R. van den Berg  final int _sendexecute(int fetchlimit,
c6d4972018-05-08Stephen R. van den Berg  void|array(Thread.MutexKey)|bufcon|conxsess plugbuffer) {
cff3a32014-09-12Stephen R. van den Berg  int flushmode;
c6d4972018-05-08Stephen R. van den Berg  array(Thread.MutexKey) reflock;
1c847c2017-06-27Stephen R. van den Berg  PD("Execute portal %O fetchlimit %d transtype %d\n", _portalname, fetchlimit, transtype);
c6d4972018-05-08Stephen R. van den Berg  if (arrayp(plugbuffer)) { reflock = plugbuffer;
c3317c2019-11-01Stephen R. van den Berg  if (!(plugbuffer = c->start(-1))) { reflock[0] = 0; return 0; // Found potential deadlock, release and try again }
c6d4972018-05-08Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  CHAIN(plugbuffer)->add_int8('E')->add_hstring(({_portalname, 0}), 4, 8)
78b2c52014-11-26Stephen R. van den Berg  ->add_int32(fetchlimit);
bd47ec2017-06-25Stephen R. van den Berg  if (!fetchlimit) { if (transtype != NOTRANS)
7cd0e42017-11-18Stephen R. van den Berg  pgsqlsess.intransaction = transtype == TRANSBEGIN;
c6d4972018-05-08Stephen R. van den Berg  flushmode = _closeportal(plugbuffer, reflock) == SYNCSEND
bd47ec2017-06-25Stephen R. van den Berg  || transtype == TRANSEND ? SYNCSEND : FLUSHSEND; } else
7cd0e42017-11-18Stephen R. van den Berg  inflight += fetchlimit, flushmode = FLUSHSEND; plugbuffer->sendcmd(flushmode, this);
c3317c2019-11-01Stephen R. van den Berg  if (reflock) reflock[0] = 0; return 1;
11b13b2014-08-16Martin Nilsson  }
ecbab12008-07-27Stephen R. van den Berg 
569a922017-12-02Stephen R. van den Berg  inline private array setuptimeout() { return local_backend->call_out(gottimeout, timeout); }
7935812018-05-17Stephen R. van den Berg  inline private void scuttletimeout(array cid) {
e5da1b2018-05-17Stephen R. van den Berg  if (local_backend) local_backend->remove_call_out(cid); }
11b13b2014-08-16Martin Nilsson  //! @returns //! One result row at a time. //! //! When using COPY FROM STDOUT, this method returns one row at a time //! as a single string containing the entire row. //!
cff3a32014-09-12Stephen R. van den Berg  //! @seealso //! @[eof()], @[send_row()]
74abb02014-11-24Stephen R. van den Berg  /*semi*/final array(mixed) fetch_row() {
cff3a32014-09-12Stephen R. van den Berg  int|array datarow;
c3317c2019-11-01Stephen R. van den Berg  if (!this) // If object already destructed, return fast return 0;
042bcd2018-05-05Stephen R. van den Berg  replenishrows();
7cd0e42017-11-18Stephen R. van den Berg  if (arrayp(datarow = datarows->try_read()))
cff3a32014-09-12Stephen R. van den Berg  return datarow;
7cd0e42017-11-18Stephen R. van den Berg  if (!eoffound) { if (!datarow) { PD("%O Block for datarow\n", _portalname);
569a922017-12-02Stephen R. van den Berg  array cid = setuptimeout();
7cd0e42017-11-18Stephen R. van den Berg  PT(datarow = datarows->read());
7935812018-05-17Stephen R. van den Berg  if (!this) // If object already destructed, return fast return 0;
e5da1b2018-05-17Stephen R. van den Berg  scuttletimeout(cid);
7cd0e42017-11-18Stephen R. van den Berg  if (arrayp(datarow))
1611e42014-11-28Stephen R. van den Berg  return datarow; }
7cd0e42017-11-18Stephen R. van den Berg  eoffound = 1;
bf20922014-11-17Stephen R. van den Berg  datarows->write(1); // Signal EOF for other threads
fb8eb42014-10-31Stephen R. van den Berg  }
cff3a32014-09-12Stephen R. van den Berg  trydelayederror(); return 0; } //! @returns //! Multiple result rows at a time (at least one). //! //! When using COPY FROM STDOUT, this method returns one row at a time //! as a single string containing the entire row. //! //! @seealso //! @[eof()], @[fetch_row()]
74abb02014-11-24Stephen R. van den Berg  /*semi*/final array(array(mixed)) fetch_row_array() {
7cd0e42017-11-18Stephen R. van den Berg  if (eoffound)
cff3a32014-09-12Stephen R. van den Berg  return 0;
042bcd2018-05-05Stephen R. van den Berg  replenishrows();
7cd0e42017-11-18Stephen R. van den Berg  array(array|int) datarow = datarows->try_read_array();
7c95032017-11-22Stephen R. van den Berg  if (!sizeof(datarow)) {
569a922017-12-02Stephen R. van den Berg  array cid = setuptimeout();
7cd0e42017-11-18Stephen R. van den Berg  PT(datarow = datarows->read_array());
7935812018-05-17Stephen R. van den Berg  if (!this) // If object already destructed, return fast return 0;
e5da1b2018-05-17Stephen R. van den Berg  scuttletimeout(cid);
1611e42014-11-28Stephen R. van den Berg  }
042bcd2018-05-05Stephen R. van den Berg  replenishrows();
7cd0e42017-11-18Stephen R. van den Berg  if (arrayp(datarow[-1]))
cff3a32014-09-12Stephen R. van den Berg  return datarow;
fac8252018-01-05Stephen R. van den Berg  do datarow = datarow[..<1]; // Swallow EOF mark(s) while (sizeof(datarow) && !arrayp(datarow[-1]));
cff3a32014-09-12Stephen R. van den Berg  trydelayederror();
7cd0e42017-11-18Stephen R. van den Berg  eoffound = 1;
bf20922014-11-17Stephen R. van den Berg  datarows->write(1); // Signal EOF for other threads
fac8252018-01-05Stephen R. van den Berg  return datarow;
cff3a32014-09-12Stephen R. van den Berg  }
933a762014-11-10Stephen R. van den Berg  //! @param copydata
11b13b2014-08-16Martin Nilsson  //! When using COPY FROM STDIN, this method accepts a string or an //! array of strings to be processed by the COPY command; when sending //! the amount of data sent per call does not have to hit row or column //! boundaries. //! //! The COPY FROM STDIN sequence needs to be completed by either
cff3a32014-09-12Stephen R. van den Berg  //! explicitly or implicitly destroying the result object, or by passing no //! argument to this method.
11b13b2014-08-16Martin Nilsson  //! //! @seealso
cff3a32014-09-12Stephen R. van den Berg  //! @[fetch_row()], @[eof()]
74abb02014-11-24Stephen R. van den Berg  /*semi*/final void send_row(void|string|array(string) copydata) {
cff3a32014-09-12Stephen R. van den Berg  trydelayederror();
7cd0e42017-11-18Stephen R. van den Berg  if (copydata) {
cff3a32014-09-12Stephen R. van den Berg  PD("CopyData\n");
7cd0e42017-11-18Stephen R. van den Berg  void|bufcon|conxsess cs = c->start();
8675b02017-06-03Stephen R. van den Berg  CHAIN(cs)->add_int8('d')->add_hstring(copydata, 4, 4); cs->sendcmd(SENDOUT);
cff3a32014-09-12Stephen R. van den Berg  } else _releasesession(); }
6eb5942014-11-12Stephen R. van den Berg  private void run_result_cb(
3b31fa2014-11-14Stephen R. van den Berg  function(sql_result, array(mixed), mixed ...:void) callback,
cff3a32014-09-12Stephen R. van den Berg  array(mixed) args) { int|array datarow;
7cd0e42017-11-18Stephen R. van den Berg  for (;;) {
569a922017-12-02Stephen R. van den Berg  array cid = setuptimeout();
7cd0e42017-11-18Stephen R. van den Berg  PT(datarow = datarows->read());
7935812018-05-17Stephen R. van den Berg  if (!this) // If object already destructed, return fast return 0;
e5da1b2018-05-17Stephen R. van den Berg  scuttletimeout(cid);
7cd0e42017-11-18Stephen R. van den Berg  if (!arrayp(datarow))
1611e42014-11-28Stephen R. van den Berg  break;
0fed8c2014-11-10Stephen R. van den Berg  callout(callback, 0, this, datarow, @args);
1611e42014-11-28Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  eoffound = 1;
0fed8c2014-11-10Stephen R. van den Berg  callout(callback, 0, this, 0, @args);
cff3a32014-09-12Stephen R. van den Berg  } //! Sets up a callback for every row returned from the database. //! First argument passed is the resultobject itself, second argument //! is the result row (zero on EOF). //! //! @seealso //! @[fetch_row()]
74abb02014-11-24Stephen R. van den Berg  /*semi*/final void set_result_callback(
3b31fa2014-11-14Stephen R. van den Berg  function(sql_result, array(mixed), mixed ...:void) callback,
cff3a32014-09-12Stephen R. van den Berg  mixed ... args) {
7cd0e42017-11-18Stephen R. van den Berg  if (callback) Thread.Thread(run_result_cb, callback, args);
cff3a32014-09-12Stephen R. van den Berg  }
6eb5942014-11-12Stephen R. van den Berg  private void run_result_array_cb(
3b31fa2014-11-14Stephen R. van den Berg  function(sql_result, array(array(mixed)), mixed ...:void) callback,
cff3a32014-09-12Stephen R. van den Berg  array(mixed) args) { array(array|int) datarow;
7cd0e42017-11-18Stephen R. van den Berg  for (;;) {
569a922017-12-02Stephen R. van den Berg  array cid = setuptimeout();
7cd0e42017-11-18Stephen R. van den Berg  PT(datarow = datarows->read_array());
7935812018-05-17Stephen R. van den Berg  if (!this) // If object already destructed, return fast return 0;
e5da1b2018-05-17Stephen R. van den Berg  scuttletimeout(cid);
7cd0e42017-11-18Stephen R. van den Berg  if (!datarow || !arrayp(datarow[-1]))
1611e42014-11-28Stephen R. van den Berg  break;
0fed8c2014-11-10Stephen R. van den Berg  callout(callback, 0, this, datarow, @args);
1611e42014-11-28Stephen R. van den Berg  }
7cd0e42017-11-18Stephen R. van den Berg  eoffound = 1; if (sizeof(datarow)>1) callout(callback, 0, this, datarow = datarow[..<1], @args);
0fed8c2014-11-10Stephen R. van den Berg  callout(callback, 0, this, 0, @args);
cff3a32014-09-12Stephen R. van den Berg  } //! Sets up a callback for sets of rows returned from the database. //! First argument passed is the resultobject itself, second argument //! is the array of result rows (zero on EOF). //! //! @seealso //! @[fetch_row()]
74abb02014-11-24Stephen R. van den Berg  /*semi*/final void set_result_array_callback(
3b31fa2014-11-14Stephen R. van den Berg  function(sql_result, array(array(mixed)), mixed ...:void) callback,
cff3a32014-09-12Stephen R. van den Berg  mixed ... args) {
7cd0e42017-11-18Stephen R. van den Berg  if (callback) Thread.Thread(run_result_array_cb, callback, args); } }; class proxy { final int _fetchlimit = FETCHLIMIT;
c6d4972018-05-08Stephen R. van den Berg  final MUTEX unnamedportalmux; final MUTEX unnamedstatement;
7cd0e42017-11-18Stephen R. van den Berg  private Thread.MutexKey termlock; final Thread.ResourceCount portalsinflight, statementsinflight; final int(0..1) wasparallelisable; final int(0..1) intransaction; final conxion c; private string cancelsecret; private int backendpid; final int(-128..127) backendstatus; final mapping(string:mixed) options; private array(string) lastmessage = emptyarray; final int(0..1) clearmessage; final int(0..1) untolderror; private mapping(string:array(mixed)) notifylist = ([]); final mapping(string:string) runtimeparameter; final mapping(string:mapping(string:mixed)) prepareds = ([]); final int pportalcount; final int totalhits; final int msgsreceived; // Number of protocol messages received final int bytesreceived; // Number of bytes received final int warningsdropcount; // Number of uncollected warnings private int warningscollected; final int(0..1) invalidatecache; private Thread.Queue qportals; final mixed delayederror;
0041452018-01-26Stephen R. van den Berg  final function (:void) readyforquery_cb;
7cd0e42017-11-18Stephen R. van den Berg  final string host; final int(0..65535) port; private string database, user, pass;
ddddf22017-11-30Henrik Grubbström (Grubba)  private Crypto.Hash.SCRAM SASLcontext;
7cd0e42017-11-18Stephen R. van den Berg  final Thread.Condition waitforauthready;
c6d4972018-05-08Stephen R. van den Berg  final MUTEX shortmux;
7cd0e42017-11-18Stephen R. van den Berg  final int readyforquerycount; private string _sprintf(int type) { string res; switch (type) { case 'O': res = sprintf(DRIVERNAME".proxy(%s@%s:%d/%s,%d,%d)",
4d69e02017-11-28Stephen R. van den Berg  user, host, port, database, c && c->socket && c->socket->query_fd(),
7cd0e42017-11-18Stephen R. van den Berg  backendpid); break; } return res; } private void create(void|string host, void|string database, void|string user, void|string pass, void|mapping(string:mixed) options) { if (this::pass = pass) { String.secure(pass); pass = "CENSORED"; } this::user = user; this::database = database; this::options = options; if (!host) host = PGSQL_DEFAULT_HOST; if (has_value(host,":") && sscanf(host,"%s:%d", host, port) != 2) error("Error in parsing the hostname argument\n"); this::host = host; if (!port) port = PGSQL_DEFAULT_PORT;
5050652018-12-16Stephen R. van den Berg  register_backend(this);
c6d4972018-05-08Stephen R. van den Berg  shortmux = MUTEX();
7cd0e42017-11-18Stephen R. van den Berg  PD("Connect\n"); waitforauthready = Thread.Condition(); qportals = Thread.Queue(); readyforquerycount = 1; qportals->write(1); if (!(c = conxion(this, qportals, 0))) error("Couldn't connect to database on %s:%d\n", host, port); runtimeparameter = ([]);
c6d4972018-05-08Stephen R. van den Berg  unnamedportalmux = MUTEX(); unnamedstatement = MUTEX();
7cd0e42017-11-18Stephen R. van den Berg  readyforquery_cb = connect_cb; portalsinflight = Thread.ResourceCount(); statementsinflight = Thread.ResourceCount(); wasparallelisable = 0;
11b13b2014-08-16Martin Nilsson  }
ecbab12008-07-27Stephen R. van den Berg 
7cd0e42017-11-18Stephen R. van den Berg  final int is_open() {
4d69e02017-11-28Stephen R. van den Berg  return c && c->socket && c->socket->is_open();
7cd0e42017-11-18Stephen R. van den Berg  } final string geterror(void|int clear) { untolderror = 0; string s = lastmessage * "\n"; if (clear) lastmessage = emptyarray; warningscollected = 0; return sizeof(s) && s; } final string host_info() { return sprintf("fd:%d TCP/IP %s:%d PID %d", c ? c->socket->query_fd() : -1, host, port, backendpid); } final void cancelquery() { if (cancelsecret > "") { PD("CancelRequest\n"); conxion lcon = conxion(this, 0, 2); #ifdef PG_DEBUG mixed err = #endif catch(lcon->add_int32(16)->add_int32(PG_PROTOCOL(1234, 5678)) ->add_int32(backendpid)->add(cancelsecret)->sendcmd(FLUSHSEND)); #ifdef PG_DEBUG if (err) PD("CancelRequest failed to connect %O\n", describe_backtrace(err)); #endif destruct(lcon); // Destruct explicitly to avoid delayed close #ifdef PG_DEBUGMORE PD("Closetrace %O\n", backtrace()); #endif } else error("Connection not established, cannot cancel any query\n"); } private string a2nls(array(string) msg) { return msg * "\n" + "\n"; } private string pinpointerror(void|string query, void|string offset) { if (!query) return ""; int k = (int)offset; if (k <= 0) return MARKSTART + query + MARKEND; return MARKSTART + (k > 1 ? query[..k-2] : "") + MARKERROR + query[k - 1..] + MARKEND; } private void connect_cb() { PD("%O\n", runtimeparameter); } private array(string) showbindings(sql_result portal) {
b901be2018-05-26Stephen R. van den Berg  return portal ? portal._showbindings() : emptyarray;
7cd0e42017-11-18Stephen R. van den Berg  } private void preplastmessage(mapping(string:string) msgresponse) { lastmessage = ({ sprintf("%s %s:%s %s\n (%s:%s:%s)", msgresponse.S, msgresponse.C, msgresponse.P || "", msgresponse.M, msgresponse.F || "", msgresponse.R || "", msgresponse.L||"")}); } private int|sql_result portal; // state information procmessage
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  private string datarowdebug; private int datarowdebugcount;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  final void processloop(conxion ci) { (c = ci)->socket->set_id(procmessage); cancelsecret = 0; portal = 0; { Stdio.Buffer plugbuffer = Stdio.Buffer()->add_int32(PG_PROTOCOL(3, 0)); if (user) plugbuffer->add("user\0", user, 0); if (database) plugbuffer->add("database\0", database, 0); foreach (options - censoroptions; string name; mixed value) plugbuffer->add(name, 0, (string)value, 0); plugbuffer->add_int8(0); PD("%O\n", (string)plugbuffer); void|bufcon|conxsess cs; if (catch(cs = ci->start())) { destruct(waitforauthready); unnamedstatement = 0; termlock = 0; return; } else { CHAIN(cs)->add_hstring(plugbuffer, 4, 4); cs->sendcmd(SENDOUT); } } // Do not flush at this point, PostgreSQL 9.4 disapproves procmessage(); } private void procmessage() { mixed err; int terminating = 0; err = catch {
b901be2018-05-26Stephen R. van den Berg  conxion ci = c; // cache value conxiin cr = ci->i; // cache value
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  PD("Processloop\n");
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUGMORE
7cd0e42017-11-18Stephen R. van den Berg  void showportalstack(string label) { PD(sprintf(">>>>>>>>>>> Portalstack %s: %O\n", label, portal)); foreach (qportals->peek_array(); ; int|sql_result qp) PD(" =========== Portal: %O\n", qp); PD("<<<<<<<<<<<<<< Portalstack end\n"); };
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  void showportal(int msgtype) { if (objectp(portal)) PD("%d<%O %d %c switch portal\n", ci->socket->query_fd(), portal._portalname, ++ci->queueinidx, msgtype);
a952372018-05-23Stephen R. van den Berg  else if (portal > 0)
7cd0e42017-11-18Stephen R. van den Berg  PD("%d<Sync %d %d %c portal\n", ci->socket->query_fd(), ++ci->queueinidx, portal, msgtype); };
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  int msgisfatal(mapping(string:string) msgresponse) {
0041452018-01-26Stephen R. van den Berg  int isfatal = (has_prefix(msgresponse.C, "53") || has_prefix(msgresponse.C, "3D") || has_prefix(msgresponse.C, "57P")) && MAGICTERMINATE; if (isfatal && !terminating) // Run the callback once per lost connection runcallback(backendpid, "_lost", ""); return isfatal;
7cd0e42017-11-18Stephen R. van den Berg  }; for (;;) { err = catch {
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  if (!portal && datarowdebug) { PD("%s rows %d\n", datarowdebug, datarowdebugcount); datarowdebug = 0; datarowdebugcount = 0; }
b52ad52018-01-20Stephen R. van den Berg #endif #ifdef PG_DEBUGMORE
7cd0e42017-11-18Stephen R. van den Berg  showportalstack("LOOPTOP");
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  if (!sizeof(cr)) { // Preliminary check, fast path Thread.MutexKey lock = cr->fillreadmux->lock(); if (!sizeof(cr)) { // Check for real if (!cr->fillread) { lock = 0; throw(MAGICTERMINATE); // Force proper termination } cr->procmsg = 1; return; // Terminate thread, wait for callback } } int msgtype = cr->read_int8(); if (!portal) { portal = qportals->try_read();
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  showportal(msgtype);
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  } int msglen = cr->read_int32(); msgsreceived++; bytesreceived += 1 + msglen; int errtype = NOERROR; PD("%d<", ci->socket->query_fd()); switch (msgtype) { array getcols() { int bintext = cr->read_int8(); int cols = cr->read_int16();
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  array a; msglen -= 4 + 1 + 2 + 2 * cols; foreach (a = allocate(cols, ([])); ; mapping m) m.type = cr->read_int16();
b52ad52018-01-20Stephen R. van den Berg #else
7cd0e42017-11-18Stephen R. van den Berg  cr->consume(cols << 1);
b52ad52018-01-20Stephen R. van den Berg #endif // Discard column info, and make it line oriented
7cd0e42017-11-18Stephen R. van den Berg  return ({ ({(["name":"line"])}), ({bintext?BYTEAOID:TEXTOID}) }); }; array(string) reads() {
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  if (msglen < 1) errtype = PROTOCOLERROR;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  array ret = emptyarray, aw = ({0}); do { string w = cr->read_cstring(); msglen -= sizeof(w) + 1; aw[0] = w; ret += aw; } while (msglen); return ret; }; mapping(string:string) getresponse() { mapping(string:string) msgresponse = ([]); msglen -= 4; foreach (reads(); ; string f) if (sizeof(f)) msgresponse[f[..0]] = f[1..]; PD("%O\n", msgresponse); return msgresponse; }; case 'R': { void authresponse(string|array msg) { void|bufcon|conxsess cs = ci->start(); CHAIN(cs)->add_int8('p')->add_hstring(msg, 4, 4); cs->sendcmd(SENDOUT); // No flushing, PostgreSQL 9.4 disapproves }; PD("Authentication "); msglen -= 4 + 4; int authtype, k; switch (authtype = cr->read_int32()) { case 0: PD("Ok\n"); if (SASLcontext) { PD("Authentication validation still in progress\n"); errtype = PROTOCOLUNSUPPORTED; } else cancelsecret = ""; break; case 2: PD("KerberosV5\n"); errtype = PROTOCOLUNSUPPORTED; break; case 3: PD("ClearTextPassword\n"); authresponse(({pass, 0})); break; case 4: PD("CryptPassword\n"); errtype = PROTOCOLUNSUPPORTED; break; case 5: PD("MD5Password\n");
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  if (msglen < 4) errtype = PROTOCOLERROR;
b52ad52018-01-20Stephen R. van den Berg #endif #define md5hex(x) String.string2hex(Crypto.MD5.hash(x))
7cd0e42017-11-18Stephen R. van den Berg  authresponse(({"md5", md5hex(md5hex(pass + user) + cr->read(msglen)), 0}));
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  msglen = 0;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  break; case 6: PD("SCMCredential\n"); errtype = PROTOCOLUNSUPPORTED; break; case 7: PD("GSS\n"); errtype = PROTOCOLUNSUPPORTED; break; case 9: PD("SSPI\n"); errtype = PROTOCOLUNSUPPORTED; break; case 8: PD("GSSContinue\n"); errtype = PROTOCOLUNSUPPORTED; cr->read(msglen); // SSauthdata
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  if (msglen<1) errtype = PROTOCOLERROR; msglen = 0;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  break; case 10: { string word; PD("AuthenticationSASL\n"); k = 0; while (sizeof(word = cr->read_cstring())) { switch (word) { case "SCRAM-SHA-256": k = 1; }
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  msglen -= sizeof(word) + 1; if (msglen < 1) break;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  } if (k) {
ddddf22017-11-30Henrik Grubbström (Grubba)  SASLcontext = Crypto.SHA256.SCRAM();
7cd0e42017-11-18Stephen R. van den Berg  word = SASLcontext.client_1(); authresponse(({ "SCRAM-SHA-256", 0, sprintf("%4c", sizeof(word)), word })); } else errtype = PROTOCOLUNSUPPORTED;
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  if (msglen != 1) errtype = PROTOCOLERROR; msglen = 0;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  break; } case 11: { PD("AuthenticationSASLContinue\n"); string response; if (response = SASLcontext.client_2(cr->read(msglen), pass)) authresponse(response); else errtype = PROTOCOLERROR;
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  msglen = 0;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  break; } case 12: PD("AuthenticationSASLFinal\n"); if (SASLcontext.client_3(cr->read(msglen))) SASLcontext = 0; // Clears context and approves server else errtype = PROTOCOLERROR;
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  msglen = 0;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  break; default: PD("Unknown Authentication Method %c\n", authtype); errtype = PROTOCOLUNSUPPORTED; break; } switch (errtype) { default: case PROTOCOLUNSUPPORTED: error("Unsupported authenticationmethod %c\n", authtype); case NOERROR: break; } break; } case 'K': msglen -= 4 + 4; backendpid = cr->read_int32(); cancelsecret = cr->read(msglen);
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  PD("BackendKeyData %O\n", cancelsecret); msglen = 0;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  break; case 'S': { PD("ParameterStatus "); msglen -= 4; array(string) ts = reads();
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  if (sizeof(ts) == 2) {
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  runtimeparameter[ts[0]] = ts[1];
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  PD("%O=%O\n", ts[0], ts[1]); } else errtype = PROTOCOLERROR;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  break; } case '3':
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  PD("CloseComplete\n"); msglen -= 4;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  break; case 'Z': { backendstatus = cr->read_int8();
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  msglen -= 4 + 1; PD("ReadyForQuery %c\n", backendstatus);
b52ad52018-01-20Stephen R. van den Berg #endif #ifdef PG_DEBUGMORE
7cd0e42017-11-18Stephen R. van den Berg  showportalstack("READYFORQUERY");
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  int keeplooking; do for (keeplooking = 0; objectp(portal); portal = qportals->read()) {
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  showportal(msgtype);
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  if (backendstatus == 'I' && intransaction && portal->transtype != TRANSEND) keeplooking = 1; portal->_purgeportal(); } while (keeplooking && (portal = qportals->read())); if (backendstatus == 'I') intransaction = 0; foreach (qportals->peek_array(); ; sql_result qp) { if (objectp(qp) && qp._synctransact && qp._synctransact <= portal) { PD("Checking portal %O %d<=%d\n", qp._portalname, qp._synctransact, portal); qp->_purgeportal(); } } portal = 0;
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUGMORE
7cd0e42017-11-18Stephen R. van den Berg  showportalstack("AFTER READYFORQUERY");
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  readyforquerycount--; if (readyforquery_cb) readyforquery_cb(), readyforquery_cb = 0; destruct(waitforauthready); break; } case '1':
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  PD("ParseComplete portal %O\n", portal); msglen -= 4;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  break; case 't': { array a;
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  int cols = cr->read_int16(); PD("%O ParameterDescription %d values\n", portal._query, cols); msglen -= 4 + 2 + 4 * cols; a = cr->read_ints(cols, 4);
b52ad52018-01-20Stephen R. van den Berg #else
7cd0e42017-11-18Stephen R. van den Berg  a = cr->read_ints(cr->read_int16(), 4);
b52ad52018-01-20Stephen R. van den Berg #endif #ifdef PG_DEBUGMORE
7cd0e42017-11-18Stephen R. van den Berg  PD("%O\n", a);
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  if (portal._tprepared) portal._tprepared.datatypeoid = a; Thread.Thread(portal->_preparebind, a); break; } case 'T': { array a, at; int cols = cr->read_int16();
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  PD("RowDescription %d columns %O\n", cols, portal._query); msglen -= 4 + 2;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  at = allocate(cols); foreach (a = allocate(cols); int i; ) { string s = cr->read_cstring(); mapping(string:mixed) res = (["name":s]);
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  msglen -= sizeof(s) + 1 + 4 + 2 + 4 + 2 + 4 + 2; res.tableoid = cr->read_int32() || UNDEFINED; res.tablecolattr = cr->read_int16() || UNDEFINED;
b52ad52018-01-20Stephen R. van den Berg #else
7cd0e42017-11-18Stephen R. van den Berg  cr->consume(6);
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  at[i] = cr->read_int32();
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  res.type = at[i]; { int len = cr->read_sint(2); res.length = len >= 0 ? len : "variable"; } res.atttypmod = cr->read_int32(); /* formatcode contains just a zero when Bind has not been issued * yet, but the content is irrelevant because it's determined * at query time */ res.formatcode = cr->read_int16();
b52ad52018-01-20Stephen R. van den Berg #else
7cd0e42017-11-18Stephen R. van den Berg  cr->consume(8);
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  a[i] = res; }
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUGMORE
7cd0e42017-11-18Stephen R. van den Berg  PD("%O\n", a);
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  if (portal._forcetext) portal->_setrowdesc(a, at); // Do not consume queued portal else { portal->_processrowdesc(a, at); portal = 0; } break; } case 'n': {
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  msglen -= 4; PD("NoData %O\n", portal._query);
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  portal._fetchlimit = 0; // disables subsequent Executes portal->_processrowdesc(emptyarray, emptyarray); portal = 0; break; } case 'H': portal->_processrowdesc(@getcols()); PD("CopyOutResponse %O\n", portal. _query); break; case '2': { mapping tp;
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  msglen -= 4; PD("%O BindComplete\n", portal._portalname);
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  if (tp = portal._tprepared) { int tend = gethrtime(); int tstart = tp.trun; if (tend == tstart) m_delete(prepareds, portal._query); else { tp.hits++; totalhits++; if (!tp.preparedname) { if (sizeof(portal._preparedname)) { PD("Finalising stored statement %s\n", portal._preparedname); tp.preparedname = portal._preparedname; } tstart = tend - tstart; if (!tp.tparse || tp.tparse>tstart) tp.tparse = tstart; } tp.trunstart = tend; } } break; } case 'D': msglen -= 4;
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG #ifdef PG_DEBUGMORE
7cd0e42017-11-18Stephen R. van den Berg  PD("%O DataRow %d bytes\n", portal._portalname, msglen);
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  datarowdebugcount++; if (!datarowdebug) datarowdebug = sprintf( "%O DataRow %d bytes", portal._portalname, msglen);
b52ad52018-01-20Stephen R. van den Berg #endif #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  msglen=
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  portal->_decodedata(msglen, runtimeparameter[CLIENT_ENCODING]); break; case 's':
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  PD("%O PortalSuspended\n", portal._portalname); msglen -= 4;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  portal = 0; break; case 'C': { msglen -= 4;
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  if (msglen < 1) errtype = PROTOCOLERROR;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  string s = cr->read(msglen - 1); portal->_storetiming(); PD("%O CommandComplete %O\n", portal._portalname, s);
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  if (cr->read_int8()) errtype = PROTOCOLERROR; msglen = 0;
b52ad52018-01-20Stephen R. van den Berg #else
7cd0e42017-11-18Stephen R. van den Berg  cr->consume(1);
b52ad52018-01-20Stephen R. van den Berg #endif #ifdef PG_DEBUGMORE
7cd0e42017-11-18Stephen R. van den Berg  showportalstack("COMMANDCOMPLETE");
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  portal->_releasesession(s); portal = 0; break; } case 'I':
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  PD("EmptyQueryResponse %O\n", portal._portalname); msglen -= 4;
b52ad52018-01-20Stephen R. van den Berg #endif #ifdef PG_DEBUGMORE
7cd0e42017-11-18Stephen R. van den Berg  showportalstack("EMPTYQUERYRESPONSE");
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  portal->_releasesession(); portal = 0; break; case 'd': PD("%O CopyData\n", portal._portalname); portal->_storetiming(); msglen -= 4;
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  if (msglen < 0) errtype = PROTOCOLERROR;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  portal->_processdataready(({cr->read(msglen)}), msglen);
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  msglen = 0;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  break; case 'G': portal->_releasestatement(); portal->_setrowdesc(@getcols()); PD("%O CopyInResponse\n", portal._portalname); portal._state = COPYINPROGRESS; break; case 'c':
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  PD("%O CopyDone\n", portal._portalname); msglen -= 4;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  portal = 0; break; case 'E': {
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUGMORE
7cd0e42017-11-18Stephen R. van den Berg  showportalstack("ERRORRESPONSE");
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  if (portalsinflight->drained() && !readyforquerycount) sendsync(); PD("%O ErrorResponse %O\n", objectp(portal) && (portal._portalname || portal._preparedname), objectp(portal) && portal._query); mapping(string:string) msgresponse; msgresponse = getresponse(); warningsdropcount += warningscollected; warningscollected = 0; untolderror = 1; switch (msgresponse.C) { case "P0001": lastmessage = ({sprintf("%s: %s", msgresponse.S, msgresponse.M)}); USERERROR(a2nls(lastmessage +({pinpointerror(portal._query, msgresponse.P)}) +showbindings(portal))); case "53000":case "53100":case "53200":case "53300":case "53400": case "57P01":case "57P02":case "57P03":case "57P04":case "3D000":
e81fed2019-11-13Stephen R. van den Berg  case "34000":
7cd0e42017-11-18Stephen R. van den Berg  preplastmessage(msgresponse); PD(a2nls(lastmessage)); throw(msgisfatal(msgresponse)); case "08P01":case "42P05": errtype = PROTOCOLERROR; case "XX000":case "42883":case "42P01": invalidatecache = 1; default: preplastmessage(msgresponse); if (msgresponse.D) lastmessage += ({msgresponse.D}); if (msgresponse.H) lastmessage += ({msgresponse.H}); lastmessage += ({ pinpointerror(objectp(portal) && portal._query, msgresponse.P) + pinpointerror(msgresponse.q, msgresponse.p)}); if (msgresponse.W) lastmessage += ({msgresponse.W}); if (objectp(portal)) lastmessage += showbindings(portal); switch (msgresponse.S) { case "PANIC":werror(a2nls(lastmessage)); } case "25P02": // Preserve last error message USERERROR(a2nls(lastmessage)); // Implicitly closed portal } break; } case 'N': { PD("NoticeResponse\n"); mapping(string:string) msgresponse = getresponse(); if (clearmessage) { warningsdropcount += warningscollected; clearmessage = warningscollected = 0; lastmessage = emptyarray; } warningscollected++; lastmessage = ({sprintf("%s %s: %s", msgresponse.S, msgresponse.C, msgresponse.M)}); int val; if (val = msgisfatal(msgresponse)) { // Some warnings are fatal preplastmessage(msgresponse); PD(a2nls(lastmessage)); throw(val); } break; } case 'A': { PD("NotificationResponse\n"); msglen -= 4 + 4; int pid = cr->read_int32(); string condition, extrainfo; { array(string) ts = reads(); switch (sizeof(ts)) {
b52ad52018-01-20Stephen R. van den Berg #if PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  case 0: errtype = PROTOCOLERROR; break; default: errtype = PROTOCOLERROR;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  case 2: extrainfo = ts[1]; case 1: condition = ts[0]; } } PD("%d %s\n%s\n", pid, condition, extrainfo); runcallback(pid, condition, extrainfo); break; } default: if (msgtype != -1) { string s; PD("Unknown message received %c\n", msgtype); s = cr->read(msglen -= 4); PD("%O\n", s);
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  msglen = 0;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  errtype = PROTOCOLUNSUPPORTED; } else { lastmessage += ({ sprintf("Connection lost to database %s@%s:%d/%s %d\n", user, host, port, database, backendpid)}); runcallback(backendpid, "_lost", ""); if (!waitforauthready) throw(0); USERERROR(a2nls(lastmessage)); } break; }
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  if (msglen) errtype = PROTOCOLERROR;
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  { string msg; switch (errtype) { case PROTOCOLUNSUPPORTED: msg = sprintf("Unsupported servermessage received %c\n", msgtype); break; case PROTOCOLERROR: msg = sprintf("Protocol error with database %s", host_info()); break; case NOERROR: continue; // Normal production loop } error(a2nls(lastmessage += ({msg}))); } }; // We only get here if there is an error if (err == MAGICTERMINATE) { // Announce connection termination to server catch { void|bufcon|conxsess cs = ci->start();
5050652018-12-16Stephen R. van den Berg  CHAIN(cs)->add(PGSYNC)->add("X\0\0\0\4");
7cd0e42017-11-18Stephen R. van den Berg  cs->sendcmd(SENDOUT); }; terminating = 1; err = 0; } else if (stringp(err)) { sql_result or; if (!objectp(or = portal)) or = this; if (!or.delayederror) or.delayederror = err;
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUGMORE
7cd0e42017-11-18Stephen R. van den Berg  showportalstack("THROWN");
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  if (objectp(portal))
ccb1172019-05-29Stephen R. van den Berg  portal->_releasesession("ERROR");
7cd0e42017-11-18Stephen R. van den Berg  portal = 0; if (!waitforauthready) continue; // Only continue if authentication did not fail } break; } PD("Closing database processloop %s\n", err ? describe_backtrace(err) : ""); delayederror = err; if (objectp(portal)) {
b52ad52018-01-20Stephen R. van den Berg #ifdef PG_DEBUG
7cd0e42017-11-18Stephen R. van den Berg  showportal(0);
b52ad52018-01-20Stephen R. van den Berg #endif
7cd0e42017-11-18Stephen R. van den Berg  portal->_purgeportal(); } destruct(waitforauthready); termlock = 0; if (err && !stringp(err)) throw(err); }; catch { unnamedstatement = 0; termlock = 0; if (err) { PD("Terminating processloop due to %s\n", describe_backtrace(err)); delayederror = err; } destruct(waitforauthready); c->purge(); }; } final void close() { throwdelayederror(this);
4d69e02017-11-28Stephen R. van den Berg  {
4177d32018-05-05Stephen R. van den Berg  Thread.MutexKey lock;
4d69e02017-11-28Stephen R. van den Berg  if (unnamedstatement) termlock = unnamedstatement->lock(1);
4674cb2018-05-07Stephen R. van den Berg  foreach (c->runningportals; sql_result result; )
4177d32018-05-05Stephen R. van den Berg  catch(result->status_command_complete());
4d69e02017-11-28Stephen R. van den Berg  if (c) // Prevent trivial backtraces c->close(); if (unnamedstatement) lock = unnamedstatement->lock(1); if (c) c->purge(); }
7cd0e42017-11-18Stephen R. van den Berg  destruct(waitforauthready); } private void destroy() { string errstring; mixed err = catch(close());
5050652018-12-16Stephen R. van den Berg  clients[this] = 0;
7cd0e42017-11-18Stephen R. van den Berg  if (untolderror) { /* * Flush out any asynchronously reported errors to stderr; because we are * inside a destructor, throwing an error will not work anymore. * Warnings will be silently discarded at this point. */ lastmessage = filter(lastmessage, lambda(string val) { return has_prefix(val, "ERROR ") || has_prefix(val, "FATAL "); }); if (err || (err = catch(errstring = geterror(1)))) werror(describe_backtrace(err)); else if (errstring && sizeof(errstring)) werror("%s\n", errstring); // Add missing terminating newline } }
0041452018-01-26Stephen R. van den Berg  final void sendsync() {
7cd0e42017-11-18Stephen R. van den Berg  readyforquerycount++; c->start()->sendcmd(SYNCSEND); } private void runcallback(int pid, string condition, string extrainfo) { array cb;
0041452018-01-26Stephen R. van den Berg  if (condition == "_lost") destruct(c);
7cd0e42017-11-18Stephen R. van den Berg  if ((cb = notifylist[condition] || notifylist[""]) && (pid != backendpid || sizeof(cb) > 1 && cb[1])) callout(cb[0], 0, pid, condition, extrainfo, @cb[2..]); } private inline void closestatement( bufcon|conxsess plugbuffer, string oldprep) { closestatement(plugbuffer, oldprep); }
74abb02014-11-24Stephen R. van den Berg };