/* Copyright (C) 1995-2002 MySQL AB This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /********************************************************************** This file contains the implementation of prepare and executes. Prepare: - Server gets the query from client with command 'COM_PREPARE' - Parse the query and recognize any parameter markers '?' and store its information list lex->param_list - Without executing the query, return back to client the total number of parameters along with result-set metadata information (if any) Prepare-execute: - Server gets the command 'COM_EXECUTE' to execute the previously prepared query. If there is any param markers; then client will send the data in the following format: [null_bits][types_specified(0/1)][[length][data]][[length][data] .. [length][data]. - Replace the param items with this new data. If it is a first execute or types altered by client; then setup the conversion routines. - Execute the query without re-parsing and send back the results to client Long data handling: - Server gets the long data in pieces with command type 'COM_LONG_DATA'. - The packet recieved will have the format as: [COM_LONG_DATA:1][parameter_number:2][type:2][data] - Checks if the type is specified by client, and if yes reads the type, and stores the data in that format. - It's up to the client to check for read data ended. The server doesn't care. ***********************************************************************/ #include "mysql_priv.h" #include "sql_acl.h" #include <assert.h> // for DEBUG_ASSERT() #include <m_ctype.h> // for isspace() #define IS_PARAM_NULL(pos, param_no) pos[param_no/8] & (1 << param_no & 7) extern int yyparse(void); /* Find prepared statement in thd SYNOPSIS find_prepared_statement() thd Thread handler stmt_id Statement id server specified to the client on prepare RETURN VALUES 0 error. In this case the error is sent with my_error() ptr Pointer to statement */ static PREP_STMT *find_prepared_statement(THD *thd, ulong stmt_id, const char *when) { PREP_STMT *stmt; DBUG_ENTER("find_prepared_statement"); DBUG_PRINT("enter",("stmt_id: %d", stmt_id)); if (thd->last_prepared_stmt && thd->last_prepared_stmt->stmt_id == stmt_id) DBUG_RETURN(thd->last_prepared_stmt); if ((stmt= (PREP_STMT*) tree_search(&thd->prepared_statements, &stmt_id, (void*) 0))) DBUG_RETURN (thd->last_prepared_stmt= stmt); my_error(ER_UNKNOWN_STMT_HANDLER, MYF(0), stmt_id, when); DBUG_RETURN(0); } /* Compare two prepared statements; Used to find a prepared statement */ int compare_prep_stmt(void *not_used, PREP_STMT *stmt, ulong *key) { return (stmt->stmt_id == *key) ? 0 : (stmt->stmt_id < *key) ? -1 : 1; } /* Free prepared statement. SYNOPSIS standard tree_element_free function. DESCRIPTION We don't have to free the stmt itself as this was stored in the tree and will be freed when the node is deleted */ void free_prep_stmt(PREP_STMT *stmt, TREE_FREE mode, void *not_used) { free_items(stmt->free_list); free_root(&stmt->mem_root, MYF(0)); } /* Send prepared stmt info to client after prepare */ static bool send_prep_stmt(PREP_STMT *stmt, uint columns) { NET *net=&stmt->thd->net; char buff[8]; int4store(buff, stmt->stmt_id); int2store(buff+4, columns); int2store(buff+6, stmt->param_count); return (my_net_write(net, buff, sizeof(buff)) || net_flush(net)); } /* Send information about all item parameters TODO: Not yet ready */ static bool send_item_params(PREP_STMT *stmt) { #if 0 char buff[1]; buff[0]=0; if (my_net_write(&stmt->thd->net, buff, sizeof(buff))) return 1; send_eof(stmt->thd); #endif return 0; } /* Read the length of the parameter data and retun back to caller by positing the pointer to param data */ static ulong get_param_length(uchar **packet) { reg1 uchar *pos= *packet; if (*pos < 251) { (*packet)++; return (ulong) *pos; } if (*pos == 252) { (*packet)+=3; return (ulong) uint2korr(pos+1); } if (*pos == 253) { (*packet)+=4; return (ulong) uint3korr(pos+1); } (*packet)+=9; // Must be 254 when here return (ulong) uint4korr(pos+1); } /* Setup param conversion routines setup_param_xx() param Parameter Item pos Input data buffer All these functions reads the data from pos and sets up that data through 'param' and advances the buffer position to predifined length position. Make a note that the NULL handling is examined at first execution (i.e. when input types altered) and for all subsequent executions we don't read any values for this. RETURN VALUES */ static void setup_param_tiny(Item_param *param, uchar **pos) { param->set_int((longlong)(**pos)); *pos+= 1; } static void setup_param_short(Item_param *param, uchar **pos) { param->set_int((longlong)sint2korr(*pos)); *pos+= 2; } static void setup_param_int32(Item_param *param, uchar **pos) { param->set_int((longlong)sint4korr(*pos)); *pos+= 4; } static void setup_param_int64(Item_param *param, uchar **pos) { param->set_int((longlong)sint8korr(*pos)); *pos+= 8; } static void setup_param_float(Item_param *param, uchar **pos) { float data; float4get(data,*pos); param->set_double((double) data); *pos+= 4; } static void setup_param_double(Item_param *param, uchar **pos) { double data; float8get(data,*pos); param->set_double((double) data); *pos+= 8; } static void setup_param_str(Item_param *param, uchar **pos) { ulong len=get_param_length(pos); param->set_value((const char *)*pos, len); *pos+=len; } static void setup_param_functions(Item_param *param, uchar read_pos) { switch (read_pos) { case FIELD_TYPE_TINY: param->setup_param_func= setup_param_tiny; param->item_result_type = INT_RESULT; break; case FIELD_TYPE_SHORT: param->setup_param_func= setup_param_short; param->item_result_type = INT_RESULT; break; case FIELD_TYPE_LONG: param->setup_param_func= setup_param_int32; param->item_result_type = INT_RESULT; break; case FIELD_TYPE_LONGLONG: param->setup_param_func= setup_param_int64; param->item_result_type = INT_RESULT; break; case FIELD_TYPE_FLOAT: param->setup_param_func= setup_param_float; param->item_result_type = REAL_RESULT; break; case FIELD_TYPE_DOUBLE: param->setup_param_func= setup_param_double; param->item_result_type = REAL_RESULT; break; default: param->setup_param_func= setup_param_str; param->item_result_type = STRING_RESULT; } } /* Update the parameter markers by reading the data from client .. */ static bool setup_params_data(PREP_STMT *stmt) { THD *thd= stmt->thd; List<Item> ¶ms= thd->lex.param_list; List_iterator<Item> param_iterator(params); Item_param *param; DBUG_ENTER("setup_params_data"); uchar *pos=(uchar*) thd->net.read_pos+1+MYSQL_STMT_HEADER; //skip header uchar *read_pos= pos+(stmt->param_count+7) / 8; //skip null bits ulong param_no; if (*read_pos++) //types supplied / first execute { /* First execute or types altered by the client, setup the conversion routines for all parameters (one time) */ while ((param= (Item_param *)param_iterator++)) { if (!param->long_data_supplied) { setup_param_functions(param,*read_pos); read_pos+= 2; } } param_iterator.rewind(); } param_no= 0; while ((param= (Item_param *)param_iterator++)) { if (!param->long_data_supplied) { if (IS_PARAM_NULL(pos,param_no)) param->maybe_null=param->null_value=1; else param->setup_param_func(param,&read_pos); } param_no++; } DBUG_RETURN(0); } /* Validates insert fields */ static int check_prepare_fields(THD *thd,TABLE *table, List<Item> &fields, List<Item> &values, ulong counter) { if (fields.elements == 0 && values.elements != 0) { if (values.elements != table->fields) { my_printf_error(ER_WRONG_VALUE_COUNT_ON_ROW, ER(ER_WRONG_VALUE_COUNT_ON_ROW), MYF(0),counter); return -1; } } else { if (fields.elements != values.elements) { my_printf_error(ER_WRONG_VALUE_COUNT_ON_ROW, ER(ER_WRONG_VALUE_COUNT_ON_ROW), MYF(0),counter); return -1; } TABLE_LIST table_list; bzero((char*) &table_list,sizeof(table_list)); table_list.db= table->table_cache_key; table_list.real_name= table_list.alias= table->table_name; table_list.table= table; table_list.grant= table->grant; thd->dupp_field=0; if (setup_tables(&table_list) || setup_fields(thd,&table_list,fields,1,0,0)) return -1; if (thd->dupp_field) { my_error(ER_FIELD_SPECIFIED_TWICE,MYF(0), thd->dupp_field->field_name); return -1; } } return 0; } /* Validate the following information for INSERT statement: - field existance - fields count */ static bool mysql_test_insert_fields(PREP_STMT *stmt, TABLE_LIST *table_list, List<Item> &fields, List<List_item> &values_list) { THD *thd= stmt->thd; TABLE *table; List_iterator_fast<List_item> its(values_list); List_item *values; DBUG_ENTER("mysql_test_insert_fields"); if (!(table = open_ltable(thd,table_list,table_list->lock_type))) DBUG_RETURN(1); if ((values= its++)) { uint value_count; ulong counter= 0; if (check_insert_fields(thd,table,fields,*values,1)) DBUG_RETURN(1); value_count= values->elements; its.rewind(); while ((values= its++)) { counter++; if (values->elements != value_count) { my_printf_error(ER_WRONG_VALUE_COUNT_ON_ROW, ER(ER_WRONG_VALUE_COUNT_ON_ROW), MYF(0), counter); DBUG_RETURN(1); } } } if (send_prep_stmt(stmt, 0) || send_item_params(stmt)) DBUG_RETURN(1); DBUG_RETURN(0); } /* Validate the following information UPDATE - set and where clause DELETE - where clause And send update-set clause column list fields info back to client. For DELETE, just validate where clause and return no fields information back to client. */ static bool mysql_test_upd_fields(PREP_STMT *stmt, TABLE_LIST *table_list, List<Item> &fields, List<Item> &values, COND *conds) { THD *thd= stmt->thd; TABLE *table; DBUG_ENTER("mysql_test_upd_fields"); if (!(table = open_ltable(thd,table_list,table_list->lock_type))) DBUG_RETURN(1); if (setup_tables(table_list) || setup_fields(thd,table_list,fields,1,0,0) || setup_conds(thd,table_list,&conds)) DBUG_RETURN(1); /* Currently return only column list info only, and we are not sending any info on where clause. */ if (send_prep_stmt(stmt, 0) || send_item_params(stmt)) DBUG_RETURN(1); DBUG_RETURN(0); } /* Validate the following information: SELECT - column list - where clause - order clause - having clause - group by clause - if no column spec i.e. '*', then setup all fields And send column list fields info back to client. */ static bool mysql_test_select_fields(PREP_STMT *stmt, TABLE_LIST *tables, List<Item> &fields, List<Item> &values, COND *conds, ORDER *order, ORDER *group, Item *having) { TABLE *table; bool hidden_group_fields; THD *thd= stmt->thd; List<Item> all_fields(fields); DBUG_ENTER("mysql_test_select_fields"); if (!(table = open_ltable(thd,tables,tables->lock_type))) DBUG_RETURN(1); thd->used_tables=0; // Updated by setup_fields if (setup_tables(tables) || setup_fields(thd,tables,fields,1,&all_fields,1) || setup_conds(thd,tables,&conds) || setup_order(thd,tables,fields,all_fields,order) || setup_group(thd,tables,fields,all_fields,group,&hidden_group_fields)) DBUG_RETURN(1); if (having) { thd->where="having clause"; thd->allow_sum_func=1; if (having->fix_fields(thd, tables, &having) || thd->fatal_error) DBUG_RETURN(1); if (having->with_sum_func) having->split_sum_func(all_fields); } if (setup_ftfuncs(&thd->lex.select_lex)) DBUG_RETURN(1); /* Currently return only column list info only, and we are not sending any info on where clause. */ if (send_prep_stmt(stmt, fields.elements) || send_fields(thd,fields,0) || send_item_params(stmt)) DBUG_RETURN(1); DBUG_RETURN(0); } /* Check the access privileges */ static bool check_prepare_access(THD *thd, TABLE_LIST *tables, uint type) { if (check_access(thd,type,tables->db,&tables->grant.privilege)) return 1; if (grant_option && check_grant(thd,type,tables)) return 1; return 0; } /* Send the prepare query results back to client */ static bool send_prepare_results(PREP_STMT *stmt) { THD *thd= stmt->thd; LEX *lex= &thd->lex; enum enum_sql_command sql_command = thd->lex.sql_command; DBUG_ENTER("send_prepare_results"); DBUG_PRINT("enter",("command: %d, param_count: %ld", sql_command, lex->param_count)); /* Setup prepared stmt */ stmt->param_count= lex->param_count; stmt->free_list= thd->free_list; // Save items used in stmt thd->free_list= 0; SELECT_LEX *select_lex = &lex->select_lex; TABLE_LIST *tables=(TABLE_LIST*) select_lex->table_list.first; switch (sql_command) { case SQLCOM_INSERT: if (mysql_test_insert_fields(stmt, tables, lex->field_list, lex->many_values)) goto abort; break; case SQLCOM_UPDATE: if (mysql_test_upd_fields(stmt, tables, select_lex->item_list, lex->value_list, select_lex->where)) goto abort; break; case SQLCOM_DELETE: if (mysql_test_upd_fields(stmt, tables, select_lex->item_list, lex->value_list, select_lex->where)) goto abort; break; case SQLCOM_SELECT: if (mysql_test_select_fields(stmt, tables, select_lex->item_list, lex->value_list, select_lex->where, (ORDER*) select_lex->order_list.first, (ORDER*) select_lex->group_list.first, select_lex->having)) goto abort; break; default: { /* Rest fall through to default category, no parsing for non-DML statements */ if (send_prep_stmt(stmt, 0)) goto abort; } } DBUG_RETURN(0); abort: send_error(thd,thd->killed ? ER_SERVER_SHUTDOWN : 0); DBUG_RETURN(1); } /* Parse the prepare query */ static bool parse_prepare_query(PREP_STMT *stmt, char *packet, uint length) { bool error= 1; THD *thd= stmt->thd; DBUG_ENTER("parse_prepare_query"); mysql_log.write(thd,COM_PREPARE,"%s",packet); mysql_init_query(thd); thd->prepare_command=true; thd->safe_to_cache_query= 0; thd->lex.param_count=0; LEX *lex=lex_start(thd, (uchar*) packet, length); if (!yyparse() && !thd->fatal_error) error= send_prepare_results(stmt); lex_end(lex); DBUG_RETURN(error); } /* Initialize parameter items in statement */ static bool init_param_items(THD *thd, PREP_STMT *stmt) { #if TO_BE_TESTED Item_param **to; if (!(to= (Item_param *) my_malloc(sizeof(Item_param*) * stmt->param_count, MYF(MY_WME)))) return 1; List<Item> ¶ms= thd->lex.param_list; List_iterator<Item> param_iterator(params); while ((to++ = (Item_param *)param_iterator++)) { DBUG_PRINT("info",("param: %lx", to)); } return 0; #endif } /* Parse the query and send the total number of parameters and resultset metadata information back to client (if any), without executing the query i.e. with out any log/disk writes. This will allow the queries to be re-executed without re-parsing during execute. If parameter markers are found in the query, then store the information using Item_param along with maintaining a list in lex->param_list, so that a fast and direct retrieveal can be made without going through all field items. */ bool mysql_stmt_prepare(THD *thd, char *packet, uint packet_length) { MEM_ROOT thd_root = thd->mem_root; PREP_STMT stmt; DBUG_ENTER("mysql_stmt_prepare"); bzero((char*) &stmt, sizeof(stmt)); stmt.thd= thd; stmt.stmt_id= ++thd->current_stmt_id; init_sql_alloc(&stmt.mem_root, 8192, 8192); thd->mem_root= stmt.mem_root; if (alloc_query(thd, packet, packet_length)) goto err; if (parse_prepare_query(&stmt, thd->query, thd->query_length)) goto err; if (!(specialflag & SPECIAL_NO_PRIOR)) my_pthread_setprio(pthread_self(),WAIT_PRIOR); #if 0 if (init_param_items(thd, &stmt)) goto err; #endif stmt.mem_root= thd->mem_root; tree_insert(&thd->prepared_statements, (void *)&stmt, 0, (void *)0); thd->mem_root= thd_root; // restore main mem_root thd->last_prepared_stmt= &stmt; DBUG_RETURN(0); err: stmt.mem_root= thd->mem_root; free_prep_stmt(&stmt, free_free, (void*) 0); thd->mem_root = thd_root; // restore main mem_root DBUG_RETURN(1); } /* Executes previously prepared query If there is any parameters(thd->param_count), then replace markers with the data supplied from client, and then execute the query */ void mysql_stmt_execute(THD *thd, char *packet) { ulong stmt_id= uint4korr(packet); PREP_STMT *stmt; DBUG_ENTER("mysql_stmt_execute"); if (!(stmt=find_prepared_statement(thd, stmt_id, "execute"))) { send_error(thd); DBUG_VOID_RETURN; } /* Check if we got an error when sending long data */ if (stmt->error_in_prepare) { send_error(thd, stmt->last_errno, stmt->last_error); DBUG_VOID_RETURN; } if (stmt->param_count && setup_params_data(stmt)) DBUG_VOID_RETURN; if (!(specialflag & SPECIAL_NO_PRIOR)) my_pthread_setprio(pthread_self(),QUERY_PRIOR); /* TODO: Also, have checks on basic executions such as mysql_insert(), mysql_delete(), mysql_update() and mysql_select() to not to have re-check on setup_* and other things .. */ mysql_execute_command(stmt->thd); thd->last_prepared_stmt= stmt; if (!(specialflag & SPECIAL_NO_PRIOR)) my_pthread_setprio(pthread_self(), WAIT_PRIOR); DBUG_VOID_RETURN; } /* Reset a prepared statement SYNOPSIS mysql_stmt_reset() thd Thread handle packet Packet with stmt handle DESCRIPTION This function is useful when one gets an error after calling mysql_stmt_getlongdata() and one wants to reset the handle so that one can call execute again. */ void mysql_stmt_reset(THD *thd, char *packet) { ulong stmt_id= uint4korr(packet); PREP_STMT *stmt; DBUG_ENTER("mysql_stmt_reset"); if (!(stmt=find_prepared_statement(thd, stmt_id, "close"))) { send_error(thd); DBUG_VOID_RETURN; } stmt->error_in_prepare=0; Item_param *item= stmt->param, *end= item + stmt->param_count; /* Free long data if used */ if (stmt->long_data_used) { stmt->long_data_used= 0; for (; item < end ; item++) item->reset(); } DBUG_VOID_RETURN; } /* Delete a prepared statement from memory */ void mysql_stmt_close(THD *thd, char *packet) { ulong stmt_id= uint4korr(packet); PREP_STMT *stmt; DBUG_ENTER("mysql_stmt_close"); if (!(stmt=find_prepared_statement(thd, stmt_id, "close"))) { send_error(thd); DBUG_VOID_RETURN; } stmt->param= 0; my_free((char *)stmt->param, MYF(MY_ALLOW_ZERO_PTR)); /* Will call free_prep_stmt() */ tree_delete(&thd->prepared_statements, (void*) &stmt, (void *)0); thd->last_prepared_stmt=0; DBUG_VOID_RETURN; } /* Long data in pieces from client SYNOPSIS mysql_stmt_get_longdata() thd Thread handle pos String to append packet_length Length of string DESCRIPTION Get a part of a long data. To make the protocol efficient, we are not sending any return packages here. If something goes wrong, then we will send the error on 'execute' We assume that the client takes care of checking that all parts are sent to the server. (No checking that we get a 'end of column' in the server) */ void mysql_stmt_get_longdata(THD *thd, char *pos, ulong packet_length) { PREP_STMT *stmt; DBUG_ENTER("mysql_stmt_get_longdata"); /* The following should never happen */ if (packet_length < MYSQL_LONG_DATA_HEADER+1) { my_error(ER_WRONG_ARGUMENTS, MYF(0), "get_longdata"); DBUG_VOID_RETURN; } ulong stmt_id= uint4korr(pos); uint param_number= uint2korr(pos+4); uint param_type= uint2korr(pos+6); pos+=MYSQL_LONG_DATA_HEADER; // Point to data if (!(stmt=find_prepared_statement(thd, stmt_id, "get_longdata"))) { /* There is a chance that the client will never see this as it doesn't expect an answer from this call... */ send_error(thd); DBUG_VOID_RETURN; } if (param_number >= stmt->param_count) { stmt->error_in_prepare=1; stmt->last_errno=ER_WRONG_ARGUMENTS; sprintf(stmt->last_error, ER(ER_WRONG_ARGUMENTS), "get_longdata"); DBUG_VOID_RETURN; } stmt->param[param_number].set_longdata(pos, packet_length-9); stmt->long_data_used= 1; DBUG_VOID_RETURN; }