~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/sql_lex.cc

MergedĀ fromĀ trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
90
90
void lex_init(void)
91
91
{
92
92
  uint i;
93
 
  DBUG_ENTER("lex_init");
94
93
  for (i=0 ; i < array_elements(symbols) ; i++)
95
94
    symbols[i].length=(uchar) strlen(symbols[i].name);
96
95
  for (i=0 ; i < array_elements(sql_functions) ; i++)
97
96
    sql_functions[i].length=(uchar) strlen(sql_functions[i].name);
98
97
 
99
 
  DBUG_VOID_RETURN;
 
98
  return;
100
99
}
101
100
 
102
101
 
103
102
void lex_free(void)
104
103
{                                       // Call this when daemon ends
105
 
  DBUG_ENTER("lex_free");
106
 
  DBUG_VOID_RETURN;
 
104
  return;
107
105
}
108
106
 
109
107
 
110
108
void
111
109
st_parsing_options::reset()
112
110
{
113
 
  allows_variable= TRUE;
114
 
  allows_select_into= TRUE;
115
 
  allows_select_procedure= TRUE;
116
 
  allows_derived= TRUE;
 
111
  allows_variable= true;
 
112
  allows_select_into= true;
 
113
  allows_select_procedure= true;
 
114
  allows_derived= true;
117
115
}
118
116
 
119
117
Lex_input_stream::Lex_input_stream(THD *thd,
132
130
  m_tok_start_prev(NULL),
133
131
  m_buf(buffer),
134
132
  m_buf_length(length),
135
 
  m_echo(TRUE),
 
133
  m_echo(true),
136
134
  m_cpp_tok_start(NULL),
137
135
  m_cpp_tok_start_prev(NULL),
138
136
  m_cpp_tok_end(NULL),
141
139
  next_state(MY_LEX_START),
142
140
  found_semicolon(NULL),
143
141
  ignore_space(1),
144
 
  stmt_prepare_mode(FALSE),
 
142
  stmt_prepare_mode(false),
145
143
  in_comment(NO_COMMENT),
146
144
  m_underscore_cs(NULL)
147
145
{
166
164
 
167
165
void Lex_input_stream::body_utf8_start(THD *thd, const char *begin_ptr)
168
166
{
169
 
  DBUG_ASSERT(begin_ptr);
170
 
  DBUG_ASSERT(m_cpp_buf <= begin_ptr && begin_ptr <= m_cpp_buf + m_buf_length);
 
167
  assert(begin_ptr);
 
168
  assert(m_cpp_buf <= begin_ptr && begin_ptr <= m_cpp_buf + m_buf_length);
171
169
 
172
170
  uint body_utf8_length=
173
171
    (m_buf_length / thd->variables.character_set_client->mbminlen) *
204
202
void Lex_input_stream::body_utf8_append(const char *ptr,
205
203
                                        const char *end_ptr)
206
204
{
207
 
  DBUG_ASSERT(m_cpp_buf <= ptr && ptr <= m_cpp_buf + m_buf_length);
208
 
  DBUG_ASSERT(m_cpp_buf <= end_ptr && end_ptr <= m_cpp_buf + m_buf_length);
 
205
  assert(m_cpp_buf <= ptr && ptr <= m_cpp_buf + m_buf_length);
 
206
  assert(m_cpp_buf <= end_ptr && end_ptr <= m_cpp_buf + m_buf_length);
209
207
 
210
208
  if (!m_body_utf8)
211
209
    return;
289
287
void lex_start(THD *thd)
290
288
{
291
289
  LEX *lex= thd->lex;
292
 
  DBUG_ENTER("lex_start");
293
290
 
294
291
  lex->thd= lex->unit.thd= thd;
295
292
 
317
314
  lex->select_lex.init_order();
318
315
  lex->select_lex.group_list.empty();
319
316
  lex->describe= 0;
320
 
  lex->subqueries= FALSE;
 
317
  lex->subqueries= false;
321
318
  lex->derived_tables= 0;
322
319
  lex->lock_option= TL_READ;
323
320
  lex->leaf_tables_insert= 0;
334
331
  lex->duplicates= DUP_ERROR;
335
332
  lex->ignore= 0;
336
333
  lex->proc_list.first= 0;
337
 
  lex->escape_used= FALSE;
 
334
  lex->escape_used= false;
338
335
  lex->query_tables= 0;
339
 
  lex->reset_query_tables_list(FALSE);
340
 
  lex->expr_allows_subselect= TRUE;
341
 
  lex->use_only_table_context= FALSE;
 
336
  lex->reset_query_tables_list(false);
 
337
  lex->expr_allows_subselect= true;
 
338
  lex->use_only_table_context= false;
342
339
 
343
340
  lex->name.str= 0;
344
341
  lex->name.length= 0;
361
358
  lex->server_options.owner= 0;
362
359
  lex->server_options.port= -1;
363
360
 
364
 
  lex->is_lex_started= TRUE;
365
 
  DBUG_VOID_RETURN;
 
361
  lex->is_lex_started= true;
 
362
  return;
366
363
}
367
364
 
368
365
void lex_end(LEX *lex)
369
366
{
370
 
  DBUG_ENTER("lex_end");
371
 
  DBUG_PRINT("enter", ("lex: 0x%lx", (long) lex));
372
367
  if (lex->yacc_yyss)
373
368
  {
374
369
    my_free(lex->yacc_yyss, MYF(0));
382
377
                     lex->plugins.elements);
383
378
  reset_dynamic(&lex->plugins);
384
379
 
385
 
  DBUG_VOID_RETURN;
 
380
  return;
386
381
}
387
382
 
388
383
 
417
412
 
418
413
bool is_keyword(const char *name, uint len)
419
414
{
420
 
  DBUG_ASSERT(len != 0);
 
415
  assert(len != 0);
421
416
  return get_hash_symbol(name,len,0)!=0;
422
417
}
423
418
 
424
419
bool is_lex_native_function(const LEX_STRING *name)
425
420
{
426
 
  DBUG_ASSERT(name != NULL);
 
421
  assert(name != NULL);
427
422
  return (get_hash_symbol(name->str, name->length, 1) != 0);
428
423
}
429
424
 
534
529
      /* Extract the text from the token */
535
530
      str += pre_skip;
536
531
      end -= post_skip;
537
 
      DBUG_ASSERT(end >= str);
 
532
      assert(end >= str);
538
533
 
539
534
      if (!(start= (char*) lip->m_thd->alloc((uint) (end-str)+1)))
540
535
        return (char*) "";              // Sql_alloc has set error flag
1250
1245
      {
1251
1246
        lip->in_comment= DISCARD_COMMENT;
1252
1247
        /* Accept '/' '*' '!', but do not keep this marker. */
1253
 
        lip->set_echo(FALSE);
 
1248
        lip->set_echo(false);
1254
1249
        lip->yySkip();
1255
1250
        lip->yySkip();
1256
1251
        lip->yySkip();
1286
1281
          if (version <= MYSQL_VERSION_ID)
1287
1282
          {
1288
1283
            /* Expand the content of the special comment as real code */
1289
 
            lip->set_echo(TRUE);
 
1284
            lip->set_echo(true);
1290
1285
            state=MY_LEX_START;
1291
1286
            break;
1292
1287
          }
1294
1289
        else
1295
1290
        {
1296
1291
          state=MY_LEX_START;
1297
 
          lip->set_echo(TRUE);
 
1292
          lip->set_echo(true);
1298
1293
          break;
1299
1294
        }
1300
1295
      }
1312
1307
        Note: There is no such thing as nesting comments,
1313
1308
        the first '*' '/' sequence seen will mark the end.
1314
1309
      */
1315
 
      comment_closed= FALSE;
 
1310
      comment_closed= false;
1316
1311
      while (! lip->eof())
1317
1312
      {
1318
1313
        c= lip->yyGet();
1321
1316
          if (lip->yyPeek() == '/')
1322
1317
          {
1323
1318
            lip->yySkip();
1324
 
            comment_closed= TRUE;
 
1319
            comment_closed= true;
1325
1320
            state = MY_LEX_START;
1326
1321
            break;
1327
1322
          }
1334
1329
        return (ABORT_SYM);
1335
1330
      state = MY_LEX_START;             // Try again
1336
1331
      lip->in_comment= NO_COMMENT;
1337
 
      lip->set_echo(TRUE);
 
1332
      lip->set_echo(true);
1338
1333
      break;
1339
1334
    case MY_LEX_END_LONG_COMMENT:
1340
1335
      if ((lip->in_comment != NO_COMMENT) && lip->yyPeek() == '/')
1345
1340
        lip->set_echo(lip->in_comment == PRESERVE_COMMENT);
1346
1341
        lip->yySkipn(2);
1347
1342
        /* And start recording the tokens again */
1348
 
        lip->set_echo(TRUE);
 
1343
        lip->set_echo(true);
1349
1344
        lip->in_comment=NO_COMMENT;
1350
1345
        state=MY_LEX_START;
1351
1346
      }
1369
1364
          lip->found_semicolon= lip->get_ptr();
1370
1365
          thd->server_status|= SERVER_MORE_RESULTS_EXISTS;
1371
1366
          lip->next_state= MY_LEX_END;
1372
 
          lip->set_echo(TRUE);
 
1367
          lip->set_echo(true);
1373
1368
          return (END_OF_INPUT);
1374
1369
        }
1375
1370
        state= MY_LEX_CHAR;             // Return ';'
1381
1376
      if (lip->eof())
1382
1377
      {
1383
1378
        lip->yyUnget();                 // Reject the last '\0'
1384
 
        lip->set_echo(FALSE);
 
1379
        lip->set_echo(false);
1385
1380
        lip->yySkip();
1386
 
        lip->set_echo(TRUE);
 
1381
        lip->set_echo(true);
1387
1382
        /* Unbalanced comments with a missing '*' '/' are a syntax error */
1388
1383
        if (lip->in_comment != NO_COMMENT)
1389
1384
          return (ABORT_SYM);
1608
1603
  first_execution= 1;
1609
1604
  first_cond_optimization= 1;
1610
1605
  parsing_place= NO_MATTER;
1611
 
  exclude_from_table_unique_test= no_wrap_view_item= FALSE;
 
1606
  exclude_from_table_unique_test= no_wrap_view_item= false;
1612
1607
  nest_level= 0;
1613
1608
  link_next= 0;
1614
1609
}
1844
1839
          sl->uncacheable|= UNCACHEABLE_UNITED;
1845
1840
      }
1846
1841
    }
1847
 
    s->is_correlated= TRUE;
 
1842
    s->is_correlated= true;
1848
1843
    Item_subselect *subquery_predicate= s->master_unit()->item;
1849
1844
    if (subquery_predicate)
1850
 
      subquery_predicate->is_correlated= TRUE;
 
1845
      subquery_predicate->is_correlated= true;
1851
1846
  }
1852
1847
}
1853
1848
 
1908
1903
bool st_select_lex::add_item_to_list(THD *thd __attribute__((__unused__)),
1909
1904
                                     Item *item)
1910
1905
{
1911
 
  DBUG_ENTER("st_select_lex::add_item_to_list");
1912
 
  DBUG_PRINT("info", ("Item: 0x%lx", (long) item));
1913
 
  DBUG_RETURN(item_list.push_back(item));
 
1906
  return(item_list.push_back(item));
1914
1907
}
1915
1908
 
1916
1909
 
1998
1991
      if (union_all)
1999
1992
        str->append(STRING_WITH_LEN("all "));
2000
1993
      else if (union_distinct == sl)
2001
 
        union_all= TRUE;
 
1994
        union_all= true;
2002
1995
    }
2003
1996
    if (sl->braces)
2004
1997
      str->append('(');
2057
2050
        subs_type == Item_subselect::IN_SUBS ||
2058
2051
        subs_type == Item_subselect::ALL_SUBS)
2059
2052
    {
2060
 
      DBUG_ASSERT(!item->fixed ||
 
2053
      assert(!item->fixed ||
2061
2054
                  /*
2062
2055
                    If not using materialization both:
2063
2056
                    select_limit == 1, and there should be no offset_limit.
2065
2058
                  (((subs_type == Item_subselect::IN_SUBS) &&
2066
2059
                    ((Item_in_subselect*)item)->exec_method ==
2067
2060
                    Item_in_subselect::MATERIALIZATION) ?
2068
 
                   TRUE :
 
2061
                   true :
2069
2062
                   (select_limit->val_int() == 1LL) &&
2070
2063
                   offset_limit == 0));
2071
2064
      return;
2104
2097
 
2105
2098
  SYNOPSIS
2106
2099
    reset_query_tables_list()
2107
 
      init  TRUE  - we should perform full initialization of object with
 
2100
      init  true  - we should perform full initialization of object with
2108
2101
                    allocating needed memory
2109
 
            FALSE - object is already initialized so we should only reset
 
2102
            false - object is already initialized so we should only reset
2110
2103
                    its state so it can be used for parsing/processing
2111
2104
                    of new statement
2112
2105
 
2188
2181
                         plugins_static_buffer,
2189
2182
                         INITIAL_LEX_PLUGIN_LIST_SIZE, 
2190
2183
                         INITIAL_LEX_PLUGIN_LIST_SIZE);
2191
 
  reset_query_tables_list(TRUE);
 
2184
  reset_query_tables_list(true);
2192
2185
}
2193
2186
 
2194
2187
 
2206
2199
    several underlying tables.
2207
2200
 
2208
2201
  RETURN
2209
 
    FALSE - only temporary table algorithm can be used
2210
 
    TRUE  - merge algorithm can be used
 
2202
    false - only temporary table algorithm can be used
 
2203
    true  - merge algorithm can be used
2211
2204
*/
2212
2205
 
2213
2206
bool st_lex::can_be_merged()
2252
2245
  DESCRIPTION
2253
2246
    Only listed here commands can use merge algorithm in top level
2254
2247
    SELECT_LEX (for subqueries will be used merge algorithm if
2255
 
    st_lex::can_not_use_merged() is not TRUE).
 
2248
    st_lex::can_not_use_merged() is not true).
2256
2249
 
2257
2250
  RETURN
2258
 
    FALSE - command can't use merged VIEWs
2259
 
    TRUE  - VIEWs with MERGE algorithms can be used
 
2251
    false - command can't use merged VIEWs
 
2252
    true  - VIEWs with MERGE algorithms can be used
2260
2253
*/
2261
2254
 
2262
2255
bool st_lex::can_use_merged()
2274
2267
  case SQLCOM_REPLACE:
2275
2268
  case SQLCOM_REPLACE_SELECT:
2276
2269
  case SQLCOM_LOAD:
2277
 
    return TRUE;
 
2270
    return true;
2278
2271
  default:
2279
 
    return FALSE;
 
2272
    return false;
2280
2273
  }
2281
2274
}
2282
2275
 
2291
2284
    listed here (see also st_lex::can_use_merged()).
2292
2285
 
2293
2286
  RETURN
2294
 
    FALSE - command can't use merged VIEWs
2295
 
    TRUE  - VIEWs with MERGE algorithms can be used
 
2287
    false - command can't use merged VIEWs
 
2288
    true  - VIEWs with MERGE algorithms can be used
2296
2289
*/
2297
2290
 
2298
2291
bool st_lex::can_not_use_merged()
2305
2298
    see get_schema_tables_result function
2306
2299
  */
2307
2300
  case SQLCOM_SHOW_FIELDS:
2308
 
    return TRUE;
 
2301
    return true;
2309
2302
  default:
2310
 
    return FALSE;
 
2303
    return false;
2311
2304
  }
2312
2305
}
2313
2306
 
2318
2311
    only_view_structure()
2319
2312
 
2320
2313
  RETURN
2321
 
    TRUE yes, we need only structure
2322
 
    FALSE no, we need data
 
2314
    true yes, we need only structure
 
2315
    false no, we need data
2323
2316
*/
2324
2317
 
2325
2318
bool st_lex::only_view_structure()
2328
2321
  case SQLCOM_SHOW_CREATE:
2329
2322
  case SQLCOM_SHOW_TABLES:
2330
2323
  case SQLCOM_SHOW_FIELDS:
2331
 
    return TRUE;
 
2324
    return true;
2332
2325
  default:
2333
 
    return FALSE;
 
2326
    return false;
2334
2327
  }
2335
2328
}
2336
2329
 
2342
2335
    need_correct_ident()
2343
2336
 
2344
2337
  RETURN
2345
 
    TRUE yes, we need only structure
2346
 
    FALSE no, we need data
 
2338
    true yes, we need only structure
 
2339
    false no, we need data
2347
2340
*/
2348
2341
 
2349
2342
 
2353
2346
  {
2354
2347
  case SQLCOM_SHOW_CREATE:
2355
2348
  case SQLCOM_SHOW_TABLES:
2356
 
    return TRUE;
 
2349
    return true;
2357
2350
  default:
2358
 
    return FALSE;
 
2351
    return false;
2359
2352
  }
2360
2353
}
2361
2354
 
2397
2390
 
2398
2391
  This method is needed to support this rule.
2399
2392
 
2400
 
  @return TRUE in case of error (parsing should be aborted, FALSE in
 
2393
  @return true in case of error (parsing should be aborted, false in
2401
2394
  case of success
2402
2395
*/
2403
2396
 
2575
2568
  NOTE
2576
2569
    This method is mostly responsible for cleaning up of selects lists and
2577
2570
    derived tables state. To rollback changes in Query_tables_list one has
2578
 
    to call Query_tables_list::reset_query_tables_list(FALSE).
 
2571
    to call Query_tables_list::reset_query_tables_list(false).
2579
2572
*/
2580
2573
 
2581
2574
void st_lex::cleanup_after_one_table_open()
2638
2631
    st_lex:table_or_sp_used()
2639
2632
 
2640
2633
  RETURN
2641
 
    FALSE  No routines and tables used
2642
 
    TRUE   Either or both routines and tables are used.
 
2634
    false  No routines and tables used
 
2635
    true   Either or both routines and tables are used.
2643
2636
*/
2644
2637
 
2645
2638
bool st_lex::table_or_sp_used()
2646
2639
{
2647
 
  DBUG_ENTER("table_or_sp_used");
2648
 
 
2649
2640
  if (sroutines.records || query_tables)
2650
 
    DBUG_RETURN(TRUE);
 
2641
    return(true);
2651
2642
 
2652
 
  DBUG_RETURN(FALSE);
 
2643
  return(false);
2653
2644
}
2654
2645
 
2655
2646