lemon-project-template-glpk: 4fc6ad2fb8a6 deps/glpk/src/glpsql.c

lemon-project-template-glpk

view deps/glpk/src/glpsql.c @ 11:4fc6ad2fb8a6

Test GLPK in src/main.cc

author	Alpar Juttner <alpar@cs.elte.hu>
date	Sun, 06 Nov 2011 21:43:29 +0100
parents
children

line source

1 /* glpsql.c */

3 /***********************************************************************

4 * This code is part of GLPK (GNU Linear Programming Kit).

5 *

6 * Author: Heinrich Schuchardt <xypron.glpk@gmx.de>.

7 *

9 * 2009, 2010 Andrew Makhorin, Department for Applied Informatics,

11 * E-mail: <mao@gnu.org>.

12 *

13 * GLPK is free software: you can redistribute it and/or modify it

14 * under the terms of the GNU General Public License as published by

15 * the Free Software Foundation, either version 3 of the License, or

16 * (at your option) any later version.

17 *

18 * GLPK is distributed in the hope that it will be useful, but WITHOUT

19 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

20 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public

21 * License for more details.

22 *

23 * You should have received a copy of the GNU General Public License

24 * along with GLPK. If not, see <http://www.gnu.org/licenses/>.

25 ***********************************************************************/

27 #ifdef HAVE_CONFIG_H

28 #include <config.h>

29 #endif

31 #include "glpmpl.h"

32 #include "glpsql.h"

34 #ifdef ODBC_DLNAME

35 #define HAVE_ODBC

36 #define libodbc ODBC_DLNAME

37 #define h_odbc (get_env_ptr()->h_odbc)

38 #endif

40 #ifdef MYSQL_DLNAME

41 #define HAVE_MYSQL

42 #define libmysql MYSQL_DLNAME

43 #define h_mysql (get_env_ptr()->h_mysql)

44 #endif

46 static void *db_iodbc_open_int(TABDCA *dca, int mode, const char

47 **sqllines);

48 static void *db_mysql_open_int(TABDCA *dca, int mode, const char

49 **sqllines);

51 /**********************************************************************/

53 #if defined(HAVE_ODBC) || defined(HAVE_MYSQL)

55 #define SQL_FIELD_MAX 100

56 /* maximal field count */

58 #define SQL_FDLEN_MAX 255

59 /* maximal field length */

61 /***********************************************************************

62 * NAME

63 *

64 * args_concat - concatenate arguments

65 *

66 * SYNOPSIS

67 *

68 * static char **args_concat(TABDCA *dca);

69 *

70 * DESCRIPTION

71 *

72 * The arguments passed in dca are SQL statements. A SQL statement may

73 * be split over multiple arguments. The last argument of a SQL

74 * statement will be terminated with a semilocon. Each SQL statement is

75 * merged into a single zero terminated string. Boundaries between

76 * arguments are replaced by space.

77 *

78 * RETURNS

79 *

80 * Buffer with SQL statements */

82 static char **args_concat(TABDCA *dca)

83 {

84 const char *arg;

85 int i;

86 int j;

87 int j0;

88 int j1;

89 int len;

90 int lentot;

91 int narg;

92 int nline = 0;

93 void *ret;

94 char **sqllines = NULL;

96 narg = mpl_tab_num_args(dca);

97 /* The SQL statements start with argument 3. */

98 if (narg < 3)

99 return NULL;

100 /* Count the SQL statements */

101 for (j = 3; j <= narg; j++)

102 {

103 arg = mpl_tab_get_arg(dca, j);

104 len = strlen(arg);

105 if (arg[len-1] == ';' || j == narg)

106 nline ++;

107 }

108 /* Allocate string buffer. */

109 sqllines = (char **) xmalloc((nline+1) * sizeof(char **));

110 /* Join arguments */

111 sqllines[0] = NULL;

112 j0 = 3;

113 i = 0;

114 lentot = 0;

115 for (j = 3; j <= narg; j++)

116 {

117 arg = mpl_tab_get_arg(dca, j);

118 len = strlen(arg);

119 /* add length of part */

120 lentot += len;

121 /* add length of space separating parts or 0x00 at end of SQL

122 statement */

123 lentot++;

124 if (arg[len-1] == ';' || j == narg)

125 { /* Join arguments for a single SQL statement */

126 sqllines[i] = xmalloc(lentot);

127 sqllines[i+1] = NULL;

128 sqllines[i][0] = 0x00;

129 for (j1 = j0; j1 <= j; j1++)

130 { if(j1>j0)

131 strcat(sqllines[i], " ");

132 strcat(sqllines[i], mpl_tab_get_arg(dca, j1));

133 }

134 len = strlen(sqllines[i]);

135 if (sqllines[i][len-1] == ';')

136 sqllines[i][len-1] = 0x00;

137 j0 = j+1;

138 i++;

139 lentot = 0;

140 }

141 }

142 return sqllines;

143 }

144

145 /***********************************************************************

146 * NAME

147 *

148 * free_buffer - free multiline string buffer

149 *

150 * SYNOPSIS

151 *

152 * static void free_buffer(char **buf);

153 *

154 * DESCRIPTION

155 *

156 * buf is a list of strings terminated by NULL.

157 * The memory for the strings and for the list is released. */

158

159 static void free_buffer(char **buf)

160 { int i;

161

162 for(i = 0; buf[i] != NULL; i++)

163 xfree(buf[i]);

164 xfree(buf);

165 }

166

167 static int db_escaped_string_length(const char* from)

168 /* length of escaped string */

169 {

170 int count;

171 const char *pointer;

172

173 for (pointer = from, count = 0; *pointer != (char) '\0'; pointer++,

174 count++)

175 {

176 switch (*pointer)

177 {

178 case '\'':

179 count++;

180 break;

181 }

182 }

183

184 return count;

185 }

186

187 static int db_escape_string (char *to, const char *from)

188 /* escape string*/

189 {

190 const char *source = from;

191 char *target = to;

192 unsigned int remaining;

193

194 remaining = strlen(from);

195

196 if (to == NULL)

197 to = (char *) (from + remaining);

198

199 while (remaining > 0)

200 {

201 switch (*source)

202 {

203 case '\'':

204 *target = '\'';

205 target++;

206 *target = '\'';

207 break;

208

209 default:

210 *target = *source;

211 }

212 source++;

213 target++;

214 remaining--;

215 }

216

217 /* Write the terminating NUL character. */

218 *target = '\0';

219

220 return target - to;

221 }

222

223 static char *db_generate_select_stmt(TABDCA *dca)

224 /* generate select statement */

225 {

226 char *arg;

227 char const *field;

228 char *query;

229 int j;

230 int narg;

231 int nf;

232 int total;

233

234 total = 50;

235 nf = mpl_tab_num_flds(dca);

236 narg = mpl_tab_num_args(dca);

237 for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)

238 {

239 field = mpl_tab_get_name(dca, j);

240 total += strlen(field);

241 total += 2;

242 }

243 arg = (char *) mpl_tab_get_arg(dca, narg);

244 total += strlen(arg);

245 query = xmalloc( total * sizeof(char));

246 strcpy (query, "SELECT ");

247 for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)

248 {

249 field = mpl_tab_get_name(dca, j);

250 strcat(query, field);

251 if ( j < nf )

252 strcat(query, ", ");

253 }

254 strcat(query, " FROM ");

255 strcat(query, arg);

256 return query;

257 }

258

259 static char *db_generate_insert_stmt(TABDCA *dca)

260 /* generate insert statement */

261 {

262 char *arg;

263 char const *field;

264 char *query;

265 int j;

266 int narg;

267 int nf;

268 int total;

269

270 total = 50;

271 nf = mpl_tab_num_flds(dca);

272 narg = mpl_tab_num_args(dca);

273 for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)

274 {

275 field = mpl_tab_get_name(dca, j);

276 total += strlen(field);

277 total += 5;

278 }

279 arg = (char *) mpl_tab_get_arg(dca, narg);

280 total += strlen(arg);

281 query = xmalloc( (total+1) * sizeof(char));

282 strcpy (query, "INSERT INTO ");

283 strcat(query, arg);

284 strcat(query, " ( ");

285 for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)

286 {

287 field = mpl_tab_get_name(dca, j);

288 strcat(query, field);

289 if ( j < nf )

290 strcat(query, ", ");

291 }

292 strcat(query, " ) VALUES ( ");

293 for (j=1; j <= nf && j <= SQL_FIELD_MAX; j++)

294 {

295 strcat(query, "?");

296 if ( j < nf )

297 strcat(query, ", ");

298 }

299 strcat(query, " )");

300 return query;

301 }

302

303 #endif

304

305 /**********************************************************************/

306

307 #ifndef HAVE_ODBC

308

309 void *db_iodbc_open(TABDCA *dca, int mode)

310 { xassert(dca == dca);

311 xassert(mode == mode);

312 xprintf("iODBC table driver not supported\n");

313 return NULL;

314 }

315

316 int db_iodbc_read(TABDCA *dca, void *link)

317 { xassert(dca != dca);

318 xassert(link != link);

319 return 0;

320 }

321

322 int db_iodbc_write(TABDCA *dca, void *link)

323 { xassert(dca != dca);

324 xassert(link != link);

325 return 0;

326 }

327

328 int db_iodbc_close(TABDCA *dca, void *link)

329 { xassert(dca != dca);

330 xassert(link != link);

331 return 0;

332 }

333

334 #else

335

336 #if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__WOE__)

337 #include <windows.h>

338 #endif

339

340 #include <sql.h>

341 #include <sqlext.h>

342

343 struct db_odbc

344 {

345 int mode; /*'R' = Read, 'W' = Write*/

346 SQLHDBC hdbc; /*connection handle*/

347 SQLHENV henv; /*environment handle*/

348 SQLHSTMT hstmt; /*statement handle*/

349 SQLSMALLINT nresultcols; /* columns in result*/

350 SQLULEN collen[SQL_FIELD_MAX+1];

351 SQLLEN outlen[SQL_FIELD_MAX+1];

352 SQLSMALLINT coltype[SQL_FIELD_MAX+1];

353 SQLCHAR data[SQL_FIELD_MAX+1][SQL_FDLEN_MAX+1];

354 SQLCHAR colname[SQL_FIELD_MAX+1][SQL_FDLEN_MAX+1];

355 int isnumeric[SQL_FIELD_MAX+1];

356 int nf;

357 /* number of fields in the csv file */

358 int ref[1+SQL_FIELD_MAX];

359 /* ref[k] = k', if k-th field of the csv file corresponds to

360 k'-th field in the table statement; if ref[k] = 0, k-th field

361 of the csv file is ignored */

362 SQLCHAR *query;

363 /* query generated by db_iodbc_open */

364 };

365

366 SQLRETURN SQL_API dl_SQLAllocHandle (

367 SQLSMALLINT HandleType,

368 SQLHANDLE InputHandle,

369 SQLHANDLE *OutputHandle)

370 {

371 typedef SQLRETURN SQL_API ep_SQLAllocHandle(

372 SQLSMALLINT HandleType,

373 SQLHANDLE InputHandle,

374 SQLHANDLE *OutputHandle);

375

376 ep_SQLAllocHandle *fn;

377 fn = (ep_SQLAllocHandle *) xdlsym(h_odbc, "SQLAllocHandle");

378 xassert(fn != NULL);

379 return (*fn)(HandleType, InputHandle, OutputHandle);

380 }

381

382 SQLRETURN SQL_API dl_SQLBindCol (

383 SQLHSTMT StatementHandle,

384 SQLUSMALLINT ColumnNumber,

385 SQLSMALLINT TargetType,

386 SQLPOINTER TargetValue,

387 SQLLEN BufferLength,

388 SQLLEN *StrLen_or_Ind)

389 {

390 typedef SQLRETURN SQL_API ep_SQLBindCol(

391 SQLHSTMT StatementHandle,

392 SQLUSMALLINT ColumnNumber,

393 SQLSMALLINT TargetType,

394 SQLPOINTER TargetValue,

395 SQLLEN BufferLength,

396 SQLLEN *StrLen_or_Ind);

397 ep_SQLBindCol *fn;

398 fn = (ep_SQLBindCol *) xdlsym(h_odbc, "SQLBindCol");

399 xassert(fn != NULL);

400 return (*fn)(StatementHandle, ColumnNumber, TargetType,

401 TargetValue, BufferLength, StrLen_or_Ind);

402 }

403

404 SQLRETURN SQL_API dl_SQLCloseCursor (

405 SQLHSTMT StatementHandle)

406 {

407 typedef SQLRETURN SQL_API ep_SQLCloseCursor (

408 SQLHSTMT StatementHandle);

409

410 ep_SQLCloseCursor *fn;

411 fn = (ep_SQLCloseCursor *) xdlsym(h_odbc, "SQLCloseCursor");

412 xassert(fn != NULL);

413 return (*fn)(StatementHandle);

414 }

415

416

417 SQLRETURN SQL_API dl_SQLDisconnect (

418 SQLHDBC ConnectionHandle)

419 {

420 typedef SQLRETURN SQL_API ep_SQLDisconnect(

421 SQLHDBC ConnectionHandle);

422

423 ep_SQLDisconnect *fn;

424 fn = (ep_SQLDisconnect *) xdlsym(h_odbc, "SQLDisconnect");

425 xassert(fn != NULL);

426 return (*fn)(ConnectionHandle);

427 }

428

429 SQLRETURN SQL_API dl_SQLDriverConnect (

430 SQLHDBC hdbc,

431 SQLHWND hwnd,

432 SQLCHAR *szConnStrIn,

433 SQLSMALLINT cbConnStrIn,

434 SQLCHAR *szConnStrOut,

435 SQLSMALLINT cbConnStrOutMax,

436 SQLSMALLINT *pcbConnStrOut,

437 SQLUSMALLINT fDriverCompletion)

438 {

439 typedef SQLRETURN SQL_API ep_SQLDriverConnect(

440 SQLHDBC hdbc,

441 SQLHWND hwnd,

442 SQLCHAR * szConnStrIn,

443 SQLSMALLINT cbConnStrIn,

444 SQLCHAR * szConnStrOut,

445 SQLSMALLINT cbConnStrOutMax,

446 SQLSMALLINT * pcbConnStrOut,

447 SQLUSMALLINT fDriverCompletion);

448

449 ep_SQLDriverConnect *fn;

450 fn = (ep_SQLDriverConnect *) xdlsym(h_odbc, "SQLDriverConnect");

451 xassert(fn != NULL);

452 return (*fn)(hdbc, hwnd, szConnStrIn, cbConnStrIn, szConnStrOut,

453 cbConnStrOutMax, pcbConnStrOut, fDriverCompletion);

454 }

455

456 SQLRETURN SQL_API dl_SQLEndTran (

457 SQLSMALLINT HandleType,

458 SQLHANDLE Handle,

459 SQLSMALLINT CompletionType)

460 {

461 typedef SQLRETURN SQL_API ep_SQLEndTran (

462 SQLSMALLINT HandleType,

463 SQLHANDLE Handle,

464 SQLSMALLINT CompletionType);

465

466 ep_SQLEndTran *fn;

467 fn = (ep_SQLEndTran *) xdlsym(h_odbc, "SQLEndTran");

468 xassert(fn != NULL);

469 return (*fn)(HandleType, Handle, CompletionType);

470 }

471

472 SQLRETURN SQL_API dl_SQLExecDirect (

473 SQLHSTMT StatementHandle,

474 SQLCHAR * StatementText,

475 SQLINTEGER TextLength)

476 {

477 typedef SQLRETURN SQL_API ep_SQLExecDirect (

478 SQLHSTMT StatementHandle,

479 SQLCHAR * StatementText,

480 SQLINTEGER TextLength);

481

482 ep_SQLExecDirect *fn;

483 fn = (ep_SQLExecDirect *) xdlsym(h_odbc, "SQLExecDirect");

484 xassert(fn != NULL);

485 return (*fn)(StatementHandle, StatementText, TextLength);

486 }

487

488 SQLRETURN SQL_API dl_SQLFetch (

489 SQLHSTMT StatementHandle)

490 {

491 typedef SQLRETURN SQL_API ep_SQLFetch (

492 SQLHSTMT StatementHandle);

493

494 ep_SQLFetch *fn;

495 fn = (ep_SQLFetch*) xdlsym(h_odbc, "SQLFetch");

496 xassert(fn != NULL);

497 return (*fn)(StatementHandle);

498 }

499

500 SQLRETURN SQL_API dl_SQLFreeHandle (

501 SQLSMALLINT HandleType,

502 SQLHANDLE Handle)

503 {

504 typedef SQLRETURN SQL_API ep_SQLFreeHandle (

505 SQLSMALLINT HandleType,

506 SQLHANDLE Handle);

507

508 ep_SQLFreeHandle *fn;

509 fn = (ep_SQLFreeHandle *) xdlsym(h_odbc, "SQLFreeHandle");

510 xassert(fn != NULL);

511 return (*fn)(HandleType, Handle);

512 }

513

514 SQLRETURN SQL_API dl_SQLDescribeCol (

515 SQLHSTMT StatementHandle,

516 SQLUSMALLINT ColumnNumber,

517 SQLCHAR * ColumnName,

518 SQLSMALLINT BufferLength,

519 SQLSMALLINT * NameLength,

520 SQLSMALLINT * DataType,

521 SQLULEN * ColumnSize,

522 SQLSMALLINT * DecimalDigits,

523 SQLSMALLINT * Nullable)

524 {

525 typedef SQLRETURN SQL_API ep_SQLDescribeCol (

526 SQLHSTMT StatementHandle,

527 SQLUSMALLINT ColumnNumber,

528 SQLCHAR *ColumnName,

529 SQLSMALLINT BufferLength,

530 SQLSMALLINT *NameLength,

531 SQLSMALLINT *DataType,

532 SQLULEN *ColumnSize,

533 SQLSMALLINT *DecimalDigits,

534 SQLSMALLINT *Nullable);

535

536 ep_SQLDescribeCol *fn;

537 fn = (ep_SQLDescribeCol *) xdlsym(h_odbc, "SQLDescribeCol");

538 xassert(fn != NULL);

539 return (*fn)(StatementHandle, ColumnNumber, ColumnName,

540 BufferLength, NameLength,

541 DataType, ColumnSize, DecimalDigits, Nullable);

542 }

543

544 SQLRETURN SQL_API dl_SQLGetDiagRec (

545 SQLSMALLINT HandleType,

546 SQLHANDLE Handle,

547 SQLSMALLINT RecNumber,

548 SQLCHAR *Sqlstate,

549 SQLINTEGER *NativeError,

550 SQLCHAR *MessageText,

551 SQLSMALLINT BufferLength,

552 SQLSMALLINT *TextLength)

553 {

554 typedef SQLRETURN SQL_API ep_SQLGetDiagRec (

555 SQLSMALLINT HandleType,

556 SQLHANDLE Handle,

557 SQLSMALLINT RecNumber,

558 SQLCHAR *Sqlstate,

559 SQLINTEGER *NativeError,

560 SQLCHAR *MessageText,

561 SQLSMALLINT BufferLength,

562 SQLSMALLINT *TextLength);

563

564 ep_SQLGetDiagRec *fn;

565 fn = (ep_SQLGetDiagRec *) xdlsym(h_odbc, "SQLGetDiagRec");

566 xassert(fn != NULL);

567 return (*fn)(HandleType, Handle, RecNumber, Sqlstate,

568 NativeError, MessageText, BufferLength, TextLength);

569 }

570

571 SQLRETURN SQL_API dl_SQLGetInfo (

572 SQLHDBC ConnectionHandle,

573 SQLUSMALLINT InfoType,

574 SQLPOINTER InfoValue,

575 SQLSMALLINT BufferLength,

576 SQLSMALLINT *StringLength)

577 {

578 typedef SQLRETURN SQL_API ep_SQLGetInfo (

579 SQLHDBC ConnectionHandle,

580 SQLUSMALLINT InfoType,

581 SQLPOINTER InfoValue,

582 SQLSMALLINT BufferLength,

583 SQLSMALLINT *StringLength);

584

585 ep_SQLGetInfo *fn;

586 fn = (ep_SQLGetInfo *) xdlsym(h_odbc, "SQLGetInfo");

587 xassert(fn != NULL);

588 return (*fn)(ConnectionHandle, InfoType, InfoValue, BufferLength,

589 StringLength);

590 }

591

592 SQLRETURN SQL_API dl_SQLNumResultCols (

593 SQLHSTMT StatementHandle,

594 SQLSMALLINT *ColumnCount)

595 {

596 typedef SQLRETURN SQL_API ep_SQLNumResultCols (

597 SQLHSTMT StatementHandle,

598 SQLSMALLINT *ColumnCount);

599

600 ep_SQLNumResultCols *fn;

601 fn = (ep_SQLNumResultCols *) xdlsym(h_odbc, "SQLNumResultCols");

602 xassert(fn != NULL);

603 return (*fn)(StatementHandle, ColumnCount);

604 }

605

606 SQLRETURN SQL_API dl_SQLSetConnectAttr (

607 SQLHDBC ConnectionHandle,

608 SQLINTEGER Attribute,

609 SQLPOINTER Value,

610 SQLINTEGER StringLength)

611 {

612 typedef SQLRETURN SQL_API ep_SQLSetConnectAttr (

613 SQLHDBC ConnectionHandle,

614 SQLINTEGER Attribute,

615 SQLPOINTER Value,

616 SQLINTEGER StringLength);

617

618 ep_SQLSetConnectAttr *fn;

619 fn = (ep_SQLSetConnectAttr *) xdlsym(h_odbc, "SQLSetConnectAttr");

620 xassert(fn != NULL);

621 return (*fn)(ConnectionHandle, Attribute, Value, StringLength);

622 }

623

624 SQLRETURN SQL_API dl_SQLSetEnvAttr (

625 SQLHENV EnvironmentHandle,

626 SQLINTEGER Attribute,

627 SQLPOINTER Value,

628 SQLINTEGER StringLength)

629 {

630 typedef SQLRETURN SQL_API ep_SQLSetEnvAttr (

631 SQLHENV EnvironmentHandle,

632 SQLINTEGER Attribute,

633 SQLPOINTER Value,

634 SQLINTEGER StringLength);

635

636 ep_SQLSetEnvAttr *fn;

637 fn = (ep_SQLSetEnvAttr *) xdlsym(h_odbc, "SQLSetEnvAttr");

638 xassert(fn != NULL);

639 return (*fn)(EnvironmentHandle, Attribute, Value, StringLength);

640 }

641

642 static void extract_error(

643 char *fn,

644 SQLHANDLE handle,

645 SQLSMALLINT type);

646

647 static int is_numeric(

648 SQLSMALLINT coltype);

649

650 /***********************************************************************

651 * NAME

652 *

653 * db_iodbc_open - open connection to ODBC data base

654 *

655 * SYNOPSIS

656 *

657 * #include "glpsql.h"

658 * void *db_iodbc_open(TABDCA *dca, int mode);

659 *

660 * DESCRIPTION

661 *

662 * The routine db_iodbc_open opens a connection to an ODBC data base.

663 * It then executes the sql statements passed.

664 *

665 * In the case of table read the SELECT statement is executed.

666 *

667 * In the case of table write the INSERT statement is prepared.

668 * RETURNS

669 *

670 * The routine returns a pointer to data storage area created. */

671 void *db_iodbc_open(TABDCA *dca, int mode)

672 { void *ret;

673 char **sqllines;

674

675 sqllines = args_concat(dca);

676 if (sqllines == NULL)

677 { xprintf("Missing arguments in table statement.\n"

678 "Please, supply table driver, dsn, and query.\n");

679 return NULL;

680 }

681 ret = db_iodbc_open_int(dca, mode, (const char **) sqllines);

682 free_buffer(sqllines);

683 return ret;

684 }

685

686 static void *db_iodbc_open_int(TABDCA *dca, int mode, const char

687 **sqllines)

688 {

689 struct db_odbc *sql;

690 SQLRETURN ret;

691 SQLCHAR FAR *dsn;

692 SQLCHAR info[256];

693 SQLSMALLINT colnamelen;

694 SQLSMALLINT nullable;

695 SQLSMALLINT scale;

696 const char *arg;

697 int narg;

698 int i, j;

699 int total;

700

701 if (libodbc == NULL)

702 {

703 xprintf("No loader for shared ODBC library available\n");

704 return NULL;

705 }

706

707 if (h_odbc == NULL)

708 {

709 h_odbc = xdlopen(libodbc);

710 if (h_odbc == NULL)

711 { xprintf("unable to open library %s\n", libodbc);

712 xprintf("%s\n", xerrmsg());

713 return NULL;

714 }

715 }

716

717 sql = (struct db_odbc *) xmalloc(sizeof(struct db_odbc));

718 if (sql == NULL)

719 return NULL;

720

721 sql->mode = mode;

722 sql->hdbc = NULL;

723 sql->henv = NULL;

724 sql->hstmt = NULL;

725 sql->query = NULL;

726 narg = mpl_tab_num_args(dca);

727

728 dsn = (SQLCHAR FAR *) mpl_tab_get_arg(dca, 2);

729 /* allocate an environment handle */

730 ret = dl_SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE,

731 &(sql->henv));

732 /* set attribute to enable application to run as ODBC 3.0

733 application */

734 ret = dl_SQLSetEnvAttr(sql->henv, SQL_ATTR_ODBC_VERSION,

735 (void *) SQL_OV_ODBC3, 0);

736 /* allocate a connection handle */

737 ret = dl_SQLAllocHandle(SQL_HANDLE_DBC, sql->henv, &(sql->hdbc));

738 /* connect */

739 ret = dl_SQLDriverConnect(sql->hdbc, NULL, dsn, SQL_NTS, NULL, 0,

740 NULL, SQL_DRIVER_COMPLETE);

741 if (SQL_SUCCEEDED(ret))

742 { /* output information about data base connection */

743 xprintf("Connected to ");

744 dl_SQLGetInfo(sql->hdbc, SQL_DBMS_NAME, (SQLPOINTER)info,

745 sizeof(info), NULL);

746 xprintf("%s ", info);

747 dl_SQLGetInfo(sql->hdbc, SQL_DBMS_VER, (SQLPOINTER)info,

748 sizeof(info), NULL);

749 xprintf("%s - ", info);

750 dl_SQLGetInfo(sql->hdbc, SQL_DATABASE_NAME, (SQLPOINTER)info,

751 sizeof(info), NULL);

752 xprintf("%s\n", info);

753 }

754 else

755 { /* describe error */

756 xprintf("Failed to connect\n");

757 extract_error("SQLDriverConnect", sql->hdbc, SQL_HANDLE_DBC);

758 dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);

759 dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);

760 xfree(sql);

761 return NULL;

762 }

763 /* set AUTOCOMMIT on*/

764 ret = dl_SQLSetConnectAttr(sql->hdbc, SQL_ATTR_AUTOCOMMIT,

765 (SQLPOINTER)SQL_AUTOCOMMIT_ON, 0);

766 /* allocate a statement handle */

767 ret = dl_SQLAllocHandle(SQL_HANDLE_STMT, sql->hdbc, &(sql->hstmt));

768

769 /* initialization queries */

770 for(j = 0; sqllines[j+1] != NULL; j++)

771 {

772 sql->query = (SQLCHAR *) sqllines[j];

773 xprintf("%s\n", sql->query);

774 ret = dl_SQLExecDirect(sql->hstmt, sql->query, SQL_NTS);

775 switch (ret)

776 {

777 case SQL_SUCCESS:

778 case SQL_SUCCESS_WITH_INFO:

779 case SQL_NO_DATA_FOUND:

780 break;

781 default:

782 xprintf("db_iodbc_open: Query\n\"%s\"\nfailed.\n",

783 sql->query);

784 extract_error("SQLExecDirect", sql->hstmt, SQL_HANDLE_STMT);

785 dl_SQLFreeHandle(SQL_HANDLE_STMT, sql->hstmt);

786 dl_SQLDisconnect(sql->hdbc);

787 dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);

788 dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);

789 xfree(sql);

790 return NULL;

791 }

792 /* commit statement */

793 dl_SQLEndTran(SQL_HANDLE_ENV, sql->henv, SQL_COMMIT);

794 }

795

796 if ( sql->mode == 'R' )

797 { sql->nf = mpl_tab_num_flds(dca);

798 for(j = 0; sqllines[j] != NULL; j++)

799 arg = sqllines[j];

800 total = strlen(arg);

801 if (total > 7 && 0 == strncmp(arg, "SELECT ", 7))

802 {

803 total = strlen(arg);

804 sql->query = xmalloc( (total+1) * sizeof(char));

805 strcpy (sql->query, arg);

806 }

807 else

808 {

809 sql->query = db_generate_select_stmt(dca);

810 }

811 xprintf("%s\n", sql->query);

812 if (dl_SQLExecDirect(sql->hstmt, sql->query, SQL_NTS) !=

813 SQL_SUCCESS)

814 {

815 xprintf("db_iodbc_open: Query\n\"%s\"\nfailed.\n", sql->query);

816 extract_error("SQLExecDirect", sql->hstmt, SQL_HANDLE_STMT);

817 dl_SQLFreeHandle(SQL_HANDLE_STMT, sql->hstmt);

818 dl_SQLDisconnect(sql->hdbc);

819 dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);

820 dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);

821 xfree(sql->query);

822 xfree(sql);

823 return NULL;

824 }

825 xfree(sql->query);

826 /* determine number of result columns */

827 ret = dl_SQLNumResultCols(sql->hstmt, &sql->nresultcols);

828 total = sql->nresultcols;

829 if (total > SQL_FIELD_MAX)

830 { xprintf("db_iodbc_open: Too many fields (> %d) in query.\n"

831 "\"%s\"\n", SQL_FIELD_MAX, sql->query);

832 dl_SQLFreeHandle(SQL_HANDLE_STMT, sql->hstmt);

833 dl_SQLDisconnect(sql->hdbc);

834 dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);

835 dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);

836 xfree(sql->query);

837 return NULL;

838 }

839 for (i = 1; i <= total; i++)

840 { /* return a set of attributes for a column */

841 ret = dl_SQLDescribeCol(sql->hstmt, (SQLSMALLINT) i,

842 sql->colname[i], SQL_FDLEN_MAX,

843 &colnamelen, &(sql->coltype[i]), &(sql->collen[i]), &scale,

844 &nullable);

845 sql->isnumeric[i] = is_numeric(sql->coltype[i]);

846 /* bind columns to program vars, converting all types to CHAR*/

847 if (sql->isnumeric[i])

848 { dl_SQLBindCol(sql->hstmt, i, SQL_DOUBLE, sql->data[i],

849 SQL_FDLEN_MAX, &(sql->outlen[i]));

850 } else

851 { dl_SQLBindCol(sql->hstmt, i, SQL_CHAR, sql->data[i],

852 SQL_FDLEN_MAX, &(sql->outlen[i]));

853 }

854 for (j = sql->nf; j >= 1; j--)

855 { if (strcmp(mpl_tab_get_name(dca, j), sql->colname[i]) == 0)

856 break;

857 }

858 sql->ref[i] = j;

859 }

860 }

861 else if ( sql->mode == 'W' )

862 { for(j = 0; sqllines[j] != NULL; j++)

863 arg = sqllines[j];

864 if ( NULL != strchr(arg, '?') )

865 {

866 total = strlen(arg);

867 sql->query = xmalloc( (total+1) * sizeof(char));

868 strcpy (sql->query, arg);

869 }

870 else

871 {

872 sql->query = db_generate_insert_stmt(dca);

873 }

874 xprintf("%s\n", sql->query);

875 }

876 return sql;

877 }

878

879 int db_iodbc_read(TABDCA *dca, void *link)

880 {

881 struct db_odbc *sql;

882 SQLRETURN ret;

883 char buf[SQL_FDLEN_MAX+1];

884 int i;

885 int len;

886 double num;

887

888 sql = (struct db_odbc *) link;

889

890 xassert(sql != NULL);

891 xassert(sql->mode == 'R');

892

893 ret=dl_SQLFetch(sql->hstmt);

894 if (ret== SQL_ERROR)

895 return -1;

896 if (ret== SQL_NO_DATA_FOUND)

897 return -1; /*EOF*/

898 for (i=1; i <= sql->nresultcols; i++)

899 {

900 if (sql->ref[i] > 0)

901 {

902 len = sql->outlen[i];

903 if (len != SQL_NULL_DATA)

904 {

905 if (sql->isnumeric[i])

906 { mpl_tab_set_num(dca, sql->ref[i],

907 *((const double *) sql->data[i]));

908 }

909 else

910 { if (len > SQL_FDLEN_MAX)

911 len = SQL_FDLEN_MAX;

912 else if (len < 0)

913 len = 0;

914 strncpy(buf, (const char *) sql->data[i], len);

915 buf[len] = 0x00;

916 mpl_tab_set_str(dca, sql->ref[i], strtrim(buf));

917 }

918 }

919 }

920 }

921 return 0;

922 }

923

924 int db_iodbc_write(TABDCA *dca, void *link)

925 {

926 struct db_odbc *sql;

927 char *part;

928 char *query;

929 char *template;

930 char num[50];

931 int k;

932 int len;

933 int nf;

934

935 sql = (struct db_odbc *) link;

936 xassert(sql != NULL);

937 xassert(sql->mode == 'W');

938

939 len = strlen(sql->query);

940 template = (char *) xmalloc( (len + 1) * sizeof(char) );

941 strcpy(template, sql->query);

942

943 nf = mpl_tab_num_flds(dca);

944 for (k = 1; k <= nf; k++)

945 { switch (mpl_tab_get_type(dca, k))

946 { case 'N':

947 len += 20;

948 break;

949 case 'S':

950 len += db_escaped_string_length(mpl_tab_get_str(dca, k));

951 len += 2;

952 break;

953 default:

954 xassert(dca != dca);

955 }

956 }

957 query = xmalloc( (len + 1 ) * sizeof(char) );

958 query[0] = 0x00;

959 for (k = 1, part = strtok (template, "?"); (part != NULL);

960 part = strtok (NULL, "?"), k++)

961 {

962 if (k > nf) break;

963 strcat( query, part );

964 switch (mpl_tab_get_type(dca, k))

965 { case 'N':

966 #if 0 /* 02/XI-2010 by xypron */

967 sprintf(num, "%-18g",mpl_tab_get_num(dca, k));

968 #else

969 sprintf(num, "%.*g", DBL_DIG, mpl_tab_get_num(dca, k));

970 #endif

971 strcat( query, num );

972 break;

973 case 'S':

974 strcat( query, "'");

975 db_escape_string( query + strlen(query),

976 mpl_tab_get_str(dca, k) );

977 strcat( query, "'");

978 break;

979 default:

980 xassert(dca != dca);

981 }

982 }

983 if (part != NULL)

984 strcat(query, part);

985 if (dl_SQLExecDirect(sql->hstmt, (SQLCHAR *) query, SQL_NTS)

986 != SQL_SUCCESS)

987 {

988 xprintf("db_iodbc_write: Query\n\"%s\"\nfailed.\n", query);

989 extract_error("SQLExecDirect", sql->hdbc, SQL_HANDLE_DBC);

990 xfree(query);

991 xfree(template);

992 return 1;

993 }

994

995 xfree(query);

996 xfree(template);

997 return 0;

998 }

999

1000 int db_iodbc_close(TABDCA *dca, void *link)

1001 {

1002 struct db_odbc *sql;

1003

1004 sql = (struct db_odbc *) link;

1005 xassert(sql != NULL);

1006 /* Commit */

1007 if ( sql->mode == 'W' )

1008 dl_SQLEndTran(SQL_HANDLE_ENV, sql->henv, SQL_COMMIT);

1009 if ( sql->mode == 'R' )

1010 dl_SQLCloseCursor(sql->hstmt);

1011

1012 dl_SQLFreeHandle(SQL_HANDLE_STMT, sql->hstmt);

1013 dl_SQLDisconnect(sql->hdbc);

1014 dl_SQLFreeHandle(SQL_HANDLE_DBC, sql->hdbc);

1015 dl_SQLFreeHandle(SQL_HANDLE_ENV, sql->henv);

1016 if ( sql->mode == 'W' )

1017 xfree(sql->query);

1018 xfree(sql);

1019 dca->link = NULL;

1020 return 0;

1021 }

1022

1023 static void extract_error(

1024 char *fn,

1025 SQLHANDLE handle,

1026 SQLSMALLINT type)

1027 {

1028 SQLINTEGER i = 0;

1029 SQLINTEGER native;

1030 SQLCHAR state[ 7 ];

1031 SQLCHAR text[256];

1032 SQLSMALLINT len;

1033 SQLRETURN ret;

1034

1035 xprintf("\nThe driver reported the following diagnostics whilst "

1036 "running %s\n", fn);

1037

1038 do

1039 {

1040 ret = dl_SQLGetDiagRec(type, handle, ++i, state, &native, text,

1041 sizeof(text), &len );

1042 if (SQL_SUCCEEDED(ret))

1043 xprintf("%s:%ld:%ld:%s\n", state, i, native, text);

1044 }

1045 while( ret == SQL_SUCCESS );

1046 }

1047

1048 static int is_numeric(SQLSMALLINT coltype)

1049 {

1050 int ret = 0;

1051 switch (coltype)

1052 {

1053 case SQL_DECIMAL:

1054 case SQL_NUMERIC:

1055 case SQL_SMALLINT:

1056 case SQL_INTEGER:

1057 case SQL_REAL:

1058 case SQL_FLOAT:

1059 case SQL_DOUBLE:

1060 case SQL_TINYINT:

1061 case SQL_BIGINT:

1062 ret = 1;

1063 break;

1064 }

1065 return ret;

1066 }

1067

1068 #endif

1069

1070 /**********************************************************************/

1071

1072 #ifndef HAVE_MYSQL

1073

1074 void *db_mysql_open(TABDCA *dca, int mode)

1075 { xassert(dca == dca);

1076 xassert(mode == mode);

1077 xprintf("MySQL table driver not supported\n");

1078 return NULL;

1079 }

1080

1081 int db_mysql_read(TABDCA *dca, void *link)

1082 { xassert(dca != dca);

1083 xassert(link != link);

1084 return 0;

1085 }

1086

1087 int db_mysql_write(TABDCA *dca, void *link)

1088 { xassert(dca != dca);

1089 xassert(link != link);

1090 return 0;

1091 }

1092

1093 int db_mysql_close(TABDCA *dca, void *link)

1094 { xassert(dca != dca);

1095 xassert(link != link);

1096 return 0;

1097 }

1098

1099 #else

1100

1101 #if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__WOE__)

1102 #include <windows.h>

1103 #endif

1104

1105 #ifdef __CYGWIN__

1106 #define byte_defined 1

1107 #endif

1108

1109 #include <my_global.h>

1110 #include <my_sys.h>

1111 #include <mysql.h>

1112

1113 struct db_mysql

1114 {

1115 int mode; /*'R' = Read, 'W' = Write*/

1116 MYSQL *con; /*connection*/

1117 MYSQL_RES *res; /*result*/

1118 int nf;

1119 /* number of fields in the csv file */

1120 int ref[1+SQL_FIELD_MAX];

1121 /* ref[k] = k', if k-th field of the csv file corresponds to

1122 k'-th field in the table statement; if ref[k] = 0, k-th field

1123 of the csv file is ignored */

1124 char *query;

1125 /* query generated by db_mysql_open */

1126 };

1127

1128 void STDCALL dl_mysql_close(MYSQL *sock)

1129 {

1130 typedef void STDCALL ep_mysql_close(MYSQL *sock);

1131

1132 ep_mysql_close *fn;

1133 fn = (ep_mysql_close *) xdlsym(h_mysql, "mysql_close");

1134 xassert(fn != NULL);

1135 return (*fn)(sock);

1136 }

1137

1138 const char * STDCALL dl_mysql_error(MYSQL *mysql)

1139 {

1140 typedef const char * STDCALL ep_mysql_error(MYSQL *mysql);

1141

1142 ep_mysql_error *fn;

1143 fn = (ep_mysql_error *) xdlsym(h_mysql, "mysql_error");

1144 xassert(fn != NULL);

1145 return (*fn)(mysql);

1146 }

1147

1148 MYSQL_FIELD * STDCALL dl_mysql_fetch_fields(MYSQL_RES *res)

1149 {

1150 typedef MYSQL_FIELD * STDCALL

1151 ep_mysql_fetch_fields(MYSQL_RES *res);

1152

1153 ep_mysql_fetch_fields *fn;

1154 fn = (ep_mysql_fetch_fields *) xdlsym(h_mysql, "mysql_fetch_fields");

1155 xassert(fn != NULL);

1156 return (*fn)(res);

1157 }

1158

1159 unsigned long * STDCALL dl_mysql_fetch_lengths(MYSQL_RES *result)

1160 {

1161 typedef unsigned long * STDCALL

1162 ep_mysql_fetch_lengths(MYSQL_RES *result);

1163

1164 ep_mysql_fetch_lengths *fn;

1165 fn = (ep_mysql_fetch_lengths *) xdlsym(h_mysql,

1166 "mysql_fetch_lengths");

1167 xassert(fn != NULL);

1168 return (*fn)(result);

1169 }

1170

1171 MYSQL_ROW STDCALL dl_mysql_fetch_row(MYSQL_RES *result)

1172 {

1173 typedef MYSQL_ROW STDCALL ep_mysql_fetch_row(MYSQL_RES *result);

1174

1175 ep_mysql_fetch_row *fn;

1176 fn = (ep_mysql_fetch_row *) xdlsym(h_mysql, "mysql_fetch_row");

1177 xassert(fn != NULL);

1178 return (*fn)(result);

1179 }

1180

1181 unsigned int STDCALL dl_mysql_field_count(MYSQL *mysql)

1182 {

1183 typedef unsigned int STDCALL ep_mysql_field_count(MYSQL *mysql);

1184

1185 ep_mysql_field_count *fn;

1186 fn = (ep_mysql_field_count *) xdlsym(h_mysql, "mysql_field_count");

1187 xassert(fn != NULL);

1188 return (*fn)(mysql);

1189 }

1190

1191 MYSQL * STDCALL dl_mysql_init(MYSQL *mysql)

1192 {

1193 typedef MYSQL * STDCALL ep_mysql_init(MYSQL *mysql);

1194

1195 ep_mysql_init *fn;

1196 fn = (ep_mysql_init *) xdlsym(h_mysql, "mysql_init");

1197 xassert(fn != NULL);

1198 return (*fn)(mysql);

1199 }

1200

1201 unsigned int STDCALL dl_mysql_num_fields(MYSQL_RES *res)

1202 {

1203 typedef unsigned int STDCALL ep_mysql_num_fields(MYSQL_RES *res);

1204

1205 ep_mysql_num_fields *fn;

1206 fn = (ep_mysql_num_fields *) xdlsym(h_mysql, "mysql_num_fields");

1207 xassert(fn != NULL);

1208 return (*fn)(res);

1209 }

1210

1211 int STDCALL dl_mysql_query(MYSQL *mysql, const char *q)

1212 {

1213 typedef int STDCALL ep_mysql_query(MYSQL *mysql, const char *q);

1214

1215 ep_mysql_query *fn;

1216 fn = (ep_mysql_query *) xdlsym(h_mysql, "mysql_query");

1217 xassert(fn != NULL);

1218 return (*fn)(mysql, q);

1219 }

1220

1221 MYSQL * STDCALL dl_mysql_real_connect(MYSQL *mysql, const char *host,

1222 const char *user,

1223 const char *passwd,

1224 const char *db,

1225 unsigned int port,

1226 const char *unix_socket,

1227 unsigned long clientflag)

1228 {

1229 typedef MYSQL * STDCALL ep_mysql_real_connect(MYSQL *mysql,

1230 const char *host,

1231 const char *user,

1232 const char *passwd,

1233 const char *db,

1234 unsigned int port,

1235 const char *unix_socket,

1236 unsigned long clientflag);

1237

1238 ep_mysql_real_connect *fn;

1239 fn = (ep_mysql_real_connect *) xdlsym(h_mysql,

1240 "mysql_real_connect");

1241 xassert(fn != NULL);

1242 return (*fn)(mysql, host, user, passwd, db, port, unix_socket,

1243 clientflag);

1244 }

1245

1246 MYSQL_RES * STDCALL dl_mysql_use_result(MYSQL *mysql)

1247 {

1248 typedef MYSQL_RES * STDCALL ep_mysql_use_result(MYSQL *mysql);

1249 ep_mysql_use_result *fn;

1250 fn = (ep_mysql_use_result *) xdlsym(h_mysql, "mysql_use_result");

1251 xassert(fn != NULL);

1252 return (*fn)(mysql);

1253 }

1254

1255 /***********************************************************************

1256 * NAME

1257 *

1258 * db_mysql_open - open connection to ODBC data base

1259 *

1260 * SYNOPSIS

1261 *

1262 * #include "glpsql.h"

1263 * void *db_mysql_open(TABDCA *dca, int mode);

1264 *

1265 * DESCRIPTION

1266 *

1267 * The routine db_mysql_open opens a connection to a MySQL data base.

1268 * It then executes the sql statements passed.

1269 *

1270 * In the case of table read the SELECT statement is executed.

1271 *

1272 * In the case of table write the INSERT statement is prepared.

1273 * RETURNS

1274 *

1275 * The routine returns a pointer to data storage area created. */

1276

1277 void *db_mysql_open(TABDCA *dca, int mode)

1278 { void *ret;

1279 char **sqllines;

1280

1281 sqllines = args_concat(dca);

1282 if (sqllines == NULL)

1283 { xprintf("Missing arguments in table statement.\n"

1284 "Please, supply table driver, dsn, and query.\n");

1285 return NULL;

1286 }

1287 ret = db_mysql_open_int(dca, mode, (const char **) sqllines);

1288 free_buffer(sqllines);

1289 return ret;

1290 }

1291

1292 static void *db_mysql_open_int(TABDCA *dca, int mode, const char

1293 **sqllines)

1294 {

1295 struct db_mysql *sql = NULL;

1296 char *arg = NULL;

1297 const char *field;

1298 MYSQL_FIELD *fields;

1299 char *keyword;

1300 char *value;

1301 char *query;

1302 char *dsn;

1303 /* "Server=[server_name];Database=[database_name];UID=[username];*/

1304 /* PWD=[password];Port=[port]"*/

1305 char *server = NULL; /* Server */

1306 char *user = NULL; /* UID */

1307 char *password = NULL; /* PWD */

1308 char *database = NULL; /* Database */

1309 unsigned int port = 0; /* Port */

1310 int narg;

1311 int i, j, total;

1312

1313 if (libmysql == NULL)

1314 {

1315 xprintf("No loader for shared MySQL library available\n");

1316 return NULL;

1317 }

1318

1319 if (h_mysql == NULL)

1320 {

1321 h_mysql = xdlopen(libmysql);

1322 if (h_mysql == NULL)

1323 { xprintf("unable to open library %s\n", libmysql);

1324 xprintf("%s\n", xerrmsg());

1325 return NULL;

1326 }

1327 }

1328

1329 sql = (struct db_mysql *) xmalloc(sizeof(struct db_mysql));

1330 if (sql == NULL)

1331 return NULL;

1332 sql->mode = mode;

1333 sql->res = NULL;

1334 sql->query = NULL;

1335 sql->nf = mpl_tab_num_flds(dca);

1336

1337 narg = mpl_tab_num_args(dca);

1338 if (narg < 3 )

1339 xprintf("MySQL driver: string list too short \n");

1340

1341 /* get connection string*/

1342 dsn = (char *) mpl_tab_get_arg(dca, 2);

1343 /* copy connection string*/

1344 i = strlen(dsn);

1345 i++;

1346 arg = xmalloc(i * sizeof(char));

1347 strcpy(arg, dsn);

1348 /*tokenize connection string*/

1349 for (i = 1, keyword = strtok (arg, "="); (keyword != NULL);

1350 keyword = strtok (NULL, "="), i++)

1351 {

1352 value = strtok (NULL, ";");

1353 if (value==NULL)

1354 {

1355 xprintf("db_mysql_open: Missing value for keyword %s\n",

1356 keyword);

1357 xfree(arg);

1358 xfree(sql);

1359 return NULL;

1360 }

1361 if (0 == strcmp(keyword, "Server"))

1362 server = value;

1363 else if (0 == strcmp(keyword, "Database"))

1364 database = value;

1365 else if (0 == strcmp(keyword, "UID"))

1366 user = value;

1367 else if (0 == strcmp(keyword, "PWD"))

1368 password = value;

1369 else if (0 == strcmp(keyword, "Port"))

1370 port = (unsigned int) atol(value);

1371 }

1372 /* Connect to database */

1373 sql->con = dl_mysql_init(NULL);

1374 if (!dl_mysql_real_connect(sql->con, server, user, password, database,

1375 port, NULL, 0))

1376 {

1377 xprintf("db_mysql_open: Connect failed\n");

1378 xprintf("%s\n", dl_mysql_error(sql->con));

1379 xfree(arg);

1380 xfree(sql);

1381 return NULL;

1382 }

1383 xfree(arg);

1384

1385 for(j = 0; sqllines[j+1] != NULL; j++)

1386 { query = (char *) sqllines[j];

1387 xprintf("%s\n", query);

1388 if (dl_mysql_query(sql->con, query))

1389 {

1390 xprintf("db_mysql_open: Query\n\"%s\"\nfailed.\n", query);

1391 xprintf("%s\n",dl_mysql_error(sql->con));

1392 dl_mysql_close(sql->con);

1393 xfree(sql);

1394 return NULL;

1395 }

1396 }

1397

1398 if ( sql->mode == 'R' )

1399 { sql->nf = mpl_tab_num_flds(dca);

1400 for(j = 0; sqllines[j] != NULL; j++)

1401 arg = (char *) sqllines[j];

1402 total = strlen(arg);

1403 if (total > 7 && 0 == strncmp(arg, "SELECT ", 7))

1404 {

1405 total = strlen(arg);

1406 query = xmalloc( (total+1) * sizeof(char));

1407 strcpy (query, arg);

1408 }

1409 else

1410 {

1411 query = db_generate_select_stmt(dca);

1412 }

1413 xprintf("%s\n", query);

1414 if (dl_mysql_query(sql->con, query))

1415 {

1416 xprintf("db_mysql_open: Query\n\"%s\"\nfailed.\n", query);

1417 xprintf("%s\n",dl_mysql_error(sql->con));

1418 dl_mysql_close(sql->con);

1419 xfree(query);

1420 xfree(sql);

1421 return NULL;

1422 }

1423 xfree(query);

1424 sql->res = dl_mysql_use_result(sql->con);

1425 if (sql->res)

1426 {

1427 /* create references between query results and table fields*/

1428 total = dl_mysql_num_fields(sql->res);

1429 if (total > SQL_FIELD_MAX)

1430 { xprintf("db_mysql_open: Too many fields (> %d) in query.\n"

1431 "\"%s\"\n", SQL_FIELD_MAX, query);

1432 xprintf("%s\n",dl_mysql_error(sql->con));

1433 dl_mysql_close(sql->con);

1434 xfree(query);

1435 xfree(sql);

1436 return NULL;

1437 }

1438 fields = dl_mysql_fetch_fields(sql->res);

1439 for (i = 1; i <= total; i++)

1440 {

1441 for (j = sql->nf; j >= 1; j--)

1442 {

1443 if (strcmp(mpl_tab_get_name(dca, j), fields[i-1].name)

1444 == 0)

1445 break;

1446 }

1447 sql->ref[i] = j;

1448 }

1449 }

1450 else

1451 {

1452 if(dl_mysql_field_count(sql->con) == 0)

1453 {

1454 xprintf("db_mysql_open: Query was not a SELECT\n\"%s\"\n",

1455 query);

1456 xprintf("%s\n",dl_mysql_error(sql->con));

1457 xfree(query);

1458 xfree(sql);

1459 return NULL;

1460 }

1461 else

1462 {

1463 xprintf("db_mysql_open: Query\n\"%s\"\nfailed.\n", query);

1464 xprintf("%s\n",dl_mysql_error(sql->con));

1465 xfree(query);

1466 xfree(sql);

1467 return NULL;

1468 }

1469 }

1470 }

1471 else if ( sql->mode == 'W' )

1472 { for(j = 0; sqllines[j] != NULL; j++)

1473 arg = (char *) sqllines[j];

1474 if ( NULL != strchr(arg, '?') )

1475 {

1476 total = strlen(arg);

1477 query = xmalloc( (total+1) * sizeof(char));

1478 strcpy (query, arg);

1479 }

1480 else

1481 query = db_generate_insert_stmt(dca);

1482 sql->query = query;

1483 xprintf("%s\n", query);

1484 }

1485 return sql;

1486 }

1487

1488 int db_mysql_read(TABDCA *dca, void *link)

1489 { struct db_mysql *sql;

1490 char buf[255+1];

1491 char **row;

1492 unsigned long *lengths;

1493 MYSQL_FIELD *fields;

1494 double num;

1495 int len;

1496 unsigned long num_fields;

1497 int i;

1498

1499 sql = (struct db_mysql *) link;

1500

1501 xassert(sql != NULL);

1502 xassert(sql->mode == 'R');

1503 if (NULL == sql->res)

1504 {

1505 xprintf("db_mysql_read: no result set available");

1506 return 1;

1507 }

1508 if (NULL==(row = (char **)dl_mysql_fetch_row(sql->res))) {

1509 return -1; /*EOF*/

1510 }

1511 lengths = dl_mysql_fetch_lengths(sql->res);

1512 fields = dl_mysql_fetch_fields(sql->res);

1513 num_fields = dl_mysql_num_fields(sql->res);

1514 for (i=1; i <= num_fields; i++)

1515 {

1516 if (row[i-1] != NULL)

1517 { len = (size_t) lengths[i-1];

1518 if (len > 255)

1519 len = 255;

1520 strncpy(buf, (const char *) row[i-1], len);

1521 buf[len] = 0x00;

1522 if (0 != (fields[i-1].flags & NUM_FLAG))

1523 { strspx(buf); /* remove spaces*/

1524 if (str2num(buf, &num) != 0)

1525 { xprintf("'%s' cannot be converted to a number.\n", buf);

1526 return 1;

1527 }

1528 if (sql->ref[i] > 0)

1529 mpl_tab_set_num(dca, sql->ref[i], num);

1530 }

1531 else

1532 { if (sql->ref[i] > 0)

1533 mpl_tab_set_str(dca, sql->ref[i], strtrim(buf));

1534 }

1535 }

1536 }

1537 return 0;

1538 }

1539

1540 int db_mysql_write(TABDCA *dca, void *link)

1541 {

1542 struct db_mysql *sql;

1543 char *part;

1544 char *query;

1545 char *template;

1546 char num[50];

1547 int k;

1548 int len;

1549 int nf;

1550

1551 sql = (struct db_mysql *) link;

1552 xassert(sql != NULL);

1553 xassert(sql->mode == 'W');

1554

1555 len = strlen(sql->query);

1556 template = (char *) xmalloc( (len + 1) * sizeof(char) );

1557 strcpy(template, sql->query);

1558

1559 nf = mpl_tab_num_flds(dca);

1560 for (k = 1; k <= nf; k++)

1561 { switch (mpl_tab_get_type(dca, k))

1562 { case 'N':

1563 len += 20;

1564 break;

1565 case 'S':

1566 len += db_escaped_string_length(mpl_tab_get_str(dca, k));

1567 len += 2;

1568 break;

1569 default:

1570 xassert(dca != dca);

1571 }

1572 }

1573 query = xmalloc( (len + 1 ) * sizeof(char) );

1574 query[0] = 0x00;

1575 for (k = 1, part = strtok (template, "?"); (part != NULL);

1576 part = strtok (NULL, "?"), k++)

1577 {

1578 if (k > nf) break;

1579 strcat( query, part );

1580 switch (mpl_tab_get_type(dca, k))

1581 { case 'N':

1582 #if 0 /* 02/XI-2010 by xypron */

1583 sprintf(num, "%-18g",mpl_tab_get_num(dca, k));

1584 #else

1585 sprintf(num, "%.*g", DBL_DIG, mpl_tab_get_num(dca, k));

1586 #endif

1587 strcat( query, num );

1588 break;

1589 case 'S':

1590 strcat( query, "'");

1591 db_escape_string( query + strlen(query),

1592 mpl_tab_get_str(dca, k) );

1593 strcat( query, "'");

1594 break;

1595 default:

1596 xassert(dca != dca);

1597 }

1598 }

1599 if (part != NULL)

1600 strcat(query, part);

1601 if (dl_mysql_query(sql->con, query))

1602 {

1603 xprintf("db_mysql_write: Query\n\"%s\"\nfailed.\n", query);

1604 xprintf("%s\n",dl_mysql_error(sql->con));

1605 xfree(query);

1606 xfree(template);

1607 return 1;

1608 }

1609

1610 xfree(query);

1611 xfree(template);

1612 return 0;

1613 }

1614

1615 int db_mysql_close(TABDCA *dca, void *link)

1616 {

1617 struct db_mysql *sql;

1618

1619 sql = (struct db_mysql *) link;

1620 xassert(sql != NULL);

1621 dl_mysql_close(sql->con);

1622 if ( sql->mode == 'W' )

1623 xfree(sql->query);

1624 xfree(sql);

1625 dca->link = NULL;

1626 return 0;

1627 }

1628

1629 #endif

1630

1631 /* eof */