generic/mysqltcl.c

   1 /*\r
   2  * $Eid: mysqltcl.c,v 1.2 2002/02/15 18:52:08 artur Exp $\r
   3  *\r
   4  * MYSQL interface to Tcl\r
   5  *\r
   6  * Hakan Soderstrom, hs@soderstrom.se\r
   7  *\r
   8  */\r
   9 \r
  10 /*\r
  11  * Copyright (c) 1994, 1995 Hakan Soderstrom and Tom Poindexter\r
  12  * \r
  13  * Permission to use, copy, modify, distribute, and sell this software\r
  14  * and its documentation for any purpose is hereby granted without fee,\r
  15  * provided that the above copyright notice and this permission notice\r
  16  * appear in all copies of the software and related documentation.\r
  17  * \r
  18  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,\r
  19  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY\r
  20  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.\r
  21  *\r
  22  * IN NO EVENT SHALL HAKAN SODERSTROM OR SODERSTROM PROGRAMVARUVERKSTAD\r
  23  * AB BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL\r
  24  * DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS\r
  25  * OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY\r
  26  * OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN\r
  27  * CONNECTON WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\r
  28  */\r
  29 \r
  30 /*\r
  31  Modified after version 2.0 by Artur Trzewik\r
  32  see http://www.xdobry.de/mysqltcl\r
  33  Patch for encoding option by Alexander Schoepe (version2.20)\r
  34 */\r
  35 \r
  36 #ifdef _WINDOWS\r
  37    #include <windows.h>\r
  38    #define PACKAGE "mysqltcl"\r
  39    #define PACKAGE_VERSION "3.052"\r
  40 #endif\r
  41 \r
  42 #include <tcl.h>\r
  43 #include <mysql.h>\r
  44 \r
  45 #include <errno.h>\r
  46 #include <string.h>\r
  47 #include <ctype.h>\r
  48 #include <stdlib.h>\r
  49 \r
  50 #define MYSQL_SMALL_SIZE  TCL_RESULT_SIZE /* Smaller buffer size. */\r
  51 #define MYSQL_NAME_LEN     80    /* Max. database name length. */\r
  52 /* #define PREPARED_STATEMENT */\r
  53 \r
  54 enum MysqlHandleType {HT_CONNECTION=1,HT_QUERY=2,HT_STATEMENT=3};\r
  55 \r
  56 typedef struct MysqlTclHandle {\r
  57   MYSQL * connection;         /* Connection handle, if connected; NULL otherwise. */\r
  58   char database[MYSQL_NAME_LEN];  /* Db name, if selected; NULL otherwise. */\r
  59   MYSQL_RES* result;              /* Stored result, if any; NULL otherwise. */\r
  60   int res_count;                 /* Count of unfetched rows in result. */\r
  61   int col_count;                 /* Column count in result, if any. */\r
  62   int number;                    /* handle id */\r
  63   enum MysqlHandleType type;                      /* handle type */\r
  64   Tcl_Encoding encoding;         /* encoding for connection */\r
  65 #ifdef PREPARED_STATEMENT\r
  66   MYSQL_STMT *statement;         /* used only by prepared statements*/\r
  67   MYSQL_BIND *bindParam;\r
  68   MYSQL_BIND *bindResult;\r
  69   MYSQL_RES *resultMetadata;\r
  70   MYSQL_RES *paramMetadata;\r
  71 #endif\r
  72 } MysqlTclHandle;\r
  73 \r
  74 typedef struct MysqltclState { \r
  75   Tcl_HashTable hash;\r
  76   int handleNum;\r
  77   char *MysqlNullvalue;\r
  78   // Tcl_Obj *nullObjPtr;\r
  79 } MysqltclState;\r
  80 \r
  81 static char *MysqlHandlePrefix = "mysql";\r
  82 /* Prefix string used to identify handles.\r
  83  * The following must be strlen(MysqlHandlePrefix).\r
  84  */\r
  85 #define MYSQL_HPREFIX_LEN 5\r
  86 \r
  87 /* Array for status info, and its elements. */\r
  88 #define MYSQL_STATUS_ARR "mysqlstatus"\r
  89 \r
  90 #define MYSQL_STATUS_CODE "code"\r
  91 #define MYSQL_STATUS_CMD  "command"\r
  92 #define MYSQL_STATUS_MSG  "message"\r
  93 #define MYSQL_STATUS_NULLV  "nullvalue"\r
  94 \r
  95 #define FUNCTION_NOT_AVAILABLE "function not available"\r
  96 \r
  97 /* C variable corresponding to mysqlstatus(nullvalue) */\r
  98 #define MYSQL_NULLV_INIT ""\r
  99 \r
 100 /* Check Level for mysql_prologue */\r
 101 enum CONNLEVEL {CL_PLAIN,CL_CONN,CL_DB,CL_RES};\r
 102 \r
 103 /* Prototypes for all functions. */\r
 104 \r
 105 static int Mysqltcl_Use(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 106 static int Mysqltcl_Escape(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 107 static int Mysqltcl_Sel(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 108 static int Mysqltcl_Fetch(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 109 static int Mysqltcl_Seek(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 110 static int Mysqltcl_Map(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 111 static int Mysqltcl_Exec(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 112 static int Mysqltcl_Close(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 113 static int Mysqltcl_Info(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 114 static int Mysqltcl_Result(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 115 static int Mysqltcl_Col(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 116 static int Mysqltcl_State(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 117 static int Mysqltcl_InsertId(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 118 static int Mysqltcl_Query(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 119 static int Mysqltcl_Receive(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);\r
 120 static int MysqlHandleSet _ANSI_ARGS_((Tcl_Interp *interp,Tcl_Obj *objPtr));\r
 121 static void MysqlHandleFree _ANSI_ARGS_((Tcl_Obj *objPtr));\r
 122 static int MysqlNullSet _ANSI_ARGS_((Tcl_Interp *interp,Tcl_Obj *objPtr));\r
 123 static Tcl_Obj *Mysqltcl_NewNullObj(MysqltclState *mysqltclState);\r
 124 static void UpdateStringOfNull _ANSI_ARGS_((Tcl_Obj *objPtr));\r
 125 \r
 126 /* handle object type \r
 127  * This section defince funtions for Handling new Tcl_Obj type */\r
 128   \r
 129 Tcl_ObjType mysqlHandleType = {\r
 130     "mysqlhandle", \r
 131     MysqlHandleFree,\r
 132     (Tcl_DupInternalRepProc *) NULL,\r
 133     NULL,\r
 134     MysqlHandleSet\r
 135 };\r
 136 Tcl_ObjType mysqlNullType = {\r
 137     "mysqlnull",\r
 138     (Tcl_FreeInternalRepProc *) NULL,\r
 139     (Tcl_DupInternalRepProc *) NULL,\r
 140     UpdateStringOfNull,\r
 141     MysqlNullSet\r
 142 };\r
 143 \r
 144 \r
 145 static MysqltclState *getMysqltclState(Tcl_Interp *interp) {\r
 146   Tcl_CmdInfo cmdInfo;\r
 147   if (Tcl_GetCommandInfo(interp,"mysqlconnect",&cmdInfo)==0) {\r
 148     return NULL;\r
 149   }\r
 150   return (MysqltclState *)cmdInfo.objClientData;\r
 151 }\r
 152 \r
 153 static int MysqlHandleSet(Tcl_Interp *interp, register Tcl_Obj *objPtr)\r
 154 {\r
 155     Tcl_ObjType *oldTypePtr = objPtr->typePtr;\r
 156     char *string;\r
 157     MysqlTclHandle *handle;\r
 158     Tcl_HashEntry *entryPtr;\r
 159     MysqltclState *statePtr;\r
 160 \r
 161     string = Tcl_GetStringFromObj(objPtr, NULL);  \r
 162     statePtr = getMysqltclState(interp);\r
 163     if (statePtr==NULL) return TCL_ERROR;\r
 164 \r
 165     entryPtr = Tcl_FindHashEntry(&statePtr->hash,string);\r
 166     if (entryPtr == NULL) {\r
 167 \r
 168       handle=0;\r
 169     } else {\r
 170       handle=(MysqlTclHandle *)Tcl_GetHashValue(entryPtr);\r
 171     }\r
 172     if (!handle) {\r
 173         if (interp != NULL)\r
 174           return TCL_ERROR;\r
 175     }\r
 176     if ((oldTypePtr != NULL) && (oldTypePtr->freeIntRepProc != NULL)) {\r
 177         oldTypePtr->freeIntRepProc(objPtr);\r
 178     }\r
 179     \r
 180     objPtr->internalRep.otherValuePtr = (MysqlTclHandle *) handle;\r
 181     objPtr->typePtr = &mysqlHandleType;\r
 182     Tcl_Preserve((char *)handle);\r
 183     return TCL_OK;\r
 184 }\r
 185 static int MysqlNullSet(Tcl_Interp *interp, Tcl_Obj *objPtr)\r
 186 {\r
 187     Tcl_ObjType *oldTypePtr = objPtr->typePtr;\r
 188 \r
 189     if ((oldTypePtr != NULL) && (oldTypePtr->freeIntRepProc != NULL)) {\r
 190         oldTypePtr->freeIntRepProc(objPtr);\r
 191     }\r
 192     objPtr->typePtr = &mysqlNullType;\r
 193     return TCL_OK;\r
 194 }\r
 195 static void UpdateStringOfNull(Tcl_Obj *objPtr) {\r
 196         int valueLen;\r
 197         MysqltclState *state = (MysqltclState *)objPtr->internalRep.otherValuePtr;\r
 198 \r
 199         valueLen = strlen(state->MysqlNullvalue);\r
 200         objPtr->bytes = Tcl_Alloc(valueLen+1);\r
 201         strcpy(objPtr->bytes,state->MysqlNullvalue);\r
 202         objPtr->length = valueLen;\r
 203 }\r
 204 static void MysqlHandleFree(Tcl_Obj *obj)\r
 205 {\r
 206   MysqlTclHandle *handle = (MysqlTclHandle *)obj->internalRep.otherValuePtr;\r
 207   Tcl_Release((char *)handle);\r
 208 }\r
 209 \r
 210 static int GetHandleFromObj(Tcl_Interp *interp,Tcl_Obj *objPtr,MysqlTclHandle **handlePtr)\r
 211 {\r
 212     if (Tcl_ConvertToType(interp, objPtr, &mysqlHandleType) != TCL_OK)\r
 213         return TCL_ERROR;\r
 214     *handlePtr = (MysqlTclHandle *)objPtr->internalRep.otherValuePtr;\r
 215     return TCL_OK;\r
 216 }\r
 217 \r
 218 static Tcl_Obj *Tcl_NewHandleObj(MysqltclState *statePtr,MysqlTclHandle *handle)\r
 219 {\r
 220     register Tcl_Obj *objPtr;\r
 221     char buffer[MYSQL_HPREFIX_LEN+TCL_DOUBLE_SPACE+1];\r
 222     register int len;\r
 223     Tcl_HashEntry *entryPtr;\r
 224     int newflag;\r
 225 \r
 226     objPtr=Tcl_NewObj();\r
 227     /* the string for "query" can not be longer as MysqlHandlePrefix see buf variable */\r
 228     len=sprintf(buffer, "%s%d", (handle->type==HT_QUERY) ? "query" : MysqlHandlePrefix,handle->number);    \r
 229     objPtr->bytes = Tcl_Alloc((unsigned) len + 1);\r
 230     strcpy(objPtr->bytes, buffer);\r
 231     objPtr->length = len;\r
 232     \r
 233     entryPtr=Tcl_CreateHashEntry(&statePtr->hash,buffer,&newflag);\r
 234     Tcl_SetHashValue(entryPtr,handle);     \r
 235   \r
 236     objPtr->internalRep.otherValuePtr = handle;\r
 237     objPtr->typePtr = &mysqlHandleType;\r
 238 \r
 239     Tcl_Preserve((char *)handle);  \r
 240 \r
 241     return objPtr;\r
 242 }\r
 243 \r
 244 \r
 245 \r
 246 \r
 247 /* CONFLICT HANDLING\r
 248  *\r
 249  * Every command begins by calling 'mysql_prologue'.\r
 250  * This function resets mysqlstatus(code) to zero; the other array elements\r
 251  * retain their previous values.\r
 252  * The function also saves objc/objv in global variables.\r
 253  * After this the command processing proper begins.\r
 254  *\r
 255  * If there is a conflict, the message is taken from one of the following\r
 256  * sources,\r
 257  * -- this code (mysql_prim_confl),\r
 258  * -- the database server (mysql_server_confl),\r
 259  * A complete message is put together from the above plus the name of the\r
 260  * command where the conflict was detected.\r
 261  * The complete message is returned as the Tcl result and is also stored in\r
 262  * mysqlstatus(message).\r
 263  * mysqlstatus(code) is set to "-1" for a primitive conflict or to mysql_errno\r
 264  * for a server conflict\r
 265  * In addition, the whole command where the conflict was detected is put\r
 266  * together from the saved objc/objv and is copied into mysqlstatus(command).\r
 267  */\r
 268 \r
 269 /*\r
 270  *-----------------------------------------------------------\r
 271  * set_statusArr\r
 272  * Help procedure to set Tcl global array with mysqltcl internal\r
 273  * informations\r
 274  */\r
 275 \r
 276 static void set_statusArr(Tcl_Interp *interp,char *elem_name,Tcl_Obj *tobj)\r
 277 {\r
 278   Tcl_SetVar2Ex (interp,MYSQL_STATUS_ARR,elem_name,tobj,TCL_GLOBAL_ONLY); \r
 279 }\r
 280 \r
 281 /*\r
 282  *----------------------------------------------------------------------\r
 283  * clear_msg\r
 284  *\r
 285  * Clears all error and message elements in the global array variable.\r
 286  *\r
 287  */\r
 288 \r
 289 static void\r
 290 clear_msg(Tcl_Interp *interp)\r
 291 {\r
 292   set_statusArr(interp,MYSQL_STATUS_CODE,Tcl_NewIntObj(0));\r
 293   set_statusArr(interp,MYSQL_STATUS_CMD,Tcl_NewObj());\r
 294   set_statusArr(interp,MYSQL_STATUS_MSG,Tcl_NewObj());\r
 295 }\r
 296 \r
 297 /*\r
 298  *----------------------------------------------------------------------\r
 299  * mysql_reassemble\r
 300  * Reassembles the current command from the saved objv; copies it into\r
 301  * mysqlstatus(command).\r
 302  */\r
 303 \r
 304 static void mysql_reassemble(Tcl_Interp *interp,int objc,Tcl_Obj *CONST objv[])\r
 305 {\r
 306    set_statusArr(interp,MYSQL_STATUS_CMD,Tcl_NewListObj(objc, objv));\r
 307 }\r
 308 \r
 309 /*\r
 310  * free result from handle and consume left result of multresult statement \r
 311  */\r
 312 static void freeResult(MysqlTclHandle *handle)\r
 313 {\r
 314         MYSQL_RES* result;\r
 315         if (handle->result != NULL) {\r
 316                 mysql_free_result(handle->result);\r
 317                 handle->result = NULL ;\r
 318         }\r
 319 #if (MYSQL_VERSION_ID >= 50000)\r
 320         while (!mysql_next_result(handle->connection)) {\r
 321                 result = mysql_store_result(handle->connection);\r
 322                 if (result) {\r
 323                         mysql_free_result(result);\r
 324                 }\r
 325         }\r
 326 #endif\r
 327 }\r
 328 \r
 329 /*\r
 330  *----------------------------------------------------------------------\r
 331  * mysql_prim_confl\r
 332  * Conflict handling after a primitive conflict.\r
 333  *\r
 334  */\r
 335 \r
 336 static int mysql_prim_confl(Tcl_Interp *interp,int objc,Tcl_Obj *CONST objv[],char *msg)\r
 337 {\r
 338   set_statusArr(interp,MYSQL_STATUS_CODE,Tcl_NewIntObj(-1));\r
 339 \r
 340   Tcl_ResetResult(interp) ;\r
 341   Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),\r
 342                           Tcl_GetString(objv[0]), ": ", msg, (char*)NULL);\r
 343 \r
 344   set_statusArr(interp,MYSQL_STATUS_MSG,Tcl_GetObjResult(interp));\r
 345 \r
 346   mysql_reassemble(interp,objc,objv) ;\r
 347   return TCL_ERROR ;\r
 348 }\r
 349 \r
 350 \r
 351 /*\r
 352  *----------------------------------------------------------------------\r
 353  * mysql_server_confl\r
 354  * Conflict handling after an mySQL conflict.\r
 355  * If error it set error message and return TCL_ERROR\r
 356  * If no error occurs it returns TCL_OK\r
 357  */\r
 358 \r
 359 static int mysql_server_confl(Tcl_Interp *interp,int objc,Tcl_Obj *CONST objv[],MYSQL * connection)\r
 360 {\r
 361   const char* mysql_errorMsg;\r
 362   if (mysql_errno(connection)) {\r
 363     mysql_errorMsg = mysql_error(connection);\r
 364 \r
 365     set_statusArr(interp,MYSQL_STATUS_CODE,Tcl_NewIntObj(mysql_errno(connection)));\r
 366 \r
 367 \r
 368     Tcl_ResetResult(interp) ;\r
 369     Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),\r
 370                           Tcl_GetString(objv[0]), "/db server: ",\r
 371                           (mysql_errorMsg == NULL) ? "" : mysql_errorMsg,\r
 372                           (char*)NULL) ;\r
 373 \r
 374     set_statusArr(interp,MYSQL_STATUS_MSG,Tcl_GetObjResult(interp));\r
 375 \r
 376     mysql_reassemble(interp,objc,objv);\r
 377     return TCL_ERROR;\r
 378   } else {\r
 379     return TCL_OK;\r
 380   }\r
 381 }\r
 382 \r
 383 static  MysqlTclHandle *get_handle(Tcl_Interp *interp,int objc,Tcl_Obj *CONST objv[],int check_level) \r
 384 {\r
 385   MysqlTclHandle *handle;\r
 386   if (GetHandleFromObj(interp, objv[1], &handle) != TCL_OK) {\r
 387     mysql_prim_confl(interp,objc,objv,"not mysqltcl handle") ;\r
 388     return NULL;\r
 389   }\r
 390   if (check_level==CL_PLAIN) return handle;\r
 391   if (handle->connection == 0) {\r
 392       mysql_prim_confl(interp,objc,objv,"handle already closed (dangling pointer)") ;\r
 393       return NULL;\r
 394   }\r
 395   if (check_level==CL_CONN) return handle;\r
 396   if (check_level!=CL_RES) {\r
 397     if (handle->database[0] == '\0') {\r
 398       mysql_prim_confl(interp,objc,objv,"no current database") ;\r
 399       return NULL;\r
 400     }\r
 401     if (check_level==CL_DB) return handle;\r
 402   }\r
 403   if (handle->result == NULL) {\r
 404       mysql_prim_confl(interp,objc,objv,"no result pending") ;\r
 405       return NULL;\r
 406   }\r
 407   return handle;\r
 408 }\r
 409 \r
 410 /*----------------------------------------------------------------------\r
 411 \r
 412  * mysql_QueryTclObj\r
 413  * This to method control how tcl data is transfered to mysql and\r
 414  * how data is imported into tcl from mysql\r
 415  * Return value : Zero on success, Non-zero if an error occurred.\r
 416  */\r
 417 static int mysql_QueryTclObj(MysqlTclHandle *handle,Tcl_Obj *obj)\r
 418 {\r
 419   char *query;\r
 420   int result,queryLen;\r
 421 \r
 422   Tcl_DString queryDS;\r
 423 \r
 424   query=Tcl_GetStringFromObj(obj, &queryLen);\r
 425 \r
 426 \r
 427   if (handle->encoding==NULL) {\r
 428     query = (char *) Tcl_GetByteArrayFromObj(obj, &queryLen);\r
 429     result =  mysql_real_query(handle->connection,query,queryLen);\r
 430   } else {\r
 431     Tcl_UtfToExternalDString(handle->encoding, query, -1, &queryDS);\r
 432     queryLen = Tcl_DStringLength(&queryDS); \r
 433     result =  mysql_real_query(handle->connection,Tcl_DStringValue(&queryDS),queryLen);\r
 434     Tcl_DStringFree(&queryDS);\r
 435   }\r
 436   return result;\r
 437 } \r
 438 static Tcl_Obj *getRowCellAsObject(MysqltclState *mysqltclState,MysqlTclHandle *handle,MYSQL_ROW row,int length) \r
 439 {\r
 440   Tcl_Obj *obj;\r
 441   Tcl_DString ds;\r
 442 \r
 443   if (*row) {\r
 444     if (handle->encoding!=NULL) {\r
 445       Tcl_ExternalToUtfDString(handle->encoding, *row, length, &ds);\r
 446       obj = Tcl_NewStringObj(Tcl_DStringValue(&ds), Tcl_DStringLength(&ds));\r
 447       Tcl_DStringFree(&ds);\r
 448     } else {\r
 449       obj = Tcl_NewByteArrayObj((unsigned char *)*row,length);\r
 450     }\r
 451   } else {\r
 452     obj = Mysqltcl_NewNullObj(mysqltclState);\r
 453   } \r
 454   return obj;\r
 455 }\r
 456 \r
 457 static MysqlTclHandle *createMysqlHandle(MysqltclState *statePtr) \r
 458 {\r
 459   MysqlTclHandle *handle;\r
 460   handle=(MysqlTclHandle *)Tcl_Alloc(sizeof(MysqlTclHandle));\r
 461   memset(handle,0,sizeof(MysqlTclHandle));\r
 462   if (handle == 0) {\r
 463     panic("no memory for handle");\r
 464     return handle;\r
 465   }\r
 466   handle->type = HT_CONNECTION;\r
 467 \r
 468   /* MT-safe, because every thread in tcl has own interpreter */\r
 469   handle->number=statePtr->handleNum++;\r
 470   return handle;\r
 471 }\r
 472 \r
 473 static MysqlTclHandle *createHandleFrom(MysqltclState *statePtr,MysqlTclHandle *handle,enum MysqlHandleType handleType)\r
 474 {\r
 475   int number;\r
 476   MysqlTclHandle *qhandle;\r
 477   qhandle = createMysqlHandle(statePtr);\r
 478   /* do not overwrite the number */\r
 479   number = qhandle->number;\r
 480   if (!qhandle) return qhandle;\r
 481   memcpy(qhandle,handle,sizeof(MysqlTclHandle));\r
 482   qhandle->type=handleType;\r
 483   qhandle->number=number;\r
 484   return qhandle;\r
 485 }\r
 486 static void closeHandle(MysqlTclHandle *handle)\r
 487 {\r
 488   freeResult(handle);\r
 489   if (handle->type==HT_CONNECTION) {\r
 490     mysql_close(handle->connection);\r
 491   }\r
 492 #ifdef PREPARED_STATEMENT\r
 493   if (handle->type==HT_STATEMENT) {\r
 494     if (handle->statement!=NULL)\r
 495             mysql_stmt_close(handle->statement);\r
 496         if (handle->bindResult!=NULL)\r
 497                 Tcl_Free((char *)handle->bindResult);\r
 498     if (handle->bindParam!=NULL)\r
 499         Tcl_Free((char *)handle->bindParam);\r
 500     if (handle->resultMetadata!=NULL)\r
 501             mysql_free_result(handle->resultMetadata);\r
 502     if (handle->paramMetadata!=NULL)\r
 503             mysql_free_result(handle->paramMetadata);\r
 504   }\r
 505 #endif\r
 506   handle->connection = (MYSQL *)NULL;\r
 507   if (handle->encoding!=NULL && handle->type==HT_CONNECTION)\r
 508   {\r
 509     Tcl_FreeEncoding(handle->encoding);\r
 510     handle->encoding = NULL;\r
 511   }\r
 512   Tcl_EventuallyFree((char *)handle,TCL_DYNAMIC);\r
 513 }\r
 514 \r
 515 /*\r
 516  *----------------------------------------------------------------------\r
 517  * mysql_prologue\r
 518  *\r
 519  * Does most of standard command prologue; required for all commands\r
 520  * having conflict handling.\r
 521  * 'req_min_args' must be the minimum number of arguments for the command,\r
 522  * including the command word.\r
 523  * 'req_max_args' must be the maximum number of arguments for the command,\r
 524  * including the command word.\r
 525  * 'usage_msg' must be a usage message, leaving out the command name.\r
 526  * Checks the handle assumed to be present in objv[1] if 'check' is not NULL.\r
 527  * RETURNS: Handle index or -1 on failure.\r
 528  * SIDE EFFECT: Sets the Tcl result on failure.\r
 529  */\r
 530 \r
 531 static MysqlTclHandle *mysql_prologue(Tcl_Interp *interp,int objc,Tcl_Obj *CONST objv[],int req_min_args,int req_max_args,int check_level,char *usage_msg)\r
 532 {\r
 533   /* Check number of args. */\r
 534   if (objc < req_min_args || objc > req_max_args) {\r
 535       Tcl_WrongNumArgs(interp, 1, objv, usage_msg);\r
 536       return NULL;\r
 537   }\r
 538 \r
 539   /* Reset mysqlstatus(code). */\r
 540   set_statusArr(interp,MYSQL_STATUS_CODE,Tcl_NewIntObj(0));\r
 541 \r
 542   /* Check the handle.\r
 543    * The function is assumed to set the status array on conflict.\r
 544    */\r
 545   return (get_handle(interp,objc,objv,check_level));\r
 546 }\r
 547 \r
 548 /*\r
 549  *----------------------------------------------------------------------\r
 550  * mysql_colinfo\r
 551  *\r
 552  * Given an MYSQL_FIELD struct and a string keyword appends a piece of\r
 553  * column info (one item) to the Tcl result.\r
 554  * ASSUMES 'fld' is non-null.\r
 555  * RETURNS 0 on success, 1 otherwise.\r
 556  * SIDE EFFECT: Sets the result and status on failure.\r
 557  */\r
 558 \r
 559 static Tcl_Obj *mysql_colinfo(Tcl_Interp *interp,int objc,Tcl_Obj *CONST objv[],MYSQL_FIELD* fld,Tcl_Obj * keyw)\r
 560 {\r
 561   int idx ;\r
 562 \r
 563   static CONST char* MysqlColkey[] =\r
 564     {\r
 565       "table", "name", "type", "length", "prim_key", "non_null", "numeric", "decimals", NULL\r
 566     };\r
 567   enum coloptions {\r
 568     MYSQL_COL_TABLE_K, MYSQL_COL_NAME_K, MYSQL_COL_TYPE_K, MYSQL_COL_LENGTH_K, \r
 569     MYSQL_COL_PRIMKEY_K, MYSQL_COL_NONNULL_K, MYSQL_COL_NUMERIC_K, MYSQL_COL_DECIMALS_K};\r
 570 \r
 571   if (Tcl_GetIndexFromObj(interp, keyw, MysqlColkey, "option",\r
 572                           TCL_EXACT, &idx) != TCL_OK)\r
 573     return NULL;\r
 574 \r
 575   switch (idx)\r
 576     {\r
 577     case MYSQL_COL_TABLE_K:\r
 578       return Tcl_NewStringObj(fld->table, -1) ;\r
 579     case MYSQL_COL_NAME_K:\r
 580       return Tcl_NewStringObj(fld->name, -1) ;\r
 581     case MYSQL_COL_TYPE_K:\r
 582       switch (fld->type)\r
 583         {\r
 584 \r
 585 \r
 586         case FIELD_TYPE_DECIMAL:\r
 587           return Tcl_NewStringObj("decimal", -1);\r
 588         case FIELD_TYPE_TINY:\r
 589           return Tcl_NewStringObj("tiny", -1);\r
 590         case FIELD_TYPE_SHORT:\r
 591           return Tcl_NewStringObj("short", -1);\r
 592         case FIELD_TYPE_LONG:\r
 593           return Tcl_NewStringObj("long", -1) ;\r
 594         case FIELD_TYPE_FLOAT:\r
 595           return Tcl_NewStringObj("float", -1);\r
 596         case FIELD_TYPE_DOUBLE:\r
 597           return Tcl_NewStringObj("double", -1);\r
 598         case FIELD_TYPE_NULL:\r
 599           return Tcl_NewStringObj("null", -1);\r
 600         case FIELD_TYPE_TIMESTAMP:\r
 601           return Tcl_NewStringObj("timestamp", -1);\r
 602         case FIELD_TYPE_LONGLONG:\r
 603           return Tcl_NewStringObj("long long", -1);\r
 604         case FIELD_TYPE_INT24:\r
 605           return Tcl_NewStringObj("int24", -1);\r
 606         case FIELD_TYPE_DATE:\r
 607           return Tcl_NewStringObj("date", -1);\r
 608         case FIELD_TYPE_TIME:\r
 609           return Tcl_NewStringObj("time", -1);\r
 610         case FIELD_TYPE_DATETIME:\r
 611           return Tcl_NewStringObj("date time", -1);\r
 612         case FIELD_TYPE_YEAR:\r
 613           return Tcl_NewStringObj("year", -1);\r
 614         case FIELD_TYPE_NEWDATE:\r
 615           return Tcl_NewStringObj("new date", -1);\r
 616         case FIELD_TYPE_ENUM:\r
 617           return Tcl_NewStringObj("enum", -1); \r
 618         case FIELD_TYPE_SET:\r
 619           return Tcl_NewStringObj("set", -1);\r
 620         case FIELD_TYPE_TINY_BLOB:\r
 621           return Tcl_NewStringObj("tiny blob", -1);\r
 622         case FIELD_TYPE_MEDIUM_BLOB:\r
 623           return Tcl_NewStringObj("medium blob", -1);\r
 624         case FIELD_TYPE_LONG_BLOB:\r
 625           return Tcl_NewStringObj("long blob", -1);\r
 626         case FIELD_TYPE_BLOB:\r
 627           return Tcl_NewStringObj("blob", -1);\r
 628         case FIELD_TYPE_VAR_STRING:\r
 629           return Tcl_NewStringObj("var string", -1);\r
 630         case FIELD_TYPE_STRING:\r
 631           return Tcl_NewStringObj("string", -1);\r
 632 #if MYSQL_VERSION_ID >= 50000\r
 633         case MYSQL_TYPE_NEWDECIMAL:\r
 634            return Tcl_NewStringObj("newdecimal", -1);\r
 635         case MYSQL_TYPE_GEOMETRY:\r
 636            return Tcl_NewStringObj("geometry", -1);\r
 637         case MYSQL_TYPE_BIT:\r
 638            return Tcl_NewStringObj("bit", -1);\r
 639 #endif\r
 640         default:\r
 641           return Tcl_NewStringObj("unknown", -1);\r
 642         }\r
 643       break ;\r
 644     case MYSQL_COL_LENGTH_K:\r
 645       return Tcl_NewIntObj(fld->length) ;\r
 646     case MYSQL_COL_PRIMKEY_K:\r
 647       return Tcl_NewBooleanObj(IS_PRI_KEY(fld->flags));\r
 648     case MYSQL_COL_NONNULL_K:\r
 649       return Tcl_NewBooleanObj(IS_NOT_NULL(fld->flags));\r
 650     case MYSQL_COL_NUMERIC_K:\r
 651       return Tcl_NewBooleanObj(IS_NUM(fld->type));\r
 652     case MYSQL_COL_DECIMALS_K:\r
 653       return IS_NUM(fld->type)? Tcl_NewIntObj(fld->decimals): Tcl_NewIntObj(-1);\r
 654     default: /* should never happen */\r
 655       mysql_prim_confl(interp,objc,objv,"weirdness in mysql_colinfo");\r
 656       return NULL ;\r
 657     }\r
 658 }\r
 659 \r
 660 /*\r
 661  * Mysqltcl_CloseAll\r
 662  * Close all connections.\r
 663  */\r
 664 \r
 665 static void Mysqltcl_CloseAll(ClientData clientData)\r
 666 {\r
 667   MysqltclState *statePtr = (MysqltclState *)clientData; \r
 668   Tcl_HashSearch search;\r
 669   MysqlTclHandle *handle;\r
 670   Tcl_HashEntry *entryPtr; \r
 671   int wasdeleted=0;\r
 672 \r
 673   for (entryPtr=Tcl_FirstHashEntry(&statePtr->hash,&search); \r
 674        entryPtr!=NULL;\r
 675        entryPtr=Tcl_NextHashEntry(&search)) {\r
 676     wasdeleted=1;\r
 677     handle=(MysqlTclHandle *)Tcl_GetHashValue(entryPtr);\r
 678 \r
 679     if (handle->connection == 0) continue;\r
 680     closeHandle(handle);\r
 681   }\r
 682   if (wasdeleted) {\r
 683     Tcl_DeleteHashTable(&statePtr->hash);\r
 684     Tcl_InitHashTable(&statePtr->hash, TCL_STRING_KEYS);\r
 685   }\r
 686 }\r
 687 /*\r
 688  * Invoked from Interpreter by removing mysqltcl command\r
 689 \r
 690  * Warnign: This procedure can be called only once\r
 691  */\r
 692 static void Mysqltcl_Kill(ClientData clientData) \r
 693 { \r
 694    MysqltclState *statePtr = (MysqltclState *)clientData; \r
 695    Tcl_HashEntry *entryPtr; \r
 696    MysqlTclHandle *handle;\r
 697    Tcl_HashSearch search; \r
 698 \r
 699    for (entryPtr=Tcl_FirstHashEntry(&statePtr->hash,&search); \r
 700        entryPtr!=NULL;\r
 701        entryPtr=Tcl_NextHashEntry(&search)) {\r
 702      handle=(MysqlTclHandle *)Tcl_GetHashValue(entryPtr);\r
 703      if (handle->connection == 0) continue;\r
 704      closeHandle(handle);\r
 705    } \r
 706    Tcl_Free(statePtr->MysqlNullvalue);\r
 707    Tcl_Free((char *)statePtr); \r
 708 }\r
 709 \r
 710 /*\r
 711  *----------------------------------------------------------------------\r
 712  *\r
 713  * Mysqltcl_Connect\r
 714  * Implements the mysqlconnect command:\r
 715  * usage: mysqlconnect ?option value ...?\r
 716  *                      \r
 717  * Results:\r
 718  *      handle - a character string of newly open handle\r
 719  *      TCL_OK - connect successful\r
 720  *      TCL_ERROR - connect not successful - error message returned\r
 721  */\r
 722 \r
 723 static CONST char* MysqlConnectOpt[] =\r
 724     {\r
 725       "-host", "-user", "-password", "-db", "-port", "-socket","-encoding",\r
 726       "-ssl", "-compress", "-noschema","-odbc",\r
 727 #if (MYSQL_VERSION_ID >= 40107)\r
 728       "-multistatement","-multiresult",\r
 729 #endif\r
 730       "-localfiles","-ignorespace","-foundrows","-interactive","-sslkey","-sslcert",\r
 731       "-sslca","-sslcapath","-sslciphers","-reconnect", NULL\r
 732     };\r
 733 \r
 734 static int Mysqltcl_Connect(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
 735 {\r
 736   MysqltclState *statePtr = (MysqltclState *)clientData; \r
 737   int        i, idx;\r
 738   int        mysql_options_reconnect = 0;\r
 739   char *hostname = NULL;\r
 740   char *user = NULL;\r
 741   char *password = NULL;\r
 742   char *db = NULL;\r
 743   int port = 0, flags = 0, booleanflag;\r
 744   char *socket = NULL;\r
 745   char *encodingname = NULL;\r
 746 \r
 747 #if (MYSQL_VERSION_ID >= 40107)\r
 748   int isSSL = 0;\r
 749 #endif\r
 750   char *sslkey = NULL;\r
 751   char *sslcert = NULL;\r
 752   char *sslca = NULL;\r
 753   char *sslcapath = NULL;\r
 754   char *sslcipher = NULL;\r
 755   \r
 756   MysqlTclHandle *handle;\r
 757   const char *groupname = "mysqltcl";\r
 758 \r
 759   \r
 760   enum connectoption {\r
 761     MYSQL_CONNHOST_OPT, MYSQL_CONNUSER_OPT, MYSQL_CONNPASSWORD_OPT, \r
 762     MYSQL_CONNDB_OPT, MYSQL_CONNPORT_OPT, MYSQL_CONNSOCKET_OPT, MYSQL_CONNENCODING_OPT,\r
 763     MYSQL_CONNSSL_OPT, MYSQL_CONNCOMPRESS_OPT, MYSQL_CONNNOSCHEMA_OPT, MYSQL_CONNODBC_OPT,\r
 764 #if (MYSQL_VERSION_ID >= 40107)\r
 765     MYSQL_MULTISTATEMENT_OPT,MYSQL_MULTIRESULT_OPT,\r
 766 #endif\r
 767     MYSQL_LOCALFILES_OPT,MYSQL_IGNORESPACE_OPT,\r
 768     MYSQL_FOUNDROWS_OPT,MYSQL_INTERACTIVE_OPT,MYSQL_SSLKEY_OPT,MYSQL_SSLCERT_OPT,\r
 769     MYSQL_SSLCA_OPT,MYSQL_SSLCAPATH_OPT,MYSQL_SSLCIPHERS_OPT, MYSQL_RECONNECT_OPT\r
 770   };\r
 771 \r
 772   if (!(objc & 1) || \r
 773     objc>(sizeof(MysqlConnectOpt)/sizeof(MysqlConnectOpt[0]-1)*2+1)) {\r
 774     Tcl_WrongNumArgs(interp, 1, objv, "[-user xxx] [-db mysql] [-port 3306] [-host localhost] [-socket sock] [-password pass] [-encoding encoding] [-ssl boolean] [-compress boolean] [-odbc boolean] [-noschema boolean] [-reconnect boolean]"\r
 775     );\r
 776         return TCL_ERROR;\r
 777   }\r
 778               \r
 779   for (i = 1; i < objc; i++) {\r
 780     if (Tcl_GetIndexFromObj(interp, objv[i], MysqlConnectOpt, "option",\r
 781                           0, &idx) != TCL_OK)\r
 782       return TCL_ERROR;\r
 783     \r
 784     switch (idx) {\r
 785     case MYSQL_CONNHOST_OPT:\r
 786       hostname = Tcl_GetStringFromObj(objv[++i],NULL);\r
 787       break;\r
 788     case MYSQL_CONNUSER_OPT:\r
 789       user = Tcl_GetStringFromObj(objv[++i],NULL);\r
 790       break;\r
 791     case MYSQL_CONNPASSWORD_OPT:\r
 792       password = Tcl_GetStringFromObj(objv[++i],NULL);\r
 793       break;\r
 794     case MYSQL_CONNDB_OPT:\r
 795       db = Tcl_GetStringFromObj(objv[++i],NULL);\r
 796       break;\r
 797     case MYSQL_CONNPORT_OPT:\r
 798       if (Tcl_GetIntFromObj(interp, objv[++i], &port) != TCL_OK)\r
 799         return TCL_ERROR;\r
 800       break;\r
 801     case MYSQL_CONNSOCKET_OPT:\r
 802       socket = Tcl_GetStringFromObj(objv[++i],NULL);\r
 803       break;\r
 804     case MYSQL_CONNENCODING_OPT:\r
 805       encodingname = Tcl_GetStringFromObj(objv[++i],NULL);\r
 806       break;\r
 807     case MYSQL_CONNSSL_OPT:\r
 808 #if (MYSQL_VERSION_ID >= 40107)\r
 809       if (Tcl_GetBooleanFromObj(interp,objv[++i],&isSSL) != TCL_OK )\r
 810         return TCL_ERROR;\r
 811 #else\r
 812       if (Tcl_GetBooleanFromObj(interp,objv[++i],&booleanflag) != TCL_OK )\r
 813         return TCL_ERROR;\r
 814       if (booleanflag)\r
 815         flags |= CLIENT_SSL;\r
 816 #endif\r
 817       break;\r
 818     case MYSQL_CONNCOMPRESS_OPT:\r
 819       if (Tcl_GetBooleanFromObj(interp,objv[++i],&booleanflag) != TCL_OK )\r
 820         return TCL_ERROR;\r
 821       if (booleanflag)\r
 822         flags |= CLIENT_COMPRESS;\r
 823       break;\r
 824     case MYSQL_CONNNOSCHEMA_OPT: \r
 825       if (Tcl_GetBooleanFromObj(interp,objv[++i],&booleanflag) != TCL_OK )\r
 826         return TCL_ERROR;\r
 827       if (booleanflag)\r
 828         flags |= CLIENT_NO_SCHEMA;\r
 829       break;\r
 830     case MYSQL_CONNODBC_OPT:\r
 831       if (Tcl_GetBooleanFromObj(interp,objv[++i],&booleanflag) != TCL_OK )\r
 832         return TCL_ERROR;\r
 833       if (booleanflag)\r
 834         flags |= CLIENT_ODBC;\r
 835       break;\r
 836 #if (MYSQL_VERSION_ID >= 40107)\r
 837     case MYSQL_MULTISTATEMENT_OPT:\r
 838       if (Tcl_GetBooleanFromObj(interp,objv[++i],&booleanflag) != TCL_OK )\r
 839         return TCL_ERROR;\r
 840       if (booleanflag)\r
 841         flags |= CLIENT_MULTI_STATEMENTS;\r
 842       break;\r
 843     case MYSQL_MULTIRESULT_OPT:\r
 844       if (Tcl_GetBooleanFromObj(interp,objv[++i],&booleanflag) != TCL_OK )\r
 845         return TCL_ERROR;\r
 846       if (booleanflag)\r
 847         flags |= CLIENT_MULTI_RESULTS;\r
 848       break;\r
 849 #endif\r
 850     case MYSQL_LOCALFILES_OPT:\r
 851       if (Tcl_GetBooleanFromObj(interp,objv[++i],&booleanflag) != TCL_OK )\r
 852         return TCL_ERROR;\r
 853       if (booleanflag)\r
 854         flags |= CLIENT_LOCAL_FILES;\r
 855       break;\r
 856     case MYSQL_IGNORESPACE_OPT:\r
 857       if (Tcl_GetBooleanFromObj(interp,objv[++i],&booleanflag) != TCL_OK )\r
 858         return TCL_ERROR;\r
 859       if (booleanflag)\r
 860         flags |= CLIENT_IGNORE_SPACE;\r
 861       break;\r
 862     case MYSQL_FOUNDROWS_OPT:\r
 863       if (Tcl_GetBooleanFromObj(interp,objv[++i],&booleanflag) != TCL_OK )\r
 864         return TCL_ERROR;\r
 865       if (booleanflag)\r
 866         flags |= CLIENT_FOUND_ROWS;\r
 867       break;\r
 868     case MYSQL_INTERACTIVE_OPT:\r
 869       if (Tcl_GetBooleanFromObj(interp,objv[++i],&booleanflag) != TCL_OK )\r
 870         return TCL_ERROR;\r
 871       if (booleanflag)\r
 872         flags |= CLIENT_INTERACTIVE;\r
 873       break;\r
 874     case MYSQL_SSLKEY_OPT:\r
 875       sslkey = Tcl_GetStringFromObj(objv[++i],NULL);\r
 876       break;\r
 877     case MYSQL_SSLCERT_OPT:\r
 878       sslcert = Tcl_GetStringFromObj(objv[++i],NULL);\r
 879       break;\r
 880     case MYSQL_SSLCA_OPT:\r
 881       sslca = Tcl_GetStringFromObj(objv[++i],NULL);\r
 882       break;\r
 883     case MYSQL_SSLCAPATH_OPT:\r
 884       sslcapath = Tcl_GetStringFromObj(objv[++i],NULL);\r
 885       break;\r
 886     case MYSQL_SSLCIPHERS_OPT:\r
 887       sslcipher = Tcl_GetStringFromObj(objv[++i],NULL);\r
 888       break;\r
 889     case MYSQL_RECONNECT_OPT:\r
 890       if (Tcl_GetBooleanFromObj(interp,objv[++i],&booleanflag) != TCL_OK )\r
 891         return TCL_ERROR;\r
 892       if (booleanflag)\r
 893         mysql_options_reconnect = 1;\r
 894       break;\r
 895     default:\r
 896       return mysql_prim_confl(interp,objc,objv,"Weirdness in options");            \r
 897     }\r
 898   }\r
 899 \r
 900   handle = createMysqlHandle(statePtr);\r
 901 \r
 902   if (handle == 0) {\r
 903     panic("no memory for handle");\r
 904     return TCL_ERROR;\r
 905 \r
 906   }\r
 907 \r
 908   handle->connection = mysql_init(NULL);\r
 909 \r
 910   /* the function below caused in version pre 3.23.50 segmentation fault */\r
 911 #if (MYSQL_VERSION_ID>=32350)\r
 912   if(mysql_options_reconnect)\r
 913   {\r
 914       my_bool reconnect = 1;\r
 915       mysql_options(handle->connection, MYSQL_OPT_RECONNECT, &reconnect);\r
 916   }\r
 917   mysql_options(handle->connection,MYSQL_READ_DEFAULT_GROUP,groupname);\r
 918 #endif\r
 919 #if (MYSQL_VERSION_ID >= 40107)\r
 920   if (isSSL) {\r
 921       mysql_ssl_set(handle->connection,sslkey,sslcert, sslca, sslcapath, sslcipher);\r
 922   }\r
 923 #endif\r
 924 \r
 925   if (!mysql_real_connect(handle->connection, hostname, user,\r
 926                                 password, db, port, socket, flags)) {\r
 927       mysql_server_confl(interp,objc,objv,handle->connection);\r
 928       closeHandle(handle);\r
 929       return TCL_ERROR;\r
 930   }\r
 931 \r
 932   if (db) {\r
 933     strncpy(handle->database, db, MYSQL_NAME_LEN) ;\r
 934     handle->database[MYSQL_NAME_LEN - 1] = '\0' ;\r
 935   }\r
 936 \r
 937   if (encodingname==NULL || (encodingname!=NULL &&  strcmp(encodingname, "binary") != 0)) {\r
 938     if (encodingname==NULL)\r
 939       encodingname = (char *)Tcl_GetEncodingName(NULL);\r
 940     handle->encoding = Tcl_GetEncoding(interp, encodingname);\r
 941     if (handle->encoding == NULL)\r
 942       return TCL_ERROR;\r
 943   }\r
 944 \r
 945   Tcl_SetObjResult(interp, Tcl_NewHandleObj(statePtr,handle));\r
 946 \r
 947   return TCL_OK;\r
 948 \r
 949 }\r
 950 \r
 951 \r
 952 /*\r
 953  *----------------------------------------------------------------------\r
 954  *\r
 955  * Mysqltcl_Use\r
 956  *    Implements the mysqluse command:\r
 957 \r
 958  *    usage: mysqluse handle dbname\r
 959  *                      \r
 960  *    results:\r
 961  *      Sets current database to dbname.\r
 962  */\r
 963 \r
 964 static int Mysqltcl_Use(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
 965 {\r
 966   int len;\r
 967   char *db;\r
 968   MysqlTclHandle *handle;  \r
 969 \r
 970   if ((handle = mysql_prologue(interp, objc, objv, 3, 3, CL_CONN,\r
 971                             "handle dbname")) == 0)\r
 972     return TCL_ERROR;\r
 973 \r
 974   db=Tcl_GetStringFromObj(objv[2], &len);\r
 975   if (len >= MYSQL_NAME_LEN) {\r
 976      mysql_prim_confl(interp,objc,objv,"database name too long");\r
 977      return TCL_ERROR;\r
 978   }\r
 979 \r
 980   if (mysql_select_db(handle->connection, db)!=0) {\r
 981     return mysql_server_confl(interp,objc,objv,handle->connection);\r
 982   }\r
 983   strcpy(handle->database, db);\r
 984   return TCL_OK;\r
 985 }\r
 986 \r
 987 \r
 988 \r
 989 /*\r
 990  *----------------------------------------------------------------------\r
 991  *\r
 992  * Mysqltcl_Escape\r
 993  *    Implements the mysqlescape command:\r
 994  *    usage: mysqlescape string\r
 995  *                      \r
 996  *    results:\r
 997  *      Escaped string for use in queries.\r
 998  */\r
 999 \r
1000 static int Mysqltcl_Escape(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1001 {\r
1002   int len;\r
1003   char *inString, *outString;\r
1004   MysqlTclHandle *handle;\r
1005   \r
1006   if (objc <2 || objc>3) {\r
1007       Tcl_WrongNumArgs(interp, 1, objv, "?handle? string");\r
1008       return TCL_ERROR;\r
1009   }\r
1010   if (objc==2) {\r
1011     inString=Tcl_GetStringFromObj(objv[1], &len);\r
1012     outString=Tcl_Alloc((len<<1) + 1);\r
1013     len=mysql_escape_string(outString, inString, len);\r
1014     Tcl_SetStringObj(Tcl_GetObjResult(interp), outString, len);\r
1015     Tcl_Free(outString);\r
1016   } else { \r
1017     if ((handle = mysql_prologue(interp, objc, objv, 3, 3, CL_CONN,\r
1018                             "handle string")) == 0)\r
1019       return TCL_ERROR;\r
1020     inString=Tcl_GetStringFromObj(objv[2], &len);\r
1021     outString=Tcl_Alloc((len<<1) + 1);\r
1022     len=mysql_real_escape_string(handle->connection, outString, inString, len);\r
1023     Tcl_SetStringObj(Tcl_GetObjResult(interp), outString, len);\r
1024     Tcl_Free(outString);\r
1025   }\r
1026   return TCL_OK;\r
1027 }\r
1028 \r
1029 \r
1030 \r
1031 /*\r
1032  *----------------------------------------------------------------------\r
1033  *\r
1034  * Mysqltcl_Sel\r
1035  *    Implements the mysqlsel command:\r
1036  *    usage: mysqlsel handle sel-query ?-list|-flatlist?\r
1037  *                      \r
1038  *    results:\r
1039  *\r
1040  *    SIDE EFFECT: Flushes any pending result, even in case of conflict.\r
1041  *    Stores new results.\r
1042  */\r
1043 \r
1044 static int Mysqltcl_Sel(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1045 {\r
1046   MysqltclState *statePtr = (MysqltclState *)clientData; \r
1047   Tcl_Obj *res, *resList;\r
1048   MYSQL_ROW row;\r
1049   MysqlTclHandle *handle;\r
1050   unsigned long *lengths;\r
1051 \r
1052 \r
1053   static CONST char* selOptions[] = {"-list", "-flatlist", NULL};\r
1054   /* Warning !! no option number */\r
1055   int i,selOption=2,colCount;\r
1056   \r
1057   if ((handle = mysql_prologue(interp, objc, objv, 3, 4, CL_CONN,\r
1058                             "handle sel-query ?-list|-flatlist?")) == 0)\r
1059     return TCL_ERROR;\r
1060 \r
1061 \r
1062   if (objc==4) {\r
1063     if (Tcl_GetIndexFromObj(interp, objv[3], selOptions, "option",\r
1064                             TCL_EXACT, &selOption) != TCL_OK)\r
1065       return TCL_ERROR;\r
1066   }\r
1067 \r
1068   /* Flush any previous result. */\r
1069   freeResult(handle);\r
1070 \r
1071   if (mysql_QueryTclObj(handle,objv[2])) {\r
1072     return mysql_server_confl(interp,objc,objv,handle->connection);\r
1073   }\r
1074   if (selOption<2) {\r
1075     /* If imadiatly result than do not store result in mysql client library cache */\r
1076     handle->result = mysql_use_result(handle->connection);\r
1077   } else {\r
1078     handle->result = mysql_store_result(handle->connection);\r
1079   }\r
1080   \r
1081   if (handle->result == NULL) {\r
1082     if (selOption==2) Tcl_SetObjResult(interp, Tcl_NewIntObj(-1));\r
1083   } else {\r
1084     colCount = handle->col_count = mysql_num_fields(handle->result);\r
1085     res = Tcl_GetObjResult(interp);\r
1086     handle->res_count = 0;\r
1087     switch (selOption) {\r
1088     case 0: /* -list */\r
1089       while ((row = mysql_fetch_row(handle->result)) != NULL) {\r
1090         resList = Tcl_NewListObj(0, NULL);\r
1091         lengths = mysql_fetch_lengths(handle->result);\r
1092         for (i=0; i< colCount; i++, row++) {\r
1093           Tcl_ListObjAppendElement(interp, resList,getRowCellAsObject(statePtr,handle,row,lengths[i]));\r
1094         }\r
1095         Tcl_ListObjAppendElement(interp, res, resList);\r
1096       }  \r
1097       break;\r
1098     case 1: /* -flatlist */\r
1099       while ((row = mysql_fetch_row(handle->result)) != NULL) {\r
1100         lengths = mysql_fetch_lengths(handle->result);\r
1101         for (i=0; i< colCount; i++, row++) {\r
1102           Tcl_ListObjAppendElement(interp, res,getRowCellAsObject(statePtr,handle,row,lengths[i]));\r
1103         }\r
1104       }  \r
1105       break;\r
1106     case 2: /* No option */\r
1107       handle->res_count = mysql_num_rows(handle->result);\r
1108       Tcl_SetIntObj(res, handle->res_count);\r
1109       break;\r
1110     }\r
1111   }\r
1112   return TCL_OK;\r
1113 }\r
1114 /*\r
1115  * Mysqltcl_Query\r
1116  * Works as mysqltclsel but return an $query handle that allow to build\r
1117  * nested queries on simple handle\r
1118  */\r
1119 \r
1120 static int Mysqltcl_Query(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1121 {\r
1122   MysqltclState *statePtr = (MysqltclState *)clientData; \r
1123   MYSQL_RES *result;\r
1124   MysqlTclHandle *handle, *qhandle;\r
1125   \r
1126   if ((handle = mysql_prologue(interp, objc, objv, 3, 3, CL_CONN,\r
1127 \r
1128                             "handle sqlstatement")) == 0)\r
1129     return TCL_ERROR;\r
1130        \r
1131   if (mysql_QueryTclObj(handle,objv[2])) {\r
1132     return mysql_server_confl(interp,objc,objv,handle->connection);\r
1133   }\r
1134 \r
1135   if ((result = mysql_store_result(handle->connection)) == NULL) {\r
1136     Tcl_SetObjResult(interp, Tcl_NewIntObj(-1));\r
1137     return TCL_OK;\r
1138   } \r
1139   if ((qhandle = createHandleFrom(statePtr,handle,HT_QUERY)) == NULL) return TCL_ERROR;\r
1140   qhandle->result = result;\r
1141   qhandle->col_count = mysql_num_fields(qhandle->result) ;\r
1142 \r
1143 \r
1144   qhandle->res_count = mysql_num_rows(qhandle->result);\r
1145   Tcl_SetObjResult(interp, Tcl_NewHandleObj(statePtr,qhandle));\r
1146   return TCL_OK;\r
1147 }\r
1148 \r
1149 /*\r
1150  * Mysqltcl_Enquery\r
1151  * close and free a query handle\r
1152  * if handle is not query than the result will be discarted\r
1153  */\r
1154 \r
1155 static int Mysqltcl_EndQuery(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1156 {\r
1157   MysqltclState *statePtr = (MysqltclState *)clientData; \r
1158   Tcl_HashEntry *entryPtr;\r
1159   MysqlTclHandle *handle;\r
1160   \r
1161   if ((handle = mysql_prologue(interp, objc, objv, 2, 2, CL_CONN,\r
1162                             "queryhandle")) == 0)\r
1163     return TCL_ERROR;\r
1164 \r
1165   if (handle->type==HT_QUERY) {\r
1166     entryPtr = Tcl_FindHashEntry(&statePtr->hash,Tcl_GetStringFromObj(objv[1],NULL));\r
1167     if (entryPtr) {\r
1168       Tcl_DeleteHashEntry(entryPtr);\r
1169     }\r
1170     closeHandle(handle);\r
1171   } else {\r
1172       freeResult(handle);\r
1173   }\r
1174   return TCL_OK;\r
1175 }\r
1176 \r
1177 /*\r
1178  *----------------------------------------------------------------------\r
1179  *\r
1180  * Mysqltcl_Exec\r
1181  * Implements the mysqlexec command:\r
1182  * usage: mysqlexec handle sql-statement\r
1183  *                      \r
1184  * Results:\r
1185  * Number of affected rows on INSERT, UPDATE or DELETE, 0 otherwise.\r
1186  *\r
1187  * SIDE EFFECT: Flushes any pending result, even in case of conflict.\r
1188  */\r
1189 \r
1190 \r
1191 \r
1192 static int Mysqltcl_Exec(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1193 {\r
1194         MysqlTclHandle *handle;\r
1195         int affected;\r
1196         Tcl_Obj *resList;\r
1197     if ((handle = mysql_prologue(interp, objc, objv, 3, 3, CL_CONN,"handle sql-statement")) == 0)\r
1198         return TCL_ERROR;\r
1199 \r
1200         /* Flush any previous result. */\r
1201         freeResult(handle);\r
1202 \r
1203         if (mysql_QueryTclObj(handle,objv[2]))\r
1204         return mysql_server_confl(interp,objc,objv,handle->connection);\r
1205 \r
1206         if ((affected=mysql_affected_rows(handle->connection)) < 0) affected=0;\r
1207 \r
1208 #if (MYSQL_VERSION_ID >= 50000)\r
1209         if (!mysql_next_result(handle->connection)) {\r
1210                 resList = Tcl_GetObjResult(interp);\r
1211                 Tcl_ListObjAppendElement(interp, resList, Tcl_NewIntObj(affected));\r
1212                 do {\r
1213                         if ((affected=mysql_affected_rows(handle->connection)) < 0) affected=0;\r
1214                 Tcl_ListObjAppendElement(interp, resList, Tcl_NewIntObj(affected));\r
1215                 } while (!mysql_next_result(handle->connection));\r
1216                 return TCL_OK;\r
1217         }\r
1218 #endif\r
1219         Tcl_SetIntObj(Tcl_GetObjResult(interp),affected);  \r
1220         return TCL_OK ;\r
1221 }\r
1222 \r
1223 \r
1224 \r
1225 /*\r
1226  *----------------------------------------------------------------------\r
1227  *\r
1228  * Mysqltcl_Fetch\r
1229  *    Implements the mysqlnext command:\r
1230 \r
1231  *    usage: mysql::fetch handle\r
1232  *                      \r
1233  *    results:\r
1234  *      next row from pending results as tcl list, or null list.\r
1235  */\r
1236 \r
1237 static int Mysqltcl_Fetch(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1238 {\r
1239   MysqltclState *statePtr = (MysqltclState *)clientData; \r
1240   MysqlTclHandle *handle;\r
1241   int idx ;\r
1242   MYSQL_ROW row ;\r
1243   Tcl_Obj *resList;\r
1244   unsigned long *lengths;\r
1245 \r
1246   if ((handle = mysql_prologue(interp, objc, objv, 2, 2, CL_RES,"handle")) == 0)\r
1247     return TCL_ERROR;\r
1248 \r
1249 \r
1250   if (handle->res_count == 0)\r
1251     return TCL_OK ;\r
1252   else if ((row = mysql_fetch_row(handle->result)) == NULL) {\r
1253     handle->res_count = 0 ;\r
1254     return mysql_prim_confl(interp,objc,objv,"result counter out of sync") ;\r
1255   } else\r
1256     handle->res_count-- ;\r
1257   \r
1258   lengths = mysql_fetch_lengths(handle->result);\r
1259 \r
1260 \r
1261   resList = Tcl_GetObjResult(interp);\r
1262   for (idx = 0 ; idx < handle->col_count ; idx++, row++) {\r
1263     Tcl_ListObjAppendElement(interp, resList,getRowCellAsObject(statePtr,handle,row,lengths[idx]));\r
1264   }\r
1265   return TCL_OK;\r
1266 }\r
1267 \r
1268 \r
1269 /*\r
1270  *----------------------------------------------------------------------\r
1271  *\r
1272  * Mysqltcl_Seek\r
1273  *    Implements the mysqlseek command:\r
1274  *    usage: mysqlseek handle rownumber\r
1275  *                      \r
1276  *    results:\r
1277  *      number of remaining rows\r
1278  */\r
1279 \r
1280 static int Mysqltcl_Seek(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1281 {\r
1282     MysqlTclHandle *handle;\r
1283     int row;\r
1284     int total;\r
1285    \r
1286     if ((handle = mysql_prologue(interp, objc, objv, 3, 3, CL_RES,\r
1287                               " handle row-index")) == 0)\r
1288       return TCL_ERROR;\r
1289 \r
1290     if (Tcl_GetIntFromObj(interp, objv[2], &row) != TCL_OK)\r
1291       return TCL_ERROR;\r
1292     \r
1293     total = mysql_num_rows(handle->result);\r
1294     \r
1295     if (total + row < 0) {\r
1296       mysql_data_seek(handle->result, 0);\r
1297 \r
1298       handle->res_count = total;\r
1299     } else if (row < 0) {\r
1300       mysql_data_seek(handle->result, total + row);\r
1301       handle->res_count = -row;\r
1302     } else if (row >= total) {\r
1303       mysql_data_seek(handle->result, row);\r
1304       handle->res_count = 0;\r
1305     } else {\r
1306       mysql_data_seek(handle->result, row);\r
1307       handle->res_count = total - row;\r
1308     }\r
1309 \r
1310     Tcl_SetObjResult(interp, Tcl_NewIntObj(handle->res_count)) ;\r
1311     return TCL_OK;\r
1312 }\r
1313 \r
1314 \r
1315 /*\r
1316  *----------------------------------------------------------------------\r
1317  *\r
1318  * Mysqltcl_Map\r
1319  * Implements the mysqlmap command:\r
1320  * usage: mysqlmap handle binding-list script\r
1321  *                      \r
1322  * Results:\r
1323  * SIDE EFFECT: For each row the column values are bound to the variables\r
1324  * in the binding list and the script is evaluated.\r
1325  * The variables are created in the current context.\r
1326  * NOTE: mysqlmap works very much like a 'foreach' construct.\r
1327  * The 'continue' and 'break' commands may be used with their usual effect.\r
1328  */\r
1329 \r
1330 static int Mysqltcl_Map(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1331 {\r
1332   MysqltclState *statePtr = (MysqltclState *)clientData; \r
1333   int code ;\r
1334   int count ;\r
1335 \r
1336   MysqlTclHandle *handle;\r
1337   int idx;\r
1338   int listObjc;\r
1339   Tcl_Obj *tempObj,*varNameObj;\r
1340   MYSQL_ROW row;\r
1341   int *val;\r
1342   unsigned long *lengths;\r
1343   \r
1344   if ((handle = mysql_prologue(interp, objc, objv, 4, 4, CL_RES,\r
1345                             "handle binding-list script")) == 0)\r
1346     return TCL_ERROR;\r
1347 \r
1348   if (Tcl_ListObjLength(interp, objv[2], &listObjc) != TCL_OK)\r
1349         return TCL_ERROR ;\r
1350   \r
1351 \r
1352   if (listObjc > handle->col_count)\r
1353     {\r
1354       return mysql_prim_confl(interp,objc,objv,"too many variables in binding list") ;\r
1355     }\r
1356   else\r
1357     count = (listObjc < handle->col_count)?listObjc\r
1358       :handle->col_count ;\r
1359   \r
1360   val=(int*)Tcl_Alloc((count * sizeof(int)));\r
1361 \r
1362   for (idx=0; idx<count; idx++) {\r
1363     val[idx]=1;\r
1364     if (Tcl_ListObjIndex(interp, objv[2], idx, &varNameObj)!=TCL_OK)\r
1365         return TCL_ERROR;\r
1366     if (Tcl_GetStringFromObj(varNameObj,0)[0] != '-')\r
1367         val[idx]=1;\r
1368     else\r
1369         val[idx]=0;\r
1370   }\r
1371   \r
1372   while (handle->res_count > 0) {\r
1373     /* Get next row, decrement row counter. */\r
1374     if ((row = mysql_fetch_row(handle->result)) == NULL) {\r
1375       handle->res_count = 0 ;\r
1376       Tcl_Free((char *)val);\r
1377       return mysql_prim_confl(interp,objc,objv,"result counter out of sync") ;\r
1378     } else\r
1379       handle->res_count-- ;\r
1380       \r
1381     /* Bind variables to column values. */\r
1382     for (idx = 0; idx < count; idx++, row++) {\r
1383       lengths = mysql_fetch_lengths(handle->result);\r
1384       if (val[idx]) {\r
1385         tempObj = getRowCellAsObject(statePtr,handle,row,lengths[idx]);\r
1386         if (Tcl_ListObjIndex(interp, objv[2], idx, &varNameObj) != TCL_OK)\r
1387             goto error;\r
1388         if (Tcl_ObjSetVar2 (interp,varNameObj,NULL,tempObj,0) == NULL)\r
1389             goto error;\r
1390       }\r
1391     }\r
1392 \r
1393     /* Evaluate the script. */\r
1394     switch(code=Tcl_EvalObjEx(interp, objv[3],0)) {\r
1395     case TCL_CONTINUE:\r
1396     case TCL_OK:\r
1397       break ;\r
1398     case TCL_BREAK:\r
1399       Tcl_Free((char *)val);\r
1400       return TCL_OK ;\r
1401     default:\r
1402       Tcl_Free((char *)val);\r
1403       return code ;\r
1404     }\r
1405   }\r
1406   Tcl_Free((char *)val);\r
1407   return TCL_OK ;\r
1408 error:\r
1409   Tcl_Free((char *)val);\r
1410   return TCL_ERROR;    \r
1411 }\r
1412 \r
1413 /*\r
1414  *----------------------------------------------------------------------\r
1415  *\r
1416  * Mysqltcl_Receive\r
1417  * Implements the mysqlmap command:\r
1418  * usage: mysqlmap handle sqlquery binding-list script\r
1419  * \r
1420  * The method use internal mysql_use_result that no cache statment on client but\r
1421  * receive it direct from server \r
1422  *\r
1423  * Results:\r
1424  * SIDE EFFECT: For each row the column values are bound to the variables\r
1425  * in the binding list and the script is evaluated.\r
1426  * The variables are created in the current context.\r
1427  * NOTE: mysqlmap works very much like a 'foreach' construct.\r
1428  * The 'continue' and 'break' commands may be used with their usual effect.\r
1429 \r
1430  */\r
1431 \r
1432 static int Mysqltcl_Receive(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1433 {\r
1434   MysqltclState *statePtr = (MysqltclState *)clientData; \r
1435   int code=0;\r
1436   int count=0;\r
1437 \r
1438   MysqlTclHandle *handle;\r
1439   int idx;\r
1440   int listObjc;\r
1441   Tcl_Obj *tempObj,*varNameObj;\r
1442   MYSQL_ROW row;\r
1443   int *val = NULL;\r
1444   int breakLoop = 0;\r
1445   unsigned long *lengths;\r
1446   \r
1447   \r
1448   if ((handle = mysql_prologue(interp, objc, objv, 5, 5, CL_CONN,\r
1449                             "handle sqlquery binding-list script")) == 0)\r
1450     return TCL_ERROR;\r
1451   \r
1452   if (Tcl_ListObjLength(interp, objv[3], &listObjc) != TCL_OK)\r
1453         return TCL_ERROR;\r
1454   \r
1455   freeResult(handle);\r
1456   \r
1457   if (mysql_QueryTclObj(handle,objv[2])) {\r
1458     return mysql_server_confl(interp,objc,objv,handle->connection);\r
1459   }\r
1460 \r
1461   if ((handle->result = mysql_use_result(handle->connection)) == NULL) {\r
1462     return mysql_server_confl(interp,objc,objv,handle->connection);\r
1463   } else {\r
1464     while ((row = mysql_fetch_row(handle->result))!= NULL) {\r
1465       if (val==NULL) {\r
1466         /* first row compute all data */\r
1467         handle->col_count = mysql_num_fields(handle->result);\r
1468         if (listObjc > handle->col_count) {\r
1469           return mysql_prim_confl(interp,objc,objv,"too many variables in binding list") ;\r
1470         } else {\r
1471           count = (listObjc < handle->col_count)?listObjc:handle->col_count ;\r
1472         }\r
1473         val=(int*)Tcl_Alloc((count * sizeof(int)));\r
1474         for (idx=0; idx<count; idx++) {\r
1475           if (Tcl_ListObjIndex(interp, objv[3], idx, &varNameObj)!=TCL_OK)\r
1476             return TCL_ERROR;\r
1477           if (Tcl_GetStringFromObj(varNameObj,0)[0] != '-')\r
1478             val[idx]=1;\r
1479           else\r
1480             val[idx]=0;\r
1481         }       \r
1482       }\r
1483       for (idx = 0; idx < count; idx++, row++) {\r
1484          lengths = mysql_fetch_lengths(handle->result);\r
1485 \r
1486          if (val[idx]) {\r
1487             if (Tcl_ListObjIndex(interp, objv[3], idx, &varNameObj)!=TCL_OK) {\r
1488                 Tcl_Free((char *)val);\r
1489                 return TCL_ERROR;\r
1490             }\r
1491             tempObj = getRowCellAsObject(statePtr,handle,row,lengths[idx]);\r
1492             if (Tcl_ObjSetVar2 (interp,varNameObj,NULL,tempObj,TCL_LEAVE_ERR_MSG) == NULL) {\r
1493                Tcl_Free((char *)val);\r
1494                return TCL_ERROR ;\r
1495             }\r
1496          }\r
1497       }\r
1498       \r
1499       /* Evaluate the script. */\r
1500       switch(code=Tcl_EvalObjEx(interp, objv[4],0)) {\r
1501       case TCL_CONTINUE:\r
1502       case TCL_OK:\r
1503         break ;\r
1504       case TCL_BREAK:\r
1505         breakLoop=1;\r
1506         break;\r
1507       default:\r
1508         breakLoop=1;\r
1509         break;\r
1510       }\r
1511       if (breakLoop==1) break;\r
1512     }\r
1513   }\r
1514   if (val!=NULL) {\r
1515     Tcl_Free((char *)val);\r
1516   } \r
1517   /*  Read all rest rows that leave in error or break case */\r
1518   while ((row = mysql_fetch_row(handle->result))!= NULL);\r
1519   if (code!=TCL_CONTINUE && code!=TCL_OK && code!=TCL_BREAK) {\r
1520     return code;\r
1521   } else {\r
1522     return mysql_server_confl(interp,objc,objv,handle->connection);\r
1523   } \r
1524 }\r
1525 \r
1526 \r
1527 /*\r
1528  *----------------------------------------------------------------------\r
1529  *\r
1530  * Mysqltcl_Info\r
1531  * Implements the mysqlinfo command:\r
1532  * usage: mysqlinfo handle option\r
1533  *\r
1534 \r
1535 \r
1536  */\r
1537 \r
1538 static int Mysqltcl_Info(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1539 {\r
1540 \r
1541   int count ;\r
1542   MysqlTclHandle *handle;\r
1543   int idx ;\r
1544   MYSQL_RES* list ;\r
1545   MYSQL_ROW row ;\r
1546   const char* val ;\r
1547   Tcl_Obj *resList;\r
1548   static CONST char* MysqlDbOpt[] =\r
1549     {\r
1550       "dbname", "dbname?", "tables", "host", "host?", "databases",\r
1551       "info","serverversion",\r
1552 #if (MYSQL_VERSION_ID >= 40107)\r
1553       "serverversionid","sqlstate",\r
1554 #endif\r
1555       "state",NULL\r
1556     };\r
1557   enum dboption {\r
1558     MYSQL_INFNAME_OPT, MYSQL_INFNAMEQ_OPT, MYSQL_INFTABLES_OPT,\r
1559     MYSQL_INFHOST_OPT, MYSQL_INFHOSTQ_OPT, MYSQL_INFLIST_OPT, MYSQL_INFO,\r
1560     MYSQL_INF_SERVERVERSION,MYSQL_INFO_SERVERVERSION_ID,MYSQL_INFO_SQLSTATE,MYSQL_INFO_STATE\r
1561   };\r
1562   \r
1563   /* We can't fully check the handle at this stage. */\r
1564   if ((handle = mysql_prologue(interp, objc, objv, 3, 3, CL_PLAIN,\r
1565                             "handle option")) == 0)\r
1566     return TCL_ERROR;\r
1567 \r
1568   if (Tcl_GetIndexFromObj(interp, objv[2], MysqlDbOpt, "option",\r
1569                           TCL_EXACT, &idx) != TCL_OK)\r
1570     return TCL_ERROR;\r
1571 \r
1572   /* First check the handle. Checking depends on the option. */\r
1573   switch (idx) {\r
1574   case MYSQL_INFNAMEQ_OPT:\r
1575     if ((handle = get_handle(interp,objc,objv,CL_CONN))!=NULL) {\r
1576       if (handle->database[0] == '\0')\r
1577         return TCL_OK ; /* Return empty string if no current db. */\r
1578     }\r
1579     break ;\r
1580   case MYSQL_INFNAME_OPT:\r
1581   case MYSQL_INFTABLES_OPT:\r
1582   case MYSQL_INFHOST_OPT:\r
1583   case MYSQL_INFLIST_OPT:\r
1584     /* !!! */\r
1585     handle = get_handle(interp,objc,objv,CL_CONN);\r
1586     break;\r
1587   case MYSQL_INFO:\r
1588   case MYSQL_INF_SERVERVERSION:\r
1589 #if (MYSQL_VERSION_ID >= 40107)\r
1590   case MYSQL_INFO_SERVERVERSION_ID:\r
1591   case MYSQL_INFO_SQLSTATE:\r
1592 #endif\r
1593   case MYSQL_INFO_STATE:\r
1594     break;\r
1595 \r
1596   case MYSQL_INFHOSTQ_OPT:\r
1597     if (handle->connection == 0)\r
1598       return TCL_OK ; /* Return empty string if not connected. */\r
1599     break;\r
1600   default: /* should never happen */\r
1601     return mysql_prim_confl(interp,objc,objv,"weirdness in Mysqltcl_Info") ;\r
1602   }\r
1603   \r
1604   if (handle == 0) return TCL_ERROR ;\r
1605 \r
1606   /* Handle OK, return the requested info. */\r
1607   switch (idx) {\r
1608   case MYSQL_INFNAME_OPT:\r
1609   case MYSQL_INFNAMEQ_OPT:\r
1610     Tcl_SetObjResult(interp, Tcl_NewStringObj(handle->database, -1));\r
1611     break ;\r
1612   case MYSQL_INFTABLES_OPT:\r
1613     if ((list = mysql_list_tables(handle->connection,(char*)NULL)) == NULL)\r
1614       return mysql_server_confl(interp,objc,objv,handle->connection);\r
1615     \r
1616     resList = Tcl_GetObjResult(interp);\r
1617     for (count = mysql_num_rows(list); count > 0; count--) {\r
1618       val = *(row = mysql_fetch_row(list)) ;\r
1619       Tcl_ListObjAppendElement(interp, resList, Tcl_NewStringObj((val == NULL)?"":val,-1));\r
1620     }\r
1621     mysql_free_result(list) ;\r
1622     break ;\r
1623   case MYSQL_INFHOST_OPT:\r
1624 \r
1625   case MYSQL_INFHOSTQ_OPT:\r
1626     Tcl_SetObjResult(interp, Tcl_NewStringObj(mysql_get_host_info(handle->connection), -1));\r
1627     break ;\r
1628   case MYSQL_INFLIST_OPT:\r
1629     if ((list = mysql_list_dbs(handle->connection,(char*)NULL)) == NULL)\r
1630       return mysql_server_confl(interp,objc,objv,handle->connection);\r
1631     \r
1632     resList = Tcl_GetObjResult(interp);\r
1633     for (count = mysql_num_rows(list); count > 0; count--) {\r
1634       val = *(row = mysql_fetch_row(list)) ;\r
1635       Tcl_ListObjAppendElement(interp, resList,\r
1636                                 Tcl_NewStringObj((val == NULL)?"":val,-1));\r
1637     }\r
1638     mysql_free_result(list) ;\r
1639     break ;\r
1640   case MYSQL_INFO:\r
1641     val = mysql_info(handle->connection);\r
1642     if (val!=NULL) {\r
1643       Tcl_SetObjResult(interp, Tcl_NewStringObj(val,-1));      \r
1644     }\r
1645     break;\r
1646   case MYSQL_INF_SERVERVERSION:\r
1647      Tcl_SetObjResult(interp, Tcl_NewStringObj(mysql_get_server_info(handle->connection),-1));\r
1648      break;\r
1649 #if (MYSQL_VERSION_ID >= 40107)\r
1650   case MYSQL_INFO_SERVERVERSION_ID:\r
1651          Tcl_SetObjResult(interp, Tcl_NewIntObj(mysql_get_server_version(handle->connection)));\r
1652          break;\r
1653   case MYSQL_INFO_SQLSTATE:\r
1654      Tcl_SetObjResult(interp, Tcl_NewStringObj(mysql_sqlstate(handle->connection),-1));\r
1655      break;\r
1656 #endif\r
1657   case MYSQL_INFO_STATE:\r
1658      Tcl_SetObjResult(interp, Tcl_NewStringObj(mysql_stat(handle->connection),-1));\r
1659      break;\r
1660   default: /* should never happen */\r
1661     return mysql_prim_confl(interp,objc,objv,"weirdness in Mysqltcl_Info") ;\r
1662   }\r
1663 \r
1664   return TCL_OK ;\r
1665 }\r
1666 \r
1667 /*\r
1668  *----------------------------------------------------------------------\r
1669  *\r
1670  * Mysqltcl_BaseInfo\r
1671  * Implements the mysqlinfo command:\r
1672  * usage: mysqlbaseinfo option\r
1673  *\r
1674  */\r
1675 \r
1676 static int Mysqltcl_BaseInfo(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1677 {\r
1678   int idx ;\r
1679   Tcl_Obj *resList;\r
1680   char **option;\r
1681   static CONST char* MysqlInfoOpt[] =\r
1682     {\r
1683       "connectparameters", "clientversion",\r
1684 #if (MYSQL_VERSION_ID >= 40107)\r
1685       "clientversionid",\r
1686 #endif\r
1687       NULL\r
1688     };\r
1689   enum baseoption {\r
1690     MYSQL_BINFO_CONNECT, MYSQL_BINFO_CLIENTVERSION,MYSQL_BINFO_CLIENTVERSIONID\r
1691   };\r
1692 \r
1693   if (objc <2) {\r
1694       Tcl_WrongNumArgs(interp, 1, objv, "connectparameters | clientversion");\r
1695 \r
1696       return TCL_ERROR;\r
1697   }  \r
1698   if (Tcl_GetIndexFromObj(interp, objv[1], MysqlInfoOpt, "option",\r
1699                           TCL_EXACT, &idx) != TCL_OK)\r
1700     return TCL_ERROR;\r
1701 \r
1702   /* First check the handle. Checking depends on the option. */\r
1703   switch (idx) {\r
1704   case MYSQL_BINFO_CONNECT:\r
1705     option = (char **)MysqlConnectOpt;\r
1706     resList = Tcl_NewListObj(0, NULL);\r
1707 \r
1708     while (*option!=NULL) {\r
1709       Tcl_ListObjAppendElement(interp, resList, Tcl_NewStringObj(*option,-1));\r
1710       option++;\r
1711     }\r
1712     Tcl_SetObjResult(interp, resList);\r
1713     break ;\r
1714   case MYSQL_BINFO_CLIENTVERSION:\r
1715     Tcl_SetObjResult(interp, Tcl_NewStringObj(mysql_get_client_info(),-1));\r
1716     break;\r
1717 #if (MYSQL_VERSION_ID >= 40107)\r
1718   case MYSQL_BINFO_CLIENTVERSIONID:\r
1719     Tcl_SetObjResult(interp, Tcl_NewIntObj(mysql_get_client_version()));\r
1720     break;\r
1721 #endif\r
1722   }\r
1723   return TCL_OK ;\r
1724 }\r
1725 \r
1726 \r
1727 /*\r
1728  *----------------------------------------------------------------------\r
1729  *\r
1730  * Mysqltcl_Result\r
1731 \r
1732  * Implements the mysqlresult command:\r
1733  * usage: mysqlresult handle option\r
1734  *\r
1735  */\r
1736 \r
1737 static int Mysqltcl_Result(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1738 {\r
1739   int idx ;\r
1740   MysqlTclHandle *handle;\r
1741   static CONST char* MysqlResultOpt[] =\r
1742     {\r
1743      "rows", "rows?", "cols", "cols?", "current", "current?", NULL\r
1744     };\r
1745   enum resultoption {\r
1746     MYSQL_RESROWS_OPT, MYSQL_RESROWSQ_OPT, MYSQL_RESCOLS_OPT, \r
1747     MYSQL_RESCOLSQ_OPT, MYSQL_RESCUR_OPT, MYSQL_RESCURQ_OPT\r
1748   };\r
1749   /* We can't fully check the handle at this stage. */\r
1750   if ((handle = mysql_prologue(interp, objc, objv, 3, 3, CL_PLAIN,\r
1751                             " handle option")) == 0)\r
1752 \r
1753     return TCL_ERROR;\r
1754 \r
1755   if (Tcl_GetIndexFromObj(interp, objv[2], MysqlResultOpt, "option",\r
1756                           TCL_EXACT, &idx) != TCL_OK)\r
1757     return TCL_ERROR;\r
1758 \r
1759   /* First check the handle. Checking depends on the option. */\r
1760   switch (idx) {\r
1761   case MYSQL_RESROWS_OPT:\r
1762   case MYSQL_RESCOLS_OPT:\r
1763   case MYSQL_RESCUR_OPT:\r
1764     handle = get_handle(interp,objc,objv,CL_RES) ;\r
1765     break ;\r
1766   case MYSQL_RESROWSQ_OPT:\r
1767   case MYSQL_RESCOLSQ_OPT:\r
1768   case MYSQL_RESCURQ_OPT:\r
1769     if ((handle = get_handle(interp,objc,objv,CL_RES))== NULL)\r
1770       return TCL_OK ; /* Return empty string if no pending result. */\r
1771     break ;\r
1772   default: /* should never happen */\r
1773     return mysql_prim_confl(interp,objc,objv,"weirdness in Mysqltcl_Result") ;\r
1774   }\r
1775   \r
1776   \r
1777   if (handle == 0)\r
1778     return TCL_ERROR ;\r
1779 \r
1780   /* Handle OK; return requested info. */\r
1781   switch (idx) {\r
1782   case MYSQL_RESROWS_OPT:\r
1783   case MYSQL_RESROWSQ_OPT:\r
1784     Tcl_SetObjResult(interp, Tcl_NewIntObj(handle->res_count));\r
1785     break ;\r
1786   case MYSQL_RESCOLS_OPT:\r
1787   case MYSQL_RESCOLSQ_OPT:\r
1788     Tcl_SetObjResult(interp, Tcl_NewIntObj(handle->col_count));\r
1789     break ;\r
1790   case MYSQL_RESCUR_OPT:\r
1791   case MYSQL_RESCURQ_OPT:\r
1792     Tcl_SetObjResult(interp,\r
1793                        Tcl_NewIntObj(mysql_num_rows(handle->result)\r
1794                                      - handle->res_count)) ;\r
1795     break ;\r
1796   default:\r
1797     return mysql_prim_confl(interp,objc,objv,"weirdness in Mysqltcl_Result");\r
1798   }\r
1799   return TCL_OK ;\r
1800 }\r
1801 \r
1802 \r
1803 /*\r
1804  *----------------------------------------------------------------------\r
1805  *\r
1806  * Mysqltcl_Col\r
1807 \r
1808  *    Implements the mysqlcol command:\r
1809  *    usage: mysqlcol handle table-name option ?option ...?\r
1810  *           mysqlcol handle -current option ?option ...?\r
1811  * '-current' can only be used if there is a pending result.\r
1812  *                      \r
1813  *    results:\r
1814  *      List of lists containing column attributes.\r
1815  *      If a single attribute is requested the result is a simple list.\r
1816  *\r
1817  * SIDE EFFECT: '-current' disturbs the field position of the result.\r
1818  */\r
1819 \r
1820 static int Mysqltcl_Col(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1821 {\r
1822   int coln ;\r
1823   int current_db ;\r
1824   MysqlTclHandle *handle;\r
1825   int idx ;\r
1826   int listObjc ;\r
1827   Tcl_Obj **listObjv, *colinfo, *resList, *resSubList;\r
1828   MYSQL_FIELD* fld ;\r
1829   MYSQL_RES* result ;\r
1830   char *argv ;\r
1831   \r
1832   /* This check is enough only without '-current'. */\r
1833   if ((handle = mysql_prologue(interp, objc, objv, 4, 99, CL_CONN,\r
1834                             "handle table-name option ?option ...?")) == 0)\r
1835     return TCL_ERROR;\r
1836 \r
1837   /* Fetch column info.\r
1838    * Two ways: explicit database and table names, or current.\r
1839    */\r
1840   argv=Tcl_GetStringFromObj(objv[2],NULL);\r
1841   current_db = strcmp(argv, "-current") == 0;\r
1842   \r
1843   if (current_db) {\r
1844     if ((handle = get_handle(interp,objc,objv,CL_RES)) == 0)\r
1845       return TCL_ERROR ;\r
1846     else\r
1847       result = handle->result ;\r
1848   } else {\r
1849     if ((result = mysql_list_fields(handle->connection, argv, (char*)NULL)) == NULL) {\r
1850       return mysql_server_confl(interp,objc,objv,handle->connection) ;\r
1851     }\r
1852   }\r
1853   /* Must examine the first specifier at this point. */\r
1854   if (Tcl_ListObjGetElements(interp, objv[3], &listObjc, &listObjv) != TCL_OK)\r
1855     return TCL_ERROR ;\r
1856   resList = Tcl_GetObjResult(interp);\r
1857   if (objc == 4 && listObjc == 1) {\r
1858       mysql_field_seek(result, 0) ;\r
1859       while ((fld = mysql_fetch_field(result)) != NULL)\r
1860         if ((colinfo = mysql_colinfo(interp,objc,objv,fld, objv[3])) != NULL) {\r
1861             Tcl_ListObjAppendElement(interp, resList, colinfo);\r
1862         } else {\r
1863             goto conflict;\r
1864             }\r
1865   } else if (objc == 4 && listObjc > 1) {\r
1866       mysql_field_seek(result, 0) ;\r
1867       while ((fld = mysql_fetch_field(result)) != NULL) {\r
1868         resSubList = Tcl_NewListObj(0, NULL);\r
1869         for (coln = 0; coln < listObjc; coln++)\r
1870             if ((colinfo = mysql_colinfo(interp,objc,objv,fld, listObjv[coln])) != NULL) {\r
1871                 Tcl_ListObjAppendElement(interp, resSubList, colinfo);\r
1872             } else {\r
1873 \r
1874                goto conflict; \r
1875             }\r
1876         Tcl_ListObjAppendElement(interp, resList, resSubList);\r
1877         }\r
1878   } else {\r
1879       for (idx = 3; idx < objc; idx++) {\r
1880         resSubList = Tcl_NewListObj(0, NULL);\r
1881         mysql_field_seek(result, 0) ;\r
1882         while ((fld = mysql_fetch_field(result)) != NULL)\r
1883         if ((colinfo = mysql_colinfo(interp,objc,objv,fld, objv[idx])) != NULL) {\r
1884 \r
1885             Tcl_ListObjAppendElement(interp, resSubList, colinfo);\r
1886         } else {\r
1887             goto conflict; \r
1888         }\r
1889         Tcl_ListObjAppendElement(interp, resList, resSubList);\r
1890       }\r
1891   }\r
1892   if (!current_db) mysql_free_result(result) ;\r
1893   return TCL_OK;\r
1894   \r
1895   conflict:\r
1896     if (!current_db) mysql_free_result(result) ;\r
1897     return TCL_ERROR;\r
1898 }\r
1899 \r
1900 \r
1901 /*\r
1902  *----------------------------------------------------------------------\r
1903  *\r
1904  * Mysqltcl_State\r
1905  *    Implements the mysqlstate command:\r
1906  *    usage: mysqlstate handle ?-numeric?\r
1907 \r
1908  *                      \r
1909  */\r
1910 \r
1911 static int Mysqltcl_State(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1912 {\r
1913   MysqlTclHandle *handle;\r
1914   int numeric=0 ;\r
1915   Tcl_Obj *res;\r
1916 \r
1917   if (objc!=2 && objc!=3) {\r
1918       Tcl_WrongNumArgs(interp, 1, objv, "handle ?-numeric");\r
1919       return TCL_ERROR;\r
1920   }\r
1921 \r
1922   if (objc==3) {\r
1923     if (strcmp(Tcl_GetStringFromObj(objv[2],NULL), "-numeric"))\r
1924       return mysql_prim_confl(interp,objc,objv,"last parameter should be -numeric");\r
1925     else\r
1926 \r
1927       numeric=1;\r
1928   }\r
1929   \r
1930   if (GetHandleFromObj(interp, objv[1], &handle) != TCL_OK)\r
1931     res = (numeric)?Tcl_NewIntObj(0):Tcl_NewStringObj("NOT_A_HANDLE",-1);\r
1932   else if (handle->connection == 0)\r
1933     res = (numeric)?Tcl_NewIntObj(1):Tcl_NewStringObj("UNCONNECTED",-1);\r
1934   else if (handle->database[0] == '\0')\r
1935     res = (numeric)?Tcl_NewIntObj(2):Tcl_NewStringObj("CONNECTED",-1);\r
1936   else if (handle->result == NULL)\r
1937     res = (numeric)?Tcl_NewIntObj(3):Tcl_NewStringObj("IN_USE",-1);\r
1938   else\r
1939     res = (numeric)?Tcl_NewIntObj(4):Tcl_NewStringObj("RESULT_PENDING",-1);\r
1940 \r
1941   Tcl_SetObjResult(interp, res);\r
1942   return TCL_OK ;\r
1943 }\r
1944 \r
1945 \r
1946 /*\r
1947  *----------------------------------------------------------------------\r
1948  *\r
1949  * Mysqltcl_InsertId\r
1950  *    Implements the mysqlstate command:\r
1951  *    usage: mysqlinsertid handle \r
1952  *    Returns the auto increment id of the last INSERT statement\r
1953  *                      \r
1954  */\r
1955 \r
1956 static int Mysqltcl_InsertId(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1957 {\r
1958 \r
1959   MysqlTclHandle *handle;\r
1960   \r
1961   if ((handle = mysql_prologue(interp, objc, objv, 2, 2, CL_CONN,\r
1962                             "handle")) == 0)\r
1963     return TCL_ERROR;\r
1964 \r
1965   Tcl_SetObjResult(interp, Tcl_NewIntObj(mysql_insert_id(handle->connection)));\r
1966 \r
1967   return TCL_OK;\r
1968 }\r
1969 \r
1970 /*\r
1971  *----------------------------------------------------------------------\r
1972  *\r
1973  * Mysqltcl_Ping\r
1974  *    usage: mysqlping handle\r
1975  *    It can be used to check and refresh (reconnect after time out) the connection\r
1976  *    Returns 0 if connection is OK\r
1977  */\r
1978 \r
1979 \r
1980 static int Mysqltcl_Ping(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
1981 {\r
1982   MysqlTclHandle *handle;\r
1983   \r
1984   if ((handle = mysql_prologue(interp, objc, objv, 2, 2, CL_CONN,\r
1985                             "handle")) == 0)\r
1986     return TCL_ERROR;\r
1987 \r
1988   Tcl_SetObjResult(interp, Tcl_NewBooleanObj(mysql_ping(handle->connection)==0));\r
1989 \r
1990   return TCL_OK;\r
1991 }\r
1992 \r
1993 /*\r
1994  *----------------------------------------------------------------------\r
1995  *\r
1996  * Mysqltcl_ChangeUser\r
1997  *    usage: mysqlchangeuser handle user password database\r
1998  *    return TCL_ERROR if operation failed\r
1999  */\r
2000 \r
2001 static int Mysqltcl_ChangeUser(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2002 {\r
2003   MysqlTclHandle *handle;\r
2004   int len;\r
2005   char *user,*password,*database=NULL;\r
2006   \r
2007   if ((handle = mysql_prologue(interp, objc, objv, 4, 5, CL_CONN,\r
2008                             "handle user password ?database?")) == 0)\r
2009     return TCL_ERROR;\r
2010 \r
2011   user = Tcl_GetStringFromObj(objv[2],NULL);\r
2012   password = Tcl_GetStringFromObj(objv[3],NULL);\r
2013   if (objc==5) {\r
2014     database = Tcl_GetStringFromObj(objv[4],&len);\r
2015     if (len >= MYSQL_NAME_LEN) {\r
2016        mysql_prim_confl(interp,objc,objv,"database name too long");\r
2017        return TCL_ERROR;\r
2018     }\r
2019   }\r
2020   if (mysql_change_user(handle->connection, user, password, database)!=0) {\r
2021       mysql_server_confl(interp,objc,objv,handle->connection);\r
2022       return TCL_ERROR;\r
2023   }\r
2024   if (database!=NULL) \r
2025           strcpy(handle->database, database);\r
2026   return TCL_OK;\r
2027 }\r
2028 /*\r
2029  *----------------------------------------------------------------------\r
2030  *\r
2031  * Mysqltcl_AutoCommit\r
2032  *    usage: mysql::autocommit bool\r
2033  *    set autocommit mode\r
2034  */\r
2035 \r
2036 static int Mysqltcl_AutoCommit(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2037 {\r
2038 #if (MYSQL_VERSION_ID < 40107)\r
2039   Tcl_AddErrorInfo(interp, FUNCTION_NOT_AVAILABLE);\r
2040   return TCL_ERROR;\r
2041 #else\r
2042   MysqlTclHandle *handle;\r
2043   int isAutocommit = 0;\r
2044 \r
2045   if ((handle = mysql_prologue(interp, objc, objv, 3, 3, CL_CONN,\r
2046                             "handle bool")) == 0)\r
2047         return TCL_ERROR;\r
2048   if (Tcl_GetBooleanFromObj(interp,objv[2],&isAutocommit) != TCL_OK )\r
2049         return TCL_ERROR;\r
2050   if (mysql_autocommit(handle->connection, isAutocommit)!=0) {\r
2051         mysql_server_confl(interp,objc,objv,handle->connection);\r
2052   }\r
2053   return TCL_OK;\r
2054 #endif\r
2055 }\r
2056 /*\r
2057  *----------------------------------------------------------------------\r
2058  *\r
2059  * Mysqltcl_Commit\r
2060  *    usage: mysql::commit\r
2061  *    \r
2062  */\r
2063 \r
2064 static int Mysqltcl_Commit(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2065 {\r
2066 #if (MYSQL_VERSION_ID < 40107)\r
2067   Tcl_AddErrorInfo(interp, FUNCTION_NOT_AVAILABLE);\r
2068   return TCL_ERROR;\r
2069 #else\r
2070   MysqlTclHandle *handle;\r
2071 \r
2072   if ((handle = mysql_prologue(interp, objc, objv, 2, 2, CL_CONN,\r
2073                             "handle")) == 0)\r
2074     return TCL_ERROR;\r
2075   if (mysql_commit(handle->connection)!=0) {\r
2076         mysql_server_confl(interp,objc,objv,handle->connection);\r
2077   }\r
2078   return TCL_OK;\r
2079 #endif\r
2080 }\r
2081 /*\r
2082  *----------------------------------------------------------------------\r
2083  *\r
2084  * Mysqltcl_Rollback\r
2085  *    usage: mysql::rollback\r
2086  *\r
2087  */\r
2088 \r
2089 static int Mysqltcl_Rollback(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2090 {\r
2091 #if (MYSQL_VERSION_ID < 40107)\r
2092   Tcl_AddErrorInfo(interp, FUNCTION_NOT_AVAILABLE);\r
2093   return TCL_ERROR;\r
2094 #else\r
2095   MysqlTclHandle *handle;\r
2096 \r
2097   if ((handle = mysql_prologue(interp, objc, objv, 2, 2, CL_CONN,\r
2098                             "handle")) == 0)\r
2099     return TCL_ERROR;\r
2100   if (mysql_rollback(handle->connection)!=0) {\r
2101       mysql_server_confl(interp,objc,objv,handle->connection);\r
2102   }\r
2103   return TCL_OK;\r
2104 #endif\r
2105 }\r
2106 /*\r
2107  *----------------------------------------------------------------------\r
2108  *\r
2109  * Mysqltcl_MoreResult\r
2110  *    usage: mysql::moreresult handle\r
2111  *    return true if more results exists\r
2112  */\r
2113 \r
2114 static int Mysqltcl_MoreResult(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2115 {\r
2116 #if (MYSQL_VERSION_ID < 40107)\r
2117   Tcl_AddErrorInfo(interp, FUNCTION_NOT_AVAILABLE);\r
2118   return TCL_ERROR;\r
2119 #else\r
2120   MysqlTclHandle *handle;\r
2121   int boolResult = 0;\r
2122 \r
2123   if ((handle = mysql_prologue(interp, objc, objv, 2, 2, CL_RES,\r
2124                             "handle")) == 0)\r
2125     return TCL_ERROR;\r
2126   boolResult =  mysql_more_results(handle->connection);\r
2127   Tcl_SetObjResult(interp,Tcl_NewBooleanObj(boolResult));\r
2128   return TCL_OK;\r
2129 #endif\r
2130 }\r
2131 /*\r
2132 \r
2133  *----------------------------------------------------------------------\r
2134  *\r
2135  * Mysqltcl_NextResult\r
2136  *    usage: mysql::nextresult\r
2137  *\r
2138  *  return nummber of rows in result set. 0 if no next result\r
2139  */\r
2140 \r
2141 static int Mysqltcl_NextResult(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2142 {\r
2143 #if (MYSQL_VERSION_ID < 40107)\r
2144   Tcl_AddErrorInfo(interp, FUNCTION_NOT_AVAILABLE);\r
2145   return TCL_ERROR;\r
2146 #else\r
2147   MysqlTclHandle *handle;\r
2148   int result = 0;\r
2149 \r
2150   if ((handle = mysql_prologue(interp, objc, objv, 2, 2, CL_RES,\r
2151                             "handle")) == 0)\r
2152     return TCL_ERROR;\r
2153   if (handle->result != NULL) {\r
2154     mysql_free_result(handle->result) ;\r
2155     handle->result = NULL ;\r
2156   }\r
2157   result = mysql_next_result(handle->connection);\r
2158   if (result==-1) {\r
2159       Tcl_SetObjResult(interp, Tcl_NewIntObj(0));\r
2160       return TCL_OK;\r
2161   }\r
2162   if (result<0) {\r
2163       return mysql_server_confl(interp,objc,objv,handle->connection);\r
2164   }\r
2165   handle->result = mysql_store_result(handle->connection);\r
2166   handle->col_count = mysql_num_fields(handle->result);\r
2167   if (handle->result == NULL) {\r
2168       Tcl_SetObjResult(interp, Tcl_NewIntObj(-1));\r
2169   } else {\r
2170       handle->res_count = mysql_num_rows(handle->result);\r
2171       Tcl_SetObjResult(interp, Tcl_NewIntObj(handle->res_count));\r
2172   }\r
2173   return TCL_OK;\r
2174 #endif\r
2175 }\r
2176 /*\r
2177  *----------------------------------------------------------------------\r
2178  *\r
2179  * Mysqltcl_WarningCount\r
2180  *    usage: mysql::warningcount\r
2181  *\r
2182  */\r
2183 \r
2184 static int Mysqltcl_WarningCount(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2185 {\r
2186 #if (MYSQL_VERSION_ID < 40107)\r
2187   Tcl_AddErrorInfo(interp, FUNCTION_NOT_AVAILABLE);\r
2188   return TCL_ERROR;\r
2189 #else\r
2190   MysqlTclHandle *handle;\r
2191   int count = 0;\r
2192 \r
2193   if ((handle = mysql_prologue(interp, objc, objv, 2, 2, CL_CONN,\r
2194                             "handle")) == 0)\r
2195     return TCL_ERROR;\r
2196   count = mysql_warning_count(handle->connection);\r
2197   Tcl_SetObjResult(interp,Tcl_NewIntObj(count));\r
2198   return TCL_OK;\r
2199 #endif\r
2200 }\r
2201 /*\r
2202  *----------------------------------------------------------------------\r
2203  *\r
2204  * Mysqltcl_IsNull\r
2205  *    usage: mysql::isnull value\r
2206  *\r
2207  */\r
2208 \r
2209 static int Mysqltcl_IsNull(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2210 {\r
2211   int boolResult = 0;\r
2212   if (objc != 2) {\r
2213       Tcl_WrongNumArgs(interp, 1, objv, "value");\r
2214       return TCL_ERROR;\r
2215   }\r
2216   boolResult = objv[1]->typePtr == &mysqlNullType;\r
2217   Tcl_SetObjResult(interp,Tcl_NewBooleanObj(boolResult));\r
2218   return TCL_OK;\r
2219 \r
2220   return TCL_OK;\r
2221 }\r
2222 /*\r
2223  * Create new Mysql NullObject\r
2224  * (similar to Tcl API for example Tcl_NewIntObj)\r
2225  */\r
2226 static Tcl_Obj *Mysqltcl_NewNullObj(MysqltclState *mysqltclState) {\r
2227   Tcl_Obj *objPtr;\r
2228   objPtr = Tcl_NewObj();\r
2229   objPtr->bytes = NULL;\r
2230   objPtr->typePtr = &mysqlNullType;\r
2231   objPtr->internalRep.otherValuePtr = mysqltclState;\r
2232   return objPtr;\r
2233 }\r
2234 /*\r
2235  *----------------------------------------------------------------------\r
2236  *\r
2237  * Mysqltcl_NewNull\r
2238  *    usage: mysql::newnull\r
2239  *\r
2240  */\r
2241 \r
2242 static int Mysqltcl_NewNull(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2243 {\r
2244   if (objc != 1) {\r
2245       Tcl_WrongNumArgs(interp, 1, objv, "");\r
2246       return TCL_ERROR;\r
2247   }\r
2248   Tcl_SetObjResult(interp,Mysqltcl_NewNullObj((MysqltclState *)clientData));\r
2249   return TCL_OK;\r
2250 }\r
2251 /*\r
2252  *----------------------------------------------------------------------\r
2253  *\r
2254  * Mysqltcl_SetServerOption\r
2255  *    usage: mysql::setserveroption (-\r
2256  *\r
2257  */\r
2258 #if (MYSQL_VERSION_ID >= 40107)\r
2259 static CONST char* MysqlServerOpt[] =\r
2260     {\r
2261       "-multi_statment_on", "-multi_statment_off", "-auto_reconnect_on", "-auto_reconnect_off", NULL\r
2262     };\r
2263 #endif\r
2264  \r
2265 static int Mysqltcl_SetServerOption(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2266 {\r
2267 #if (MYSQL_VERSION_ID < 40107)\r
2268   Tcl_AddErrorInfo(interp, FUNCTION_NOT_AVAILABLE);\r
2269   return TCL_ERROR;\r
2270 #else\r
2271   MysqlTclHandle *handle;\r
2272   int idx;\r
2273   enum enum_mysql_set_option mysqlServerOption;\r
2274   \r
2275   enum serveroption {\r
2276     MYSQL_MSTATMENT_ON_SOPT, MYSQL_MSTATMENT_OFF_SOPT\r
2277   };\r
2278 \r
2279   if ((handle = mysql_prologue(interp, objc, objv, 3, 3, CL_CONN,\r
2280                             "handle option")) == 0)\r
2281     return TCL_ERROR;\r
2282 \r
2283   if (Tcl_GetIndexFromObj(interp, objv[2], MysqlServerOpt, "option",\r
2284                           0, &idx) != TCL_OK)\r
2285       return TCL_ERROR;\r
2286 \r
2287   switch (idx) {\r
2288     case MYSQL_MSTATMENT_ON_SOPT:\r
2289       mysqlServerOption = MYSQL_OPTION_MULTI_STATEMENTS_ON;\r
2290       break;\r
2291     case MYSQL_MSTATMENT_OFF_SOPT:\r
2292       mysqlServerOption = MYSQL_OPTION_MULTI_STATEMENTS_OFF;\r
2293       break;\r
2294     default:\r
2295       return mysql_prim_confl(interp,objc,objv,"Weirdness in server options");\r
2296   }\r
2297   if (mysql_set_server_option(handle->connection,mysqlServerOption)!=0) {\r
2298         mysql_server_confl(interp,objc,objv,handle->connection);\r
2299   }\r
2300   return TCL_OK;\r
2301 #endif\r
2302 }\r
2303 /*\r
2304  *----------------------------------------------------------------------\r
2305  *\r
2306  * Mysqltcl_ShutDown\r
2307  *    usage: mysql::shutdown handle\r
2308  *\r
2309  */\r
2310 static int Mysqltcl_ShutDown(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2311 {\r
2312   MysqlTclHandle *handle;\r
2313 \r
2314   if ((handle = mysql_prologue(interp, objc, objv, 2, 2, CL_CONN,\r
2315                             "handle")) == 0)\r
2316     return TCL_ERROR;\r
2317 #if (MYSQL_VERSION_ID >= 40107)\r
2318   if (mysql_shutdown(handle->connection,SHUTDOWN_DEFAULT)!=0) {\r
2319 #else\r
2320   if (mysql_shutdown(handle->connection)!=0) {\r
2321 #endif\r
2322         mysql_server_confl(interp,objc,objv,handle->connection);\r
2323   }\r
2324   return TCL_OK;\r
2325 }\r
2326 /*\r
2327  *----------------------------------------------------------------------\r
2328  *\r
2329  * Mysqltcl_Encoding\r
2330  *    usage: mysql::encoding handle ?encoding|binary?\r
2331  *\r
2332  */\r
2333 static int Mysqltcl_Encoding(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2334 {\r
2335   MysqltclState *statePtr = (MysqltclState *)clientData;\r
2336   Tcl_HashSearch search;\r
2337   Tcl_HashEntry *entryPtr;\r
2338   MysqlTclHandle *handle,*qhandle;\r
2339   char *encodingname;\r
2340   Tcl_Encoding encoding;\r
2341   \r
2342   if ((handle = mysql_prologue(interp, objc, objv, 2, 3, CL_CONN,\r
2343                             "handle")) == 0)\r
2344         return TCL_ERROR;\r
2345   if (objc==2) {\r
2346       if (handle->encoding == NULL)\r
2347          Tcl_SetObjResult(interp, Tcl_NewStringObj("binary",-1));\r
2348       else \r
2349          Tcl_SetObjResult(interp, Tcl_NewStringObj(Tcl_GetEncodingName(handle->encoding),-1));\r
2350   } else {\r
2351       if (handle->type!=HT_CONNECTION) {\r
2352             Tcl_SetObjResult(interp, Tcl_NewStringObj("encoding set can be used only on connection handle",-1));\r
2353             return TCL_ERROR;\r
2354       }\r
2355       encodingname = Tcl_GetStringFromObj(objv[2],NULL);\r
2356       if (strcmp(encodingname, "binary") == 0) {\r
2357          encoding = NULL;       \r
2358       } else {\r
2359          encoding = Tcl_GetEncoding(interp, encodingname);\r
2360          if (encoding == NULL)\r
2361              return TCL_ERROR;\r
2362       }\r
2363       if (handle->encoding!=NULL)\r
2364           Tcl_FreeEncoding(handle->encoding);\r
2365       handle->encoding = encoding;\r
2366 \r
2367       /* change encoding of all subqueries */\r
2368       for (entryPtr=Tcl_FirstHashEntry(&statePtr->hash,&search);\r
2369                entryPtr!=NULL;\r
2370                 entryPtr=Tcl_NextHashEntry(&search)) {\r
2371             qhandle=(MysqlTclHandle *)Tcl_GetHashValue(entryPtr);\r
2372             if (qhandle->type==HT_QUERY && handle->connection==qhandle->connection) {\r
2373                 qhandle->encoding = encoding;\r
2374             }\r
2375       }\r
2376 \r
2377   }\r
2378   return TCL_OK;\r
2379 }\r
2380 /*\r
2381  *----------------------------------------------------------------------\r
2382  *\r
2383  * Mysqltcl_Close --\r
2384  *    Implements the mysqlclose command:\r
2385  *    usage: mysqlclose ?handle?\r
2386  *                      \r
2387  *    results:\r
2388  *      null string\r
2389  */\r
2390 \r
2391 static int Mysqltcl_Close(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2392 \r
2393 {\r
2394   MysqltclState *statePtr = (MysqltclState *)clientData; \r
2395   MysqlTclHandle *handle,*thandle;\r
2396   Tcl_HashEntry *entryPtr;\r
2397   Tcl_HashEntry *qentries[16];\r
2398   Tcl_HashSearch search;\r
2399 \r
2400   int i,qfound = 0;\r
2401 \r
2402 \r
2403   /* If handle omitted, close all connections. */\r
2404   if (objc == 1) {\r
2405       Mysqltcl_CloseAll(clientData) ;\r
2406       return TCL_OK ;\r
2407   }\r
2408   \r
2409   if ((handle = mysql_prologue(interp, objc, objv, 2, 2, CL_CONN,\r
2410                             "?handle?")) == 0)\r
2411     return TCL_ERROR;\r
2412 \r
2413 \r
2414   /* Search all queries and statements on this handle and close those */\r
2415   if (handle->type==HT_CONNECTION)  {\r
2416     while (1) {\r
2417       for (entryPtr=Tcl_FirstHashEntry(&statePtr->hash,&search); \r
2418            entryPtr!=NULL;\r
2419            entryPtr=Tcl_NextHashEntry(&search)) {\r
2420 \r
2421         thandle=(MysqlTclHandle *)Tcl_GetHashValue(entryPtr);\r
2422         if (thandle->connection == handle->connection &&\r
2423             thandle->type!=HT_CONNECTION) {\r
2424           qentries[qfound++] = entryPtr;\r
2425         }\r
2426         if (qfound==16) break;\r
2427       }\r
2428       if (qfound>0) {\r
2429         for(i=0;i<qfound;i++) {\r
2430           entryPtr=qentries[i];\r
2431           thandle=(MysqlTclHandle *)Tcl_GetHashValue(entryPtr);\r
2432           Tcl_DeleteHashEntry(entryPtr);\r
2433           closeHandle(thandle);\r
2434         }\r
2435       }\r
2436       if (qfound!=16) break;\r
2437       qfound = 0;\r
2438     }\r
2439   }\r
2440   entryPtr = Tcl_FindHashEntry(&statePtr->hash,Tcl_GetStringFromObj(objv[1],NULL));\r
2441   if (entryPtr) Tcl_DeleteHashEntry(entryPtr);\r
2442   closeHandle(handle);\r
2443   return TCL_OK;\r
2444 }\r
2445 \r
2446 #ifdef PREPARED_STATEMENT\r
2447 /*\r
2448  *----------------------------------------------------------------------\r
2449  *\r
2450  * Mysqltcl_Prepare --\r
2451  *    Implements the mysql::prepare command:\r
2452  *    usage: mysql::prepare handle statements\r
2453  *\r
2454  *    results:\r
2455  *          prepared statment handle\r
2456  */\r
2457 \r
2458 static int Mysqltcl_Prepare(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2459 {\r
2460   MysqltclState *statePtr = (MysqltclState *)clientData;\r
2461 \r
2462   MysqlTclHandle *handle;\r
2463   MysqlTclHandle *shandle;\r
2464   MYSQL_STMT *statement;\r
2465   char *query;\r
2466   int queryLen;\r
2467   int resultColumns;\r
2468   int paramCount;\r
2469 \r
2470   if ((handle = mysql_prologue(interp, objc, objv, 3, 3, CL_CONN,\r
2471                             "handle sql-statement")) == 0)\r
2472     return TCL_ERROR;\r
2473 \r
2474   statement = mysql_stmt_init(handle->connection);\r
2475   if (statement==NULL) {\r
2476         return TCL_ERROR;\r
2477   }\r
2478   query = (char *)Tcl_GetByteArrayFromObj(objv[2], &queryLen);\r
2479   if (mysql_stmt_prepare(statement,query,queryLen)) {\r
2480 \r
2481         mysql_stmt_close(statement);\r
2482     return mysql_server_confl(interp,objc,objv,handle->connection);\r
2483   }\r
2484   if ((shandle = createHandleFrom(statePtr,handle,HT_STATEMENT)) == NULL) return TCL_ERROR;\r
2485   shandle->statement=statement;\r
2486   shandle->resultMetadata = mysql_stmt_result_metadata(statement);\r
2487   shandle->paramMetadata = mysql_stmt_param_metadata(statement);\r
2488   /* set result bind memory */\r
2489   resultColumns = mysql_stmt_field_count(statement);\r
2490   if (resultColumns>0) {\r
2491         shandle->bindResult = (MYSQL_BIND *)Tcl_Alloc(sizeof(MYSQL_BIND)*resultColumns);\r
2492     memset(shandle->bindResult,0,sizeof(MYSQL_BIND)*resultColumns);\r
2493   }\r
2494   paramCount = mysql_stmt_param_count(statement);\r
2495   if (resultColumns>0) {\r
2496         shandle->bindParam = (MYSQL_BIND *)Tcl_Alloc(sizeof(MYSQL_BIND)*paramCount);\r
2497     memset(shandle->bindParam,0,sizeof(MYSQL_BIND)*paramCount);\r
2498   }\r
2499   Tcl_SetObjResult(interp, Tcl_NewHandleObj(statePtr,shandle));\r
2500   return TCL_OK;\r
2501 }\r
2502 static int Mysqltcl_ParamMetaData(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2503 {\r
2504   MysqltclState *statePtr = (MysqltclState *)clientData;\r
2505   MysqlTclHandle *handle;\r
2506   MYSQL_RES *res;\r
2507   MYSQL_ROW row;\r
2508   Tcl_Obj *colinfo,*resObj;\r
2509   unsigned long *lengths;\r
2510   int i;\r
2511   int colCount;\r
2512   MYSQL_FIELD* fld;\r
2513 \r
2514   if ((handle = mysql_prologue(interp, objc, objv, 3, 3, CL_CONN,\r
2515                             "statement-handle")) == 0)\r
2516     return TCL_ERROR;\r
2517   if(handle->type!=HT_STATEMENT)\r
2518         return TCL_ERROR;\r
2519 \r
2520   resObj = Tcl_GetObjResult(interp);\r
2521   printf("statement %p count %d\n",handle->statement,mysql_stmt_param_count(handle->statement));\r
2522   res = mysql_stmt_result_metadata(handle->statement);\r
2523   printf("res %p\n",res);\r
2524   if(res==NULL)\r
2525         return TCL_ERROR;\r
2526 \r
2527   mysql_field_seek(res, 0) ;\r
2528   while ((fld = mysql_fetch_field(res)) != NULL) {\r
2529         if ((colinfo = mysql_colinfo(interp,objc,objv,fld, objv[2])) != NULL) {\r
2530             Tcl_ListObjAppendElement(interp, resObj, colinfo);\r
2531         } else {\r
2532             goto conflict;\r
2533             }\r
2534   }\r
2535   conflict:\r
2536 \r
2537   mysql_free_result(res);\r
2538   return TCL_OK;\r
2539 }\r
2540 /*----------------------------------------------------------------------\r
2541  *\r
2542  * Mysqltcl_PSelect --\r
2543  *    Implements the mysql::pselect command:\r
2544  *    usage: mysql::pselect $statement_handle ?arguments...?\r
2545  *\r
2546  *    results:\r
2547  *          number of returned rows\r
2548  */\r
2549 \r
2550 static int Mysqltcl_PSelect(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2551 {\r
2552   MysqltclState *statePtr = (MysqltclState *)clientData;\r
2553   MysqlTclHandle *handle;\r
2554 \r
2555   if ((handle = mysql_prologue(interp, objc, objv, 3, 3, CL_CONN,\r
2556                             "handle sql-statement")) == 0)\r
2557     return TCL_ERROR;\r
2558   if (handle->type!=HT_STATEMENT) {\r
2559         return TCL_ERROR;\r
2560   }\r
2561   mysql_stmt_reset(handle->statement);\r
2562   if (mysql_stmt_execute(handle->statement)) {\r
2563         return mysql_server_confl(interp,objc,objv,handle->connection);\r
2564   }\r
2565   mysql_stmt_bind_result(handle->statement, handle->bindResult);\r
2566   mysql_stmt_store_result(handle->statement);\r
2567   return TCL_OK;\r
2568 }\r
2569 /*----------------------------------------------------------------------\r
2570  *\r
2571  * Mysqltcl_PFetch --\r
2572  *    Implements the mysql::pfetch command:\r
2573  *    usage: mysql::pfetch $statement_handle\r
2574  *\r
2575  *    results:\r
2576  *          number of returned rows\r
2577  */\r
2578 \r
2579 static int Mysqltcl_PFetch(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2580 {\r
2581   MysqltclState *statePtr = (MysqltclState *)clientData;\r
2582   MysqlTclHandle *handle;\r
2583 \r
2584   if ((handle = mysql_prologue(interp, objc, objv, 2, 2, CL_CONN,\r
2585                             "prep-stat-handle")) == 0)\r
2586     return TCL_ERROR;\r
2587   if (handle->type!=HT_STATEMENT) {\r
2588         return TCL_ERROR;\r
2589   }\r
2590   \r
2591   return TCL_OK;\r
2592 }\r
2593 /*----------------------------------------------------------------------\r
2594  *\r
2595  * Mysqltcl_PExecute --\r
2596  *    Implements the mysql::pexecute command:\r
2597  *    usage: mysql::pexecute statement-handle ?arguments...?\r
2598  *\r
2599  *    results:\r
2600  *          number of effected rows\r
2601  */\r
2602 \r
2603 static int Mysqltcl_PExecute(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])\r
2604 {\r
2605   MysqltclState *statePtr = (MysqltclState *)clientData;\r
2606   MysqlTclHandle *handle;\r
2607 \r
2608   if ((handle = mysql_prologue(interp, objc, objv, 3, 3, CL_CONN,\r
2609                             "handle sql-statement")) == 0)\r
2610     return TCL_ERROR;\r
2611   if (handle->type!=HT_STATEMENT) {\r
2612         return TCL_ERROR;\r
2613   }\r
2614   mysql_stmt_reset(handle->statement);\r
2615 \r
2616   if (mysql_stmt_param_count(handle->statement)!=0) {\r
2617           Tcl_SetStringObj(Tcl_GetObjResult(interp),"works only for 0 params",-1);\r
2618           return TCL_ERROR;\r
2619   }\r
2620   if (mysql_stmt_execute(handle->statement))\r
2621   {\r
2622         Tcl_SetStringObj(Tcl_GetObjResult(interp),mysql_stmt_error(handle->statement),-1);\r
2623         return TCL_ERROR;\r
2624   }\r
2625   return TCL_OK;\r
2626 }\r
2627 #endif\r
2628 \r
2629 /*\r
2630  *----------------------------------------------------------------------\r
2631  * Mysqltcl_Init\r
2632  * Perform all initialization for the MYSQL to Tcl interface.\r
2633  * Adds additional commands to interp, creates message array, initializes\r
2634  * all handles.\r
2635  *\r
2636  * A call to Mysqltcl_Init should exist in Tcl_CreateInterp or\r
2637  * Tcl_CreateExtendedInterp.\r
2638 \r
2639  */\r
2640 \r
2641 \r
2642 #ifdef _WINDOWS\r
2643 __declspec( dllexport )\r
2644 #endif\r
2645 int Mysqltcl_Init(interp)\r
2646     Tcl_Interp *interp;\r
2647 {\r
2648   char nbuf[MYSQL_SMALL_SIZE];\r
2649   MysqltclState *statePtr;\r
2650  \r
2651   if (Tcl_InitStubs(interp, "8.1", 0) == NULL)\r
2652     return TCL_ERROR;\r
2653   if (Tcl_PkgRequire(interp, "Tcl", "8.1", 0) == NULL)\r
2654     return TCL_ERROR;\r
2655   if (Tcl_PkgProvide(interp, "mysqltcl" , PACKAGE_VERSION) != TCL_OK)\r
2656     return TCL_ERROR;\r
2657   /*\r
2658 \r
2659    * Initialize the new Tcl commands.\r
2660    * Deleting any command will close all connections.\r
2661    */\r
2662    statePtr = (MysqltclState*)Tcl_Alloc(sizeof(MysqltclState)); \r
2663    Tcl_InitHashTable(&statePtr->hash, TCL_STRING_KEYS);\r
2664    statePtr->handleNum = 0;\r
2665 \r
2666    Tcl_CreateObjCommand(interp,"mysqlconnect",Mysqltcl_Connect,(ClientData)statePtr, NULL);\r
2667    Tcl_CreateObjCommand(interp,"mysqluse", Mysqltcl_Use,(ClientData)statePtr, NULL);\r
2668    Tcl_CreateObjCommand(interp,"mysqlescape", Mysqltcl_Escape,(ClientData)statePtr, NULL);\r
2669    Tcl_CreateObjCommand(interp,"mysqlsel", Mysqltcl_Sel,(ClientData)statePtr, NULL);\r
2670    Tcl_CreateObjCommand(interp,"mysqlnext", Mysqltcl_Fetch,(ClientData)statePtr, NULL);\r
2671    Tcl_CreateObjCommand(interp,"mysqlseek", Mysqltcl_Seek,(ClientData)statePtr, NULL);\r
2672    Tcl_CreateObjCommand(interp,"mysqlmap", Mysqltcl_Map,(ClientData)statePtr, NULL);\r
2673    Tcl_CreateObjCommand(interp,"mysqlexec", Mysqltcl_Exec,(ClientData)statePtr, NULL);\r
2674    Tcl_CreateObjCommand(interp,"mysqlclose", Mysqltcl_Close,(ClientData)statePtr, NULL);\r
2675    Tcl_CreateObjCommand(interp,"mysqlinfo", Mysqltcl_Info,(ClientData)statePtr, NULL);\r
2676    Tcl_CreateObjCommand(interp,"mysqlresult", Mysqltcl_Result,(ClientData)statePtr, NULL);\r
2677    Tcl_CreateObjCommand(interp,"mysqlcol", Mysqltcl_Col,(ClientData)statePtr, NULL);\r
2678    Tcl_CreateObjCommand(interp,"mysqlstate", Mysqltcl_State,(ClientData)statePtr, NULL);\r
2679    Tcl_CreateObjCommand(interp,"mysqlinsertid", Mysqltcl_InsertId,(ClientData)statePtr, NULL);\r
2680    Tcl_CreateObjCommand(interp,"mysqlquery", Mysqltcl_Query,(ClientData)statePtr, NULL);\r
2681    Tcl_CreateObjCommand(interp,"mysqlendquery", Mysqltcl_EndQuery,(ClientData)statePtr, NULL);\r
2682    Tcl_CreateObjCommand(interp,"mysqlbaseinfo", Mysqltcl_BaseInfo,(ClientData)statePtr, NULL);\r
2683    Tcl_CreateObjCommand(interp,"mysqlping", Mysqltcl_Ping,(ClientData)statePtr, NULL);\r
2684    Tcl_CreateObjCommand(interp,"mysqlchangeuser", Mysqltcl_ChangeUser,(ClientData)statePtr, NULL);\r
2685    Tcl_CreateObjCommand(interp,"mysqlreceive", Mysqltcl_Receive,(ClientData)statePtr, NULL);\r
2686    \r
2687    Tcl_CreateObjCommand(interp,"::mysql::connect",Mysqltcl_Connect,(ClientData)statePtr, Mysqltcl_Kill);\r
2688    Tcl_CreateObjCommand(interp,"::mysql::use", Mysqltcl_Use,(ClientData)statePtr, NULL);\r
2689    Tcl_CreateObjCommand(interp,"::mysql::escape", Mysqltcl_Escape,(ClientData)statePtr, NULL);\r
2690    Tcl_CreateObjCommand(interp,"::mysql::sel", Mysqltcl_Sel,(ClientData)statePtr, NULL);\r
2691    Tcl_CreateObjCommand(interp,"::mysql::fetch", Mysqltcl_Fetch,(ClientData)statePtr, NULL);\r
2692    Tcl_CreateObjCommand(interp,"::mysql::seek", Mysqltcl_Seek,(ClientData)statePtr, NULL);\r
2693    Tcl_CreateObjCommand(interp,"::mysql::map", Mysqltcl_Map,(ClientData)statePtr, NULL);\r
2694    Tcl_CreateObjCommand(interp,"::mysql::exec", Mysqltcl_Exec,(ClientData)statePtr, NULL);\r
2695    Tcl_CreateObjCommand(interp,"::mysql::close", Mysqltcl_Close,(ClientData)statePtr, NULL);\r
2696    Tcl_CreateObjCommand(interp,"::mysql::info", Mysqltcl_Info,(ClientData)statePtr, NULL);\r
2697    Tcl_CreateObjCommand(interp,"::mysql::result", Mysqltcl_Result,(ClientData)statePtr, NULL);\r
2698    Tcl_CreateObjCommand(interp,"::mysql::col", Mysqltcl_Col,(ClientData)statePtr, NULL);\r
2699    Tcl_CreateObjCommand(interp,"::mysql::state", Mysqltcl_State,(ClientData)statePtr, NULL);\r
2700    Tcl_CreateObjCommand(interp,"::mysql::insertid", Mysqltcl_InsertId,(ClientData)statePtr, NULL);\r
2701    /* new in mysqltcl 2.0 */\r
2702    Tcl_CreateObjCommand(interp,"::mysql::query", Mysqltcl_Query,(ClientData)statePtr, NULL);\r
2703    Tcl_CreateObjCommand(interp,"::mysql::endquery", Mysqltcl_EndQuery,(ClientData)statePtr, NULL);\r
2704    Tcl_CreateObjCommand(interp,"::mysql::baseinfo", Mysqltcl_BaseInfo,(ClientData)statePtr, NULL);\r
2705    Tcl_CreateObjCommand(interp,"::mysql::ping", Mysqltcl_Ping,(ClientData)statePtr, NULL);\r
2706    Tcl_CreateObjCommand(interp,"::mysql::changeuser", Mysqltcl_ChangeUser,(ClientData)statePtr, NULL);\r
2707    Tcl_CreateObjCommand(interp,"::mysql::receive", Mysqltcl_Receive,(ClientData)statePtr, NULL);\r
2708    /* new in mysqltcl 3.0 */\r
2709    Tcl_CreateObjCommand(interp,"::mysql::autocommit", Mysqltcl_AutoCommit,(ClientData)statePtr, NULL);\r
2710    Tcl_CreateObjCommand(interp,"::mysql::commit", Mysqltcl_Commit,(ClientData)statePtr, NULL);\r
2711    Tcl_CreateObjCommand(interp,"::mysql::rollback", Mysqltcl_Rollback,(ClientData)statePtr, NULL);\r
2712    Tcl_CreateObjCommand(interp,"::mysql::nextresult", Mysqltcl_NextResult,(ClientData)statePtr, NULL);\r
2713    Tcl_CreateObjCommand(interp,"::mysql::moreresult", Mysqltcl_MoreResult,(ClientData)statePtr, NULL);\r
2714    Tcl_CreateObjCommand(interp,"::mysql::warningcount", Mysqltcl_WarningCount,(ClientData)statePtr, NULL);\r
2715    Tcl_CreateObjCommand(interp,"::mysql::isnull", Mysqltcl_IsNull,(ClientData)statePtr, NULL);\r
2716    Tcl_CreateObjCommand(interp,"::mysql::newnull", Mysqltcl_NewNull,(ClientData)statePtr, NULL);\r
2717    Tcl_CreateObjCommand(interp,"::mysql::setserveroption", Mysqltcl_SetServerOption,(ClientData)statePtr, NULL);\r
2718    Tcl_CreateObjCommand(interp,"::mysql::shutdown", Mysqltcl_ShutDown,(ClientData)statePtr, NULL);\r
2719    Tcl_CreateObjCommand(interp,"::mysql::encoding", Mysqltcl_Encoding,(ClientData)statePtr, NULL);\r
2720    /* prepared statements */\r
2721 \r
2722 #ifdef PREPARED_STATEMENT\r
2723    Tcl_CreateObjCommand(interp,"::mysql::prepare", Mysqltcl_Prepare,(ClientData)statePtr, NULL);\r
2724    // Tcl_CreateObjCommand(interp,"::mysql::parammetadata", Mysqltcl_ParamMetaData,(ClientData)statePtr, NULL);\r
2725    Tcl_CreateObjCommand(interp,"::mysql::pselect", Mysqltcl_PSelect,(ClientData)statePtr, NULL);\r
2726    Tcl_CreateObjCommand(interp,"::mysql::pselect", Mysqltcl_PFetch,(ClientData)statePtr, NULL);\r
2727    Tcl_CreateObjCommand(interp,"::mysql::pexecute", Mysqltcl_PExecute,(ClientData)statePtr, NULL);\r
2728 #endif\r
2729    \r
2730 \r
2731    \r
2732    /* Initialize mysqlstatus global array. */\r
2733    \r
2734    clear_msg(interp);\r
2735   \r
2736    /* Link the null value element to the corresponding C variable. */\r
2737    if ((statePtr->MysqlNullvalue = Tcl_Alloc (12)) == NULL) return TCL_ERROR;\r
2738    strcpy (statePtr->MysqlNullvalue, MYSQL_NULLV_INIT);\r
2739    sprintf (nbuf, "%s(%s)", MYSQL_STATUS_ARR, MYSQL_STATUS_NULLV);\r
2740 \r
2741    /* set null object in mysqltcl state */\r
2742    /* statePtr->nullObjPtr = Mysqltcl_NewNullObj(statePtr); */\r
2743    \r
2744    if (Tcl_LinkVar(interp,nbuf,(char *)&statePtr->MysqlNullvalue, TCL_LINK_STRING) != TCL_OK)\r
2745      return TCL_ERROR;\r
2746    \r
2747    /* Register the handle object type */\r
2748    Tcl_RegisterObjType(&mysqlHandleType);\r
2749    /* Register own null type object */\r
2750    Tcl_RegisterObjType(&mysqlNullType);\r
2751    \r
2752    /* A little sanity check.\r
2753     * If this message appears you must change the source code and recompile.\r
2754    */\r
2755    if (strlen(MysqlHandlePrefix) == MYSQL_HPREFIX_LEN)\r
2756      return TCL_OK;\r
2757    else {\r
2758      panic("*** mysqltcl (mysqltcl.c): handle prefix inconsistency!\n");\r
2759      return TCL_ERROR ;\r
2760    }\r
2761 }\r
2762 \r
2763 #ifdef _WINDOWS\r
2764 __declspec( dllexport )\r
2765 #endif\r
2766 int Mysqltcl_SafeInit(interp)\r
2767     Tcl_Interp *interp;\r
2768 {\r
2769   return Mysqltcl_Init(interp);\r
2770 }\r
2771 \r