static inline int
scanner_read_more(struct scanner *lc, int n)
{
bstream *b = lc->rs;
int more = 0;
while (b->len < b->pos + lc->yycur + n) {
if (lc->mode == LINE_1 || !lc->started)
return EOF;
/* query is not finished ask for more */
if (b->eof || !isa_block_stream(b->s)) {
if (mnstr_write(lc->ws, PROMPT2, sizeof(PROMPT2) - 1, 1) == 1)
mnstr_flush(lc->ws);
b->eof = 0;
more = 1;
}
/* we need more query text */
if (bstream_next(b) < 0 ||
/* we asked for more data but didn't get any */
(more && b->eof && b->len < b->pos + lc->yycur + n))
return EOF;
}
return 1;
}
/* #define _SQL_READER_DEBUG */
str
SQLreader(Client c)
{
int go = TRUE;
int more = TRUE;
int commit_done = FALSE;
backend *be = (backend *) c->sqlcontext;
bstream *in = c->fdin;
int language = -1;
mvc *m = NULL;
int blocked = isa_block_stream(in->s);
if (SQLinitialized == FALSE) {
c->mode = FINISHCLIENT;
return NULL;
}
if (!be || c->mode <= FINISHCLIENT) {
#ifdef _SQL_READER_DEBUG
mnstr_printf(GDKout, "#SQL client finished\n");
#endif
c->mode = FINISHCLIENT;
return NULL;
}
#ifdef _SQL_READER_DEBUG
mnstr_printf(GDKout, "#SQLparser: start reading SQL %s %s\n", (be->console ? " from console" : ""), (blocked ? "Blocked read" : ""));
#endif
language = be->language; /* 'S' for SQL, 'D' from debugger */
m = be->mvc;
m->errstr[0] = 0;
/*
* Continue processing any left-over input from the previous round.
*/
#ifdef _SQL_READER_DEBUG
mnstr_printf(GDKout, "#pos %d len %d eof %d \n", in->pos, in->len, in->eof);
#endif
/*
* Distinguish between console reading and mclient connections.
* The former comes with readline functionality.
*/
while (more) {
more = FALSE;
/* Different kinds of supported statements sequences
A; -- single line s
A \n B; -- multi line S
A; B; -- compound single block s
A; -- many multi line
B \n C; -- statements in one block S
*/
/* auto_commit on end of statement */
if (m->scanner.mode == LINE_N && !commit_done) {
go = SQLautocommit(c, m);
commit_done = TRUE;
}
if (go && in->pos >= in->len) {
ssize_t rd;
if (c->bak) {
#ifdef _SQL_READER_DEBUG
mnstr_printf(GDKout, "#Switch to backup stream\n");
#endif
in = c->fdin;
blocked = isa_block_stream(in->s);
m->scanner.rs = c->fdin;
c->fdin->pos += c->yycur;
c->yycur = 0;
}
if (in->eof || !blocked) {
language = (be->console) ? 'S' : 0;
/* The rules of auto_commit require us to finish
and start a transaction on the start of a new statement (s A;B; case) */
if (!(m->emod & mod_debug) && !commit_done) {
go = SQLautocommit(c, m);
commit_done = TRUE;
}
if (go && ((!blocked && mnstr_write(c->fdout, c->prompt, c->promptlength, 1) != 1) || mnstr_flush(c->fdout))) {
go = FALSE;
break;
}
in->eof = 0;
}
if (in->buf == NULL) {
more = FALSE;
go = FALSE;
} else if (go && (rd = bstream_next(in)) <= 0) {
#ifdef _SQL_READER_DEBUG
mnstr_printf(GDKout, "#rd %d language %d eof %d\n", rd, language, in->eof);
#endif
if (be->language == 'D' && in->eof == 0)
return 0;
if (rd == 0 && language !=0 && in->eof && !be->console) {
/* we hadn't seen the EOF before, so just try again
(this time with prompt) */
more = TRUE;
continue;
}
go = FALSE;
break;
} else if (go && !be->console && language == 0) {
if (in->buf[in->pos] == 's' && !in->eof) {
while ((rd = bstream_next(in)) > 0)
;
}
be->language = in->buf[in->pos++];
if (be->language == 's') {
be->language = 'S';
m->scanner.mode = LINE_1;
} else if (be->language == 'S') {
m->scanner.mode = LINE_N;
}
}
#ifdef _SQL_READER_DEBUG
mnstr_printf(GDKout, "#SQL blk:%s\n", in->buf + in->pos);
#endif
}
}
if ( (c->stimeout && (GDKusec() - c->session) > c->stimeout) || !go || (strncmp(CURRENT(c), "\\q", 2) == 0)) {
in->pos = in->len; /* skip rest of the input */
c->mode = FINISHCLIENT;
return NULL;
}
return 0;
}
/*
* Input to be processed is collected in a Client specific buffer. It
* is filled by reading information from a stream, a terminal, or by
* scheduling strings constructed internally. The latter involves
* removing any escape character needed to manipulate the string within
* the kernel. The buffer space is automatically expanded to
* accommodate new information and the read pointers are adjusted.
*
* The input is read from a (blocked) stream and stored in the client
* record input buffer. The storage area grows automatically upon need.
* The origin of the input stream depends on the connectivity mode.
*
* Each operation received from a front-end consists of at least one
* line. To simplify misaligned communication with front-ends, we use
* different prompts structures.
*
* The default action is to read information from an ascii-stream one
* line at a time. This is the preferred mode for reading from terminal.
*
* The next statement block is to be read. Send a prompt to warn the
* front-end to issue the request.
*/
int
MCreadClient(Client c)
{
bstream *in = c->fdin;
#ifdef MAL_CLIENT_DEBUG
printf("# streamClient %d %d\n", c->idx, isa_block_stream(in->s));
#endif
while (in->pos < in->len &&
(isspace((int) (in->buf[in->pos])) ||
in->buf[in->pos] == ';' || !in->buf[in->pos]))
in->pos++;
if (in->pos >= in->len || in->mode) {
ssize_t rd, sum = 0;
if (in->eof || !isa_block_stream(c->fdout)) {
if (!isa_block_stream(c->fdout) && c->promptlength > 0)
mnstr_write(c->fdout, c->prompt, c->promptlength, 1);
mnstr_flush(c->fdout);
in->eof = 0;
}
while ((rd = bstream_next(in)) > 0 && !in->eof) {
sum += rd;
if (!in->mode) /* read one line at a time in line mode */
break;
}
if (in->mode) { /* find last new line */
char *p = in->buf + in->len - 1;
while (p > in->buf && *p != '\n') {
*(p + 1) = *p;
p--;
}
if (p > in->buf)
*(p + 1) = 0;
if (p != in->buf + in->len - 1)
in->len++;
}
if (sum == 0 && in->eof && isa_block_stream(in->s)) {
/* we hadn't seen the EOF before, so just try again
(this time with prompt) */
#ifdef MAL_CLIENT_DEBUG
printf("# retry stream reading %d %d\n", c->idx, in->eof);
#endif
return MCreadClient(c);
}
#ifdef MAL_CLIENT_DEBUG
printf("# simple stream received %d sum " SZFMT "\n", c->idx, sum);
#endif
}
if (in->pos >= in->len) {
/* end of stream reached */
#ifdef MAL_CLIENT_DEBUG
printf("# end of stream received %d %d\n", c->idx, c->bak == 0);
#endif
if (c->bak) {
MCpopClientInput(c);
if (c->fdin == NULL)
return 0;
return MCreadClient(c);
}
return 0;
}
if (*CURRENT(c) == '?') {
showHelp(c->nspace, CURRENT(c) + 1, c->fdout);
in->pos = in->len;
return MCreadClient(c);
}
#ifdef MAL_CLIENT_DEBUG
printf("# finished stream read %d %d\n", (int) in->pos, (int) in->len);
printf("#%s\n", in->buf);
#endif
return 1;
}
/*
* Input to be processed is collected in a Client specific buffer. It
* is filled by reading information from a stream, a terminal, or by
* scheduling strings constructed internally. The latter involves
* removing any escape character needed to manipulate the string within
* the kernel. The buffer space is automatically expanded to
* accommodate new information and the read pointers are adjusted.
*
* The input is read from a (blocked) stream and stored in the client
* record input buffer. The storage area grows automatically upon need.
* The origin of the input stream depends on the connectivity mode.
*
* Each operation received from a front-end consists of at least one
* line. To simplify misaligned communication with front-ends, we use
* different prompts structures.
*
* The default action is to read information from an ascii-stream one
* line at a time. This is the preferred mode for reading from terminal.
*
* The next statement block is to be read. Send a prompt to warn the
* front-end to issue the request.
*/
int
MCreadClient(Client c)
{
bstream *in = c->fdin;
#ifdef MAL_CLIENT_DEBUG
fprintf(stderr,"# streamClient %d %d\n", c->idx, isa_block_stream(in->s));
#endif
while (in->pos < in->len &&
(isspace((unsigned char) (in->buf[in->pos])) ||
in->buf[in->pos] == ';' || !in->buf[in->pos]))
in->pos++;
if (in->pos >= in->len || in->mode) {
ssize_t rd, sum = 0;
if (in->eof || !isa_block_stream(c->fdout)) {
if (!isa_block_stream(c->fdout) && c->promptlength > 0)
mnstr_write(c->fdout, c->prompt, c->promptlength, 1);
mnstr_flush(c->fdout);
in->eof = false;
}
while ((rd = bstream_next(in)) > 0 && !in->eof) {
sum += rd;
if (!in->mode) /* read one line at a time in line mode */
break;
}
if (in->mode) { /* find last new line */
char *p = in->buf + in->len - 1;
while (p > in->buf && *p != '\n') {
*(p + 1) = *p;
p--;
}
if (p > in->buf)
*(p + 1) = 0;
if (p != in->buf + in->len - 1)
in->len++;
}
#ifdef MAL_CLIENT_DEBUG
fprintf(stderr, "# simple stream received %d sum %zu\n", c->idx, sum);
#endif
}
if (in->pos >= in->len) {
/* end of stream reached */
#ifdef MAL_CLIENT_DEBUG
fprintf(stderr,"# end of stream received %d %d\n", c->idx, c->bak == 0);
#endif
if (c->bak) {
MCpopClientInput(c);
if (c->fdin == NULL)
return 0;
return MCreadClient(c);
}
return 0;
}
#ifdef MAL_CLIENT_DEBUG
fprintf(stderr,"# finished stream read %d %d\n", (int) in->pos, (int) in->len);
printf("#%s\n", in->buf);
#endif
return 1;
}
