开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
parse.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：19k
源码类别：

数据库系统

开发平台：

Unix_Linux

parse.c：源码内容
  2. /* Module:          parse.c
  3.  *
  4.  * Description:     This module contains routines related to parsing SQL statements.
  5.  *                  This can be useful for two reasons:
  6.  *
  7.  *                  1. So the query does not actually have to be executed to return data about it
  8.  *
  9.  *                  2. To be able to return information about precision, nullability, aliases, etc.
  10.  *                     in the functions SQLDescribeCol and SQLColAttributes.  Currently, Postgres
  11.  *                     doesn't return any information about these things in a query.
  12.  *
  13.  * Classes:         none
  14.  *
  15.  * API functions:   none
  16.  *
  17.  * Comments:        See "notice.txt" for copyright and license information.
  18.  *
  19.  */
  21. #include <stdio.h>
  22. #include <string.h>
  23. #include <ctype.h>
  25. #include "statement.h"
  26. #include "connection.h"
  27. #include "qresult.h"
  28. #include "pgtypes.h"
  30. #ifndef WIN32
  31. #ifndef HAVE_STRICMP
  32. #define stricmp(s1,s2)  strcasecmp(s1,s2)
  33. #define strnicmp(s1,s2,n) strncasecmp(s1,s2,n)
  34. #endif
  35. #endif
  37. #define FLD_INCR 32
  38. #define TAB_INCR 8
  39. #define COL_INCR 16
  41. char *getNextToken(char *s, char *token, int smax, char *delim, char *quote, char *dquote, char *numeric);
  42. void getColInfo(COL_INFO *col_info, FIELD_INFO *fi, int k);
  43. char searchColInfo(COL_INFO *col_info, FIELD_INFO *fi);
  45. char *
  46. getNextToken(char *s, char *token, int smax, char *delim, char *quote, char *dquote, char *numeric)
  47. {
  48. int i = 0;
  49. int out = 0;
  50. char qc, in_escape = FALSE;
  52. if (smax <= 1)
  53. return NULL;
  55. smax--;
  57. /* skip leading delimiters */
  58. while (isspace(s[i]) || s[i] == ',') {
  59. // mylog("skipping '%c'n", s[i]);
  60. i++;
  61. }
  63. if (s[0] == '') {
  64. token[0] = '';
  65. return NULL;
  66. }
  68. if (quote) *quote = FALSE;
  69. if (dquote) *dquote = FALSE;
  70. if (numeric) *numeric = FALSE;
  72. /* get the next token */
  73. while ( ! isspace(s[i]) && s[i] != ',' && s[i] != '' && out != smax) {
  75. /* Handle quoted stuff */
  76. if ( out == 0 && (s[i] == '"' || s[i] == ''')) {
  77. qc = s[i];
  78. if (qc == '"') {
  79. if (dquote) *dquote = TRUE;
  80. }
  81. if (qc == ''') {
  82. if (quote) *quote = TRUE;
  83. }
  85. i++; /* dont return the quote */
  86. while (s[i] != '' && out != smax) {  
  87. if (s[i] == qc && ! in_escape) {
  88. break;
  89. }
  90. if (s[i] == '\' && ! in_escape) {
  91. in_escape = TRUE;
  92. }
  93. else {
  94. in_escape = FALSE;
  95. token[out++] = s[i];
  96. }
  97. i++;
  98. }
  99. if (s[i] == qc)
  100. i++;
  101. break;
  102. }
  104. /* Check for numeric literals */
  105. if ( out == 0 && isdigit(s[i])) {
  106. if (numeric) *numeric = TRUE;
  107. token[out++] = s[i++];
  108. while ( isalnum(s[i]) || s[i] == '.')
  109. token[out++] = s[i++];
  111. break;
  112. }
  114. if ( ispunct(s[i]) && s[i] != '_') {
  115. mylog("got ispunct: s[%d] = '%c'n", i, s[i]);
  117. if (out == 0) {
  118. token[out++] = s[i++];
  119. break;
  120. }
  121. else
  122. break;
  123. }
  125. if (out != smax)
  126. token[out++] = s[i];
  128. i++;
  129. }
  131. // mylog("done -- s[%d] = '%c'n", i, s[i]);
  133. token[out] = '';
  135. /* find the delimiter  */
  136. while ( isspace(s[i]))
  137. i++;
  139. /* return the most priority delimiter */
  140. if (s[i] == ',')  {
  141. if (delim) *delim = s[i];
  142. }
  143. else if (s[i] == '') {
  144. if (delim) *delim = '';
  145. }
  146. else  {
  147. if (delim) *delim = ' ';
  148. }
  150. /* skip trailing blanks  */
  151. while ( isspace(s[i])) {
  152. i++;
  153. }
  155. return &s[i];
  156. }
  159. /*
  160. QR_set_num_fields(stmt->result, 14);
  161. QR_set_field_info(stmt->result, 0, "TABLE_QUALIFIER", PG_TYPE_TEXT, MAX_INFO_STRING);
  162. QR_set_field_info(stmt->result, 1, "TABLE_OWNER", PG_TYPE_TEXT, MAX_INFO_STRING);
  163. QR_set_field_info(stmt->result, 2, "TABLE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  164. QR_set_field_info(stmt->result, 3, "COLUMN_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  165. QR_set_field_info(stmt->result, 4, "DATA_TYPE", PG_TYPE_INT2, 2);
  166. QR_set_field_info(stmt->result, 5, "TYPE_NAME", PG_TYPE_TEXT, MAX_INFO_STRING);
  167. QR_set_field_info(stmt->result, 6, "PRECISION", PG_TYPE_INT4, 4);
  168. QR_set_field_info(stmt->result, 7, "LENGTH", PG_TYPE_INT4, 4);
  169. QR_set_field_info(stmt->result, 8, "SCALE", PG_TYPE_INT2, 2);
  170. QR_set_field_info(stmt->result, 9, "RADIX", PG_TYPE_INT2, 2);
  171. QR_set_field_info(stmt->result, 10, "NULLABLE", PG_TYPE_INT2, 2);
  172. QR_set_field_info(stmt->result, 11, "REMARKS", PG_TYPE_TEXT, 254);
  173. // User defined fields
  174. QR_set_field_info(stmt->result, 12, "DISPLAY_SIZE", PG_TYPE_INT4, 4);
  175. QR_set_field_info(stmt->result, 13, "FIELD_TYPE", PG_TYPE_INT4, 4);
  176. */
  178. void
  179. getColInfo(COL_INFO *col_info, FIELD_INFO *fi, int k)
  180. {
  181. if (fi->name[0] == '')
  182. strcpy(fi->name, QR_get_value_manual(col_info->result, k, 3));
  184. fi->type = atoi( QR_get_value_manual(col_info->result, k, 13));
  185. fi->precision = atoi( QR_get_value_manual(col_info->result, k, 6));
  186. fi->length = atoi( QR_get_value_manual(col_info->result, k, 7));
  187. fi->nullable = atoi( QR_get_value_manual(col_info->result, k, 10));
  188. fi->display_size = atoi( QR_get_value_manual(col_info->result, k, 12));
  189. }
  191. char
  192. searchColInfo(COL_INFO *col_info, FIELD_INFO *fi)
  193. {
  194. int k;
  195. char *col;
  198. for (k = 0; k < QR_get_num_tuples(col_info->result); k++) {
  199. col = QR_get_value_manual(col_info->result, k, 3);
  200. if ( ! strcmp(col, fi->name)) {
  201. getColInfo(col_info, fi, k);
  203. mylog("PARSE: searchColInfo: n");
  204. return TRUE;
  205. }
  206. }
  208. return FALSE;
  209. }
  212. char
  213. parse_statement(StatementClass *stmt)
  214. {
  215. static char *func="parse_statement";
  216. char token[256];
  217. char delim, quote, dquote, numeric, unquoted;
  218. char *ptr;
  219. char in_select = FALSE, in_distinct = FALSE, in_on = FALSE, in_from = FALSE, in_where = FALSE, in_table = FALSE;
  220. char in_field = FALSE, in_expr = FALSE, in_func = FALSE, in_dot = FALSE, in_as = FALSE;
  221. int j, i, k = 0, n, blevel = 0;
  222. FIELD_INFO **fi;
  223. TABLE_INFO **ti;
  224. char parse;
  225. ConnectionClass *conn = stmt->hdbc;
  226. HSTMT hcol_stmt;
  227. StatementClass *col_stmt;
  228. RETCODE result;
  231. mylog("%s: entering...n", func);
  233. ptr = stmt->statement;
  234. fi = stmt->fi;
  235. ti = stmt->ti;
  237. stmt->nfld = 0;
  238. stmt->ntab = 0;
  240. while ((ptr = getNextToken(ptr, token, sizeof(token), &delim, &quote, &dquote, &numeric)) != NULL) {
  242. unquoted = ! ( quote || dquote );
  244. mylog("unquoted=%d, quote=%d, dquote=%d, numeric=%d, delim='%c', token='%s', ptr='%s'n", unquoted, quote, dquote, numeric, delim, token, ptr);
  246. if ( unquoted && ! stricmp(token, "select")) {
  247. in_select = TRUE;
  249. mylog("SELECTn");
  250. continue;
  251. }
  253. if ( unquoted && in_select && ! stricmp(token, "distinct")) {
  254. in_distinct = TRUE;
  256. mylog("DISTINCTn");
  257. continue;
  258. }
  260. if ( unquoted && ! stricmp(token, "into")) {
  261. in_select = FALSE;
  263. mylog("INTOn");
  264. continue;
  265. }
  267. if ( unquoted && ! stricmp(token, "from")) {
  268. in_select = FALSE;
  269. in_from = TRUE;
  271. mylog("FROMn");
  272. continue;
  273. }
  275. if ( unquoted && (! stricmp(token, "where") ||
  276. ! stricmp(token, "union") || 
  277. ! stricmp(token, "order") || 
  278. ! stricmp(token, "group") || 
  279. ! stricmp(token, "having"))) {
  281. in_select = FALSE;
  282. in_from = FALSE;
  283. in_where = TRUE;
  285. mylog("WHERE...n");
  286. break;
  287. }
  289. if (in_select) {
  291. if ( in_distinct) {
  292. mylog("in distinctn");
  294. if (unquoted && ! stricmp(token, "on")) {
  295. in_on = TRUE;
  296. mylog("got onn");
  297. continue;
  298. }
  299. if (in_on) {
  300. in_distinct = FALSE;
  301. in_on = FALSE;
  302. continue; /* just skip the unique on field */
  303. }
  304. mylog("done distinctn");
  305. in_distinct = FALSE;
  306. }
  308. if ( in_expr || in_func) { /* just eat the expression */
  309. mylog("in_expr=%d or func=%dn", in_expr, in_func);
  310. if (quote || dquote)
  311. continue;
  313. if (in_expr && blevel == 0 && delim == ',') {
  314. mylog("**** in_expr and Got comman");
  315. in_expr = FALSE;
  316. in_field = FALSE;
  317. }
  319. else if (token[0] == '(') {
  320. blevel++;
  321. mylog("blevel++ = %dn", blevel);
  322. }
  323. else if (token[0] == ')') {
  324. blevel--;
  325. mylog("blevel-- = %dn", blevel);
  326. if (delim==',') {
  327. in_func = FALSE;
  328. in_expr = FALSE;
  329. in_field = FALSE;
  330. }
  331. }
  332. continue;
  333. }
  335. if ( ! in_field) {
  337. if ( ! token[0])
  338. continue;
  340. if ( ! (stmt->nfld % FLD_INCR)) {
  341. mylog("reallocing at nfld=%dn", stmt->nfld);
  342. fi = (FIELD_INFO **) realloc(fi, (stmt->nfld + FLD_INCR) * sizeof(FIELD_INFO *));
  343. if ( ! fi) {
  344. stmt->parse_status = STMT_PARSE_FATAL;
  345. return FALSE;
  346. }
  347. stmt->fi = fi;
  348. }
  350. fi[stmt->nfld] = (FIELD_INFO *) malloc( sizeof(FIELD_INFO));
  351. if (fi[stmt->nfld] == NULL) {
  352. stmt->parse_status = STMT_PARSE_FATAL;
  353. return FALSE;
  354. }
  356. /* Initialize the field info */
  357. memset(fi[stmt->nfld], 0, sizeof(FIELD_INFO));
  359. /* double quotes are for qualifiers */
  360. if (dquote)
  361. fi[stmt->nfld]->dquote = TRUE;
  363. if (quote) {
  364. fi[stmt->nfld++]->quote = TRUE;
  365. continue;
  366. }
  367. else if (numeric) {
  368. mylog("**** got numeric: nfld = %dn", stmt->nfld);
  369. fi[stmt->nfld]->numeric = TRUE;
  370. }
  371. else if (token[0] == '(') { /* expression */
  372. mylog("got EXPRESSIONn");
  373. fi[stmt->nfld++]->expr = TRUE;
  374. in_expr = TRUE;
  375. blevel = 1;
  376. continue;
  377. }
  379. else {
  380. strcpy(fi[stmt->nfld]->name, token);
  381. fi[stmt->nfld]->dot[0] = '';
  382. }
  383. mylog("got field='%s', dot='%s'n", fi[stmt->nfld]->name, fi[stmt->nfld]->dot);
  385. if (delim == ',') {
  386. mylog("comma (1)n");
  387. }
  388. else {
  389. in_field = TRUE;
  390. }
  391. stmt->nfld++;
  392. continue;
  393. }
  395. /**************************/
  396. /* We are in a field now */
  397. /**************************/
  398. if (in_dot) {
  399. stmt->nfld--;
  400. strcpy(fi[stmt->nfld]->dot, fi[stmt->nfld]->name);
  401. strcpy(fi[stmt->nfld]->name, token);
  402. stmt->nfld++;
  403. in_dot = FALSE;
  405. if (delim == ',') {
  406. mylog("in_dot: got comman");
  407. in_field = FALSE;
  408. }
  410. continue;
  411. }
  413. if (in_as) {
  414. stmt->nfld--;
  415. strcpy(fi[stmt->nfld]->alias, token);
  416. mylog("alias for field '%s' is '%s'n", fi[stmt->nfld]->name, fi[stmt->nfld]->alias);
  417. in_as = FALSE;
  418. in_field = FALSE;
  420. stmt->nfld++;
  422. if (delim == ',') {
  423. mylog("comma(2)n");
  424. }
  425. continue;
  426. }
  428. /* Function */
  429. if (token[0] == '(') {
  430. in_func = TRUE;
  431. blevel = 1;
  432. fi[stmt->nfld-1]->func = TRUE;
  433. /* name will have the function name -- maybe useful some day */
  434. mylog("**** got function = '%s'n", fi[stmt->nfld-1]->name);
  435. continue;
  436. }
  438. if (token[0] == '.') {
  439. in_dot = TRUE;
  440. mylog("got dotn");
  441. continue;
  442. }
  444. if ( ! stricmp(token, "as")) {
  445. in_as = TRUE;
  446. mylog("got ASn");
  447. continue;
  448. }
  450. /* otherwise, its probably an expression */
  451. in_expr = TRUE;
  452. fi[stmt->nfld-1]->expr = TRUE;
  453. fi[stmt->nfld-1]->name[0] = '';
  454. mylog("*** setting expressionn");
  456. }
  458. if (in_from) {
  460. if ( ! in_table) {
  461. if ( ! token[0])
  462. continue;
  464. if ( ! (stmt->ntab % TAB_INCR)) {
  465. ti = (TABLE_INFO **) realloc(ti, (stmt->ntab + TAB_INCR) * sizeof(TABLE_INFO *));
  466. if ( ! ti) {
  467. stmt->parse_status = STMT_PARSE_FATAL;
  468. return FALSE;
  469. }
  470. stmt->ti = ti;
  471. }
  472. ti[stmt->ntab] = (TABLE_INFO *) malloc(sizeof(TABLE_INFO));
  473. if (ti[stmt->ntab] == NULL) {
  474. stmt->parse_status = STMT_PARSE_FATAL;
  475. return FALSE;
  476. }
  478. ti[stmt->ntab]->alias[0] = '';
  480. strcpy(ti[stmt->ntab]->name, token);
  481. mylog("got table = '%s'n", ti[stmt->ntab]->name);
  483. if (delim == ',') {
  484. mylog("more than 1 tablesn");
  485. }
  486. else {
  487. in_table = TRUE;
  488. }
  489. stmt->ntab++;
  490. continue;
  491. }
  493. strcpy(ti[stmt->ntab-1]->alias, token);
  494. mylog("alias for table '%s' is '%s'n", ti[stmt->ntab-1]->name, ti[stmt->ntab-1]->alias);
  495. in_table = FALSE;
  496. if (delim == ',') {
  497. mylog("more than 1 tablesn");
  498. }
  499. }
  500. }
  503. /*************************************************/
  504. /* Resolve any possible field names with tables */
  505. /*************************************************/
  507. parse = TRUE;
  509. /* Resolve field names with tables */
  510. for (i = 0; i < stmt->nfld; i++) {
  512. if (fi[i]->func || fi[i]->expr || fi[i]->numeric) {
  513. fi[i]->ti = NULL;
  514. fi[i]->type = -1;
  515. parse = FALSE;
  516. continue;
  517. }
  519. else if (fi[i]->quote) { /* handle as text */
  520. fi[i]->ti = NULL;
  521. fi[i]->type = PG_TYPE_TEXT;
  522. fi[i]->precision = 0;
  523. continue;
  524. } 
  526. /* its a dot, resolve to table or alias */
  527. else if (fi[i]->dot[0]) {
  528. for (k = 0; k < stmt->ntab; k++) {
  529. if ( ! stricmp(ti[k]->name, fi[i]->dot)) {
  530. fi[i]->ti = ti[k];
  531. break;
  532. }
  533. else if ( ! stricmp(ti[k]->alias, fi[i]->dot)) {
  534. fi[i]->ti = ti[k];
  535. break;
  536. }
  537. }
  538. }
  539. else if (stmt->ntab == 1)
  540. fi[i]->ti = ti[0];
  541. }
  543. mylog("--------------------------------------------n");
  544. mylog("nfld=%d, ntab=%dn", stmt->nfld, stmt->ntab);
  546. for (i=0; i < stmt->nfld; i++) {
  547. mylog("Field %d:  expr=%d, func=%d, quote=%d, dquote=%d, numeric=%d, name='%s', alias='%s', dot='%s'n", i, fi[i]->expr, fi[i]->func, fi[i]->quote, fi[i]->dquote, fi[i]->numeric, fi[i]->name, fi[i]->alias, fi[i]->dot);
  548. if (fi[i]->ti)
  549. mylog("     ----> table_name='%s', table_alias='%s'n", fi[i]->ti->name, fi[i]->ti->alias);
  550. }
  552. for (i=0; i < stmt->ntab; i++) {
  553. mylog("Table %d: name='%s', alias='%s'n", i, ti[i]->name, ti[i]->alias);
  554. }
  557. /******************************************************/
  558. /* Now save the SQLColumns Info for the parse tables */
  559. /******************************************************/
  562. /* Call SQLColumns for each table and store the result */
  563. for (i = 0; i < stmt->ntab; i++) {
  565. /* See if already got it */
  566. char found = FALSE;
  567. for (k = 0; k < conn->ntables; k++) {
  568. if ( ! stricmp(conn->col_info[k]->name, ti[i]->name)) {
  569. mylog("FOUND col_info table='%s'n", ti[i]->name);
  570. found = TRUE;
  571. break;
  572. }
  573. }
  575. if ( ! found) {
  577. mylog("PARSE: Getting SQLColumns for table[%d]='%s'n", i, ti[i]->name);
  579. result = SQLAllocStmt( stmt->hdbc, &hcol_stmt);
  580. if((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) {
  581. stmt->errormsg = "SQLAllocStmt failed in parse_statement for columns.";
  582. stmt->errornumber = STMT_NO_MEMORY_ERROR;
  583. stmt->parse_status = STMT_PARSE_FATAL;
  584. return FALSE;
  585. }
  587. col_stmt = (StatementClass *) hcol_stmt;
  588. col_stmt->internal = TRUE;
  590. result = SQLColumns(hcol_stmt, "", 0, "", 0, 
  591. ti[i]->name, (SWORD) strlen(ti[i]->name), "", 0);
  593. mylog("        Past SQLColumnsn");
  594. if (result == SQL_SUCCESS) {
  595. mylog("      Successn");
  596. if ( ! (conn->ntables % COL_INCR)) {
  598. mylog("PARSE: Allocing col_info at ntables=%dn", conn->ntables);
  600. conn->col_info = (COL_INFO **) realloc(conn->col_info, (conn->ntables + COL_INCR) * sizeof(COL_INFO *));
  601. if ( ! conn->col_info) {
  602. stmt->parse_status = STMT_PARSE_FATAL;
  603. return FALSE;
  604. }
  605. }
  607. mylog("PARSE: malloc at conn->col_info[%d]n", conn->ntables);
  608. conn->col_info[conn->ntables] = (COL_INFO *) malloc(sizeof(COL_INFO));
  609. if ( ! conn->col_info[conn->ntables]) {
  610. stmt->parse_status = STMT_PARSE_FATAL;
  611. return FALSE;
  612. }
  614. /* Store the table name and the SQLColumns result structure */
  615. strcpy(conn->col_info[conn->ntables]->name, ti[i]->name);
  616. conn->col_info[conn->ntables]->result = col_stmt->result;
  618. /* The connection will now free the result structures, so make
  619. sure that the statement doesn't free it 
  620. */
  621. col_stmt->result = NULL;
  623. conn->ntables++;
  625. SQLFreeStmt(hcol_stmt, SQL_DROP);
  626. mylog("Created col_info table='%s', ntables=%dn", ti[i]->name, conn->ntables);
  627. }
  628. else {
  629. SQLFreeStmt(hcol_stmt, SQL_DROP);
  630. break;
  631. }
  632. }
  634. /* Associate a table from the statement with a SQLColumn info */
  635. ti[i]->col_info = conn->col_info[k];
  636. mylog("associate col_info: i=%d, k=%dn", i, k);
  637. }
  640. mylog("Done SQLColumnsn");
  642. /******************************************************/
  643. /* Now resolve the fields to point to column info    */
  644. /******************************************************/
  648. for (i = 0; i < stmt->nfld;) {
  650. /* Dont worry about functions or quotes */
  651. if (fi[i]->func || fi[i]->quote || fi[i]->numeric) {
  652. i++;
  653. continue;
  654. }
  656. /* Stars get expanded to all fields in the table */
  657. else if (fi[i]->name[0] == '*') {
  659. char do_all_tables;
  660. int total_cols, old_size, need, cols;
  662. mylog("expanding field %dn", i);
  664. total_cols = 0;
  666. if (fi[i]->ti) /* The star represents only the qualified table */
  667. total_cols = QR_get_num_tuples(fi[i]->ti->col_info->result);
  669. else { /* The star represents all tables */
  671. /* Calculate the total number of columns after expansion */
  672. for (k = 0; k < stmt->ntab; k++) {
  673. total_cols += QR_get_num_tuples(ti[k]->col_info->result);
  674. }
  675. }
  676. total_cols--; /* makes up for the star  */
  678. /* Allocate some more field pointers if necessary */
  679. //-------------------------------------------------------------
  680. old_size = (stmt->nfld / FLD_INCR * FLD_INCR + FLD_INCR);
  681. need = total_cols - (old_size - stmt->nfld);
  683. mylog("k=%d, total_cols=%d, old_size=%d, need=%dn", k,total_cols,old_size,need);
  685. if (need > 0) {
  686. int new_size = need / FLD_INCR * FLD_INCR + FLD_INCR;
  687. mylog("need more cols: new_size = %dn", new_size);
  688. fi = (FIELD_INFO **) realloc(fi, (old_size + new_size) * sizeof(FIELD_INFO *));
  689. if ( ! fi) {
  690. stmt->parse_status = STMT_PARSE_FATAL;
  691. return FALSE;
  692. }
  693. }
  695. //-------------------------------------------------------------
  696. // copy any other fields (if there are any) up past the expansion
  697. for (j = stmt->nfld - 1; j > i; j--) {
  698. mylog("copying field %d to %dn", j, total_cols + j);
  699. fi[total_cols + j] = fi[j];
  700. }
  701. mylog("done copying fieldsn");
  703. //-------------------------------------------------------------
  704. // Set the new number of fields
  705. stmt->nfld += total_cols;
  706. mylog("stmt->nfld now at %dn", stmt->nfld);
  709. //-------------------------------------------------------------
  710. // copy the new field info
  713. do_all_tables = (fi[i]->ti ? FALSE : TRUE);
  715. for (k = 0; k < (do_all_tables ? stmt->ntab : 1); k++) {
  717. TABLE_INFO *the_ti = do_all_tables ? ti[k] : fi[i]->ti;
  719. cols = QR_get_num_tuples(the_ti->col_info->result);
  721. for (n = 0; n < cols; n++) {
  722. mylog("creating field info: n=%dn", n);
  723. // skip malloc (already did it for the Star)
  724. if (k > 0 || n > 0) {
  725. mylog("allocating field info at %dn", n + i);
  726. fi[n + i] = (FIELD_INFO *) malloc( sizeof(FIELD_INFO));
  727. if (fi[n + i] == NULL) {
  728. stmt->parse_status = STMT_PARSE_FATAL;
  729. return FALSE;
  730. }
  731. }
  732. /* Initialize the new space (or the * field) */
  733. memset(fi[n + i], 0, sizeof(FIELD_INFO));
  734. fi[n + i]->ti = the_ti;
  736. mylog("about to copy at %dn", n + i);
  738. getColInfo(the_ti->col_info, fi[n + i], n);
  740. mylog("done copyingn");
  741. }
  743. i += cols;
  744. mylog("i now at %dn", i);
  745. }
  747. //-------------------------------------------------------------
  748. }
  750. /* We either know which table the field was in because it was qualified 
  751. with a table name or alias -OR- there was only 1 table.
  752. */
  753. else if (fi[i]->ti) {
  755. if ( ! searchColInfo(fi[i]->ti->col_info, fi[i]))
  756. parse = FALSE;
  758. i++;
  759. }
  761. /* Don't know the table -- search all tables in "from" list */
  762. else {
  763. parse = FALSE;
  764. for (k = 0; k < stmt->ntab; k++) {
  765. if ( searchColInfo(ti[k]->col_info, fi[i])) {
  766. fi[i]->ti = ti[k]; /* now know the table */
  767. parse = TRUE;
  768. break;
  769. }
  770. }
  771. i++;
  772. }
  773. }
  776. if ( ! parse)
  777. stmt->parse_status = STMT_PARSE_INCOMPLETE;
  778. else
  779. stmt->parse_status = STMT_PARSE_COMPLETE;
  782. mylog("done parse_statement: parse=%d, parse_status=%dn", parse, stmt->parse_status);
  783. return parse;
  784. }