~drizzle-trunk/drizzle/development : revision 202

107

/* SERVERS CACHE CHANGES */

108

typedef struct st_lex_server_options

109

{

110

long port;

111

uint server_name_length;

110

int32_t port;

111

uint32_t server_name_length;

112

char *server_name, *host, *db, *username, *password, *scheme, *owner;

113

} LEX_SERVER_OPTIONS;

114

115

typedef struct st_lex_master_info

116

{

117

char *host, *user, *password, *log_file_name;

118

uint port, connect_retry;

118

uint32_t port, connect_retry;

119

float heartbeat_period;

120

uint64_t pos;

121

ulong server_id;

121

uint32_t server_id;

122

/*

123

Enum is used for making it possible to detect if the user

124

changed variable or if it should be left at old value

127

ssl, ssl_verify_server_cert, heartbeat_opt;

128

char *ssl_key, *ssl_cert, *ssl_ca, *ssl_capath, *ssl_cipher;

129

char *relay_log_name;

130

ulong relay_log_pos;

130

uint32_t relay_log_pos;

131

} LEX_MASTER_INFO;

132

133

180

LEX_STRING key_name;

181

182

Index_hint (enum index_hint_type type_arg, index_clause_map clause_arg,

183

char *str, uint length) :

183

char *str, uint32_t length) :

184

type(type_arg), clause(clause_arg)

185

{

186

key_name.str= str;

328

UNCACHEABLE_EXPLAIN

329

UNCACHEABLE_PREPARE

330

*/

331

uint8 uncacheable;

331

uint8_t uncacheable;

332

enum sub_select_type linkage;

333

bool no_table_names_allowed; /* used for global order by */

334

bool no_error; /* suppress error message (convert it to warnings) */

338

return sql_alloc(size);

339

}

340

static void *operator new(size_t size, MEM_ROOT *mem_root)

341

{ return (void*) alloc_root(mem_root, (uint) size); }

341

{ return (void*) alloc_root(mem_root, (uint32_t) size); }

342

static void operator delete(void *ptr __attribute__((__unused__)),

343

size_t size __attribute__((__unused__)))

344

{ TRASH(ptr, size); }

362

363

virtual bool set_braces(bool value);

364

virtual bool inc_in_sum_expr();

365

virtual uint get_in_sum_expr();

365

virtual uint32_t get_in_sum_expr();

366

virtual TABLE_LIST* get_table_list();

367

virtual List<Item>* get_item_list();

368

virtual ulong get_table_join_options();

368

virtual uint32_t get_table_join_options();

369

virtual TABLE_LIST *add_table_to_list(THD *thd, Table_ident *table,

370

LEX_STRING *alias,

371

ulong table_options,

371

uint32_t table_options,

372

thr_lock_type flags= TL_UNLOCK,

373

List<Index_hint> *hints= 0,

374

LEX_STRING *option= 0);

458

void exclude_tree();

459

460

/* UNION methods */

461

bool prepare(THD *thd, select_result *result, ulong additional_options);

461

bool prepare(THD *thd, select_result *result, uint32_t additional_options);

462

bool exec();

463

bool cleanup();

464

inline void unclean() { cleaned= 0; }

534

bigger then can be number of entries that will be added to all item

535

list during split_sum_func

536

*/

537

uint select_n_having_items;

538

uint cond_count; /* number of arguments of and/or/xor in where/having/on */

539

uint between_count; /* number of between predicates in where/having/on */

540

uint max_equal_elems; /* maximal number of elements in multiple equalities */

537

uint32_t select_n_having_items;

538

uint32_t cond_count; /* number of arguments of and/or/xor in where/having/on */

539

uint32_t between_count; /* number of between predicates in where/having/on */

540

uint32_t max_equal_elems; /* maximal number of elements in multiple equalities */

541

/*

542

Number of fields used in select list or where clause of current select

543

and all inner subselects.

544

*/

545

uint select_n_where_fields;

545

uint32_t select_n_where_fields;

546

enum_parsing_place parsing_place; /* where we are parsing expression */

547

bool with_sum_func; /* sum function indicator */

548

/*

551

*/

552

bool conds_processed_with_permanent_arena;

553

554

ulong table_join_options;

555

uint in_sum_expr;

556

uint select_number; /* number of select (used for EXPLAIN) */

554

uint32_t table_join_options;

555

uint32_t in_sum_expr;

556

uint32_t select_number; /* number of select (used for EXPLAIN) */

557

int nest_level; /* nesting level of select */

558

Item_sum *inner_sum_func_list; /* list of sum func in nested selects */

559

uint with_wild; /* item list contain '*' */

559

uint32_t with_wild; /* item list contain '*' */

560

bool braces; /* SELECT ... UNION (SELECT ... ) <- this braces */

561

/* true when having fix field called in processing of this SELECT */

562

bool having_fix_field;

563

/* List of references to fields referenced from inner selects */

564

List<Item_outer_ref> inner_refs_list;

565

/* Number of Item_sum-derived objects in this SELECT */

566

uint n_sum_items;

566

uint32_t n_sum_items;

567

/* Number of Item_sum-derived objects in children and descendant SELECTs */

568

uint n_child_sum_items;

568

uint32_t n_child_sum_items;

569

570

/* explicit LIMIT clause was used */

571

bool explicit_limit;

621

1 - aggregate functions are used in this select,

622

defined as SUM_FUNC_USED.

623

*/

624

uint8 full_group_by_flag;

624

uint8_t full_group_by_flag;

625

void init_query();

626

void init_select();

627

st_select_lex_unit* master_unit();

648

649

bool set_braces(bool value);

650

bool inc_in_sum_expr();

651

uint get_in_sum_expr();

651

uint32_t get_in_sum_expr();

652

653

bool add_item_to_list(THD *thd, Item *item);

654

bool add_group_to_list(THD *thd, Item *item, bool asc);

655

bool add_order_to_list(THD *thd, Item *item, bool asc);

656

TABLE_LIST* add_table_to_list(THD *thd, Table_ident *table,

657

LEX_STRING *alias,

658

ulong table_options,

658

uint32_t table_options,

659

thr_lock_type flags= TL_UNLOCK,

660

List<Index_hint> *hints= 0,

661

LEX_STRING *option= 0);

666

void add_joined_table(TABLE_LIST *table);

667

TABLE_LIST *convert_right_join();

668

List<Item>* get_item_list();

669

ulong get_table_join_options();

669

uint32_t get_table_join_options();

670

void set_lock_for_tables(thr_lock_type lock_type);

671

inline void init_order()

672

{

690

init_query();

691

init_select();

692

}

693

bool setup_ref_array(THD *thd, uint order_group_num);

693

bool setup_ref_array(THD *thd, uint32_t order_group_num);

694

void print(THD *thd, String *str, enum_query_type query_type);

695

static void print_order(String *str,

696

ORDER *order,

714

Add a index hint to the tagged list of hints. The type and clause of the

715

hint will be the current ones (set by set_index_hint())

716

*/

717

bool add_index_hint (THD *thd, char *str, uint length);

717

bool add_index_hint (THD *thd, char *str, uint32_t length);

718

719

/* make a list to hold index hints */

720

void alloc_index_hints (THD *thd);

778

List<Alter_column> alter_list;

779

List<Key> key_list;

780

List<Create_field> create_list;

781

uint flags;

781

uint32_t flags;

782

enum enum_enable_or_disable keys_onoff;

783

enum tablespace_op_type tablespace_op;

784

uint no_parts;

784

uint32_t no_parts;

785

enum ha_build_method build_method;

786

Create_field *datetime_field;

787

bool error_if_not_empty;

865

*/

866

SQL_LIST sroutines_list;

867

uchar **sroutines_list_own_last;

868

uint sroutines_list_own_elements;

868

uint32_t sroutines_list_own_elements;

869

870

/*

871

These constructor and destructor serve for creation/destruction

1215

}

1216

1217

/** Get the length of the current token, in the raw buffer. */

1218

uint yyLength()

1218

uint32_t yyLength()

1219

{

1220

/*

1221

The assumption is that the lexical analyser is always 1 character ahead,

1222

which the -1 account for.

1223

*/

1224

assert(m_ptr > m_tok_start);

1225

return (uint) ((m_ptr - m_tok_start) - 1);

1225

return (uint32_t) ((m_ptr - m_tok_start) - 1);

1226

}

1227

1228

/** Get the utf8-body string. */

1232

}

1233

1234

/** Get the utf8-body length. */

1235

uint get_body_utf8_length()

1235

uint32_t get_body_utf8_length()

1236

{

1237

return m_body_utf8_ptr - m_body_utf8;

1238

}

1249

THD *m_thd;

1250

1251

/** Current line number. */

1252

uint yylineno;

1252

uint32_t yylineno;

1253

1254

/** Length of the last token parsed. */

1255

uint yytoklen;

1255

uint32_t yytoklen;

1256

1257

/** Interface with bison, value of the last token parsed. */

1258

LEX_YYSTYPE yylval;

1283

const char *m_buf;

1284

1285

/** Length of the raw buffer. */

1286

uint m_buf_length;

1286

uint32_t m_buf_length;

1287

1288

/** Echo the parsed stream to the pre-processed buffer. */

1289

bool m_echo;

1436

KEY_CREATE_INFO key_create_info;

1437

LEX_MASTER_INFO mi; // used by CHANGE MASTER

1438

LEX_SERVER_OPTIONS server_options;

1439

ulong type;

1439

uint32_t type;

1440

/*

1441

This variable is used in post-parse stage to declare that sum-functions,

1442

or functions which have sense only if GROUP BY is present, are allowed.

1467

};

1468

enum enum_var_type option_type;

1469

1470

uint profile_query_id;

1471

uint profile_options;

1470

uint32_t profile_query_id;

1471

uint32_t profile_options;

1472

enum column_format_type column_format;

1473

uint which_columns;

1473

uint32_t which_columns;

1474

enum Foreign_key::fk_match_opt fk_match_option;

1475

enum Foreign_key::fk_option fk_update_opt;

1476

enum Foreign_key::fk_option fk_delete_opt;

1477

uint slave_thd_opt, start_transaction_opt;

1477

uint32_t slave_thd_opt, start_transaction_opt;

1478

int nest_level;

1479

/*

1480

In LEX representing update which were transformed to multi-update

1481

stores total number of tables. For LEX representing multi-delete

1482

holds number of tables from which we will delete records.

1483

*/

1484

uint table_count;

1485

uint8 describe;

1484

uint32_t table_count;

1485

uint8_t describe;

1486

/*

1487

A flag that indicates what kinds of derived tables are present in the

1488

query (0 if no derived tables, otherwise DERIVED_SUBQUERY).

1489

*/

1490

uint8 derived_tables;

1490

uint8_t derived_tables;

1491

bool drop_if_exists, drop_temporary, local_file, one_shot_set;

1492

bool autocommit;

1493

bool verbose, no_write_to_binlog;

1599

}

1600

static void *operator new(size_t size, MEM_ROOT *mem_root) throw()

1601

{

1602

return (void*) alloc_root(mem_root, (uint) size);

1602

return (void*) alloc_root(mem_root, (uint32_t) size);

1603

}

1604

static void operator delete(void *ptr __attribute__((__unused__)),

1605

size_t size __attribute__((__unused__)))