← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/sql_yacc.yy

Merged from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/sql_yacc.yy
95
95
#define __attribute__(X)
96
96
#endif
97
97
 
98
 
 
99
 
#ifndef DBUG_OFF
100
 
#define YYDEBUG 1
101
 
#else
102
98
#define YYDEBUG 0
103
 
#endif
104
99
 
105
100
/**
106
101
  @brief Push an error message into MySQL error stack with line
162
157
  my_parse_error(s);
163
158
}
164
159
 
165
 
 
166
 
#ifndef DBUG_OFF
167
 
void turn_parser_debug_on()
168
 
{
169
 
  /*
170
 
     MYSQLdebug is in sql/sql_yacc.cc, in bison generated code.
171
 
     Turning this option on is **VERY** verbose, and should be
172
 
     used when investigating a syntax error problem only.
173
 
 
174
 
     The syntax to run with bison traces is as follows :
175
 
     - Starting a server manually :
176
 
       mysqld --debug="d,parser_debug" ...
177
 
     - Running a test :
178
 
       mysql-test-run.pl --mysqld="--debug=d,parser_debug" ...
179
 
 
180
 
     The result will be in the process stderr (var/log/master.err)
181
 
   */
182
 
 
183
 
  extern int yydebug;
184
 
  yydebug= 1;
185
 
}
186
 
#endif
187
 
 
188
160
/**
189
161
  Helper to resolve the SQL:2003 Syntax exception 1) in <in predicate>.
190
162
  See SQL:2003, Part 2, section 8.4 <in predicate>, Note 184, page 383.
223
195
 
224
196
  Item *result;
225
197
 
226
 
  DBUG_ENTER("handle_sql2003_note184_exception");
227
 
 
228
198
  if (expr->type() == Item::SUBSELECT_ITEM)
229
199
  {
230
200
    Item_subselect *expr2 = (Item_subselect*) expr;
248
218
      if (! equal)
249
219
        result = negate_expression(thd, result);
250
220
 
251
 
      DBUG_RETURN(result);
 
221
      return(result);
252
222
    }
253
223
  }
254
224
 
257
227
  else
258
228
    result= new (thd->mem_root) Item_func_ne(left, expr);
259
229
 
260
 
  DBUG_RETURN(result);
 
230
  return(result);
261
231
}
262
232
 
263
233
/**
281
251
  {
282
252
    /* Only the last SELECT can have  INTO...... */
283
253
    my_error(ER_WRONG_USAGE, MYF(0), "UNION", "INTO");
284
 
    return TRUE;
 
254
    return true;
285
255
  }
286
256
  if (lex->current_select->linkage == GLOBAL_OPTIONS_TYPE)
287
257
  {
288
258
    my_parse_error(ER(ER_SYNTAX_ERROR));
289
 
    return TRUE;
 
259
    return true;
290
260
  }
291
261
  /* This counter shouldn't be incremented for UNION parts */
292
262
  lex->nest_level--;
293
263
  if (mysql_new_select(lex, 0))
294
 
    return TRUE;
 
264
    return true;
295
265
  mysql_init_select(lex);
296
266
  lex->current_select->linkage=UNION_TYPE;
297
267
  if (is_union_distinct) /* UNION DISTINCT - remember position */
298
268
    lex->current_select->master_unit()->union_distinct=
299
269
      lex->current_select;
300
 
  return FALSE;
 
270
  return false;
301
271
}
302
272
 
303
273
/**
313
283
  if (sel->set_braces(1))
314
284
  {
315
285
    my_parse_error(ER(ER_SYNTAX_ERROR));
316
 
    return TRUE;
 
286
    return true;
317
287
  }
318
288
  if (sel->linkage == UNION_TYPE &&
319
289
      !sel->master_unit()->first_select()->braces &&
321
291
      UNION_TYPE)
322
292
  {
323
293
    my_parse_error(ER(ER_SYNTAX_ERROR));
324
 
    return TRUE;
 
294
    return true;
325
295
  }
326
296
  if (sel->linkage == UNION_TYPE &&
327
297
      sel->olap != UNSPECIFIED_OLAP_TYPE &&
328
298
      sel->master_unit()->fake_select_lex)
329
299
  {
330
300
    my_error(ER_WRONG_USAGE, MYF(0), "CUBE/ROLLUP", "ORDER BY");
331
 
    return TRUE;
 
301
    return true;
332
302
  }
333
303
  /* select in braces, can't contain global parameters */
334
304
  if (sel->master_unit()->fake_select_lex)
335
305
    sel->master_unit()->global_parameters=
336
306
      sel->master_unit()->fake_select_lex;
337
 
  return FALSE;
 
307
  return false;
338
308
}
339
309
 
340
310
%}
3207
3177
        | remember_name expr remember_end select_alias
3208
3178
          {
3209
3179
            THD *thd= YYTHD;
3210
 
            DBUG_ASSERT($1 < $3);
 
3180
            assert($1 < $3);
3211
3181
 
3212
3182
            if (add_item_to_list(thd, $2))
3213
3183
              MYSQL_YYABORT;
3214
3184
            if ($4.str)
3215
3185
            {
3216
 
              $2->is_autogenerated_name= FALSE;
 
3186
              $2->is_autogenerated_name= false;
3217
3187
              $2->set_name($4.str, $4.length, system_charset_info);
3218
3188
            }
3219
3189
            else if (!$2->name)
3917
3887
            */
3918
3888
            if ($4.str)
3919
3889
            {
3920
 
              $2->is_autogenerated_name= FALSE;
 
3890
              $2->is_autogenerated_name= false;
3921
3891
              $2->set_name($4.str, $4.length, system_charset_info);
3922
3892
            }
3923
3893
            else
4741
4711
opt_escape:
4742
4712
          ESCAPE_SYM simple_expr 
4743
4713
          {
4744
 
            Lex->escape_used= TRUE;
 
4714
            Lex->escape_used= true;
4745
4715
            $$= $2;
4746
4716
          }
4747
4717
        | /* empty */
4748
4718
          {
4749
 
            Lex->escape_used= FALSE;
 
4719
            Lex->escape_used= false;
4750
4720
            $$= new Item_string("\\", 1, &my_charset_latin1);
4751
4721
          }
4752
4722
        ;
4936
4906
limit_option:
4937
4907
        param_marker
4938
4908
        {
4939
 
          ((Item_param *) $1)->limit_clause_param= TRUE;
 
4909
          ((Item_param *) $1)->limit_clause_param= true;
4940
4910
        }
4941
4911
        | ULONGLONG_NUM { $$= new Item_uint($1.str, $1.length); }
4942
4912
        | LONG_NUM      { $$= new Item_uint($1.str, $1.length); }
5023
4993
                The parser won't create select_result instance only
5024
4994
                if it's an EXPLAIN.
5025
4995
              */
5026
 
              DBUG_ASSERT(lex->describe);
 
4996
              assert(lex->describe);
5027
4997
          }
5028
4998
        ;
5029
4999
 
5917
5887
field_term:
5918
5888
          TERMINATED BY text_string 
5919
5889
          {
5920
 
            DBUG_ASSERT(Lex->exchange != 0);
 
5890
            assert(Lex->exchange != 0);
5921
5891
            Lex->exchange->field_term= $3;
5922
5892
          }
5923
5893
        | OPTIONALLY ENCLOSED BY text_string
5924
5894
          {
5925
5895
            LEX *lex= Lex;
5926
 
            DBUG_ASSERT(lex->exchange != 0);
 
5896
            assert(lex->exchange != 0);
5927
5897
            lex->exchange->enclosed= $4;
5928
5898
            lex->exchange->opt_enclosed= 1;
5929
5899
          }
5930
5900
        | ENCLOSED BY text_string
5931
5901
          {
5932
 
            DBUG_ASSERT(Lex->exchange != 0);
 
5902
            assert(Lex->exchange != 0);
5933
5903
            Lex->exchange->enclosed= $3;
5934
5904
          }
5935
5905
        | ESCAPED BY text_string
5936
5906
          {
5937
 
            DBUG_ASSERT(Lex->exchange != 0);
 
5907
            assert(Lex->exchange != 0);
5938
5908
            Lex->exchange->escaped= $3;
5939
5909
          }
5940
5910
        ;
5952
5922
line_term:
5953
5923
          TERMINATED BY text_string
5954
5924
          {
5955
 
            DBUG_ASSERT(Lex->exchange != 0);
 
5925
            assert(Lex->exchange != 0);
5956
5926
            Lex->exchange->line_term= $3;
5957
5927
          }
5958
5928
        | STARTING BY text_string
5959
5929
          {
5960
 
            DBUG_ASSERT(Lex->exchange != 0);
 
5930
            assert(Lex->exchange != 0);
5961
5931
            Lex->exchange->line_start= $3;
5962
5932
          }
5963
5933
        ;
5971
5941
          /* empty */
5972
5942
        | IGNORE_SYM NUM lines_or_rows
5973
5943
          {
5974
 
            DBUG_ASSERT(Lex->exchange != 0);
 
5944
            assert(Lex->exchange != 0);
5975
5945
            Lex->exchange->skip_lines= atol($2.str);
5976
5946
          }
5977
5947
        ;
6030
6000
          {
6031
6001
            uint repertoire= Lex->text_string_is_7bit ?
6032
6002
                             MY_REPERTOIRE_ASCII : MY_REPERTOIRE_UNICODE30;
6033
 
            DBUG_ASSERT(my_charset_is_ascii_based(national_charset_info));
 
6003
            assert(my_charset_is_ascii_based(national_charset_info));
6034
6004
            $$= new Item_string($1.str, $1.length, national_charset_info,
6035
6005
                                DERIVATION_COERCIBLE, repertoire);
6036
6006
          }
6038
6008
          {
6039
6009
            Item_string *str= new Item_string($2.str, $2.length, $1);
6040
6010
            str->set_repertoire_from_value();
6041
 
            str->set_cs_specified(TRUE);
 
6011
            str->set_cs_specified(true);
6042
6012
 
6043
6013
            $$= str;
6044
6014
          }
6150
6120
                              str ? str->length() : 0,
6151
6121
                              $1);
6152
6122
            if (!item_str ||
6153
 
                !item_str->check_well_formed_result(&item_str->str_value, TRUE))
 
6123
                !item_str->check_well_formed_result(&item_str->str_value, true))
6154
6124
            {
6155
6125
              MYSQL_YYABORT;
6156
6126
            }
6157
6127
 
6158
6128
            item_str->set_repertoire_from_value();
6159
 
            item_str->set_cs_specified(TRUE);
 
6129
            item_str->set_cs_specified(true);
6160
6130
 
6161
6131
            $$= item_str;
6162
6132
          }
6177
6147
                              str ? str->length() : 0,
6178
6148
                              $1);
6179
6149
            if (!item_str ||
6180
 
                !item_str->check_well_formed_result(&item_str->str_value, TRUE))
 
6150
                !item_str->check_well_formed_result(&item_str->str_value, true))
6181
6151
            {
6182
6152
              MYSQL_YYABORT;
6183
6153
            }
6184
6154
 
6185
 
            item_str->set_cs_specified(TRUE);
 
6155
            item_str->set_cs_specified(true);
6186
6156
 
6187
6157
            $$= item_str;
6188
6158
          }
6930
6900
              requested for the table. This is used to warn about a
6931
6901
              changed locking method later.
6932
6902
            */
6933
 
            Lex->lock_transactional= TRUE;
 
6903
            Lex->lock_transactional= true;
6934
6904
          }
6935
6905
          table_or_tables
6936
6906
          {
6963
6933
          tlist->lock_transactional= $3.lock_transactional;
6964
6934
          /* Compute the resulting lock method for all tables. */
6965
6935
          if (!$3.lock_transactional)
6966
 
            Lex->lock_transactional= FALSE;
 
6936
            Lex->lock_transactional= false;
6967
6937
        }
6968
6938
        ;
6969
6939
 
6972
6942
        {
6973
6943
          $$.lock_type=          TL_READ_NO_INSERT;
6974
6944
          $$.lock_timeout=       -1;
6975
 
          $$.lock_transactional= FALSE;
 
6945
          $$.lock_transactional= false;
6976
6946
        }
6977
6947
        | WRITE_SYM
6978
6948
        {
6979
6949
          $$.lock_type=          TL_WRITE_DEFAULT;
6980
6950
          $$.lock_timeout=       -1;
6981
 
          $$.lock_transactional= FALSE;
 
6951
          $$.lock_transactional= false;
6982
6952
        }
6983
6953
        | LOW_PRIORITY WRITE_SYM
6984
6954
        {
6985
6955
          $$.lock_type=          TL_WRITE_LOW_PRIORITY;
6986
6956
          $$.lock_timeout=       -1;
6987
 
          $$.lock_transactional= FALSE;
 
6957
          $$.lock_transactional= false;
6988
6958
        }
6989
6959
        | READ_SYM LOCAL_SYM
6990
6960
        {
6991
6961
          $$.lock_type=          TL_READ;
6992
6962
          $$.lock_timeout=       -1;
6993
 
          $$.lock_transactional= FALSE;
 
6963
          $$.lock_transactional= false;
6994
6964
        }
6995
6965
        | IN_SYM transactional_lock_mode MODE_SYM opt_transactional_lock_timeout
6996
6966
        {
6997
6967
          $$.lock_type=          $2;
6998
6968
          $$.lock_timeout=       $4;
6999
 
          $$.lock_transactional= TRUE;
 
6969
          $$.lock_transactional= true;
7000
6970
        }
7001
6971
        ;
7002
6972
 
7145
7115
          {
7146
7116
            THD *thd= YYTHD;
7147
7117
            LEX *lex= thd->lex;
7148
 
            DBUG_ASSERT(lex->current_select->linkage != GLOBAL_OPTIONS_TYPE);
 
7118
            assert(lex->current_select->linkage != GLOBAL_OPTIONS_TYPE);
7149
7119
            SELECT_LEX *sel= lex->current_select;
7150
7120
            SELECT_LEX_UNIT *unit= sel->master_unit();
7151
7121
            SELECT_LEX *fake= unit->fake_select_lex;