~drizzle-trunk/drizzle/development : revision 577

528

};

529

530

531

bool sys_var::check(Session *session __attribute__((unused)), set_var *var)

531

bool sys_var::check(Session *, set_var *var)

532

{

533

var->save_result.uint64_t_value= var->value->val_int();

534

return 0;

582

}

583

584

585

static bool sys_update_init_connect(Session *session __attribute__((unused)), set_var *var)

585

static bool sys_update_init_connect(Session *, set_var *var)

586

{

587

return update_sys_var_str(&sys_init_connect, &LOCK_sys_init_connect, var);

588

}

589

590

591

static void sys_default_init_connect(Session* session __attribute__((unused)),

592

enum_var_type type __attribute__((unused)))

591

static void sys_default_init_connect(Session *, enum_var_type)

593

592

{

594

593

update_sys_var_str(&sys_init_connect, &LOCK_sys_init_connect, 0);

595

594

}

596

595

597

596

598

static bool sys_update_init_slave(Session *session __attribute__((unused)),

599

set_var *var)

597

static bool sys_update_init_slave(Session *, set_var *var)

600

598

{

601

599

return update_sys_var_str(&sys_init_slave, &LOCK_sys_init_slave, var);

602

600

}

603

601

604

602

605

static void sys_default_init_slave(Session* session __attribute__((unused)),

606

enum_var_type type __attribute__((unused)))

603

static void sys_default_init_slave(Session *, enum_var_type)

607

604

{

608

605

update_sys_var_str(&sys_init_slave, &LOCK_sys_init_slave, 0);

609

606

}

627

624

628

625

629

626

static void

630

fix_myisam_max_sort_file_size(Session *session __attribute__((unused)),

631

enum_var_type type __attribute__((unused)))

627

fix_myisam_max_sort_file_size(Session *, enum_var_type)

632

628

{

633

629

myisam_max_temp_length=

634

630

(my_off_t) global_system_variables.myisam_max_sort_file_size;

672

668

{

673

669

if (type == OPT_SESSION)

674

670

session->session_tx_isolation= ((enum_tx_isolation)

675

session->variables.tx_isolation);

671

session->variables.tx_isolation);

676

672

}

677

673

678

static void fix_completion_type(Session *session __attribute__((unused)),

679

enum_var_type type __attribute__((unused))) {}

674

static void fix_completion_type(Session *, enum_var_type) {}

680

675

681

static int check_completion_type(Session *session __attribute__((unused)),

682

set_var *var)

676

static int check_completion_type(Session *, set_var *var)

683

677

{

684

678

int64_t val= var->value->val_int();

685

679

if (val < 0 || val > 2)

716

710

}

717

711

718

712

719

extern void fix_delay_key_write(Session *session __attribute__((unused)),

720

enum_var_type type __attribute__((unused)))

713

extern void fix_delay_key_write(Session *, enum_var_type)

721

714

{

722

715

switch ((enum_delay_key_write) delay_key_write_options) {

723

716

case DELAY_KEY_WRITE_NONE:

733

726

}

734

727

}

735

728

736

bool sys_var_set::update(Session *session __attribute__((unused)),

737

set_var *var)

729

bool sys_var_set::update(Session *, set_var *var)

738

730

{

739

731

*value= var->save_result.uint32_t_value;

740

732

return 0;

741

733

}

742

734

743

735

unsigned char *sys_var_set::value_ptr(Session *session,

744

enum_var_type type __attribute__((unused)),

745

LEX_STRING *base __attribute__((unused)))

736

enum_var_type,

737

LEX_STRING *)

746

738

{

747

739

char buff[256];

748

740

String tmp(buff, sizeof(buff), &my_charset_utf8_general_ci);

765

757

return (unsigned char*) session->strmake(tmp.ptr(), length);

766

758

}

767

759

768

void sys_var_set_slave_mode::set_default(Session *session __attribute__((unused)),

769

enum_var_type type __attribute__((unused)))

760

void sys_var_set_slave_mode::set_default(Session *, enum_var_type)

770

761

{

771

762

slave_exec_mode_options= 0;

772

763

bit_do_set(slave_exec_mode_options, SLAVE_EXEC_MODE_STRICT);

794

785

return rc;

795

786

}

796

787

797

void fix_slave_exec_mode(enum_var_type type __attribute__((unused)))

788

void fix_slave_exec_mode(enum_var_type)

798

789

{

799

790

if (bit_is_set(slave_exec_mode_options, SLAVE_EXEC_MODE_STRICT) == 1 &&

800

791

bit_is_set(slave_exec_mode_options, SLAVE_EXEC_MODE_IDEMPOTENT) == 1)

835

826

}

836

827

837

828

838

void fix_binlog_format_after_update(Session *session,

839

enum_var_type type __attribute__((unused)))

829

void fix_binlog_format_after_update(Session *session, enum_var_type)

840

830

{

841

831

session->reset_current_stmt_binlog_row_based();

842

832

}

843

833

844

834

845

static void fix_max_binlog_size(Session *session __attribute__((unused)),

846

enum_var_type type __attribute__((unused)))

835

static void fix_max_binlog_size(Session *, enum_var_type)

847

836

{

848

837

mysql_bin_log.set_max_size(max_binlog_size);

849

838

if (!max_relay_log_size)

851

840

return;

852

841

}

853

842

854

static void fix_max_relay_log_size(Session *session __attribute__((unused)),

855

enum_var_type type __attribute__((unused)))

843

static void fix_max_relay_log_size(Session *, enum_var_type)

856

844

{

857

845

active_mi->rli.relay_log.set_max_size(max_relay_log_size ?

858

846

max_relay_log_size: max_binlog_size);

859

847

return;

860

848

}

861

849

862

static void fix_max_connections(Session *session __attribute__((unused)),

863

enum_var_type type __attribute__((unused)))

850

static void fix_max_connections(Session *, enum_var_type)

864

851

{

865

852

resize_thr_alarm(max_connections + 10);

866

853

}

884

871

}

885

872

886

873

887

static void fix_server_id(Session *session __attribute__((unused)),

888

enum_var_type type __attribute__((unused)))

874

static void fix_server_id(Session *session, enum_var_type)

889

875

{

890

876

server_id_supplied = 1;

891

877

session->server_id= server_id;

921

907

return out;

922

908

}

923

909

924

static bool get_unsigned(Session *session __attribute__((unused)), set_var *var)

910

static bool get_unsigned(Session *, set_var *var)

925

911

{

926

912

if (var->value->unsigned_flag)

927

913

var->save_result.uint64_t_value= (uint64_t) var->value->val_int();

969

955

}

970

956

971

957

972

void sys_var_long_ptr_global::set_default(Session *session __attribute__((unused)), enum_var_type type __attribute__((unused)))

958

void sys_var_long_ptr_global::set_default(Session *, enum_var_type)

973

959

{

974

960

bool not_used;

975

961

pthread_mutex_lock(guard);

991

977

}

992

978

993

979

994

void sys_var_uint32_t_ptr::set_default(Session *session __attribute__((unused)),

995

enum_var_type type __attribute__((unused)))

980

void sys_var_uint32_t_ptr::set_default(Session *, enum_var_type)

996

981

{

997

982

bool not_used;

998

983

pthread_mutex_lock(&LOCK_global_system_variables);

1015

1000

}

1016

1001

1017

1002

1018

void sys_var_uint64_t_ptr::set_default(Session *session __attribute__((unused)),

1019

enum_var_type type __attribute__((unused)))

1003

void sys_var_uint64_t_ptr::set_default(Session *, enum_var_type)

1020

1004

{

1021

1005

bool not_used;

1022

1006

pthread_mutex_lock(&LOCK_global_system_variables);

1026

1010

}

1027

1011

1028

1012

1029

bool sys_var_bool_ptr::update(Session *session __attribute__((unused)), set_var *var)

1013

bool sys_var_bool_ptr::update(Session *, set_var *var)

1030

1014

{

1031

1015

*value= (bool) var->save_result.uint32_t_value;

1032

1016

return 0;

1033

1017

}

1034

1018

1035

1019

1036

void sys_var_bool_ptr::set_default(Session *session __attribute__((unused)), enum_var_type type __attribute__((unused)))

1020

void sys_var_bool_ptr::set_default(Session *, enum_var_type)

1037

1021

{

1038

1022

*value= (bool) option_limits->def_value;

1039

1023

}

1040

1024

1041

1025

1042

bool sys_var_enum::update(Session *session __attribute__((unused)), set_var *var)

1026

bool sys_var_enum::update(Session *, set_var *var)

1043

1027

{

1044

1028

*value= (uint) var->save_result.uint32_t_value;

1045

1029

return 0;

1046

1030

}

1047

1031

1048

1032

1049

unsigned char *sys_var_enum::value_ptr(Session *session __attribute__((unused)),

1050

enum_var_type type __attribute__((unused)),

1051

LEX_STRING *base __attribute__((unused)))

1033

unsigned char *sys_var_enum::value_ptr(Session *, enum_var_type, LEX_STRING *)

1052

1034

{

1053

1035

return (unsigned char*) enum_names->type_names[*value];

1054

1036

}

1055

1037

1056

1038

1057

unsigned char *sys_var_enum_const::value_ptr(Session *session __attribute__((unused)),

1058

enum_var_type type __attribute__((unused)),

1059

LEX_STRING *base __attribute__((unused)))

1039

unsigned char *sys_var_enum_const::value_ptr(Session *, enum_var_type,

1040

LEX_STRING *)

1060

1041

{

1061

1042

return (unsigned char*) enum_names->type_names[global_system_variables.*offset];

1062

1043

}

1110

1091

}

1111

1092

1112

1093

1113

unsigned char *sys_var_session_ulong::value_ptr(Session *session, enum_var_type type,

1114

LEX_STRING *base __attribute__((unused)))

1094

unsigned char *sys_var_session_ulong::value_ptr(Session *session,

1095

enum_var_type type,

1096

LEX_STRING *)

1115

1097

{

1116

1098

if (type == OPT_GLOBAL)

1117

1099

return (unsigned char*) &(global_system_variables.*offset);

1159

1141

}

1160

1142

1161

1143

1162

unsigned char *sys_var_session_ha_rows::value_ptr(Session *session, enum_var_type type,

1163

LEX_STRING *base __attribute__((unused)))

1144

unsigned char *sys_var_session_ha_rows::value_ptr(Session *session,

1145

enum_var_type type,

1146

LEX_STRING *)

1164

1147

{

1165

1148

if (type == OPT_GLOBAL)

1166

1149

return (unsigned char*) &(global_system_variables.*offset);

1211

1194

}

1212

1195

1213

1196

1214

unsigned char *sys_var_session_uint64_t::value_ptr(Session *session, enum_var_type type,

1215

LEX_STRING *base __attribute__((unused)))

1197

unsigned char *sys_var_session_uint64_t::value_ptr(Session *session,

1198

enum_var_type type,

1199

LEX_STRING *)

1216

1200

{

1217

1201

if (type == OPT_GLOBAL)

1218

1202

return (unsigned char*) &(global_system_variables.*offset);

1239

1223

}

1240

1224

1241

1225

1242

unsigned char *sys_var_session_bool::value_ptr(Session *session, enum_var_type type,

1243

LEX_STRING *base __attribute__((unused)))

1226

unsigned char *sys_var_session_bool::value_ptr(Session *session,

1227

enum_var_type type,

1228

LEX_STRING *)

1244

1229

{

1245

1230

if (type == OPT_GLOBAL)

1246

1231

return (unsigned char*) &(global_system_variables.*offset);

1248

1233

}

1249

1234

1250

1235

1251

bool sys_var::check_enum(Session *session __attribute__((unused)),

1236

bool sys_var::check_enum(Session *,

1252

1237

set_var *var, const TYPELIB *enum_names)

1253

1238

{

1254

1239

char buff[STRING_BUFFER_USUAL_SIZE];

1282

1267

}

1283

1268

1284

1269

1285

bool sys_var::check_set(Session *session __attribute__((unused)),

1286

set_var *var, TYPELIB *enum_names)

1270

bool sys_var::check_set(Session *, set_var *var, TYPELIB *enum_names)

1287

1271

{

1288

1272

bool not_used;

1289

1273

char buff[STRING_BUFFER_USUAL_SIZE], *error= 0;

1481

1465

}

1482

1466

1483

1467

1484

unsigned char *sys_var_session_enum::value_ptr(Session *session, enum_var_type type,

1485

LEX_STRING *base __attribute__((unused)))

1468

unsigned char *sys_var_session_enum::value_ptr(Session *session,

1469

enum_var_type type,

1470

LEX_STRING *)

1486

1471

{

1487

1472

ulong tmp= ((type == OPT_GLOBAL) ?

1488

1473

global_system_variables.*offset :

1503

1488

}

1504

1489

1505

1490

1506

unsigned char *sys_var_session_bit::value_ptr(Session *session,

1507

enum_var_type type __attribute__((unused)),

1508

LEX_STRING *base __attribute__((unused)))

1491

unsigned char *sys_var_session_bit::value_ptr(Session *session, enum_var_type,

1492

LEX_STRING *)

1509

1493

{

1510

1494

/*

1511

1495

If reverse is 0 (default) return 1 if bit is set.

1601

1585

}

1602

1586

1603

1587

1604

unsigned char *sys_var_session_date_time_format::value_ptr(Session *session, enum_var_type type,

1605

LEX_STRING *base __attribute__((unused)))

1588

unsigned char *sys_var_session_date_time_format::value_ptr(Session *session,

1589

enum_var_type type,

1590

LEX_STRING *)

1606

1591

{

1607

1592

if (type == OPT_GLOBAL)

1608

1593

{

1626

1611

const char *new_name;

1627

1612

} my_old_conv;

1628

1613

1629

bool sys_var_collation::check(Session *session __attribute__((unused)),

1630

set_var *var)

1614

bool sys_var_collation::check(Session *, set_var *var)

1631

1615

{

1632

1616

const CHARSET_INFO *tmp;

1633

1617

1661

1645

}

1662

1646

1663

1647

1664

bool sys_var_character_set::check(Session *session __attribute__((unused)),

1665

set_var *var)

1648

bool sys_var_character_set::check(Session *, set_var *var)

1666

1649

{

1667

1650

const CHARSET_INFO *tmp;

1668

1651

1708

1691

}

1709

1692

1710

1693

1711

unsigned char *sys_var_character_set::value_ptr(Session *session, enum_var_type type,

1712

LEX_STRING *base __attribute__((unused)))

1694

unsigned char *sys_var_character_set::value_ptr(Session *session,

1695

enum_var_type type,

1696

LEX_STRING *)

1713

1697

{

1714

1698

const CHARSET_INFO * const cs= ci_ptr(session,type)[0];

1715

1699

return cs ? (unsigned char*) cs->csname : (unsigned char*) NULL;

1741

1725

}

1742

1726

1743

1727

1744

unsigned char *sys_var_collation_sv::value_ptr(Session *session, enum_var_type type,

1745

LEX_STRING *base __attribute__((unused)))

1728

unsigned char *sys_var_collation_sv::value_ptr(Session *session,

1729

enum_var_type type,

1730

LEX_STRING *)

1746

1731

{

1747

1732

const CHARSET_INFO *cs= ((type == OPT_GLOBAL) ?

1748

global_system_variables.*offset : session->variables.*offset);

1733

global_system_variables.*offset :

1734

session->variables.*offset);

1749

1735

return cs ? (unsigned char*) cs->name : (unsigned char*) "NULL";

1750

1736

}

1751

1737

1764

1750

}

1765

1751

1766

1752

1767

unsigned char *sys_var_key_cache_param::value_ptr(Session *session __attribute__((unused)),

1768

enum_var_type type __attribute__((unused)),

1769

LEX_STRING *base __attribute__((unused)))

1753

unsigned char *sys_var_key_cache_param::value_ptr(Session *, enum_var_type,

1754

LEX_STRING *base)

1770

1755

{

1771

1756

KEY_CACHE *key_cache= get_key_cache(base);

1772

1757

if (!key_cache)

1909

1894

error= (bool) (ha_resize_key_cache(key_cache));

1910

1895

1911

1896

pthread_mutex_lock(&LOCK_global_system_variables);

1912

key_cache->in_init= 0;

1897

key_cache->in_init= 0;

1913

1898

1914

1899

end:

1915

1900

pthread_mutex_unlock(&LOCK_global_system_variables);

1917

1902

}

1918

1903

1919

1904

1920

bool sys_var_log_state::update(Session *session __attribute__((unused)), set_var *var)

1905

bool sys_var_log_state::update(Session *, set_var *var)

1921

1906

{

1922

1907

bool res;

1923

1908

pthread_mutex_lock(&LOCK_global_system_variables);

1929

1914

return res;

1930

1915

}

1931

1916

1932

void sys_var_log_state::set_default(Session *session __attribute__((unused)),

1933

enum_var_type type __attribute__((unused)))

1917

void sys_var_log_state::set_default(Session *, enum_var_type)

1934

1918

{

1935

1919

}

1936

1920

1937

1921

1938

bool update_sys_var_str_path(Session *session __attribute__((unused)),

1939

sys_var_str *var_str,

1922

bool update_sys_var_str_path(Session *, sys_var_str *var_str,

1940

1923

set_var *var, const char *log_ext,

1941

1924

bool log_state, uint32_t log_type)

1942

1925

{

1984

1967

}

1985

1968

1986

1969

1987

bool sys_var_log_output::update(Session *session __attribute__((unused)),

1988

set_var *var)

1970

bool sys_var_log_output::update(Session *, set_var *var)

1989

1971

{

1990

1972

pthread_mutex_lock(&LOCK_global_system_variables);

1991

1973

logger.lock_exclusive();

1996

1978

}

1997

1979

1998

1980

1999

void sys_var_log_output::set_default(Session *session __attribute__((unused)),

2000

enum_var_type type __attribute__((unused)))

1981

void sys_var_log_output::set_default(Session *, enum_var_type)

2001

1982

{

2002

1983

pthread_mutex_lock(&LOCK_global_system_variables);

2003

1984

logger.lock_exclusive();

2008

1989

2009

1990

2010

1991

unsigned char *sys_var_log_output::value_ptr(Session *session,

2011

enum_var_type type __attribute__((unused)),

2012

LEX_STRING *base __attribute__((unused)))

1992

enum_var_type, LEX_STRING *)

2013

1993

{

2014

1994

char buff[256];

2015

1995

String tmp(buff, sizeof(buff), &my_charset_utf8_general_ci);

2037

2017

Functions to handle SET NAMES and SET CHARACTER SET

2038

2018

*****************************************************************************/

2039

2019

2040

int set_var_collation_client::check(Session *session __attribute__((unused)))

2020

int set_var_collation_client::check(Session *)

2041

2021

{

2042

2022

/* Currently, UCS-2 cannot be used as a client character set */

2043

2023

if (character_set_client->mbminlen > 1)

2068

2048

}

2069

2049

2070

2050

2071

void sys_var_timestamp::set_default(Session *session,

2072

enum_var_type type __attribute__((unused)))

2051

void sys_var_timestamp::set_default(Session *session, enum_var_type)

2073

2052

{

2074

2053

session->user_time=0;

2075

2054

}

2076

2055

2077

2056

2078

unsigned char *sys_var_timestamp::value_ptr(Session *session,

2079

enum_var_type type __attribute__((unused)),

2080

LEX_STRING *base __attribute__((unused)))

2057

unsigned char *sys_var_timestamp::value_ptr(Session *session, enum_var_type,

2058

LEX_STRING *)

2081

2059

{

2082

2060

session->sys_var_tmp.long_value= (long) session->start_time;

2083

2061

return (unsigned char*) &session->sys_var_tmp.long_value;

2093

2071

2094

2072

2095

2073

unsigned char *sys_var_last_insert_id::value_ptr(Session *session,

2096

enum_var_type type __attribute__((unused)),

2097

LEX_STRING *base __attribute__((unused)))

2074

enum_var_type,

2075

LEX_STRING *)

2098

2076

{

2099

2077

/*

2100

2078

this tmp var makes it robust againt change of type of

2101

2079

read_first_successful_insert_id_in_prev_stmt().

2102

2080

*/

2103

session->sys_var_tmp.uint64_t_value=

2081

session->sys_var_tmp.uint64_t_value=

2104

2082

session->read_first_successful_insert_id_in_prev_stmt();

2105

2083

return (unsigned char*) &session->sys_var_tmp.uint64_t_value;

2106

2084

}

2113

2091

}

2114

2092

2115

2093

2116

unsigned char *sys_var_insert_id::value_ptr(Session *session,

2117

enum_var_type type __attribute__((unused)),

2118

LEX_STRING *base __attribute__((unused)))

2094

unsigned char *sys_var_insert_id::value_ptr(Session *session, enum_var_type,

2095

LEX_STRING *)

2119

2096

{

2120

2097

session->sys_var_tmp.uint64_t_value=

2121

2098

session->auto_inc_intervals_forced.minimum();

2166

2143

}

2167

2144

2168

2145

2169

unsigned char *sys_var_session_time_zone::value_ptr(Session *session, enum_var_type type,

2170

LEX_STRING *base __attribute__((unused)))

2146

unsigned char *sys_var_session_time_zone::value_ptr(Session *session,

2147

enum_var_type type,

2148

LEX_STRING *)

2171

2149

{

2172

/*

2150

/*

2173

2151

We can use ptr() instead of c_ptr() here because String contaning

2174

2152

time zone name is guaranteed to be zero ended.

2175

2153

*/

2229

2207

}

2230

2208

}

2231

2209

2232

bool sys_var_max_user_conn::update(Session *session __attribute__((unused)),

2233

set_var *var)

2210

bool sys_var_max_user_conn::update(Session *, set_var *var)

2234

2211

{

2235

2212

assert(var->type == OPT_GLOBAL);

2236

2213

pthread_mutex_lock(&LOCK_global_system_variables);

2240

2217

}

2241

2218

2242

2219

2243

void sys_var_max_user_conn::set_default(Session *session __attribute__((unused)),

2244

enum_var_type type __attribute__((unused)))

2220

void sys_var_max_user_conn::set_default(Session *, enum_var_type type)

2245

2221

{

2246

2222

assert(type == OPT_GLOBAL);

2247

2223

pthread_mutex_lock(&LOCK_global_system_variables);

2250

2226

}

2251

2227

2252

2228

2253

unsigned char *sys_var_max_user_conn::value_ptr(Session *session, enum_var_type type,

2254

LEX_STRING *base __attribute__((unused)))

2229

unsigned char *sys_var_max_user_conn::value_ptr(Session *session,

2230

enum_var_type type,

2231

LEX_STRING *)

2255

2232

{

2256

2233

if (type != OPT_GLOBAL &&

2257

2234

session->user_connect && session->user_connect->user_resources.user_conn)

2260

2237

}

2261

2238

2262

2239

2263

bool sys_var_session_lc_time_names::check(Session *session __attribute__((unused)),

2264

set_var *var)

2240

bool sys_var_session_lc_time_names::check(Session *, set_var *var)

2265

2241

{

2266

2242

MY_LOCALE *locale_match;

2267

2243

2309

2285

2310

2286

2311

2287

unsigned char *sys_var_session_lc_time_names::value_ptr(Session *session,

2312

enum_var_type type,

2313

LEX_STRING *base __attribute__((unused)))

2288

enum_var_type type,

2289

LEX_STRING *)

2314

2290

{

2315

2291

return type == OPT_GLOBAL ?

2316

2292

(unsigned char *) global_system_variables.lc_time_names->name :

2370

2346

}

2371

2347

2372

2348

2373

unsigned char *sys_var_microseconds::value_ptr(Session *session, enum_var_type type,

2374

LEX_STRING *base __attribute__((unused)))

2349

unsigned char *sys_var_microseconds::value_ptr(Session *session,

2350

enum_var_type type,

2351

LEX_STRING *)

2375

2352

{

2376

2353

session->tmp_double_value= (double) ((type == OPT_GLOBAL) ?

2377

2354

global_system_variables.*offset :

2426

2403

return 0;

2427

2404

}

2428

2405

2429

static int check_log_update(Session *session __attribute__((unused)),

2430

set_var *var __attribute__((unused)))

2406

static int check_log_update(Session *, set_var *)

2431

2407

{

2432

2408

return 0;

2433

2409

}

2434

2410

2435

2411

2436

static int check_pseudo_thread_id(Session *session __attribute__((unused)),

2437

set_var *var)

2412

static int check_pseudo_thread_id(Session *, set_var *var)

2438

2413

{

2439

2414

var->save_result.uint64_t_value= var->value->val_int();

2440

2415

return 0;

2471

2446

@retval

2472

2447

ptr pointer to NUL-terminated string

2473

2448

*/

2474

static unsigned char *get_tmpdir(Session *session __attribute__((unused)))

2449

static unsigned char *get_tmpdir(Session *)

2475

2450

{

2476

2451

if (opt_mysql_tmpdir)

2477

2452

return (unsigned char *)opt_mysql_tmpdir;

2522

2497

*/

2523

2498

2524

2499

static unsigned char *get_sys_var_length(const sys_var *var, size_t *length,

2525

bool first __attribute__((unused)))

2500

bool)

2526

2501

{

2527

2502

*length= var->name_length;

2528

2503

return (unsigned char*) var->name;

2894

2869

}

2895

2870

2896

2871

2897

int set_var_user::update(Session *session __attribute__((unused)))

2872

int set_var_user::update(Session *)

2898

2873

{

2899

2874

if (user_var_item->update())

2900

2875

{

2941

2916

}

2942

2917

2943

2918

2944

unsigned char *sys_var_session_storage_engine::value_ptr(Session *session, enum_var_type type,

2945

LEX_STRING *base __attribute__((unused)))

2919

unsigned char *sys_var_session_storage_engine::value_ptr(Session *session,

2920

enum_var_type type,

2921

LEX_STRING *)

2946

2922

{

2947

2923

unsigned char* result;

2948

2924

handlerton *hton;

3023

2999

}

3024

3000

3025

3001

3026

unsigned char *sys_var_session_optimizer_switch::value_ptr(Session *session, enum_var_type type,

3027

LEX_STRING *base __attribute__((unused)))

3002

unsigned char *sys_var_session_optimizer_switch::value_ptr(Session *session,

3003

enum_var_type type,

3004

LEX_STRING *)

3028

3005

{

3029

3006

LEX_STRING opts;

3030

3007

uint64_t val= ((type == OPT_GLOBAL) ? global_system_variables.*offset :

3124

3101

}

3125

3102

3126

3103

3127

void free_key_cache(const char *name __attribute__((unused)),

3128

KEY_CACHE *key_cache)

3104

void free_key_cache(const char *, KEY_CACHE *key_cache)

3129

3105

{

3130

3106

ha_end_key_cache(key_cache);

3131

3107

free((char*) key_cache);