← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_parse.cc

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_parse.cc
18
18
#include "sql_repl.h"
19
19
#include "rpl_filter.h"
20
20
#include "repl_failsafe.h"
21
 
#include <m_ctype.h>
22
 
#include <myisam.h>
23
 
#include <my_dir.h>
24
21
 
25
22
/**
26
23
  @defgroup Runtime_Environment Runtime Environment
31
28
 
32
29
const char *any_db="*any*";     // Special symbol for check_access
33
30
 
34
 
const LEX_STRING command_name[]={
 
31
const LEX_STRING command_name[COM_END+1]={
35
32
  { C_STRING_WITH_LEN("Sleep") },
36
33
  { C_STRING_WITH_LEN("Quit") },
37
34
  { C_STRING_WITH_LEN("Init DB") },
45
42
  { C_STRING_WITH_LEN("Processlist") },
46
43
  { C_STRING_WITH_LEN("Connect") },
47
44
  { C_STRING_WITH_LEN("Kill") },
48
 
  { C_STRING_WITH_LEN("Debug") },
49
45
  { C_STRING_WITH_LEN("Ping") },
50
46
  { C_STRING_WITH_LEN("Time") },
51
 
  { C_STRING_WITH_LEN("Delayed insert") },
52
47
  { C_STRING_WITH_LEN("Change user") },
53
48
  { C_STRING_WITH_LEN("Binlog Dump") },
54
 
  { C_STRING_WITH_LEN("Table Dump") },
55
49
  { C_STRING_WITH_LEN("Connect Out") },
56
50
  { C_STRING_WITH_LEN("Register Slave") },
57
 
  { C_STRING_WITH_LEN("Prepare") },
58
 
  { C_STRING_WITH_LEN("Execute") },
59
 
  { C_STRING_WITH_LEN("Long Data") },
60
 
  { C_STRING_WITH_LEN("Close stmt") },
61
 
  { C_STRING_WITH_LEN("Reset stmt") },
62
51
  { C_STRING_WITH_LEN("Set option") },
63
 
  { C_STRING_WITH_LEN("Fetch") },
64
52
  { C_STRING_WITH_LEN("Daemon") },
65
53
  { C_STRING_WITH_LEN("Error") }  // Last command number
66
54
};
177
165
 
178
166
void init_update_queries(void)
179
167
{
180
 
  bzero((uchar*) &sql_command_flags, sizeof(sql_command_flags));
 
168
  memset((uchar*) &sql_command_flags, 0, sizeof(sql_command_flags));
181
169
 
182
170
  sql_command_flags[SQLCOM_CREATE_TABLE]=   CF_CHANGES_DATA;
183
171
  sql_command_flags[SQLCOM_CREATE_INDEX]=   CF_CHANGES_DATA;
253
241
  */
254
242
  rw_rdlock(var_mutex);
255
243
  save_client_capabilities= thd->client_capabilities;
256
 
  thd->client_capabilities|= CLIENT_MULTI_QUERIES;
 
244
  thd->client_capabilities|= CLIENT_MULTI_STATEMENTS;
257
245
  /*
258
246
    We don't need return result of execution to client side.
259
247
    To forbid this we should set thd->net.vio to 0.
737
725
    lex_start(thd);
738
726
 
739
727
    status_var_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS]);
740
 
    bzero((char*) &table_list,sizeof(table_list));
 
728
    memset((char*) &table_list, 0, sizeof(table_list));
741
729
    if (thd->copy_db_to(&table_list.db, &table_list.db_length))
742
730
      break;
743
731
    /*
793
781
    {
794
782
      ulong pos;
795
783
      ushort flags;
796
 
      uint32 slave_server_id;
 
784
      uint32_t slave_server_id;
797
785
 
798
786
      status_var_increment(thd->status_var.com_other);
799
787
      thd->enable_slow_log= opt_log_slow_admin_statements;
822
810
      SHUTDOWN_DEFAULT is 0. If client is >= 4.1.3, the shutdown level is in
823
811
      packet[0].
824
812
    */
825
 
    enum mysql_enum_shutdown_level level=
826
 
      (enum mysql_enum_shutdown_level) (uchar) packet[0];
 
813
    enum drizzle_enum_shutdown_level level=
 
814
      (enum drizzle_enum_shutdown_level) (uchar) packet[0];
827
815
    if (level == SHUTDOWN_DEFAULT)
828
816
      level= SHUTDOWN_WAIT_ALL_BUFFERS; // soon default will be configurable
829
817
    else if (level != SHUTDOWN_WAIT_ALL_BUFFERS)
1648
1636
    */
1649
1637
    thd->enable_slow_log= opt_log_slow_admin_statements;
1650
1638
 
1651
 
    bzero((char*) &create_info, sizeof(create_info));
 
1639
    memset((char*) &create_info, 0, sizeof(create_info));
1652
1640
    create_info.db_type= 0;
1653
1641
    create_info.row_type= ROW_TYPE_NOT_USED;
1654
1642
    create_info.default_table_charset= thd->variables.collation_database;
1714
1702
 
1715
1703
      { // Rename of table
1716
1704
          TABLE_LIST tmp_table;
1717
 
          bzero((char*) &tmp_table,sizeof(tmp_table));
 
1705
          memset((char*) &tmp_table, 0, sizeof(tmp_table));
1718
1706
          tmp_table.table_name= lex->name.str;
1719
1707
          tmp_table.db=select_lex->db;
1720
1708
      }
2681
2669
      if (lex->describe & DESCRIBE_EXTENDED)
2682
2670
      {
2683
2671
        char buff[1024];
2684
 
        String str(buff,(uint32) sizeof(buff), system_charset_info);
 
2672
        String str(buff,(uint32_t) sizeof(buff), system_charset_info);
2685
2673
        str.length(0);
2686
2674
        thd->lex->unit.print(&str, QT_ORDINARY);
2687
2675
        str.append('\0');
2940
2928
  lex->sql_command= SQLCOM_SELECT;
2941
2929
  tmp.str= (char*) var_name;
2942
2930
  tmp.length=strlen(var_name);
2943
 
  bzero((char*) &null_lex_string.str, sizeof(null_lex_string));
 
2931
  memset((char*) &null_lex_string.str, 0, sizeof(null_lex_string));
2944
2932
  /*
2945
2933
    We set the name of Item to @@session.var_name because that then is used
2946
2934
    as the column name in the output.
3134
3122
    */
3135
3123
    if (default_value->type() == Item::FUNC_ITEM && 
3136
3124
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
3137
 
         type == MYSQL_TYPE_TIMESTAMP))
 
3125
         type == DRIZZLE_TYPE_TIMESTAMP))
3138
3126
    {
3139
3127
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name->str);
3140
3128
      return(1);
3156
3144
    }
3157
3145
  }
3158
3146
 
3159
 
  if (on_update_value && type != MYSQL_TYPE_TIMESTAMP)
 
3147
  if (on_update_value && type != DRIZZLE_TYPE_TIMESTAMP)
3160
3148
  {
3161
3149
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name->str);
3162
3150
    return(1);
3240
3228
TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
3241
3229
                                             Table_ident *table,
3242
3230
                                             LEX_STRING *alias,
3243
 
                                             ulong table_options,
 
3231
                                             uint32_t table_options,
3244
3232
                                             thr_lock_type lock_type,
3245
3233
                                             List<Index_hint> *index_hints_arg,
3246
3234
                                             LEX_STRING *option)
3434
3422
    - 0, otherwise
3435
3423
*/
3436
3424
 
3437
 
TABLE_LIST *st_select_lex::end_nested_join(THD *thd __attribute__((__unused__)))
 
3425
TABLE_LIST *st_select_lex::end_nested_join(THD *thd __attribute__((unused)))
3438
3426
{
3439
3427
  TABLE_LIST *ptr;
3440
3428
  NESTED_JOIN *nested_join;
3925
3913
    This is written such that we have a short lock on LOCK_thread_count
3926
3914
*/
3927
3915
 
3928
 
uint kill_one_thread(THD *thd __attribute__((__unused__)),
3929
 
                     ulong id, bool only_kill_query)
 
3916
static unsigned int
 
3917
kill_one_thread(THD *thd __attribute__((unused)),
 
3918
                ulong id, bool only_kill_query)
3930
3919
{
3931
3920
  THD *tmp;
3932
3921
  uint error=ER_NO_SUCH_THREAD;
4106
4095
*/
4107
4096
 
4108
4097
bool multi_update_precheck(THD *thd,
4109
 
                           TABLE_LIST *tables __attribute__((__unused__)))
 
4098
                           TABLE_LIST *tables __attribute__((unused)))
4110
4099
{
4111
4100
  const char *msg= 0;
4112
4101
  LEX *lex= thd->lex;
4143
4132
*/
4144
4133
 
4145
4134
bool multi_delete_precheck(THD *thd,
4146
 
                           TABLE_LIST *tables __attribute__((__unused__)))
 
4135
                           TABLE_LIST *tables __attribute__((unused)))
4147
4136
{
4148
4137
  SELECT_LEX *select_lex= &thd->lex->select_lex;
4149
4138
  TABLE_LIST **save_query_tables_own_last= thd->lex->query_tables_own_last;
4178
4167
  @return Matching table, NULL otherwise.
4179
4168
*/
4180
4169
 
4181
 
static TABLE_LIST *multi_delete_table_match(LEX *lex __attribute__((__unused__)),
 
4170
static TABLE_LIST *multi_delete_table_match(LEX *lex __attribute__((unused)),
4182
4171
                                            TABLE_LIST *tbl,
4183
4172
                                            TABLE_LIST *tables)
4184
4173
{
4270
4259
    true  Error
4271
4260
*/
4272
4261
 
4273
 
bool update_precheck(THD *thd, TABLE_LIST *tables __attribute__((__unused__)))
 
4262
bool update_precheck(THD *thd, TABLE_LIST *tables __attribute__((unused)))
4274
4263
{
4275
4264
  if (thd->lex->select_lex.item_list.elements != thd->lex->value_list.elements)
4276
4265
  {
4293
4282
    true   error
4294
4283
*/
4295
4284
 
4296
 
bool insert_precheck(THD *thd, TABLE_LIST *tables __attribute__((__unused__)))
 
4285
bool insert_precheck(THD *thd, TABLE_LIST *tables __attribute__((unused)))
4297
4286
{
4298
4287
  LEX *lex= thd->lex;
4299
4288
 
4324
4313
*/
4325
4314
 
4326
4315
bool create_table_precheck(THD *thd,
4327
 
                           TABLE_LIST *tables __attribute__((__unused__)),
 
4316
                           TABLE_LIST *tables __attribute__((unused)),
4328
4317
                           TABLE_LIST *create_table)
4329
4318
{
4330
4319
  LEX *lex= thd->lex;
4535
4524
 
4536
4525
  if (home_dir_len < dir_len)
4537
4526
  {
4538
 
    if (lower_case_file_system)
4539
 
    {
4540
 
      if (!my_strnncoll(character_set_filesystem,
4541
 
                        (const uchar*) conv_path, home_dir_len,
4542
 
                        (const uchar*) mysql_unpacked_real_data_home,
4543
 
                        home_dir_len))
4544
 
        return(1);
4545
 
    }
4546
 
    else if (!memcmp(conv_path, mysql_unpacked_real_data_home, home_dir_len))
 
4527
    if (!my_strnncoll(character_set_filesystem,
 
4528
                      (const uchar*) conv_path, home_dir_len,
 
4529
                      (const uchar*) mysql_unpacked_real_data_home,
 
4530
                      home_dir_len))
4547
4531
      return(1);
4548
4532
  }
4549
4533
  return(0);