POOL_STATUS NotificationResponse(POOL_CONNECTION *frontend,
POOL_CONNECTION_POOL *backend)
{
int pid, pid1;
char *condition, *condition1 = NULL;
int len, len1 = 0;
int i;
POOL_STATUS status;
pool_write(frontend, "A", 1);
for (i=0;i<NUM_BACKENDS;i++)
{
if (VALID_BACKEND(i))
{
if (pool_read(CONNECTION(backend, i), &pid, sizeof(pid)) < 0)
return POOL_ERROR;
condition = pool_read_string(CONNECTION(backend, i), &len, 0);
if (condition == NULL)
return POOL_END;
if (IS_MASTER_NODE_ID(i))
{
pid1 = pid;
len1 = len;
condition1 = strdup(condition);
}
}
}
pool_write(frontend, &pid1, sizeof(pid1));
status = pool_write_and_flush(frontend, condition1, len1);
free(condition1);
return status;
}
POOL_STATUS CompletedResponse(POOL_CONNECTION *frontend,
POOL_CONNECTION_POOL *backend)
{
int i;
char *string = NULL;
char *string1 = NULL;
int len, len1 = 0;
/* read command tag */
string = pool_read_string(MASTER(backend), &len, 0);
if (string == NULL)
return POOL_END;
else if (!strncmp(string, "BEGIN", 5))
TSTATE(backend, MASTER_NODE_ID) = 'T';
else if (!strncmp(string, "COMMIT", 6) || !strncmp(string, "ROLLBACK", 8))
TSTATE(backend, MASTER_NODE_ID) = 'I';
len1 = len;
string1 = strdup(string);
for (i=0;i<NUM_BACKENDS;i++)
{
if (!VALID_BACKEND(i) || IS_MASTER_NODE_ID(i))
continue;
/* read command tag */
string = pool_read_string(CONNECTION(backend, i), &len, 0);
if (string == NULL)
return POOL_END;
else if (!strncmp(string, "BEGIN", 5))
TSTATE(backend, i) = 'T';
else if (!strncmp(string, "COMMIT", 6) || !strncmp(string, "ROLLBACK", 8))
TSTATE(backend, i) = 'I';
if (len != len1)
{
pool_debug("CompletedResponse: message length does not match between master(%d \"%s\",) and %d th server (%d \"%s\",)",
len, string, i, len1, string1);
/* we except INSERT, because INSERT response has OID */
if (strncmp(string1, "INSERT", 6))
{
free(string1);
return POOL_END;
}
}
}
/* forward to the frontend */
pool_write(frontend, "C", 1);
pool_debug("CompletedResponse: string: \"%s\"", string1);
if (pool_write(frontend, string1, len1) < 0)
{
free(string1);
return POOL_END;
}
free(string1);
return pool_flush(frontend);
}
POOL_STATUS CursorResponse(POOL_CONNECTION *frontend,
POOL_CONNECTION_POOL *backend)
{
char *string = NULL;
char *string1 = NULL;
int len, len1 = 0;
int i;
/* read cursor name */
string = pool_read_string(MASTER(backend), &len, 0);
if (string == NULL)
return POOL_END;
len1 = len;
string1 = strdup(string);
for (i=0;i<NUM_BACKENDS;i++)
{
if (VALID_BACKEND(i) && !IS_MASTER_NODE_ID(i))
{
/* read cursor name */
string = pool_read_string(CONNECTION(backend, i), &len, 0);
if (string == NULL)
return POOL_END;
if (len != len1)
{
pool_error("CursorResponse: length does not match between master(%d) and %d th backend(%d)",
len, i, len1);
pool_error("CursorResponse: master(%s) %d th backend(%s)", string1, i, string);
free(string1);
return POOL_END;
}
}
}
/* forward to the frontend */
pool_write(frontend, "P", 1);
if (pool_write(frontend, string1, len1) < 0)
{
free(string1);
return POOL_END;
}
free(string1);
if (pool_flush(frontend))
return POOL_END;
return POOL_CONTINUE;
}
/*
* Send extended query and wait for response
* send_type:
* -1: do not send this node_id
* 0: send to all nodes
* >0: send to this node_id
*/
POOL_STATUS pool_extended_send_and_wait(POOL_QUERY_CONTEXT *query_context,
char *kind, int len, char *contents,
int send_type, int node_id)
{
POOL_SESSION_CONTEXT *session_context;
POOL_CONNECTION *frontend;
POOL_CONNECTION_POOL *backend;
bool is_commit;
bool is_begin_read_write;
int i;
int str_len;
int rewritten_len;
char *str;
char *rewritten_begin;
session_context = pool_get_session_context();
frontend = session_context->frontend;
backend = session_context->backend;
is_commit = is_commit_or_rollback_query(query_context->parse_tree);
is_begin_read_write = false;
str_len = 0;
rewritten_len = 0;
str = NULL;
rewritten_begin = NULL;
/*
* If the query is BEGIN READ WRITE or
* BEGIN ... SERIALIZABLE in master/slave mode,
* we send BEGIN to slaves/standbys instead.
* original_query which is BEGIN READ WRITE is sent to primary.
* rewritten_query which is BEGIN is sent to standbys.
*/
if (pool_need_to_treat_as_if_default_transaction(query_context))
{
is_begin_read_write = true;
if (*kind == 'P')
{
rewritten_begin = remove_read_write(len, contents, &rewritten_len);
if (rewritten_begin == NULL)
return POOL_END;
}
}
if (!rewritten_begin)
{
str_len = len;
str = contents;
}
/* Send query */
for (i=0;i<NUM_BACKENDS;i++)
{
if (!VALID_BACKEND(i))
continue;
else if (send_type < 0 && i == node_id)
continue;
else if (send_type > 0 && i != node_id)
continue;
/*
* If in reset context, we send COMMIT/ABORT to nodes those
* are not in I(idle) state. This will ensure that
* transactions are closed.
*/
if (is_commit && session_context->reset_context && TSTATE(backend, i) == 'I')
{
pool_unset_node_to_be_sent(query_context, i);
continue;
}
if (rewritten_begin)
{
if (REAL_PRIMARY_NODE_ID == i)
{
str = contents;
str_len = len;
}
else
{
str = rewritten_begin;
str_len = rewritten_len;
}
}
if (pool_config->log_per_node_statement)
{
char msgbuf[QUERY_STRING_BUFFER_LEN];
char *stmt;
if (*kind == 'P' || *kind == 'E')
{
if (query_context->rewritten_query)
{
if (is_begin_read_write)
{
if (REAL_PRIMARY_NODE_ID == i)
stmt = query_context->original_query;
else
stmt = query_context->rewritten_query;
}
else
{
stmt = query_context->rewritten_query;
}
}
else
{
stmt = query_context->original_query;
}
if (*kind == 'P')
snprintf(msgbuf, sizeof(msgbuf), "Parse: %s", stmt);
else
snprintf(msgbuf, sizeof(msgbuf), "Execute: %s", stmt);
}
else
{
snprintf(msgbuf, sizeof(msgbuf), "%c message", *kind);
}
per_node_statement_log(backend, i, msgbuf);
}
if (send_extended_protocol_message(backend, i, kind, str_len, str) != POOL_CONTINUE)
{
free(rewritten_begin);
return POOL_END;
}
}
if (!is_begin_read_write)
{
if (query_context->rewritten_query)
str = query_context->rewritten_query;
else
str = query_context->original_query;
}
/* Wait for response */
for (i=0;i<NUM_BACKENDS;i++)
{
if (!VALID_BACKEND(i))
continue;
else if (send_type < 0 && i == node_id)
continue;
else if (send_type > 0 && i != node_id)
continue;
/*
* If in master/slave mode, we do not send COMMIT/ABORT to
* slaves/standbys if it's in I(idle) state.
*/
if (is_commit && MASTER_SLAVE && !IS_MASTER_NODE_ID(i) && TSTATE(backend, i) == 'I')
{
continue;
}
if (is_begin_read_write)
{
if (REAL_PRIMARY_NODE_ID == i)
str = query_context->original_query;
else
str = query_context->rewritten_query;
}
if (wait_for_query_response(frontend, CONNECTION(backend, i), MAJOR(backend)) != POOL_CONTINUE)
{
/* Cancel current transaction */
CancelPacket cancel_packet;
cancel_packet.protoVersion = htonl(PROTO_CANCEL);
cancel_packet.pid = MASTER_CONNECTION(backend)->pid;
cancel_packet.key= MASTER_CONNECTION(backend)->key;
cancel_request(&cancel_packet);
free(rewritten_begin);
return POOL_END;
}
/*
* Check if some error detected. If so, emit
* log. This is usefull when invalid encoding error
* occurs. In this case, PostgreSQL does not report
* what statement caused that error and make users
* confused.
*/
per_node_error_log(backend, i, str, "pool_send_and_wait: Error or notice message from backend: ", true);
}
free(rewritten_begin);
return POOL_CONTINUE;
}
/*
* Send simple query and wait for response
* send_type:
* -1: do not send this node_id
* 0: send to all nodes
* >0: send to this node_id
*/
POOL_STATUS pool_send_and_wait(POOL_QUERY_CONTEXT *query_context,
int send_type, int node_id)
{
POOL_SESSION_CONTEXT *session_context;
POOL_CONNECTION *frontend;
POOL_CONNECTION_POOL *backend;
bool is_commit;
bool is_begin_read_write;
int i;
int len;
char *string;
session_context = pool_get_session_context();
frontend = session_context->frontend;
backend = session_context->backend;
is_commit = is_commit_or_rollback_query(query_context->parse_tree);
is_begin_read_write = false;
len = 0;
string = NULL;
/*
* If the query is BEGIN READ WRITE or
* BEGIN ... SERIALIZABLE in master/slave mode,
* we send BEGIN to slaves/standbys instead.
* original_query which is BEGIN READ WRITE is sent to primary.
* rewritten_query which is BEGIN is sent to standbys.
*/
if (pool_need_to_treat_as_if_default_transaction(query_context))
{
is_begin_read_write = true;
}
else
{
if (query_context->rewritten_query)
{
len = query_context->rewritten_length;
string = query_context->rewritten_query;
}
else
{
len = query_context->original_length;
string = query_context->original_query;
}
}
/* Send query */
for (i=0;i<NUM_BACKENDS;i++)
{
if (!VALID_BACKEND(i))
continue;
else if (send_type < 0 && i == node_id)
continue;
else if (send_type > 0 && i != node_id)
continue;
/*
* If in master/slave mode, we do not send COMMIT/ABORT to
* slaves/standbys if it's in I(idle) state.
*/
if (is_commit && MASTER_SLAVE && !IS_MASTER_NODE_ID(i) && TSTATE(backend, i) == 'I')
{
pool_unset_node_to_be_sent(query_context, i);
continue;
}
/*
* If in reset context, we send COMMIT/ABORT to nodes those
* are not in I(idle) state. This will ensure that
* transactions are closed.
*/
if (is_commit && session_context->reset_context && TSTATE(backend, i) == 'I')
{
pool_unset_node_to_be_sent(query_context, i);
continue;
}
if (is_begin_read_write)
{
if (REAL_PRIMARY_NODE_ID == i)
{
len = query_context->original_length;
string = query_context->original_query;
}
else
{
len = query_context->rewritten_length;
string = query_context->rewritten_query;
}
}
per_node_statement_log(backend, i, string);
if (send_simplequery_message(CONNECTION(backend, i), len, string, MAJOR(backend)) != POOL_CONTINUE)
{
return POOL_END;
}
}
/* Wait for response */
for (i=0;i<NUM_BACKENDS;i++)
{
if (!VALID_BACKEND(i))
continue;
else if (send_type < 0 && i == node_id)
continue;
else if (send_type > 0 && i != node_id)
continue;
#ifdef NOT_USED
/*
* If in master/slave mode, we do not send COMMIT/ABORT to
* slaves/standbys if it's in I(idle) state.
*/
if (is_commit && MASTER_SLAVE && !IS_MASTER_NODE_ID(i) && TSTATE(backend, i) == 'I')
{
continue;
}
#endif
if (is_begin_read_write)
{
if(REAL_PRIMARY_NODE_ID == i)
string = query_context->original_query;
else
string = query_context->rewritten_query;
}
if (wait_for_query_response(frontend, CONNECTION(backend, i), MAJOR(backend)) != POOL_CONTINUE)
{
/* Cancel current transaction */
CancelPacket cancel_packet;
cancel_packet.protoVersion = htonl(PROTO_CANCEL);
cancel_packet.pid = MASTER_CONNECTION(backend)->pid;
cancel_packet.key= MASTER_CONNECTION(backend)->key;
cancel_request(&cancel_packet);
return POOL_END;
}
/*
* Check if some error detected. If so, emit
* log. This is usefull when invalid encoding error
* occurs. In this case, PostgreSQL does not report
* what statement caused that error and make users
* confused.
*/
per_node_error_log(backend, i, string, "pool_send_and_wait: Error or notice message from backend: ", true);
}
return POOL_CONTINUE;
}
/*
* read a string until EOF or NULL is encountered.
* if line is not 0, read until new line is encountered.
*/
char *pool_read_string(POOL_CONNECTION *cp, int *len, int line)
{
int readp;
int readsize;
int readlen;
int strlength;
int flag;
int consume_size;
#ifdef DEBUG
static char pbuf[READBUFSZ];
#endif
*len = 0;
readp = 0;
/* initialize read buffer */
if (cp->sbufsz == 0)
{
cp->sbuf = malloc(READBUFSZ);
if (cp->sbuf == NULL)
{
pool_error("pool_read_string: malloc failed");
return NULL;
}
cp->sbufsz = READBUFSZ;
*cp->sbuf = '\0';
}
/* any pending data? */
if (cp->len)
{
if (line)
strlength = mystrlinelen(cp->hp+cp->po, cp->len, &flag);
else
strlength = mystrlen(cp->hp+cp->po, cp->len, &flag);
/* buffer is too small? */
if ((strlength + 1) > cp->sbufsz)
{
cp->sbufsz = ((strlength+1)/READBUFSZ+1)*READBUFSZ;
cp->sbuf = realloc(cp->sbuf, cp->sbufsz);
if (cp->sbuf == NULL)
{
pool_error("pool_read_string: realloc failed");
return NULL;
}
}
/* consume pending and save to read string buffer */
consume_size = consume_pending_data(cp, cp->sbuf, strlength);
*len = strlength;
/* is the string null terminated? */
if (consume_size == strlength && !flag)
{
/* not null or line terminated.
* we need to read more since we have not encountered NULL or new line yet
*/
readsize = cp->sbufsz - strlength;
readp = strlength;
}
else
{
pool_debug("pool_read_string: read all from pending data. po:%d len:%d",
cp->po, cp->len);
return cp->sbuf;
}
} else
{
readsize = cp->sbufsz;
}
for (;;)
{
if (pool_check_fd(cp))
{
if (!IS_MASTER_NODE_ID(cp->db_node_id))
{
pool_log("pool_read_string: data is not ready in DB node:%d. abort this session",
cp->db_node_id);
exit(1);
}
else
{
pool_error("pool_read_string: pool_check_fd failed (%s)", strerror(errno));
return NULL;
}
}
if (cp->ssl_active > 0) {
readlen = pool_ssl_read(cp, cp->sbuf+readp, readsize);
} else {
readlen = read(cp->fd, cp->sbuf+readp, readsize);
}
if (readlen == -1)
{
pool_error("pool_read_string: read() failed. reason:%s", strerror(errno));
if (cp->isbackend)
{
notice_backend_error(cp->db_node_id);
child_exit(1);
}
else
{
return NULL;
}
}
else if (readlen == 0) /* EOF detected */
{
/*
* just returns an error, not trigger failover or degeneration
*/
pool_error("pool_read_string: read () EOF detected");
return NULL;
}
/* check overrun */
if (line)
strlength = mystrlinelen(cp->sbuf+readp, readlen, &flag);
else
strlength = mystrlen(cp->sbuf+readp, readlen, &flag);
if (strlength < readlen)
{
save_pending_data(cp, cp->sbuf+readp+strlength, readlen-strlength);
*len += strlength;
pool_debug("pool_read_string: total result %d with pending data po:%d len:%d", *len, cp->po, cp->len);
return cp->sbuf;
}
*len += readlen;
/* encountered null or newline? */
if (flag)
{
/* ok we have read all data */
pool_debug("pool_read_string: total result %d ", *len);
break;
}
readp += readlen;
readsize = READBUFSZ;
if ((*len+readsize) > cp->sbufsz)
{
cp->sbufsz += READBUFSZ;
cp->sbuf = realloc(cp->sbuf, cp->sbufsz);
if (cp->sbuf == NULL)
{
pool_error("pool_read_string: realloc failed");
return NULL;
}
}
}
return cp->sbuf;
}
/*
* read exactly len bytes from cp
* returns buffer address on success otherwise NULL.
*/
char *pool_read2(POOL_CONNECTION *cp, int len)
{
char *buf;
int req_size;
int alloc_size;
int consume_size;
int readlen;
req_size = cp->len + len;
if (req_size > cp->bufsz2)
{
alloc_size = ((req_size+1)/READBUFSZ+1)*READBUFSZ;
cp->buf2 = realloc(cp->buf2, alloc_size);
if (cp->buf2 == NULL)
{
pool_error("pool_read2: failed to realloc");
exit(1);
}
cp->bufsz2 = alloc_size;
}
buf = cp->buf2;
consume_size = consume_pending_data(cp, buf, len);
len -= consume_size;
buf += consume_size;
while (len > 0)
{
if (pool_check_fd(cp))
{
if (!IS_MASTER_NODE_ID(cp->db_node_id))
{
pool_log("pool_read2: data is not ready in DB node:%d. abort this session",
cp->db_node_id);
exit(1);
}
else
{
pool_error("pool_read2: pool_check_fd failed (%s)", strerror(errno));
return NULL;
}
}
if (cp->ssl_active > 0) {
readlen = pool_ssl_read(cp, buf, len);
} else {
readlen = read(cp->fd, buf, len);
}
if (readlen == -1)
{
if (errno == EINTR || errno == EAGAIN)
{
pool_debug("pool_read2: retrying due to %s", strerror(errno));
continue;
}
pool_error("pool_read2: read failed (%s)", strerror(errno));
if (cp->isbackend)
{
/* fatal error, notice to parent and exit */
notice_backend_error(cp->db_node_id);
child_exit(1);
}
else
{
return NULL;
}
}
else if (readlen == 0)
{
if (cp->isbackend)
{
pool_error("pool_read2: EOF encountered with backend");
return NULL;
#ifdef NOT_USED
/* fatal error, notice to parent and exit */
notice_backend_error(IS_MASTER_NODE_ID(cp->db_node_id));
child_exit(1);
#endif
}
else
{
/*
* if backend offers authentication method, frontend could close connection
*/
return NULL;
}
}
buf += readlen;
len -= readlen;
}
return cp->buf2;
}
/*
* read len bytes from cp
* returns 0 on success otherwise -1.
*/
int pool_read(POOL_CONNECTION *cp, void *buf, int len)
{
static char readbuf[READBUFSZ];
int consume_size;
int readlen;
consume_size = consume_pending_data(cp, buf, len);
len -= consume_size;
buf += consume_size;
while (len > 0)
{
if (pool_check_fd(cp))
{
if (!IS_MASTER_NODE_ID(cp->db_node_id))
{
pool_log("pool_read: data is not ready in DB node: %d. abort this session",
cp->db_node_id);
exit(1);
}
else
{
pool_error("pool_read: pool_check_fd failed (%s)", strerror(errno));
return -1;
}
}
if (cp->ssl_active > 0) {
readlen = pool_ssl_read(cp, readbuf, READBUFSZ);
} else {
readlen = read(cp->fd, readbuf, READBUFSZ);
}
if (readlen == -1)
{
if (errno == EINTR || errno == EAGAIN)
{
pool_debug("pool_read: retrying due to %s", strerror(errno));
continue;
}
pool_error("pool_read: read failed (%s)", strerror(errno));
if (cp->isbackend)
{
/* fatal error, notice to parent and exit */
notice_backend_error(cp->db_node_id);
child_exit(1);
}
else
{
return -1;
}
}
else if (readlen == 0)
{
if (cp->isbackend)
{
pool_error("pool_read: EOF encountered with backend");
return -1;
#ifdef NOT_USED
/* fatal error, notice to parent and exit */
notice_backend_error(IS_MASTER_NODE_ID(cp->db_node_id));
child_exit(1);
#endif
}
else
{
/*
* if backend offers authentication method, frontend could close connection
*/
return -1;
}
}
if (len < readlen)
{
/* overrun. we need to save remaining data to pending buffer */
if (save_pending_data(cp, readbuf+len, readlen-len))
return -1;
memmove(buf, readbuf, len);
break;
}
memmove(buf, readbuf, readlen);
buf += readlen;
len -= readlen;
}
return 0;
}
int RowDescription(POOL_CONNECTION *frontend,
POOL_CONNECTION_POOL *backend,
short *result)
{
short num_fields, num_fields1 = 0;
int oid, mod;
int oid1, mod1;
short size, size1;
char *string;
int len, len1;
int i;
pool_read(MASTER(backend), &num_fields, sizeof(short));
num_fields1 = num_fields;
for (i=0;i<NUM_BACKENDS;i++)
{
if (VALID_BACKEND(i) && !IS_MASTER_NODE_ID(i))
{
/* # of fields (could be 0) */
pool_read(CONNECTION(backend, i), &num_fields, sizeof(short));
if (num_fields != num_fields1)
{
pool_error("RowDescription: num_fields does not match between backends master(%d) and %d th backend(%d)",
num_fields, i, num_fields1);
return POOL_FATAL;
}
}
}
/* forward it to the frontend */
pool_write(frontend, "T", 1);
pool_write(frontend, &num_fields, sizeof(short));
num_fields = ntohs(num_fields);
for (i = 0;i<num_fields;i++)
{
int j;
/* field name */
string = pool_read_string(MASTER(backend), &len, 0);
if (string == NULL)
return POOL_END;
len1 = len;
if (pool_write(frontend, string, len) < 0)
return POOL_END;
for (j=0;j<NUM_BACKENDS;j++)
{
if (VALID_BACKEND(j) && !IS_MASTER_NODE_ID(j))
{
string = pool_read_string(CONNECTION(backend, j), &len, 0);
if (string == NULL)
return POOL_END;
if (len != len1)
{
pool_error("RowDescription: field length does not match between backends master(%d) and %d th backend(%d)",
ntohl(len), j, ntohl(len1));
return POOL_FATAL;
}
}
}
/* type oid */
pool_read(MASTER(backend), &oid, sizeof(int));
oid1 = oid;
pool_debug("RowDescription: type oid: %d", ntohl(oid));
for (j=0;j<NUM_BACKENDS;j++)
{
if (VALID_BACKEND(j) && !IS_MASTER_NODE_ID(j))
{
pool_read(CONNECTION(backend, j), &oid, sizeof(int));
/* we do not regard oid mismatch as fatal */
if (oid != oid1)
{
pool_debug("RowDescription: field oid does not match between backends master(%d) and %d th backend(%d)",
ntohl(oid), j, ntohl(oid1));
}
}
}
if (pool_write(frontend, &oid1, sizeof(int)) < 0)
return POOL_END;
/* size */
pool_read(MASTER(backend), &size, sizeof(short));
size1 = size;
for (j=0;j<NUM_BACKENDS;j++)
{
if (VALID_BACKEND(j) && !IS_MASTER_NODE_ID(j))
{
pool_read(CONNECTION(backend, j), &size, sizeof(short));
if (size1 != size1)
{
pool_error("RowDescription: field size does not match between backends master(%d) and %d th backend(%d)",
ntohs(size), j, ntohs(size1));
return POOL_FATAL;
}
}
}
pool_debug("RowDescription: field size: %d", ntohs(size));
pool_write(frontend, &size1, sizeof(short));
/* modifier */
pool_read(MASTER(backend), &mod, sizeof(int));
pool_debug("RowDescription: modifier: %d", ntohs(mod));
mod1 = mod;
for (j=0;j<NUM_BACKENDS;j++)
{
if (VALID_BACKEND(j) && !IS_MASTER_NODE_ID(j))
{
pool_read(CONNECTION(backend, j), &mod, sizeof(int));
if (mod != mod1)
{
pool_debug("RowDescription: modifier does not match between backends master(%d) and %d th backend(%d)",
ntohl(mod), j, ntohl(mod1));
}
}
}
if (pool_write(frontend, &mod1, sizeof(int)) < 0)
return POOL_END;
}
*result = num_fields;
return pool_flush(frontend);
}
POOL_STATUS AsciiRow(POOL_CONNECTION *frontend,
POOL_CONNECTION_POOL *backend,
short num_fields)
{
static char nullmap[8192], nullmap1[8192];
int nbytes;
int i, j;
unsigned char mask;
int size, size1 = 0;
char *buf = NULL, *sendbuf = NULL;
char msgbuf[1024];
pool_write(frontend, "D", 1);
nbytes = (num_fields + 7)/8;
if (nbytes <= 0)
return POOL_CONTINUE;
/* NULL map */
pool_read(MASTER(backend), nullmap, nbytes);
memcpy(nullmap1, nullmap, nbytes);
for (i=0;i<NUM_BACKENDS;i++)
{
if (VALID_BACKEND(i) && !IS_MASTER_NODE_ID(i))
{
pool_read(CONNECTION(backend, i), nullmap, nbytes);
if (memcmp(nullmap, nullmap1, nbytes))
{
/* XXX: NULLMAP maybe different among
backends. If we were a paranoid, we have to treat
this as a fatal error. However in the real world
we'd better to adapt this situation. Just throw a
log... */
pool_debug("AsciiRow: NULLMAP differ between master and %d th backend", i);
}
}
}
if (pool_write(frontend, nullmap1, nbytes) < 0)
return POOL_END;
mask = 0;
for (i = 0;i<num_fields;i++)
{
if (mask == 0)
mask = 0x80;
/* NOT NULL? */
if (mask & nullmap[i/8])
{
/* field size */
if (pool_read(MASTER(backend), &size, sizeof(int)) < 0)
return POOL_END;
size1 = ntohl(size) - 4;
/* read and send actual data only when size > 0 */
if (size1 > 0)
{
sendbuf = pool_read2(MASTER(backend), size1);
if (sendbuf == NULL)
return POOL_END;
}
/* forward to frontend */
pool_write(frontend, &size, sizeof(int));
pool_write(frontend, sendbuf, size1);
snprintf(msgbuf, Min(sizeof(msgbuf), size1+1), "%s", sendbuf);
pool_debug("AsciiRow: len: %d data: %s", size1, msgbuf);
for (j=0;j<NUM_BACKENDS;j++)
{
if (VALID_BACKEND(j) && !IS_MASTER_NODE_ID(j))
{
/* field size */
if (pool_read(CONNECTION(backend, j), &size, sizeof(int)) < 0)
return POOL_END;
buf = NULL;
size = ntohl(size) - 4;
/* XXX: field size maybe different among
backends. If we were a paranoid, we have to treat
this as a fatal error. However in the real world
we'd better to adapt this situation. Just throw a
log... */
if (size != size1)
pool_debug("AsciiRow: %d th field size does not match between master(%d) and %d th backend(%d)",
i, ntohl(size), j, ntohl(size1));
/* read and send actual data only when size > 0 */
if (size > 0)
{
buf = pool_read2(CONNECTION(backend, j), size);
if (buf == NULL)
return POOL_END;
}
}
}
}
mask >>= 1;
}
if (pool_flush(frontend))
return POOL_END;
return POOL_CONTINUE;
}