~drizzle-trunk/drizzle/development : revision 112

97

static int check_log_update(THD *thd, set_var *var);

98

static bool set_log_update(THD *thd, set_var *var);

99

static int check_pseudo_thread_id(THD *thd, set_var *var);

100

void fix_binlog_format_after_update(THD *thd, enum_var_type type);

101

100

static void fix_low_priority_updates(THD *thd, enum_var_type type);

102

101

static int check_tx_isolation(THD *thd, set_var *var);

103

102

static void fix_tx_isolation(THD *thd, enum_var_type type);

651

650

};

652

651

653

652

654

bool sys_var::check(THD *thd, set_var *var)

653

bool sys_var::check(THD *thd __attribute__((__unused__)), set_var *var)

655

654

{

656

655

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

657

656

return 0;

705

704

}

706

705

707

706

708

static bool sys_update_init_connect(THD *thd, set_var *var)

707

static bool sys_update_init_connect(THD *thd __attribute__((__unused__)), set_var *var)

709

708

{

710

709

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

711

710

}

712

711

713

712

714

static void sys_default_init_connect(THD* thd, enum_var_type type)

713

static void sys_default_init_connect(THD* thd __attribute__((__unused__)),

714

enum_var_type type __attribute__((__unused__)))

715

{

716

update_sys_var_str(&sys_init_connect, &LOCK_sys_init_connect, 0);

717

}

718

719

720

static bool sys_update_init_slave(THD *thd, set_var *var)

720

static bool sys_update_init_slave(THD *thd __attribute__((__unused__)),

721

set_var *var)

721

722

{

722

723

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

723

724

}

724

725

726

static void sys_default_init_slave(THD* thd, enum_var_type type)

727

static void sys_default_init_slave(THD* thd __attribute__((__unused__)),

728

enum_var_type type __attribute__((__unused__)))

727

729

{

728

730

update_sys_var_str(&sys_init_slave, &LOCK_sys_init_slave, 0);

729

731

}

747

749

748

750

749

751

static void

750

fix_myisam_max_sort_file_size(THD *thd, enum_var_type type)

752

fix_myisam_max_sort_file_size(THD *thd __attribute__((__unused__)),

753

enum_var_type type __attribute__((__unused__)))

751

754

{

752

755

myisam_max_temp_length=

753

756

(my_off_t) global_system_variables.myisam_max_sort_file_size;

797

800

static void fix_completion_type(THD *thd __attribute__((unused)),

798

801

enum_var_type type __attribute__((unused))) {}

799

802

800

static int check_completion_type(THD *thd, set_var *var)

803

static int check_completion_type(THD *thd __attribute__((__unused__)),

804

set_var *var)

801

805

{

802

806

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

803

807

if (val < 0 || val > 2)

846

850

#endif /* HAVE_REPLICATION */

847

851

848

852

849

extern void fix_delay_key_write(THD *thd, enum_var_type type)

853

extern void fix_delay_key_write(THD *thd __attribute__((__unused__)),

854

enum_var_type type __attribute__((__unused__)))

850

855

{

851

856

switch ((enum_delay_key_write) delay_key_write_options) {

852

857

case DELAY_KEY_WRITE_NONE:

862

867

}

863

868

}

864

869

865

bool sys_var_set::update(THD *thd, set_var *var)

870

bool sys_var_set::update(THD *thd __attribute__((__unused__)),

871

set_var *var)

866

872

{

867

873

*value= var->save_result.ulong_value;

868

874

return 0;

869

875

}

870

876

871

uchar *sys_var_set::value_ptr(THD *thd, enum_var_type type,

872

LEX_STRING *base)

877

uchar *sys_var_set::value_ptr(THD *thd,

878

enum_var_type type __attribute__((__unused__)),

879

LEX_STRING *base __attribute__((__unused__)))

873

880

{

874

881

char buff[256];

875

882

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

892

899

return (uchar*) thd->strmake(tmp.ptr(), length);

893

900

}

894

901

895

void sys_var_set_slave_mode::set_default(THD *thd, enum_var_type type)

902

void sys_var_set_slave_mode::set_default(THD *thd __attribute__((__unused__)),

903

enum_var_type type __attribute__((__unused__)))

896

904

{

897

905

slave_exec_mode_options= 0;

898

906

bit_do_set(slave_exec_mode_options, SLAVE_EXEC_MODE_STRICT);

920

928

return rc;

921

929

}

922

930

923

void fix_slave_exec_mode(enum_var_type type)

931

void fix_slave_exec_mode(enum_var_type type __attribute__((__unused__)))

924

932

{

925

933

DBUG_ENTER("fix_slave_exec_mode");

926

934

compile_time_assert(sizeof(slave_exec_mode_options) * CHAR_BIT

971

979

}

972

980

973

981

974

void fix_binlog_format_after_update(THD *thd, enum_var_type type)

982

void fix_binlog_format_after_update(THD *thd,

983

enum_var_type type __attribute__((__unused__)))

975

984

{

976

985

thd->reset_current_stmt_binlog_row_based();

977

986

}

978

987

979

988

980

static void fix_max_binlog_size(THD *thd, enum_var_type type)

989

static void fix_max_binlog_size(THD *thd __attribute__((__unused__)),

990

enum_var_type type __attribute__((__unused__)))

981

991

{

982

992

DBUG_ENTER("fix_max_binlog_size");

983

993

DBUG_PRINT("info",("max_binlog_size=%lu max_relay_log_size=%lu",

990

1000

DBUG_VOID_RETURN;

991

1001

}

992

1002

993

static void fix_max_relay_log_size(THD *thd, enum_var_type type)

1003

static void fix_max_relay_log_size(THD *thd __attribute__((__unused__)),

1004

enum_var_type type __attribute__((__unused__)))

994

1005

{

995

1006

DBUG_ENTER("fix_max_relay_log_size");

996

1007

DBUG_PRINT("info",("max_binlog_size=%lu max_relay_log_size=%lu",

1002

1013

DBUG_VOID_RETURN;

1003

1014

}

1004

1015

1005

static void fix_max_connections(THD *thd, enum_var_type type)

1016

static void fix_max_connections(THD *thd __attribute__((__unused__)),

1017

enum_var_type type __attribute__((__unused__)))

1006

1018

{

1007

1019

resize_thr_alarm(max_connections + 10);

1008

1020

}

1026

1038

}

1027

1039

1028

1040

1029

static void fix_server_id(THD *thd, enum_var_type type)

1041

static void fix_server_id(THD *thd __attribute__((__unused__)),

1042

enum_var_type type __attribute__((__unused__)))

1030

1043

{

1031

1044

server_id_supplied = 1;

1032

1045

thd->server_id= server_id;

1062

1075

return out;

1063

1076

}

1064

1077

1065

static bool get_unsigned(THD *thd, set_var *var)

1078

static bool get_unsigned(THD *thd __attribute__((__unused__)), set_var *var)

1066

1079

{

1067

1080

if (var->value->unsigned_flag)

1068

1081

var->save_result.ulonglong_value= (ulonglong) var->value->val_int();

1113

1126

}

1114

1127

1115

1128

1116

void sys_var_long_ptr_global::set_default(THD *thd, enum_var_type type)

1129

void sys_var_long_ptr_global::set_default(THD *thd __attribute__((__unused__)), enum_var_type type __attribute__((__unused__)))

1117

1130

{

1118

1131

my_bool not_used;

1119

1132

pthread_mutex_lock(guard);

1136

1149

}

1137

1150

1138

1151

1139

void sys_var_ulonglong_ptr::set_default(THD *thd, enum_var_type type)

1152

void sys_var_ulonglong_ptr::set_default(THD *thd __attribute__((__unused__)),

1153

enum_var_type type __attribute__((__unused__)))

1140

1154

{

1141

1155

my_bool not_used;

1142

1156

pthread_mutex_lock(&LOCK_global_system_variables);

1146

1160

}

1147

1161

1148

1162

1149

bool sys_var_bool_ptr::update(THD *thd, set_var *var)

1163

bool sys_var_bool_ptr::update(THD *thd __attribute__((__unused__)), set_var *var)

1150

1164

{

1151

1165

*value= (my_bool) var->save_result.ulong_value;

1152

1166

return 0;

1153

1167

}

1154

1168

1155

1169

1156

void sys_var_bool_ptr::set_default(THD *thd, enum_var_type type)

1170

void sys_var_bool_ptr::set_default(THD *thd __attribute__((__unused__)), enum_var_type type __attribute__((__unused__)))

1157

1171

{

1158

1172

*value= (my_bool) option_limits->def_value;

1159

1173

}

1160

1174

1161

1175

1162

bool sys_var_enum::update(THD *thd, set_var *var)

1176

bool sys_var_enum::update(THD *thd __attribute__((__unused__)), set_var *var)

1163

1177

{

1164

1178

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

1165

1179

return 0;

1166

1180

}

1167

1181

1168

1182

1169

uchar *sys_var_enum::value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)

1183

uchar *sys_var_enum::value_ptr(THD *thd __attribute__((__unused__)),

1184

enum_var_type type __attribute__((__unused__)),

1185

LEX_STRING *base __attribute__((__unused__)))

1170

1186

{

1171

1187

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

1172

1188

}

1173

1189

1174

1190

1175

uchar *sys_var_enum_const::value_ptr(THD *thd, enum_var_type type,

1176

LEX_STRING *base)

1191

uchar *sys_var_enum_const::value_ptr(THD *thd __attribute__((__unused__)),

1192

enum_var_type type __attribute__((__unused__)),

1193

LEX_STRING *base __attribute__((__unused__)))

1177

1194

{

1178

1195

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

1179

1196

}

1187

1204

bool sys_var_thd_ulong::update(THD *thd, set_var *var)

1188

1205

{

1189

1206

ulonglong tmp= var->save_result.ulonglong_value;

1190

1207

1191

1208

/* Don't use bigger value than given with --maximum-variable-name=.. */

1192

1209

if ((ulong) tmp > max_system_variables.*offset)

1193

1210

{

1194

1211

throw_bounds_warning(thd, TRUE, TRUE, name, (longlong) tmp);

1195

1212

tmp= max_system_variables.*offset;

1196

1213

}

1197

1214

1198

1215

if (option_limits)

1199

1216

tmp= (ulong) fix_unsigned(thd, tmp, option_limits);

1200

1217

#if SIZEOF_LONG < SIZEOF_LONG_LONG

1204

1221

throw_bounds_warning(thd, TRUE, TRUE, name, (longlong) var->save_result.ulonglong_value);

1205

1222

}

1206

1223

#endif

1207

1224

1208

1225

if (var->type == OPT_GLOBAL)

1209

global_system_variables.*offset= (ulong) tmp;

1210

else

1211

thd->variables.*offset= (ulong) tmp;

1212

1213

return 0;

1214

}

1215

1216

1217

void sys_var_thd_ulong::set_default(THD *thd, enum_var_type type)

1218

{

1219

if (type == OPT_GLOBAL)

1220

{

1221

my_bool not_used;

1222

/* We will not come here if option_limits is not set */

1223

global_system_variables.*offset=

1224

(ulong) getopt_ull_limit_value((ulong) option_limits->def_value,

1225

option_limits, &not_used);

1226

}

1227

else

1228

thd->variables.*offset= global_system_variables.*offset;

1229

}

1226

global_system_variables.*offset= (ulong) tmp;

1227

else

1228

thd->variables.*offset= (ulong) tmp;

1229

1230

return 0;

1231

}

1232

1233

1234

void sys_var_thd_ulong::set_default(THD *thd, enum_var_type type)

1235

{

1236

if (type == OPT_GLOBAL)

1237

{

1238

my_bool not_used;

1239

/* We will not come here if option_limits is not set */

1240

global_system_variables.*offset=

1241

(ulong) getopt_ull_limit_value((ulong) option_limits->def_value,

1242

option_limits, &not_used);

1243

}

1244

else

1245

thd->variables.*offset= global_system_variables.*offset;

1246

}

1230

1247

1231

1248

1232

1249

uchar *sys_var_thd_ulong::value_ptr(THD *thd, enum_var_type type,

1233

LEX_STRING *base)

1250

LEX_STRING *base __attribute__((__unused__)))

1234

1251

{

1235

1252

if (type == OPT_GLOBAL)

1236

1253

return (uchar*) &(global_system_variables.*offset);

1279

1296

1280

1297

1281

1298

uchar *sys_var_thd_ha_rows::value_ptr(THD *thd, enum_var_type type,

1282

LEX_STRING *base)

1299

LEX_STRING *base __attribute__((__unused__)))

1283

1300

{

1284

1301

if (type == OPT_GLOBAL)

1285

1302

return (uchar*) &(global_system_variables.*offset);

1330

1347

1331

1348

1332

1349

uchar *sys_var_thd_ulonglong::value_ptr(THD *thd, enum_var_type type,

1333

LEX_STRING *base)

1350

LEX_STRING *base __attribute__((__unused__)))

1334

1351

{

1335

1352

if (type == OPT_GLOBAL)

1336

1353

return (uchar*) &(global_system_variables.*offset);

1358

1375

1359

1376

1360

1377

uchar *sys_var_thd_bool::value_ptr(THD *thd, enum_var_type type,

1361

LEX_STRING *base)

1378

LEX_STRING *base __attribute__((__unused__)))

1362

1379

{

1363

1380

if (type == OPT_GLOBAL)

1364

1381

return (uchar*) &(global_system_variables.*offset);

1366

1383

}

1367

1384

1368

1385

1369

bool sys_var::check_enum(THD *thd, set_var *var, const TYPELIB *enum_names)

1386

bool sys_var::check_enum(THD *thd __attribute__((__unused__)),

1387

set_var *var, const TYPELIB *enum_names)

1370

1388

{

1371

1389

char buff[STRING_BUFFER_USUAL_SIZE];

1372

1390

const char *value;

1402

1420

}

1403

1421

1404

1422

1405

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

1423

bool sys_var::check_set(THD *thd __attribute__((__unused__)),

1424

set_var *var, TYPELIB *enum_names)

1406

1425

{

1407

1426

bool not_used;

1408

1427

char buff[STRING_BUFFER_USUAL_SIZE], *error= 0;

1601

1620

1602

1621

1603

1622

uchar *sys_var_thd_enum::value_ptr(THD *thd, enum_var_type type,

1604

LEX_STRING *base)

1623

LEX_STRING *base __attribute__((__unused__)))

1605

1624

{

1606

1625

ulong tmp= ((type == OPT_GLOBAL) ?

1607

1626

global_system_variables.*offset :

1622

1641

}

1623

1642

1624

1643

1625

uchar *sys_var_thd_bit::value_ptr(THD *thd, enum_var_type type,

1626

LEX_STRING *base)

1644

uchar *sys_var_thd_bit::value_ptr(THD *thd,

1645

enum_var_type type __attribute__((__unused__)),

1646

LEX_STRING *base __attribute__((__unused__)))

1627

1647

{

1628

1648

/*

1629

1649

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

1723

1743

1724

1744

1725

1745

uchar *sys_var_thd_date_time_format::value_ptr(THD *thd, enum_var_type type,

1726

LEX_STRING *base)

1746

LEX_STRING *base __attribute__((__unused__)))

1727

1747

{

1728

1748

if (type == OPT_GLOBAL)

1729

1749

{

1775

1795

}

1776

1796

1777

1797

1778

bool sys_var_collation::check(THD *thd, set_var *var)

1798

bool sys_var_collation::check(THD *thd __attribute__((__unused__)),

1799

set_var *var)

1779

1800

{

1780

1801

CHARSET_INFO *tmp;

1781

1802

1809

1830

}

1810

1831

1811

1832

1812

bool sys_var_character_set::check(THD *thd, set_var *var)

1833

bool sys_var_character_set::check(THD *thd __attribute__((__unused__)),

1834

set_var *var)

1813

1835

{

1814

1836

CHARSET_INFO *tmp;

1815

1837

1857

1879

1858

1880

1859

1881

uchar *sys_var_character_set::value_ptr(THD *thd, enum_var_type type,

1860

LEX_STRING *base)

1882

LEX_STRING *base __attribute__((__unused__)))

1861

1883

{

1862

1884

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

1863

1885

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

1946

1968

1947

1969

1948

1970

uchar *sys_var_collation_sv::value_ptr(THD *thd, enum_var_type type,

1949

LEX_STRING *base)

1971

LEX_STRING *base __attribute__((__unused__)))

1950

1972

{

1951

1973

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

1952

1974

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

1968

1990

}

1969

1991

1970

1992

1971

uchar *sys_var_key_cache_param::value_ptr(THD *thd, enum_var_type type,

1972

LEX_STRING *base)

1993

uchar *sys_var_key_cache_param::value_ptr(THD *thd __attribute__((__unused__)),

1994

enum_var_type type __attribute__((__unused__)),

1995

LEX_STRING *base __attribute__((__unused__)))

1973

1996

{

1974

1997

KEY_CACHE *key_cache= get_key_cache(base);

1975

1998

if (!key_cache)

2135

2158

return res;

2136

2159

}

2137

2160

2138

void sys_var_log_state::set_default(THD *thd, enum_var_type type)

2161

void sys_var_log_state::set_default(THD *thd,

2162

enum_var_type type __attribute__((__unused__)))

2139

2163

{

2140

2164

pthread_mutex_lock(&LOCK_global_system_variables);

2141

2165

logger.deactivate_log_handler(thd, log_type);

2143

2167

}

2144

2168

2145

2169

2146

static int sys_check_log_path(THD *thd, set_var *var)

2170

static int sys_check_log_path(THD *thd __attribute__((__unused__)),

2171

set_var *var)

2147

2172

{

2148

2173

char path[FN_REFLEN], buff[FN_REFLEN];

2149

2174

struct stat f_stat;

2203

2228

}

2204

2229

2205

2230

2206

bool update_sys_var_str_path(THD *thd, sys_var_str *var_str,

2207

set_var *var, const char *log_ext,

2208

bool log_state, uint log_type)

2231

bool update_sys_var_str_path(THD *thd __attribute__((__unused__)),

2232

sys_var_str *var_str,

2233

set_var *var, const char *log_ext,

2234

bool log_state, uint log_type)

2209

2235

{

2210

2236

MYSQL_QUERY_LOG *file_log;

2211

2237

char buff[FN_REFLEN];

2268

2294

2269

2295

static bool sys_update_general_log_path(THD *thd, set_var * var)

2270

2296

{

2271

return update_sys_var_str_path(thd, &sys_var_general_log_path,

2272

var, ".log", opt_log, QUERY_LOG_GENERAL);

2297

return update_sys_var_str_path(thd, &sys_var_general_log_path,

2298

var, ".log", opt_log, QUERY_LOG_GENERAL);

2273

2299

}

2274

2300

2275

2301

2276

static void sys_default_general_log_path(THD *thd, enum_var_type type)

2302

static void sys_default_general_log_path(THD *thd,

2303

enum_var_type type __attribute__((__unused__)))

2277

2304

{

2278

2305

(void) update_sys_var_str_path(thd, &sys_var_general_log_path,

2279

0, ".log", opt_log, QUERY_LOG_GENERAL);

2306

0, ".log", opt_log, QUERY_LOG_GENERAL);

2280

2307

}

2281

2308

2282

2309

2283

2310

static bool sys_update_slow_log_path(THD *thd, set_var * var)

2284

2311

{

2285

2312

return update_sys_var_str_path(thd, &sys_var_slow_log_path,

2286

var, "-slow.log", opt_slow_log,

2313

var, "-slow.log", opt_slow_log,

2287

2314

QUERY_LOG_SLOW);

2288

2315

}

2289

2316

2290

2317

2291

static void sys_default_slow_log_path(THD *thd, enum_var_type type)

2318

static void sys_default_slow_log_path(THD *thd,

2319

enum_var_type type __attribute__((__unused__)))

2292

2320

{

2293

2321

(void) update_sys_var_str_path(thd, &sys_var_slow_log_path,

2294

0, "-slow.log", opt_slow_log,

2322

0, "-slow.log", opt_slow_log,

2295

2323

QUERY_LOG_SLOW);

2296

2324

}

2297

2325

2298

2326

2299

bool sys_var_log_output::update(THD *thd, set_var *var)

2327

bool sys_var_log_output::update(THD *thd __attribute__((__unused__)),

2328

set_var *var)

2300

2329

{

2301

2330

pthread_mutex_lock(&LOCK_global_system_variables);

2302

2331

logger.lock_exclusive();

2309

2338

}

2310

2339

2311

2340

2312

void sys_var_log_output::set_default(THD *thd, enum_var_type type)

2341

void sys_var_log_output::set_default(THD *thd __attribute__((__unused__)),

2342

enum_var_type type __attribute__((__unused__)))

2313

2343

{

2314

2344

pthread_mutex_lock(&LOCK_global_system_variables);

2315

2345

logger.lock_exclusive();

2321

2351

}

2322

2352

2323

2353

2324

uchar *sys_var_log_output::value_ptr(THD *thd, enum_var_type type,

2325

LEX_STRING *base)

2354

uchar *sys_var_log_output::value_ptr(THD *thd,

2355

enum_var_type type __attribute__((__unused__)),

2356

LEX_STRING *base __attribute__((__unused__)))

2326

2357

{

2327

2358

char buff[256];

2328

2359

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

2350

2381

Functions to handle SET NAMES and SET CHARACTER SET

2351

2382

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

2352

2383

2353

int set_var_collation_client::check(THD *thd)

2384

int set_var_collation_client::check(THD *thd __attribute__((__unused__)))

2354

2385

{

2355

2386

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

2356

2387

if (character_set_client->mbminlen > 1)

2381

2412

}

2382

2413

2383

2414

2384

void sys_var_timestamp::set_default(THD *thd, enum_var_type type)

2415

void sys_var_timestamp::set_default(THD *thd,

2416

enum_var_type type __attribute__((__unused__)))

2385

2417

{

2386

2418

thd->user_time=0;

2387

2419

}

2388

2420

2389

2421

2390

uchar *sys_var_timestamp::value_ptr(THD *thd, enum_var_type type,

2391

LEX_STRING *base)

2422

uchar *sys_var_timestamp::value_ptr(THD *thd,

2423

enum_var_type type __attribute__((__unused__)),

2424

LEX_STRING *base __attribute__((__unused__)))

2392

2425

{

2393

2426

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

2394

2427

return (uchar*) &thd->sys_var_tmp.long_value;

2397

2430

2398

2431

bool sys_var_last_insert_id::update(THD *thd, set_var *var)

2399

2432

{

2400

thd->first_successful_insert_id_in_prev_stmt=

2433

thd->first_successful_insert_id_in_prev_stmt=

2401

2434

var->save_result.ulonglong_value;

2402

2435

return 0;

2403

2436

}

2404

2437

2405

2438

2406

uchar *sys_var_last_insert_id::value_ptr(THD *thd, enum_var_type type,

2407

LEX_STRING *base)

2439

uchar *sys_var_last_insert_id::value_ptr(THD *thd,

2440

enum_var_type type __attribute__((__unused__)),

2441

LEX_STRING *base __attribute__((__unused__)))

2408

2442

{

2409

2443

/*

2410

this tmp var makes it robust againt change of type of

2444

this tmp var makes it robust againt change of type of

2411

2445

read_first_successful_insert_id_in_prev_stmt().

2412

2446

*/

2413

2447

thd->sys_var_tmp.ulonglong_value=

2423

2457

}

2424

2458

2425

2459

2426

uchar *sys_var_insert_id::value_ptr(THD *thd, enum_var_type type,

2427

LEX_STRING *base)

2460

uchar *sys_var_insert_id::value_ptr(THD *thd,

2461

enum_var_type type __attribute__((__unused__)),

2462

LEX_STRING *base __attribute__((__unused__)))

2428

2463

{

2429

thd->sys_var_tmp.ulonglong_value=

2464

thd->sys_var_tmp.ulonglong_value=

2430

2465

thd->auto_inc_intervals_forced.minimum();

2431

2466

return (uchar*) &thd->sys_var_tmp.ulonglong_value;

2432

2467

}

2476

2511

2477

2512

2478

2513

uchar *sys_var_thd_time_zone::value_ptr(THD *thd, enum_var_type type,

2479

LEX_STRING *base)

2514

LEX_STRING *base __attribute__((__unused__)))

2480

2515

{

2481

2516

/*

2482

2517

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

2538

2573

}

2539

2574

}

2540

2575

2541

bool sys_var_max_user_conn::update(THD *thd, set_var *var)

2576

bool sys_var_max_user_conn::update(THD *thd __attribute__((__unused__)),

2577

set_var *var)

2542

2578

{

2543

2579

DBUG_ASSERT(var->type == OPT_GLOBAL);

2544

2580

pthread_mutex_lock(&LOCK_global_system_variables);

2548

2584

}

2549

2585

2550

2586

2551

void sys_var_max_user_conn::set_default(THD *thd, enum_var_type type)

2587

void sys_var_max_user_conn::set_default(THD *thd __attribute__((__unused__)),

2588

enum_var_type type __attribute__((__unused__)))

2552

2589

{

2553

2590

DBUG_ASSERT(type == OPT_GLOBAL);

2554

2591

pthread_mutex_lock(&LOCK_global_system_variables);

2558

2595

2559

2596

2560

2597

uchar *sys_var_max_user_conn::value_ptr(THD *thd, enum_var_type type,

2561

LEX_STRING *base)

2598

LEX_STRING *base __attribute__((__unused__)))

2562

2599

{

2563

2600

if (type != OPT_GLOBAL &&

2564

2601

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

2567

2604

}

2568

2605

2569

2606

2570

bool sys_var_thd_lc_time_names::check(THD *thd, set_var *var)

2607

bool sys_var_thd_lc_time_names::check(THD *thd __attribute__((__unused__)),

2608

set_var *var)

2571

2609

{

2572

2610

MY_LOCALE *locale_match;

2573

2611

2614

2652

}

2615

2653

2616

2654

2617

uchar *sys_var_thd_lc_time_names::value_ptr(THD *thd, enum_var_type type,

2618

LEX_STRING *base)

2655

uchar *sys_var_thd_lc_time_names::value_ptr(THD *thd,

2656

enum_var_type type,

2657

LEX_STRING *base __attribute__((__unused__)))

2619

2658

{

2620

2659

return type == OPT_GLOBAL ?

2621

2660

(uchar *) global_system_variables.lc_time_names->name :

2676

2715

2677

2716

2678

2717

uchar *sys_var_microseconds::value_ptr(THD *thd, enum_var_type type,

2679

LEX_STRING *base)

2718

LEX_STRING *base __attribute__((__unused__)))

2680

2719

{

2681

2720

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

2682

2721

global_system_variables.*offset :

2731

2770

return 0;

2732

2771

}

2733

2772

2734

static int check_log_update(THD *thd, set_var *var)

2773

static int check_log_update(THD *thd __attribute__((__unused__)),

2774

set_var *var __attribute__((__unused__)))

2735

2775

{

2736

2776

return 0;

2737

2777

}

2738

2778

2739

static bool set_log_update(THD *thd, set_var *var)

2779

static bool set_log_update(THD *thd __attribute__((__unused__)),

2780

set_var *var __attribute__((__unused__)))

2740

2781

{

2741

2782

/*

2742

2783

The update log is not supported anymore since 5.0.

2759

2800

}

2760

2801

2761

2802

2762

static int check_pseudo_thread_id(THD *thd, set_var *var)

2803

static int check_pseudo_thread_id(THD *thd __attribute__((__unused__)),

2804

set_var *var)

2763

2805

{

2764

2806

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

2765

2807

return 0;

2796

2838

@retval

2797

2839

ptr pointer to NUL-terminated string

2798

2840

*/

2799

static uchar *get_tmpdir(THD *thd)

2841

static uchar *get_tmpdir(THD *thd __attribute__((__unused__)))

2800

2842

{

2801

2843

if (opt_mysql_tmpdir)

2802

2844

return (uchar *)opt_mysql_tmpdir;

2847

2889

*/

2848

2890

2849

2891

static uchar *get_sys_var_length(const sys_var *var, size_t *length,

2850

my_bool first)

2892

my_bool first __attribute__((__unused__)))

2851

2893

{

2852

2894

*length= var->name_length;

2853

2895

return (uchar*) var->name;

3229

3271

}

3230

3272

3231

3273

3232

int set_var_user::update(THD *thd)

3274

int set_var_user::update(THD *thd __attribute__((__unused__)))

3233

3275

{

3234

3276

if (user_var_item->update())

3235

3277

{

3278

3320

3279

3321

3280

3322

uchar *sys_var_thd_storage_engine::value_ptr(THD *thd, enum_var_type type,

3281

LEX_STRING *base)

3323

LEX_STRING *base __attribute__((__unused__)))

3282

3324

{

3283

3325

uchar* result;

3284

3326

handlerton *hton;

3360

3402

3361

3403

3362

3404

uchar *sys_var_thd_optimizer_switch::value_ptr(THD *thd, enum_var_type type,

3363

LEX_STRING *base)

3405

LEX_STRING *base __attribute__((__unused__)))

3364

3406

{

3365

3407

LEX_STRING opts;

3366

3408

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

3463

3505

}

3464

3506

3465

3507

3466

void free_key_cache(const char *name, KEY_CACHE *key_cache)

3508

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

3509

KEY_CACHE *key_cache)

3467

3510

{

3468

3511

ha_end_key_cache(key_cache);

3469

3512

my_free((char*) key_cache, MYF(0));

3547

3590

DBUG_RETURN(result);

3548

3591

}

3549

3592

3550

bool sys_var_thd_dbug::update(THD *thd, set_var *var)

3593

bool sys_var_thd_dbug::update(THD *thd __attribute__((__unused__)),

3594

set_var *var)

3551

3595

{

3552

3596

if (var->type == OPT_GLOBAL)

3553

3597

{

3562

3606

}

3563

3607

3564

3608

3565

uchar *sys_var_thd_dbug::value_ptr(THD *thd, enum_var_type type, LEX_STRING *b)

3609

uchar *sys_var_thd_dbug::value_ptr(THD *thd, enum_var_type type,

3610

LEX_STRING *b __attribute__((__unused__)))

3566

3611

{

3567

3612

char buf[256];

3568

3613

if (type == OPT_GLOBAL)