~drizzle-trunk/drizzle/development

 

#define DRIZZLE_LEX 1

#include <drizzled/server_includes.h>

 

 

/*

  We are using pointer to this variable for distinguishing between assignment

*/

const LEX_STRING null_lex_str= {NULL, 0};

 

 

/*

  The following data is based on the latin1 character set, and is only

  used when comparing keywords

*/

 

{

    0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,

   16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,

  "FORCE INDEX"

};

 

{

  while (len-- != 0 &&

  return (int) len+1;

}

 

 

void lex_init(void)

{

  for (i=0 ; i < array_elements(symbols) ; i++)

  for (i=0 ; i < array_elements(sql_functions) ; i++)

 

  return;

}

  allows_derived= true;

}

 

                                   const char* buffer,

                                   unsigned int length)

  yylineno(1),

  yytoklen(0),

  yylval(NULL),

  in_comment(NO_COMMENT),

  m_underscore_cs(NULL)

{

  m_cpp_ptr= m_cpp_buf;

}

 

     statement;

  2) Determine the beginning of the body.

 

  @param begin_ptr  Pointer to the start of the body in the pre-processed

                    buffer.

*/

 

{

  assert(begin_ptr);

  assert(m_cpp_buf <= begin_ptr && begin_ptr <= m_cpp_buf + m_buf_length);

 

    my_charset_utf8_bin.mbmaxlen;

 

  m_body_utf8_ptr= m_body_utf8;

  *m_body_utf8_ptr= 0;

 

  The operation converts the specified text literal to the utf8 and appends

  the result to the utf8-body.

 

  @param txt      Text literal.

  @param txt_cs   Character set of the text literal.

  @param end_ptr  Pointer in the pre-processed buffer, to which

                  operation.

*/

 

                                                const LEX_STRING *txt,

                                                const CHARSET_INFO * const txt_cs,

                                                const char *end_ptr)

 

  if (!my_charset_same(txt_cs, &my_charset_utf8_general_ci))

  {

                        &my_charset_utf8_general_ci,

                        txt->str, txt->length,

                        txt_cs);

  (We already do too much here)

*/

 

{

 

 

  lex->context_stack.empty();

  lex->unit.init_query();

  lex->reset_query_tables_list(false);

  lex->expr_allows_subselect= true;

  lex->use_only_table_context= false;

 

  lex->name.str= 0;

  lex->name.length= 0;

{

  if (lex->yacc_yyss)

  {

    lex->yacc_yyss= 0;

    lex->yacc_yyvs= 0;

  }

                     lex->plugins.elements);

  reset_dynamic(&lex->plugins);

 

  return;

}

 

 

{

  const char *tok= lip->get_tok_start();

 

    1         name isn't a keyword

*/

 

{

  assert(len != 0);

  return get_hash_symbol(name,len,0)!=0;

 

/* make a copy of token before ptr and set yytoklen */

 

{

  LEX_STRING tmp;

  lip->yyUnget();                       // ptr points now after last token char

  tmp.length=lip->yytoklen=length;

 

  lip->m_cpp_text_start= lip->get_cpp_tok_start() + skip;

  lip->m_cpp_text_end= lip->m_cpp_text_start + tmp.length;

*/

 

static LEX_STRING get_quoted_token(Lex_input_stream *lip,

{

  LEX_STRING tmp;

  const char *from, *end;

  char *to;

  lip->yyUnget();                       // ptr points now after last token char

  tmp.length= lip->yytoklen=length;

  from= lip->get_tok_start() + skip;

  to= tmp.str;

  end= to+length;

 

static char *get_text(Lex_input_stream *lip, int pre_skip, int post_skip)

{

 

  lip->tok_bitmap= 0;

  sep= lip->yyGetLast();                        // String should end with this

      end -= post_skip;

      assert(end >= str);

 

        return (char*) "";              // Sql_alloc has set error flag

 

      lip->m_cpp_text_start= lip->get_cpp_tok_start() + pre_skip;

/*

** Calc type of integer; long integer, int64_t integer or real.

** Returns smallest type that match the string.

** because else they will be unexpected sign changes because all calculation

** is done with int64_t or double.

*/

 

static const char *long_str="2147483647";

static const char *signed_long_str="-2147483648";

static const char *int64_t_str="9223372036854775807";

static const char *signed_int64_t_str="-9223372036854775808";

static const char *unsigned_int64_t_str="18446744073709551615";

 

{

  if (length < long_len)                        // quick normal case

    return NUM;

  if (length < long_len)

    return NUM;

 

  const char *cmp;

  if (neg)

  {

    }

  }

  while (*cmp && *cmp++ == *str++) ;

}

 

 

/*

 

  - MY_LEX_EOQ                  Found end of query

  - MY_LEX_OPERATOR_OR_IDENT    Last state was an ident, text or number

                                (which can't be followed by a signed number)

*/

 

{

  YYSTYPE *yylval=(YYSTYPE*) arg;

  int token;

 

    return token;

  }

 

 

  switch(token) {

  case WITH:

    /*

      which makes the grammar LALR(2).

      Replace by a single 'WITH_ROLLUP' or 'WITH_CUBE' token,

      to transform the grammar into a LALR(1) grammar,

      which sql_yacc.yy can process.

    */

      return WITH_ROLLUP_SYM;

      /*

        Save the token following 'WITH'

      */

  return token;

}

 

{

  register unsigned char c= 0; /* Just set to shutup GCC */

  bool comment_closed;

  int   tokval, result_state;

  unsigned int length;

  enum my_lex_states state;

  YYSTYPE *yylval=(YYSTYPE*) arg;

 

  lip->yylval=yylval;                   // The global state

 

 

      lip->body_utf8_append(lip->m_cpp_text_start);

 

                                    lip->m_cpp_text_end);

 

      return(result_state);                     // IDENT or IDENT_QUOTED

 

      lip->body_utf8_append(lip->m_cpp_text_start);

 

                                    lip->m_cpp_text_end);

 

      return(result_state);

 

    case MY_LEX_USER_VARIABLE_DELIMITER:        // Found quote char

    {

      char quote_char= c;                       // Used char

      while ((c=lip->yyGet()))

      {

 

      lip->body_utf8_append(lip->m_cpp_text_start);

 

                                    lip->m_cpp_text_end);

 

      return(IDENT_QUOTED);

 

      lip->body_utf8_append(lip->m_cpp_text_start);

 

        lip->m_underscore_cs ? lip->m_underscore_cs : cs,

        lip->m_cpp_text_end);

 

    case MY_LEX_SEMICOLON:                      // optional line terminator

      if (lip->yyPeek())

      {

        {

          lip->found_semicolon= lip->get_ptr();

          lip->next_state= MY_LEX_END;

          lip->set_echo(true);

          return (END_OF_INPUT);

 

      lip->body_utf8_append(lip->m_cpp_text_start);

 

                                    lip->m_cpp_text_end);

 

      return(result_state);

  statements and stored procedures and is compensated by always

  supplying a copy of Alter_info to these functions.

 

  of memory condition after calling this function.

*/

 

  select_n_having_items= 0;

  subquery_in_having= explicit_limit= 0;

  is_item_list_lookup= 0;

  parsing_place= NO_MATTER;

  exclude_from_table_unique_test= false;

  nest_level= 0;

  linkage= UNSPECIFIED_TYPE;

  order_list.elements= 0;

  order_list.first= 0;

  /* Set limit and offset to default values */

  select_limit= 0;      /* denotes the default limit = HA_POS_ERROR */

  offset_limit= 0;      /* denotes the default offset = 0 */

bool st_select_lex_node::set_braces(bool value __attribute__((unused)))

{ return 1; }

bool st_select_lex_node::inc_in_sum_expr()           { return 1; }

TableList* st_select_lex_node::get_table_list()     { return 0; }

List<Item>* st_select_lex_node::get_item_list()      { return 0; }

                                                   Table_ident *table __attribute__((unused)),

                                                  LEX_STRING *alias __attribute__((unused)),

                                                  uint32_t table_join_options __attribute__((unused)),

}

 

 

{

}

 

 

                                     Item *item)

{

  return(item_list.push_back(item));

}

 

 

{

}

 

 

}

 

 

{

  return in_sum_expr;

}

}

 

 

{

  if (ref_pointer_array)

    return 0;

 

  return (ref_pointer_array=

                                                 item_list.elements +

                                                 select_n_having_items +

                                                 select_n_where_fields +

    }

    if (sl->braces)

      str->append('(');

    if (sl->braces)

      str->append(')');

  }

        (order_st *) fake_select_lex->order_list.first,

        query_type);

    }

  }

}

 

    if (order->counter_used)

    {

      char buffer[20];

      str->append(buffer, length);

    }

    else

}

 

 

                                String *str,

                                enum_query_type query_type)

{

                    ((Item_in_subselect*)item)->exec_method ==

                    Item_in_subselect::MATERIALIZATION) ?

                   true :

                   offset_limit == 0));

      return;

    }

}

 

/**

 

  This is a clean up call that is invoked by the Bison generated

  semantic actions manipulate with the global thread state (which

  is a very bad practice and should not normally be employed) and

  need a clean-up in case of error, and you can not use %destructor

  to implement the clean up.

*/

 

{

}

 

 

  NOTE

    LEX object initialized with this constructor can be used as part of

    and close_thread_tables() functions. But it is not yet ready for

    statement parsing. On should use lex_start() function to prepare LEX

    for this.

bool

st_lex::copy_db_to(char **p_db, size_t *p_db_length) const

{

}

 

/*

 

  val= sl->select_limit ? sl->select_limit->val_uint() : HA_POS_ERROR;

  select_limit_val= (ha_rows)val;

  /* 

    Check for overflow : ha_rows can be smaller then uint64_t if

    BIG_TABLES is off.

    */

  if (val != (uint64_t)select_limit_val)

    select_limit_val= HA_POS_ERROR;

  offset_limit_cnt= (ha_rows)(sl->offset_limit ? sl->offset_limit->val_uint() :

  select_limit_cnt= select_limit_val + offset_limit_cnt;

  if (select_limit_cnt < select_limit_val)

    select_limit_cnt= HA_POS_ERROR;             // no limit

    {

      select_lex.context.table_list= 

        select_lex.context.first_name_resolution_table= first->next_local;

      select_lex.table_list.elements--; //safety

      first->next_local= 0;

      /*

    {

      first->next_local= (TableList*) select_lex.table_list.first;

      select_lex.context.table_list= first;

      select_lex.table_list.elements++; //safety

    }

  }

void st_lex::cleanup_after_one_table_open()

{

  /*

    to prevent processing of derived tables during next open_and_lock_tables

    if next table is a real table and cleanup & remove underlying units

    have not UNION on most upper level.

    */

  if (all_selects_list != &select_lex)

 

  SYNOPSIS

    fix_prepare_info_in_table_list()

      tbl  List of tables to process

 

  DESCRIPTION

 

*/

 

{

  for (; tbl; tbl= tbl->next_local)

  {

    if (tbl->on_expr)

    {

      tbl->prep_on_expr= tbl->on_expr;

    }

  }

}

 

 

  SYNOPSIS

    alloc_index_hints()

*/

 

{ 

}

 

 

 

  SYNOPSIS

    add_index_hint()