~kentokushiba/spiderformysql/spider-2.0-src : revision 16

58

#endif

59

PSI_mutex_key spd_key_mutex_open_conn;

60

PSI_mutex_key spd_key_mutex_allocated_thds;

61

PSI_mutex_key spd_key_mutex_mon_table_cache;

61

62

PSI_mutex_key spd_key_mutex_udf_table_mon;

62

63

PSI_mutex_key spd_key_mutex_mta_conn;

63

64

#ifndef WITHOUT_SPIDER_BG_SEARCH

98

99

#endif

99

100

{ &spd_key_mutex_open_conn, "open_conn", PSI_FLAG_GLOBAL},

100

101

{ &spd_key_mutex_allocated_thds, "allocated_thds", PSI_FLAG_GLOBAL},

102

{ &spd_key_mutex_mon_table_cache, "mon_table_cache", PSI_FLAG_GLOBAL},

101

103

{ &spd_key_mutex_udf_table_mon, "udf_table_mon", PSI_FLAG_GLOBAL},

102

104

{ &spd_key_mutex_mta_conn, "mta_conn", 0},

103

105

#ifndef WITHOUT_SPIDER_BG_SEARCH

179

181

extern pthread_mutex_t *spider_udf_table_mon_mutexes;

180

182

extern pthread_cond_t *spider_udf_table_mon_conds;

181

183

extern pthread_mutex_t spider_open_conn_mutex;

184

extern pthread_mutex_t spider_mon_table_cache_mutex;

185

extern DYNAMIC_ARRAY spider_mon_table_cache;

182

186

183

187

HASH spider_open_tables;

184

188

pthread_mutex_t spider_tbl_mutex;

542

546

}

543

547

my_free(share->tgt_default_groups, MYF(0));

544

548

}

549

#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)

550

if (share->hs_read_socks)

551

{

552

for (roop_count = 0; roop_count < share->hs_read_socks_length;

553

roop_count++)

554

{

555

if (share->hs_read_socks[roop_count])

556

my_free(share->hs_read_socks[roop_count], MYF(0));

557

}

558

my_free(share->hs_read_socks, MYF(0));

559

}

560

if (share->hs_write_socks)

561

{

562

for (roop_count = 0; roop_count < share->hs_write_socks_length;

563

roop_count++)

564

{

565

if (share->hs_write_socks[roop_count])

566

my_free(share->hs_write_socks[roop_count], MYF(0));

567

}

568

my_free(share->hs_write_socks, MYF(0));

569

}

570

#endif

545

571

if (share->bka_engine)

546

572

my_free(share->bka_engine, MYF(0));

547

573

if (share->conn_keys)

558

584

#endif

559

585

if (share->monitoring_kind)

560

586

my_free(share->monitoring_kind, MYF(0));

587

#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)

588

if (share->use_hs_reads)

589

my_free(share->use_hs_reads, MYF(0));

590

if (share->use_hs_writes)

591

my_free(share->use_hs_writes, MYF(0));

592

if (share->hs_read_ports)

593

my_free(share->hs_read_ports, MYF(0));

594

if (share->hs_write_ports)

595

my_free(share->hs_write_ports, MYF(0));

596

#endif

597

if (share->use_handlers)

598

my_free(share->use_handlers, MYF(0));

561

599

#ifndef WITHOUT_SPIDER_BG_SEARCH

562

600

if (share->monitoring_bg_interval)

563

601

my_free(share->monitoring_bg_interval, MYF(0));

665

703

my_free(share->tgt_default_groups[0], MYF(0));

666

704

share->tgt_default_groups[0] = NULL;

667

705

}

706

#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)

707

if (share->hs_read_socks && share->hs_read_socks[0])

708

{

709

my_free(share->hs_read_socks[0], MYF(0));

710

share->hs_read_socks[0] = NULL;

711

}

712

if (share->hs_write_socks && share->hs_write_socks[0])

713

{

714

my_free(share->hs_write_socks[0], MYF(0));

715

share->hs_write_socks[0] = NULL;

716

}

717

#endif

668

718

if (share->bka_engine)

669

719

{

670

720

my_free(share->bka_engine, MYF(0));

1556

1606

share->auto_increment_mode = -1;

1557

1607

share->use_table_charset = -1;

1558

1608

share->use_pushdown_udf = -1;

1609

share->skip_default_condition = -1;

1559

1610

share->direct_dup_insert = -1;

1611

share->direct_order_limit = -1;

1560

1612

share->bka_mode = -1;

1561

1613

1562

1614

#ifdef WITH_PARTITION_STORAGE_ENGINE

1689

1741

SPIDER_PARAM_INT_WITH_MAX("ddi", direct_dup_insert, 0, 1);

1690

1742

SPIDER_PARAM_STR_LIST("dff", tgt_default_files);

1691

1743

SPIDER_PARAM_STR_LIST("dfg", tgt_default_groups);

1744

SPIDER_PARAM_LONGLONG("dol", direct_order_limit, 0);

1692

1745

#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)

1693

1746

SPIDER_PARAM_LONG_LIST_WITH_MAX(

1694

1747

"hrp", hs_read_ports, 0, 65535);

1732

1785

SPIDER_PARAM_INT_WITH_MAX("scm", select_column_mode, 0, 1);

1733

1786

SPIDER_PARAM_STR_LIST("scp", tgt_ssl_capaths);

1734

1787

SPIDER_PARAM_STR_LIST("scr", tgt_ssl_certs);

1788

SPIDER_PARAM_INT_WITH_MAX("sdc", skip_default_condition, 0, 1);

1735

1789

SPIDER_PARAM_STR_LIST("sky", tgt_ssl_keys);

1736

1790

SPIDER_PARAM_LONG_LIST_WITH_MAX("svc", tgt_ssl_vscs, 0, 1);

1737

1791

SPIDER_PARAM_INT("srt", scan_rate, 0);

1945

1999

SPIDER_PARAM_LONG_LIST_WITH_MAX(

1946

2000

"monitoring_bg_kind", monitoring_bg_kind, 0, 3);

1947

2001

#endif

2002

SPIDER_PARAM_LONGLONG(

2003

"direct_order_limit", direct_order_limit, 0);

1948

2004

error_num = ER_SPIDER_INVALID_CONNECT_INFO_NUM;

1949

2005

my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_STR,

1950

2006

MYF(0), tmp_ptr);

1978

2034

SPIDER_PARAM_LONGLONG_LIST_WITH_MAX(

1979

2035

"monitoring_bg_interval", monitoring_bg_interval, 0, 4294967295);

1980

2036

#endif

2037

SPIDER_PARAM_INT_WITH_MAX(

2038

"skip_default_condition", skip_default_condition, 0, 1);

1981

2039

error_num = ER_SPIDER_INVALID_CONNECT_INFO_NUM;

1982

2040

my_printf_error(error_num, ER_SPIDER_INVALID_CONNECT_INFO_STR,

1983

2041

MYF(0), tmp_ptr);

2957

3015

share->use_table_charset = 1;

2958

3016

if (share->use_pushdown_udf == -1)

2959

3017

share->use_pushdown_udf = 1;

3018

if (share->skip_default_condition == -1)

3019

share->skip_default_condition = 1;

2960

3020

if (share->direct_dup_insert == -1)

2961

3021

share->direct_dup_insert = 0;

3022

if (share->direct_order_limit == -1)

3023

share->direct_order_limit = 0;

2962

3024

if (share->bka_mode == -1)

2963

3025

share->bka_mode = 1;

2964

3026

if (!share->bka_engine)

3263

3325

} else

3264

3326

tmp_name++;

3265

3327

tmp_name++;

3328

tmp_name++;

3266

3329

#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)

3267

3330

share->hs_read_conn_keys[roop_count] = tmp_hs_r_name;

3268

3331

*tmp_hs_r_name = '0';

3285

3348

} else

3286

3349

tmp_hs_r_name++;

3287

3350

tmp_hs_r_name++;

3351

tmp_hs_r_name++;

3288

3352

share->hs_write_conn_keys[roop_count] = tmp_hs_w_name;

3289

3353

*tmp_hs_w_name = '0';

3290

3354

DBUG_PRINT("info",("spider tgt_wrappers[%d]=%s", roop_count,

3306

3370

} else

3307

3371

tmp_hs_w_name++;

3308

3372

tmp_hs_w_name++;

3373

tmp_hs_w_name++;

3309

3374

#endif

3310

3375

}

3311

3376

DBUG_RETURN(0);

4403

4468

SPIDER_SHARE tmp_share;

4404

4469

char *db_name, *table_name;

4405

4470

uint db_name_length, table_name_length;

4406

char *tmp_connect_info[15];

4407

uint tmp_connect_info_length[15];

4408

long tmp_long[5];

4409

longlong tmp_longlong[3];

4471

char *tmp_connect_info[SPIDER_TMP_SHARE_CHAR_PTR_COUNT];

4472

uint tmp_connect_info_length[SPIDER_TMP_SHARE_UINT_COUNT];

4473

long tmp_long[SPIDER_TMP_SHARE_LONG_COUNT];

4474

longlong tmp_longlong[SPIDER_TMP_SHARE_LONGLONG_COUNT];

4410

4475

SPIDER_CONN *conn, **conns;

4411

4476

ha_spider *spider;

4412

4477

SPIDER_SHARE *share;

4523

4588

if (!(share = (SPIDER_SHARE *)

4524

4589

my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),

4525

4590

&share, sizeof(*share),

4526

&connect_info, sizeof(char *) * 15,

4527

&connect_info_length, sizeof(uint) * 15,

4528

&long_info, sizeof(long) * 5,

4529

&longlong_info, sizeof(longlong) * 3,

4591

&connect_info, sizeof(char *) * SPIDER_TMP_SHARE_CHAR_PTR_COUNT,

4592

&connect_info_length, sizeof(uint) * SPIDER_TMP_SHARE_UINT_COUNT,

4593

&long_info, sizeof(long) * SPIDER_TMP_SHARE_LONG_COUNT,

4594

&longlong_info, sizeof(longlong) * SPIDER_TMP_SHARE_LONGLONG_COUNT,

4530

4595

&conns, sizeof(SPIDER_CONN *),

4531

4596

&need_mon, sizeof(int),

4532

4597

NullS))

4770

4835

spider_free_conn(conn);

4771

4836

}

4772

4837

pthread_mutex_unlock(&spider_conn_mutex);

4838

delete_dynamic(&spider_mon_table_cache);

4773

4839

my_hash_free(&spider_allocated_thds);

4774

4840

#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)

4775

4841

my_hash_free(&spider_hs_w_conn_hash);

4789

4855

pthread_mutex_unlock(&spider_init_error_tbl_mutex);

4790

4856

my_hash_free(&spider_init_error_tables);

4791

4857

my_hash_free(&spider_open_tables);

4858

pthread_mutex_destroy(&spider_mon_table_cache_mutex);

4792

4859

pthread_mutex_destroy(&spider_allocated_thds_mutex);

4793

4860

pthread_mutex_destroy(&spider_open_conn_mutex);

4794

4861

#ifndef WITHOUT_SPIDER_BG_SEARCH

4969

5036

error_num = HA_ERR_OUT_OF_MEM;

4970

5037

goto error_allocated_thds_mutex_init;

4971

5038

}

5039

#if MYSQL_VERSION_ID < 50500

5040

if (pthread_mutex_init(&spider_mon_table_cache_mutex, MY_MUTEX_INIT_FAST))

5041

#else

5042

if (mysql_mutex_init(spd_key_mutex_mon_table_cache,

5043

&spider_mon_table_cache_mutex, MY_MUTEX_INIT_FAST))

5044

#endif

5045

{

5046

error_num = HA_ERR_OUT_OF_MEM;

5047

goto error_mon_table_cache_mutex_init;

5048

}

4972

5049

4973

5050

if(

4974

5051

my_hash_init(&spider_open_tables, system_charset_info, 32, 0, 0,

5024

5101

goto error_allocated_thds_hash_init;

5025

5102

}

5026

5103

5104

if(

5105

my_init_dynamic_array2(&spider_mon_table_cache, sizeof(SPIDER_MON_KEY),

5106

NULL, 64, 64)

5107

) {

5108

error_num = HA_ERR_OUT_OF_MEM;

5109

goto error_mon_table_cache_array_init;

5110

}

5111

5027

5112

if (!(spider_udf_table_mon_mutexes = (pthread_mutex_t *)

5028

5113

my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),

5029

5114

&spider_udf_table_mon_mutexes, sizeof(pthread_mutex_t) *

5101

5186

pthread_mutex_destroy(&spider_udf_table_mon_mutexes[roop_count]);

5102

5187

my_free(spider_udf_table_mon_mutexes, MYF(0));

5103

5188

error_alloc_mon_mutxes:

5189

delete_dynamic(&spider_mon_table_cache);

5190

error_mon_table_cache_array_init:

5104

5191

my_hash_free(&spider_allocated_thds);

5105

5192

error_allocated_thds_hash_init:

5106

5193

#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)

5119

5206

error_init_error_tables_hash_init:

5120

5207

my_hash_free(&spider_open_tables);

5121

5208

error_open_tables_hash_init:

5209

pthread_mutex_destroy(&spider_mon_table_cache_mutex);

5210

error_mon_table_cache_mutex_init:

5122

5211

pthread_mutex_destroy(&spider_allocated_thds_mutex);

5123

5212

error_allocated_thds_mutex_init:

5124

5213

#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)

5656

5745

tmp_share->tgt_ssl_keys = &tmp_connect_info[12];

5657

5746

tmp_share->tgt_default_files = &tmp_connect_info[13];

5658

5747

tmp_share->tgt_default_groups = &tmp_connect_info[14];

5748

#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)

5749

tmp_share->hs_read_socks = &tmp_connect_info[15];

5750

tmp_share->hs_write_socks = &tmp_connect_info[16];

5751

#endif

5659

5752

tmp_share->tgt_ports = &tmp_long[0];

5660

5753

tmp_share->tgt_ssl_vscs = &tmp_long[1];

5661

5754

tmp_share->link_statuses = &tmp_long[2];

5663

5756

#ifndef WITHOUT_SPIDER_BG_SEARCH

5664

5757

tmp_share->monitoring_bg_kind = &tmp_long[4];

5665

5758

#endif

5759

#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)

5760

tmp_share->use_hs_reads = &tmp_long[5];

5761

tmp_share->use_hs_writes = &tmp_long[6];

5762

tmp_share->hs_read_ports = &tmp_long[7];

5763

tmp_share->hs_write_ports = &tmp_long[8];

5764

#endif

5765

tmp_share->use_handlers = &tmp_long[9];

5666

5766

tmp_share->monitoring_limit = &tmp_longlong[0];

5667

5767

tmp_share->monitoring_sid = &tmp_longlong[1];

5668

5768

#ifndef WITHOUT_SPIDER_BG_SEARCH

5683

5783

tmp_share->tgt_ssl_keys_lengths = &tmp_connect_info_length[12];

5684

5784

tmp_share->tgt_default_files_lengths = &tmp_connect_info_length[13];

5685

5785

tmp_share->tgt_default_groups_lengths = &tmp_connect_info_length[14];

5786

#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)

5787

tmp_share->hs_read_socks_lengths = &tmp_connect_info_length[15];

5788

tmp_share->hs_write_socks_lengths = &tmp_connect_info_length[16];

5789

#endif

5686

5790

tmp_share->server_names_length = 1;

5687

5791

tmp_share->tgt_table_names_length = 1;

5688

5792

tmp_share->tgt_dbs_length = 1;

5710

5814

#ifndef WITHOUT_SPIDER_BG_SEARCH

5711

5815

tmp_share->monitoring_bg_interval_length = 1;

5712

5816

#endif

5817

#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)

5818

tmp_share->hs_read_socks_length = 1;

5819

tmp_share->hs_write_socks_length = 1;

5820

tmp_share->use_hs_reads_length = 1;

5821

tmp_share->use_hs_writes_length = 1;

5822

tmp_share->hs_read_ports_length = 1;

5823

tmp_share->hs_write_ports_length = 1;

5824

#endif

5825

tmp_share->use_handlers_length = 1;

5713

5826

tmp_share->net_timeout = -1;

5714

5827

5715

5828

#ifndef WITHOUT_SPIDER_BG_SEARCH

5796

5909

THDVAR(thd, split_read)

5797

5910

);

5798

5911

}

5912

5913

bool spider_check_direct_order_limit(

5914

ha_spider *spider

5915

) {

5916

THD *thd = spider->trx->thd;

5917

SPIDER_SHARE *share = spider->share;

5918

longlong direct_order_limit = (THDVAR(thd, direct_order_limit) == -1 ?

5919

share->direct_order_limit : THDVAR(thd, direct_order_limit));

5920

DBUG_ENTER("spider_check_direct_order_limit");

5921

if (direct_order_limit)

5922

{

5923

st_select_lex *select_lex;

5924

longlong select_limit;

5925

longlong offset_limit;

5926

spider_get_select_limit(spider, &select_lex, &select_limit, &offset_limit);

5927

if (

5928

#if MYSQL_VERSION_ID < 50500

5929

!thd->variables.engine_condition_pushdown ||

5930

#else

5931

!(thd->variables.optimizer_switch &

5932

OPTIMIZER_SWITCH_ENGINE_CONDITION_PUSHDOWN) ||

5933

#endif

5934

!select_lex ||

5935

!select_lex->explicit_limit ||

5936

(select_lex->options & OPTION_FOUND_ROWS) ||

5937

select_lex->with_sum_func ||

5938

select_lex->group_list.elements ||

5939

select_lex->having ||

5940

select_lex->table_list.elements != 1 ||

5941

!select_lex->order_list.elements ||

5942

select_limit > direct_order_limit - offset_limit

5943

) {

5944

DBUG_PRINT("info",("spider FALSE by select_lex"));

5945

DBUG_RETURN(FALSE);

5946

}

5947

ORDER *order;

5948

for (order = (ORDER *) select_lex->order_list.first; order;

5949

order = order->next)

5950

{

5951

if (spider_db_print_item_type((*order->item), spider, NULL, NULL, 0))

5952

{

5953

DBUG_PRINT("info",("spider FALSE by order"));

5954

DBUG_RETURN(FALSE);

5955

}

5956

}

5957

if (spider_db_append_condition(spider, NULL, NULL, 0))

5958

{

5959

DBUG_PRINT("info",("spider FALSE by condition"));

5960

DBUG_RETURN(FALSE);

5961

}

5962

DBUG_PRINT("info",("spider TRUE"));

5963

spider->trx->direct_order_limit_count++;

5964

DBUG_RETURN(TRUE);

5965

}

5966

DBUG_PRINT("info",("spider FALSE by parameter"));

5967

DBUG_RETURN(FALSE);

5968

}

5969

5970

int spider_compare_for_sort(

5971

SPIDER_SORT *a,

5972

SPIDER_SORT *b

5973

) {

5974

DBUG_ENTER("spider_compare_for_sort");

5975

if (a->sort > b->sort)

5976

DBUG_RETURN(-1);

5977

if (a->sort < b->sort)

5978

DBUG_RETURN(1);

5979

DBUG_RETURN(0);

5980

}

5981

5982

ulong spider_calc_for_sort(

5983

uint count,

5984

...

5985

) {

5986

ulong sort = 0;

5987

va_list args;

5988

va_start(args, count);

5989

DBUG_ENTER("spider_calc_for_sort");

5990

while (count--)

5991

{

5992

char *start = va_arg(args, char *), *str;

5993

uint wild_pos = 0;

5994

5995

if ((str = start))

5996

{

5997

wild_pos = 128;

5998

for (; *str; str++)

5999

{

6000

if (*str == wild_prefix && str[1])

6001

str++;

6002

else if (*str == wild_many || *str == wild_one)

6003

{

6004

wild_pos = (uint) (str - start) + 1;

6005

if (wild_pos > 127)

6006

wild_pos = 127;

6007

break;

6008

}

6009

}

6010

}

6011

sort = (sort << 8) + wild_pos;

6012

}

6013

va_end(args);

6014

DBUG_RETURN(sort);

6015

}