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

2879

DBUG_ENTER("spider_db_append_select_columns");

2880

if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)

2881

{

2882

if ((error_num = spider_db_append_match_select(&result_list->sql, spider,

2883

NULL, 0)))

2884

DBUG_RETURN(error_num);

2882

2885

if (!spider->select_column_mode)

2883

2886

{

2884

2887

if (result_list->keyread)

3005

3008

const char *alias,

3006

3009

uint alias_length

3007

3010

) {

3011

int error_num;

3008

3012

SPIDER_RESULT_LIST *result_list = &spider->result_list;

3009

3013

DBUG_ENTER("spider_db_append_select_columns_with_alias");

3014

if ((error_num = spider_db_append_match_select(&result_list->sql, spider,

3015

alias, alias_length)))

3016

DBUG_RETURN(error_num);

3010

3017

if (!spider->select_column_mode)

3011

3018

{

3012

3019

if (result_list->keyread)

3945

3952

DBUG_RETURN(0);

3946

3953

}

3947

3954

3948

int spider_db_append_match_where(

3949

ha_spider *spider

3955

int spider_db_append_match_against(

3956

String *str,

3957

ha_spider *spider,

3958

st_spider_ft_info *ft_info,

3959

const char *alias,

3960

uint alias_length

3950

3961

) {

3951

SPIDER_RESULT_LIST *result_list = &spider->result_list;

3952

3962

SPIDER_SHARE *share = spider->share;

3953

String *str = &result_list->sql;

3954

String *ft_init_key = spider->ft_init_key;

3955

KEY *key_info = result_list->key_info;

3963

TABLE *table = spider->get_table();

3964

String *ft_init_key;

3965

KEY *key_info;

3956

3966

uint key_name_length;

3957

3967

int key_count;

3958

3968

KEY_PART_INFO *key_part;

3959

3969

Field *field;

3960

DBUG_ENTER("spider_db_append_match_where");

3961

3962

DBUG_PRINT("info", ("spider key_info->key_parts=%u", key_info->key_parts));

3963

3964

if (str->reserve(SPIDER_SQL_WHERE_LEN + SPIDER_SQL_MATCH_LEN))

3970

DBUG_ENTER("spider_db_append_match_against");

3971

3972

if (str->reserve(SPIDER_SQL_MATCH_LEN))

3965

3973

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

3966

str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN);

3967

3974

str->q_append(SPIDER_SQL_MATCH_STR, SPIDER_SQL_MATCH_LEN);

3968

3975

3976

ft_init_key = ft_info->key;

3977

key_info = &table->key_info[ft_info->inx];

3978

DBUG_PRINT("info", ("spider key_info->key_parts=%u",

3979

key_info->key_parts));

3980

3969

3981

for (

3970

3982

key_part = key_info->key_part,

3971

3983

key_count = 0;

3975

3987

) {

3976

3988

field = key_part->field;

3977

3989

key_name_length = share->column_name_str[field->field_index].length();

3978

if (str->reserve(key_name_length + SPIDER_SQL_COMMA_LEN))

3979

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

3990

if (alias_length)

3991

{

3992

if (str->reserve(alias_length + key_name_length +

3993

(SPIDER_SQL_NAME_QUOTE_LEN) * 2 + SPIDER_SQL_COMMA_LEN))

3994

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

3995

str->q_append(alias, alias_length);

3996

} else {

3997

if (str->reserve(key_name_length + SPIDER_SQL_COMMA_LEN))

3998

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

3999

}

3980

4000

spider_db_append_column_name(share, str, field->field_index);

3981

4001

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

3982

4002

}

3998

4018

3999

4019

if (str->reserve(

4000

4020

SPIDER_SQL_VALUE_QUOTE_LEN + SPIDER_SQL_CLOSE_PAREN_LEN +

4001

((spider->ft_init_flags & FT_BOOL) ? SPIDER_SQL_IN_BOOLEAN_MODE_LEN : 0) +

4002

((spider->ft_init_flags & FT_EXPAND) ?

4021

((ft_info->flags & FT_BOOL) ? SPIDER_SQL_IN_BOOLEAN_MODE_LEN : 0) +

4022

((ft_info->flags & FT_EXPAND) ?

4003

4023

SPIDER_SQL_WITH_QUERY_EXPANSION_LEN : 0)

4004

4024

))

4005

4025

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4006

4026

str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);

4007

if (spider->ft_init_flags & FT_BOOL)

4027

if (ft_info->flags & FT_BOOL)

4008

4028

str->q_append(SPIDER_SQL_IN_BOOLEAN_MODE_STR,

4009

4029

SPIDER_SQL_IN_BOOLEAN_MODE_LEN);

4010

if (spider->ft_init_flags & FT_EXPAND)

4030

if (ft_info->flags & FT_EXPAND)

4011

4031

str->q_append(SPIDER_SQL_WITH_QUERY_EXPANSION_STR,

4012

4032

SPIDER_SQL_WITH_QUERY_EXPANSION_LEN);

4013

4033

str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);

4034

DBUG_RETURN(0);

4035

}

4036

4037

int spider_db_append_match_select(

4038

String *str,

4039

ha_spider *spider,

4040

const char *alias,

4041

uint alias_length

4042

) {

4043

int error_num;

4044

DBUG_ENTER("spider_db_append_match_select");

4045

if (spider->ft_current)

4046

{

4047

st_spider_ft_info *ft_info = spider->ft_first;

4048

while (TRUE)

4049

{

4050

if ((error_num = spider_db_append_match_against(str, spider, ft_info,

4051

alias, alias_length)))

4052

DBUG_RETURN(error_num);

4053

if (str->reserve(SPIDER_SQL_COMMA_LEN))

4054

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4055

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

4056

if (ft_info == spider->ft_current)

4057

break;

4058

ft_info = ft_info->next;

4059

}

4060

}

4061

DBUG_RETURN(0);

4062

}

4063

4064

int spider_db_append_match_fetch(

4065

ha_spider *spider,

4066

st_spider_ft_info *ft_first,

4067

st_spider_ft_info *ft_current,

4068

SPIDER_DB_ROW *row,

4069

ulong **lengths

4070

) {

4071

DBUG_ENTER("spider_db_append_match_fetch");

4072

if (ft_current)

4073

{

4074

st_spider_ft_info *ft_info = ft_first;

4075

while (TRUE)

4076

{

4077

DBUG_PRINT("info",("spider ft_info=%p", ft_info));

4078

if (**row)

4079

ft_info->score = (float) atof(**row);

4080

else

4081

DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM);

4082

(*row)++;

4083

(*lengths)++;

4084

if (ft_info == ft_current)

4085

break;

4086

ft_info = ft_info->next;

4087

}

4088

}

4089

DBUG_RETURN(0);

4090

}

4091

4092

int spider_db_append_match_where(

4093

ha_spider *spider

4094

) {

4095

int error_num;

4096

SPIDER_RESULT_LIST *result_list = &spider->result_list;

4097

String *str = &result_list->sql;

4098

bool first = TRUE;

4099

st_spider_ft_info *ft_info = spider->ft_first;

4100

DBUG_ENTER("spider_db_append_match_where");

4101

4102

if (spider->ft_current)

4103

{

4104

while (TRUE)

4105

{

4106

if (ft_info->used_in_where)

4107

{

4108

if (first)

4109

{

4110

if (str->reserve(SPIDER_SQL_WHERE_LEN))

4111

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4112

str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN);

4113

first = FALSE;

4114

}

4115

if ((error_num = spider_db_append_match_against(str, spider, ft_info,

4116

NULL, 0)))

4117

DBUG_RETURN(error_num);

4118

if (str->reserve(SPIDER_SQL_AND_LEN))

4119

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4120

str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);

4121

}

4122

4123

if (ft_info == spider->ft_current)

4124

break;

4125

ft_info = ft_info->next;

4126

}

4127

if (!first)

4128

str->length(str->length() - SPIDER_SQL_AND_LEN);

4129

}

4014

4130

4015

4131

/* use condition */

4016

4132

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

4130

4246

)

4131

4247

DBUG_RETURN(0);

4132

4248

4133

if (result_list->sorted == TRUE)

4249

if (result_list->direct_order_limit)

4134

4250

{

4135

if (result_list->desc_flg == TRUE)

4136

{

4137

for (

4138

key_part = key_info->key_part + result_list->key_order,

4139

length = 1;

4140

length + result_list->key_order < key_info->key_parts &&

4141

length < result_list->max_order;

4142

key_part++,

4143

length++

4144

) {

4145

field = key_part->field;

4146

key_name_length = share->column_name_str[field->field_index].length();

4147

if (length == 1)

4148

{

4149

if (str->reserve(SPIDER_SQL_ORDER_LEN))

4150

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4151

str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);

4152

}

4153

if (key_part->key_part_flag & HA_REVERSE_SORT)

4154

{

4155

if (str->reserve(key_name_length + SPIDER_SQL_COMMA_LEN))

4156

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4157

spider_db_append_column_name(share, str, field->field_index);

4158

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

4159

} else {

4160

if (str->reserve(key_name_length +

4161

SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN))

4162

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4163

spider_db_append_column_name(share, str, field->field_index);

4164

str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);

4165

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

4166

}

4167

}

4168

if (

4169

length + result_list->key_order <= key_info->key_parts &&

4170

length <= result_list->max_order

4171

) {

4172

field = key_part->field;

4173

key_name_length = share->column_name_str[field->field_index].length();

4174

if (length == 1)

4175

{

4176

if (str->reserve(SPIDER_SQL_ORDER_LEN))

4177

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4178

str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);

4179

}

4180

if (key_part->key_part_flag & HA_REVERSE_SORT)

4181

{

4182

if (str->reserve(key_name_length))

4183

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4184

spider_db_append_column_name(share, str, field->field_index);

4185

} else {

4186

if (str->reserve(key_name_length + SPIDER_SQL_DESC_LEN))

4187

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4188

spider_db_append_column_name(share, str, field->field_index);

4189

str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);

4190

}

4191

}

4192

} else {

4193

for (

4194

key_part = key_info->key_part + result_list->key_order,

4195

length = 1;

4196

length + result_list->key_order < key_info->key_parts &&

4197

length < result_list->max_order;

4198

key_part++,

4199

length++

4200

) {

4201

field = key_part->field;

4202

key_name_length = share->column_name_str[field->field_index].length();

4203

if (length == 1)

4204

{

4205

if (str->reserve(SPIDER_SQL_ORDER_LEN))

4206

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4207

str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);

4208

}

4209

if (key_part->key_part_flag & HA_REVERSE_SORT)

4210

{

4211

if (str->reserve(key_name_length +

4212

SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN))

4213

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4214

spider_db_append_column_name(share, str, field->field_index);

4215

str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);

4216

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

4217

} else {

4218

if (str->reserve(key_name_length + SPIDER_SQL_COMMA_LEN))

4219

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4220

spider_db_append_column_name(share, str, field->field_index);

4221

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

4222

}

4223

}

4224

if (

4225

length + result_list->key_order <= key_info->key_parts &&

4226

length <= result_list->max_order

4227

) {

4228

field = key_part->field;

4229

key_name_length = share->column_name_str[field->field_index].length();

4230

if (length == 1)

4231

{

4232

if (str->reserve(SPIDER_SQL_ORDER_LEN))

4233

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4234

str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);

4235

}

4236

if (key_part->key_part_flag & HA_REVERSE_SORT)

4237

{

4238

if (str->reserve(key_name_length + SPIDER_SQL_DESC_LEN))

4239

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4240

spider_db_append_column_name(share, str, field->field_index);

4241

str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);

4242

} else {

4243

if (str->reserve(key_name_length))

4244

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4245

spider_db_append_column_name(share, str, field->field_index);

4251

int error_num;

4252

ORDER *order;

4253

st_select_lex *select_lex;

4254

longlong select_limit;

4255

longlong offset_limit;

4256

spider_get_select_limit(spider, &select_lex, &select_limit,

4257

&offset_limit);

4258

if (str->reserve(SPIDER_SQL_ORDER_LEN))

4259

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4260

str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);

4261

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

4262

order = order->next)

4263

{

4264

if ((error_num =

4265

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

4266

{

4267

DBUG_PRINT("info",("spider error=%d", error_num));

4268

DBUG_RETURN(error_num);

4269

}

4270

if (order->asc)

4271

{

4272

if (str->reserve(SPIDER_SQL_COMMA_LEN))

4273

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4274

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

4275

} else {

4276

if (str->reserve(SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN))

4277

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4278

str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);

4279

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

4280

}

4281

}

4282

str->length(str->length() - SPIDER_SQL_COMMA_LEN);

4283

} else {

4284

if (result_list->sorted == TRUE)

4285

{

4286

if (result_list->desc_flg == TRUE)

4287

{

4288

for (

4289

key_part = key_info->key_part + result_list->key_order,

4290

length = 1;

4291

length + result_list->key_order < key_info->key_parts &&

4292

length < result_list->max_order;

4293

key_part++,

4294

length++

4295

) {

4296

field = key_part->field;

4297

key_name_length =

4298

share->column_name_str[field->field_index].length();

4299

if (length == 1)

4300

{

4301

if (str->reserve(SPIDER_SQL_ORDER_LEN))

4302

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4303

str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);

4304

}

4305

if (key_part->key_part_flag & HA_REVERSE_SORT)

4306

{

4307

if (str->reserve(key_name_length + SPIDER_SQL_COMMA_LEN))

4308

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4309

spider_db_append_column_name(share, str, field->field_index);

4310

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

4311

} else {

4312

if (str->reserve(key_name_length +

4313

SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN))

4314

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4315

spider_db_append_column_name(share, str, field->field_index);

4316

str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);

4317

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

4318

}

4319

}

4320

if (

4321

length + result_list->key_order <= key_info->key_parts &&

4322

length <= result_list->max_order

4323

) {

4324

field = key_part->field;

4325

key_name_length =

4326

share->column_name_str[field->field_index].length();

4327

if (length == 1)

4328

{

4329

if (str->reserve(SPIDER_SQL_ORDER_LEN))

4330

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4331

str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);

4332

}

4333

if (key_part->key_part_flag & HA_REVERSE_SORT)

4334

{

4335

if (str->reserve(key_name_length))

4336

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4337

spider_db_append_column_name(share, str, field->field_index);

4338

} else {

4339

if (str->reserve(key_name_length + SPIDER_SQL_DESC_LEN))

4340

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4341

spider_db_append_column_name(share, str, field->field_index);

4342

str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);

4343

}

4344

}

4345

} else {

4346

for (

4347

key_part = key_info->key_part + result_list->key_order,

4348

length = 1;

4349

length + result_list->key_order < key_info->key_parts &&

4350

length < result_list->max_order;

4351

key_part++,

4352

length++

4353

) {

4354

field = key_part->field;

4355

key_name_length =

4356

share->column_name_str[field->field_index].length();

4357

if (length == 1)

4358

{

4359

if (str->reserve(SPIDER_SQL_ORDER_LEN))

4360

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4361

str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);

4362

}

4363

if (key_part->key_part_flag & HA_REVERSE_SORT)

4364

{

4365

if (str->reserve(key_name_length +

4366

SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN))

4367

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4368

spider_db_append_column_name(share, str, field->field_index);

4369

str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);

4370

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

4371

} else {

4372

if (str->reserve(key_name_length + SPIDER_SQL_COMMA_LEN))

4373

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4374

spider_db_append_column_name(share, str, field->field_index);

4375

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

4376

}

4377

}

4378

if (

4379

length + result_list->key_order <= key_info->key_parts &&

4380

length <= result_list->max_order

4381

) {

4382

field = key_part->field;

4383

key_name_length =

4384

share->column_name_str[field->field_index].length();

4385

if (length == 1)

4386

{

4387

if (str->reserve(SPIDER_SQL_ORDER_LEN))

4388

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4389

str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);

4390

}

4391

if (key_part->key_part_flag & HA_REVERSE_SORT)

4392

{

4393

if (str->reserve(key_name_length + SPIDER_SQL_DESC_LEN))

4394

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4395

spider_db_append_column_name(share, str, field->field_index);

4396

str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);

4397

} else {

4398

if (str->reserve(key_name_length))

4399

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

4400

spider_db_append_column_name(share, str, field->field_index);

4401

}

4246

4402

}

4247

4403

}

4248

4404

}

4298

4454

DBUG_ENTER("spider_db_append_limit");

4299

4455

if (spider)

4300

4456

{

4457

if (spider->result_list.direct_order_limit)

4458

{

4459

st_select_lex *select_lex;

4460

longlong select_limit;

4461

longlong offset_limit;

4462

spider_get_select_limit(spider, &select_lex, &select_limit,

4463

&offset_limit);

4464

if ((error_num = spider_db_append_limit_internal(spider, str, 0,

4465

select_limit + offset_limit, SPIDER_SQL_KIND_SQL)))

4466

DBUG_RETURN(error_num);

4467

spider->result_list.internal_limit = 0;

4468

DBUG_RETURN(0);

4469

}

4470

4301

4471

if (

4302

4472

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

4303

4473

#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS

5041

5211

} else

5042

5212

spider->multi_range_hit_point = 0;

5043

5213

}

5214

5215

if ((error_num = spider_db_append_match_fetch(spider,

5216

spider->ft_first, spider->ft_current, &row, &lengths)))

5217

DBUG_RETURN(error_num);

5044

5218

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

5045

5219

} else {

5046

5220

if (spider->conn_kind[spider->result_link_idx] == SPIDER_CONN_KIND_HS_READ)

5151

5325

row++;

5152

5326

lengths++;

5153

5327

}

5328

if ((error_num = spider_db_append_match_fetch(spider,

5329

spider->ft_first, spider->ft_current, &row, &lengths)))

5330

DBUG_RETURN(error_num);

5154

5331

5155

5332

for (

5156

5333

key_part = key_info->key_part,

5222

5399

row++;

5223

5400

lengths++;

5224

5401

}

5402

if ((error_num = spider_db_append_match_fetch(spider,

5403

spider->ft_first, spider->ft_current, &row, &lengths)))

5404

DBUG_RETURN(error_num);

5225

5405

5226

5406

for (

5227

5407

field = table->field;

6669

6849

pos->use_position = TRUE;

6670

6850

pos->mrr_with_cnt = spider->mrr_with_cnt;

6671

6851

pos->position_bitmap = spider->position_bitmap;

6852

pos->ft_first = spider->ft_first;

6853

pos->ft_current = spider->ft_current;

6672

6854

DBUG_RETURN(pos);

6673

6855

}

6674

6856

6712

6894

my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(buf, table->record[0]);

6713

6895

DBUG_ENTER("spider_db_seek_tmp_table");

6714

6896

/* for mrr */

6715

if (spider->mrr_with_cnt)

6897

if (pos->mrr_with_cnt)

6716

6898

{

6717

6899

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

6718

6900

if (spider->sql_kind[spider->result_link_idx] == SPIDER_SQL_KIND_SQL)

6721

6903

lengths++;

6722

6904

}

6723

6905

}

6906

if ((error_num = spider_db_append_match_fetch(spider,

6907

pos->ft_first, pos->ft_current, &row, &lengths)))

6908

DBUG_RETURN(error_num);

6724

6909

6725

6910

for (

6726

6911

field = table->field;

6765

6950

my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(buf, table->record[0]);

6766

6951

DBUG_ENTER("spider_db_seek_tmp_key");

6767

6952

/* for mrr */

6768

if (spider->mrr_with_cnt)

6953

if (pos->mrr_with_cnt)

6769

6954

{

6770

6955

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

6771

6956

row++;

6772

6957

lengths++;

6773

6958

}

6959

if ((error_num = spider_db_append_match_fetch(spider,

6960

pos->ft_first, pos->ft_current, &row, &lengths)))

6961

DBUG_RETURN(error_num);

6774

6962

6775

6963

for (

6776

6964

key_part = key_info->key_part,

6814

7002

SPIDER_DB_ROW row = pos->row;

6815

7003

my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(buf, table->record[0]);

6816

7004

DBUG_ENTER("spider_db_seek_tmp_minimum_columns");

6817

/*

6818

DBUG_ASSERT(spider->position_bitmap_init);

6819

*/

6820

7005

/* for mrr */

6821

7006

if (pos->mrr_with_cnt)

6822

7007

{

6824

7009

row++;

6825

7010

lengths++;

6826

7011

}

7012

if ((error_num = spider_db_append_match_fetch(spider,

7013

pos->ft_first, pos->ft_current, &row, &lengths)))

7014

DBUG_RETURN(error_num);

6827

7015

6828

7016

for (

6829

7017

field = table->field;

7962

8150

if (conn->conn_kind != SPIDER_CONN_KIND_MYSQL)

7963

8151

{

7964

8152

size_t num_fields;

7965

if ((error_num = conn->hs_conn->response_recv(num_fields)))

8153

SPIDER_HS_CONN hs_conn = conn->hs_conn;

8154

uint roop_count;

8155

DBUG_PRINT("info",("spider result_list->hs_upd_rows=%ull",

8156

result_list->hs_upd_rows));

8157

for (roop_count = 0; roop_count < result_list->hs_upd_rows;

8158

roop_count++)

7966

8159

{

7967

if (error_num > 0)

7968

conn->hs_conn->response_buf_remove();

7969

spider_db_errorno(conn);

7970

DBUG_RETURN(ER_SPIDER_HS_NUM);

8160

if ((error_num = hs_conn->response_recv(num_fields)))

8161

{

8162

if (error_num > 0)

8163

hs_conn->response_buf_remove();

8164

spider_db_errorno(conn);

8165

DBUG_RETURN(ER_SPIDER_HS_NUM);

8166

}

8167

hs_conn->response_buf_remove();

7971

8168

}

7972

conn->hs_conn->response_buf_remove();

7973

8169

}

7974

8170

#endif

7975

8171

pthread_mutex_unlock(&conn->mta_conn_mutex);

10088

10284

case Item::DECIMAL_ITEM:

10089

10285

DBUG_RETURN(spider_db_open_item_int(item, spider, str,

10090

10286

alias, alias_length));

10287

case Item::CACHE_ITEM:

10288

DBUG_RETURN(spider_db_open_item_cache((Item_cache *)item, spider, str,

10289

alias, alias_length));

10091

10290

case Item::SUBSELECT_ITEM:

10092

10291

case Item::TRIGGER_FIELD_ITEM:

10093

case Item::CACHE_ITEM:

10094

10292

DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);

10095

10293

default:

10096

if (spider->share->access_charset->cset == system_charset_info->cset)

10097

item->print(str, QT_IS);

10098

else

10099

item->print(str, QT_ORDINARY);

10294

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

10295

SPIDER_SHARE *share = spider->share;

10296

if ((THDVAR(thd, skip_default_condition) == -1 ?

10297

share->skip_default_condition : THDVAR(thd, skip_default_condition)))

10298

DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);

10299

if (str)

10300

{

10301

if (spider->share->access_charset->cset == system_charset_info->cset)

10302

item->print(str, QT_IS);

10303

else

10304

item->print(str, QT_ORDINARY);

10305

}

10100

10306

break;

10101

10307

}

10102

10308

DBUG_RETURN(0);

10115

10321

char *func_name = NULL;

10116

10322

int func_name_length, restart_pos;

10117

10323

DBUG_ENTER("spider_db_open_item_cond");

10118

if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))

10119

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10120

str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);

10324

if (str)

10325

{

10326

if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))

10327

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10328

str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);

10329

}

10121

10330

10122

10331

restart_first:

10123

10332

if ((item = lif++))

10124

10333

{

10125

restart_pos = str->length();

10334

if (str)

10335

restart_pos = str->length();

10126

10336

if ((error_num = spider_db_print_item_type(item, spider, str,

10127

10337

alias, alias_length)))

10128

10338

{

10129

10339

if (

10340

str &&

10130

10341

error_num == ER_SPIDER_COND_SKIP_NUM &&

10131

10342

item_cond->functype() == Item_func::COND_AND_FUNC

10132

10343

) {

10141

10352

DBUG_RETURN(error_num);

10142

10353

while ((item = lif++))

10143

10354

{

10144

restart_pos = str->length();

10145

if (!func_name)

10355

if (str)

10146

10356

{

10147

func_name = (char*) item_cond->func_name();

10148

func_name_length = strlen(func_name);

10357

restart_pos = str->length();

10358

if (!func_name)

10359

{

10360

func_name = (char*) item_cond->func_name();

10361

func_name_length = strlen(func_name);

10362

}

10363

if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN * 2))

10364

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10365

str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);

10366

str->q_append(func_name, func_name_length);

10367

str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);

10149

10368

}

10150

if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN * 2))

10151

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10152

str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);

10153

str->q_append(func_name, func_name_length);

10154

str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);

10155

10369

10156

10370

if ((error_num = spider_db_print_item_type(item, spider, str,

10157

10371

alias, alias_length)))

10158

10372

{

10159

10373

if (

10374

str &&

10160

10375

error_num == ER_SPIDER_COND_SKIP_NUM &&

10161

10376

item_cond->functype() == Item_func::COND_AND_FUNC

10162

10377

) {

10166

10381

DBUG_RETURN(error_num);

10167

10382

}

10168

10383

}

10169

if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))

10170

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10171

str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);

10384

if (str)

10385

{

10386

if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))

10387

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10388

str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);

10389

}

10172

10390

DBUG_RETURN(0);

10173

10391

}

10174

10392

10190

10408

last_str_length = SPIDER_SQL_NULL_CHAR_LEN;

10191

10409

int use_pushdown_udf;

10192

10410

DBUG_ENTER("spider_db_open_item_func");

10193

if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))

10194

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10195

str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);

10411

if (str)

10412

{

10413

if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))

10414

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10415

str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);

10416

}

10196

10417

DBUG_PRINT("info",("spider functype = %d", item_func->functype()));

10197

10418

switch (item_func->functype())

10198

10419

{

10240

10461

!strncasecmp("rand", func_name, func_name_length) &&

10241

10462

!item_func->arg_count

10242

10463

) {

10243

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10464

if (str)

10465

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10244

10466

DBUG_RETURN(spider_db_open_item_int(item_func, spider, str,

10245

10467

alias, alias_length));

10246

10468

} else if (func_name_length == 6 &&

10261

10483

!strncasecmp("curdate", func_name, func_name_length) ||

10262

10484

!strncasecmp("curtime", func_name, func_name_length)

10263

10485

) {

10264

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10486

if (str)

10487

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10265

10488

DBUG_RETURN(spider_db_open_item_string(item_func, spider, str,

10266

10489

alias, alias_length));

10267

10490

}

10271

10494

!strncasecmp("utc_time", func_name, func_name_length)

10272

10495

)

10273

10496

) {

10274

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10497

if (str)

10498

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10275

10499

DBUG_RETURN(spider_db_open_item_string(item_func, spider, str,

10276

10500

alias, alias_length));

10277

10501

} else if (func_name_length == 9 &&

10290

10514

{

10291

10515

if (!strncasecmp("cast_as_date", func_name, func_name_length))

10292

10516

{

10293

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10294

if (str->reserve(SPIDER_SQL_CAST_LEN))

10295

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10296

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10517

if (str)

10518

{

10519

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10520

if (str->reserve(SPIDER_SQL_CAST_LEN))

10521

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10522

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10523

}

10297

10524

last_str = SPIDER_SQL_AS_DATE_STR;

10298

10525

last_str_length = SPIDER_SQL_AS_DATE_LEN;

10299

10526

break;

10300

10527

} else if (!strncasecmp("cast_as_time", func_name, func_name_length))

10301

10528

{

10302

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10303

if (str->reserve(SPIDER_SQL_CAST_LEN))

10304

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10305

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10529

if (str)

10530

{

10531

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10532

if (str->reserve(SPIDER_SQL_CAST_LEN))

10533

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10534

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10535

}

10306

10536

last_str = SPIDER_SQL_AS_TIME_STR;

10307

10537

last_str_length = SPIDER_SQL_AS_TIME_LEN;

10308

10538

break;

10310

10540

} else if (func_name_length == 13 &&

10311

10541

!strncasecmp("utc_timestamp", func_name, func_name_length)

10312

10542

) {

10313

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10543

if (str)

10544

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10314

10545

DBUG_RETURN(spider_db_open_item_string(item_func, spider, str,

10315

10546

alias, alias_length));

10316

10547

} else if (func_name_length == 14)

10317

10548

{

10318

10549

if (!strncasecmp("cast_as_binary", func_name, func_name_length))

10319

10550

{

10320

char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;

10321

String tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());

10322

tmp_str.length(0);

10323

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10324

if (str->reserve(SPIDER_SQL_CAST_LEN))

10325

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10326

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10327

item_func->print(&tmp_str, QT_IS);

10328

if (tmp_str.reserve(1))

10329

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10330

tmp_ptr = tmp_str.c_ptr_quick();

10331

DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));

10332

while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_BINARY_STR)))

10333

tmp_ptr = tmp_ptr2 + 1;

10334

last_str = tmp_ptr - 1;

10335

last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;

10551

if (str)

10552

{

10553

char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;

10554

String tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());

10555

tmp_str.length(0);

10556

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10557

if (str->reserve(SPIDER_SQL_CAST_LEN))

10558

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10559

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10560

item_func->print(&tmp_str, QT_IS);

10561

if (tmp_str.reserve(1))

10562

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10563

tmp_ptr = tmp_str.c_ptr_quick();

10564

DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));

10565

while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_BINARY_STR)))

10566

tmp_ptr = tmp_ptr2 + 1;

10567

last_str = tmp_ptr - 1;

10568

last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;

10569

}

10336

10570

break;

10337

10571

} else if (!strncasecmp("cast_as_signed", func_name, func_name_length))

10338

10572

{

10339

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10340

if (str->reserve(SPIDER_SQL_CAST_LEN))

10341

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10342

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10573

if (str)

10574

{

10575

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10576

if (str->reserve(SPIDER_SQL_CAST_LEN))

10577

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10578

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10579

}

10343

10580

last_str = SPIDER_SQL_AS_SIGNED_STR;

10344

10581

last_str_length = SPIDER_SQL_AS_SIGNED_LEN;

10345

10582

break;

10348

10585

{

10349

10586

if (!strncasecmp("cast_as_unsigned", func_name, func_name_length))

10350

10587

{

10351

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10352

if (str->reserve(SPIDER_SQL_CAST_LEN))

10353

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10354

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10588

if (str)

10589

{

10590

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10591

if (str->reserve(SPIDER_SQL_CAST_LEN))

10592

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10593

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10594

}

10355

10595

last_str = SPIDER_SQL_AS_UNSIGNED_STR;

10356

10596

last_str_length = SPIDER_SQL_AS_UNSIGNED_LEN;

10357

10597

break;

10358

10598

} else if (!strncasecmp("decimal_typecast", func_name,

10359

10599

func_name_length))

10360

10600

{

10361

char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;

10362

String tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());

10363

tmp_str.length(0);

10364

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10365

if (str->reserve(SPIDER_SQL_CAST_LEN))

10366

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10367

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10368

item_func->print(&tmp_str, QT_IS);

10369

if (tmp_str.reserve(1))

10370

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10371

tmp_ptr = tmp_str.c_ptr_quick();

10372

DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));

10373

while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_DECIMAL_STR)))

10374

tmp_ptr = tmp_ptr2 + 1;

10375

last_str = tmp_ptr - 1;

10376

last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;

10601

if (str)

10602

{

10603

char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;

10604

String tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());

10605

tmp_str.length(0);

10606

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10607

if (str->reserve(SPIDER_SQL_CAST_LEN))

10608

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10609

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10610

item_func->print(&tmp_str, QT_IS);

10611

if (tmp_str.reserve(1))

10612

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10613

tmp_ptr = tmp_str.c_ptr_quick();

10614

DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));

10615

while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_DECIMAL_STR)))

10616

tmp_ptr = tmp_ptr2 + 1;

10617

last_str = tmp_ptr - 1;

10618

last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;

10619

}

10377

10620

break;

10378

10621

} else if (!strncasecmp("cast_as_datetime", func_name,

10379

10622

func_name_length))

10380

10623

{

10381

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10382

if (str->reserve(SPIDER_SQL_CAST_LEN))

10383

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10384

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10624

if (str)

10625

{

10626

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10627

if (str->reserve(SPIDER_SQL_CAST_LEN))

10628

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10629

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10630

}

10385

10631

last_str = SPIDER_SQL_AS_DATETIME_STR;

10386

10632

last_str_length = SPIDER_SQL_AS_DATETIME_LEN;

10387

10633

break;

10388

10634

}

10389

10635

}

10390

if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))

10391

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10392

str->q_append(func_name, func_name_length);

10393

str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);

10636

if (str)

10637

{

10638

if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))

10639

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10640

str->q_append(func_name, func_name_length);

10641

str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);

10642

}

10394

10643

func_name = SPIDER_SQL_COMMA_STR;

10395

10644

func_name_length = SPIDER_SQL_COMMA_LEN;

10396

10645

separete_str = SPIDER_SQL_COMMA_STR;

10399

10648

last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;

10400

10649

break;

10401

10650

case Item_func::NOW_FUNC:

10402

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10651

if (str)

10652

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10403

10653

DBUG_RETURN(spider_db_open_item_string(item_func, spider, str,

10404

10654

alias, alias_length));

10405

10655

case Item_func::CHAR_TYPECAST_FUNC:

10406

10656

{

10407

char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;

10408

String tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());

10409

tmp_str.length(0);

10410

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10411

if (str->reserve(SPIDER_SQL_CAST_LEN))

10412

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10413

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10414

item_func->print(&tmp_str, QT_IS);

10415

if (tmp_str.reserve(1))

10416

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10417

tmp_ptr = tmp_str.c_ptr_quick();

10418

DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));

10419

while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_CHAR_STR)))

10420

tmp_ptr = tmp_ptr2 + 1;

10421

last_str = tmp_ptr - 1;

10422

last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;

10657

if (str)

10658

{

10659

char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;

10660

String tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());

10661

tmp_str.length(0);

10662

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10663

if (str->reserve(SPIDER_SQL_CAST_LEN))

10664

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10665

str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);

10666

item_func->print(&tmp_str, QT_IS);

10667

if (tmp_str.reserve(1))

10668

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10669

tmp_ptr = tmp_str.c_ptr_quick();

10670

DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));

10671

while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_CHAR_STR)))

10672

tmp_ptr = tmp_ptr2 + 1;

10673

last_str = tmp_ptr - 1;

10674

last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;

10675

}

10423

10676

}

10424

10677

break;

10425

10678

case Item_func::NOT_FUNC:

10426

10679

case Item_func::NEG_FUNC:

10427

func_name = (char*) item_func->func_name();

10428

func_name_length = strlen(func_name);

10429

if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN))

10430

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10431

str->q_append(func_name, func_name_length);

10432

str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);

10680

if (str)

10681

{

10682

func_name = (char*) item_func->func_name();

10683

func_name_length = strlen(func_name);

10684

if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN))

10685

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10686

str->q_append(func_name, func_name_length);

10687

str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);

10688

}

10433

10689

break;

10434

10690

case Item_func::IN_FUNC:

10435

10691

if (((Item_func_opt_neg *) item_func)->negated)

10469

10725

THDVAR(spider->trx->thd, use_pushdown_udf);

10470

10726

if (!use_pushdown_udf)

10471

10727

DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);

10472

func_name = (char*) item_func->func_name();

10473

func_name_length = strlen(func_name);

10474

DBUG_PRINT("info",("spider func_name = %s", func_name));

10475

DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));

10476

if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))

10477

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10478

str->q_append(func_name, func_name_length);

10479

str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);

10728

if (str)

10729

{

10730

func_name = (char*) item_func->func_name();

10731

func_name_length = strlen(func_name);

10732

DBUG_PRINT("info",("spider func_name = %s", func_name));

10733

DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));

10734

if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))

10735

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10736

str->q_append(func_name, func_name_length);

10737

str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);

10738

}

10480

10739

func_name = SPIDER_SQL_COMMA_STR;

10481

10740

func_name_length = SPIDER_SQL_COMMA_LEN;

10482

10741

separete_str = SPIDER_SQL_COMMA_STR;

10485

10744

last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;

10486

10745

break;

10487

10746

case Item_func::COND_XOR_FUNC:

10488

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10747

if (str)

10748

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10489

10749

DBUG_RETURN(

10490

10750

spider_db_open_item_cond((Item_cond *) item_func, spider, str,

10491

10751

alias, alias_length));

10492

10752

case Item_func::TRIG_COND_FUNC:

10493

10753

DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);

10494

10754

case Item_func::GUSERVAR_FUNC:

10495

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10755

if (str)

10756

str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);

10496

10757

if (item_func->result_type() == STRING_RESULT)

10497

10758

DBUG_RETURN(spider_db_open_item_string(item_func, spider, str,

10498

10759

alias, alias_length));

10503

10764

if (spider_db_check_ft_idx(item_func, spider) == MAX_KEY)

10504

10765

DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);

10505

10766

start_item = 1;

10506

if (str->reserve(SPIDER_SQL_MATCH_LEN))

10507

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10508

str->q_append(SPIDER_SQL_MATCH_STR, SPIDER_SQL_MATCH_LEN);

10767

if (str)

10768

{

10769

if (str->reserve(SPIDER_SQL_MATCH_LEN))

10770

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10771

str->q_append(SPIDER_SQL_MATCH_STR, SPIDER_SQL_MATCH_LEN);

10772

}

10509

10773

separete_str = SPIDER_SQL_COMMA_STR;

10510

10774

separete_str_length = SPIDER_SQL_COMMA_LEN;

10511

10775

last_str = SPIDER_SQL_CLOSE_PAREN_STR;

10512

10776

last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;

10513

10777

break;

10514

/* memo

10515

10778

case Item_func::EQ_FUNC:

10516

10779

case Item_func::EQUAL_FUNC:

10517

10780

case Item_func::NE_FUNC:

10519

10782

case Item_func::LE_FUNC:

10520

10783

case Item_func::GE_FUNC:

10521

10784

case Item_func::GT_FUNC:

10522

*/

10785

if (str)

10786

{

10787

func_name = (char*) item_func->func_name();

10788

func_name_length = strlen(func_name);

10789

}

10790

break;

10523

10791

default:

10524

func_name = (char*) item_func->func_name();

10525

func_name_length = strlen(func_name);

10792

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

10793

SPIDER_SHARE *share = spider->share;

10794

if ((THDVAR(thd, skip_default_condition) == -1 ?

10795

share->skip_default_condition : THDVAR(thd, skip_default_condition)))

10796

DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);

10797

if (str)

10798

{

10799

func_name = (char*) item_func->func_name();

10800

func_name_length = strlen(func_name);

10801

}

10526

10802

break;

10527

10803

}

10528

10804

DBUG_PRINT("info",("spider func_name = %s", func_name));

10545

10821

func_name = separete_str;

10546

10822

func_name_length = separete_str_length;

10547

10823

}

10548

if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN * 2))

10549

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10550

str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);

10551

str->q_append(func_name, func_name_length);

10552

str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);

10824

if (str)

10825

{

10826

if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN * 2))

10827

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10828

str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);

10829

str->q_append(func_name, func_name_length);

10830

str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);

10831

}

10553

10832

}

10554

10833

item = item_list[roop_count];

10555

10834

if ((error_num = spider_db_print_item_type(item, spider, str,

10559

10838

if (item_func->functype() == Item_func::FT_FUNC)

10560

10839

{

10561

10840

Item_func_match *item_func_match = (Item_func_match *)item_func;

10562

if (str->reserve(SPIDER_SQL_AGAINST_LEN))

10563

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10564

str->q_append(SPIDER_SQL_AGAINST_STR, SPIDER_SQL_AGAINST_LEN);

10841

if (str)

10842

{

10843

if (str->reserve(SPIDER_SQL_AGAINST_LEN))

10844

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10845

str->q_append(SPIDER_SQL_AGAINST_STR, SPIDER_SQL_AGAINST_LEN);

10846

}

10565

10847

item = item_list[0];

10566

10848

if ((error_num = spider_db_print_item_type(item, spider, str,

10567

10849

alias, alias_length)))

10568

10850

DBUG_RETURN(error_num);

10569

if (str->reserve(

10570

((item_func_match->flags & FT_BOOL) ?

10571

SPIDER_SQL_IN_BOOLEAN_MODE_LEN : 0) +

10572

((item_func_match->flags & FT_EXPAND) ?

10573

SPIDER_SQL_WITH_QUERY_EXPANSION_LEN : 0)

10574

))

10851

if (str)

10852

{

10853

if (str->reserve(

10854

((item_func_match->flags & FT_BOOL) ?

10855

SPIDER_SQL_IN_BOOLEAN_MODE_LEN : 0) +

10856

((item_func_match->flags & FT_EXPAND) ?

10857

SPIDER_SQL_WITH_QUERY_EXPANSION_LEN : 0)

10858

))

10859

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10860

if (item_func_match->flags & FT_BOOL)

10861

str->q_append(SPIDER_SQL_IN_BOOLEAN_MODE_STR,

10862

SPIDER_SQL_IN_BOOLEAN_MODE_LEN);

10863

if (item_func_match->flags & FT_EXPAND)

10864

str->q_append(SPIDER_SQL_WITH_QUERY_EXPANSION_STR,

10865

SPIDER_SQL_WITH_QUERY_EXPANSION_LEN);

10866

}

10867

}

10868

if (str)

10869

{

10870

if (str->reserve(last_str_length + SPIDER_SQL_CLOSE_PAREN_LEN))

10575

10871

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10576

if (item_func_match->flags & FT_BOOL)

10577

str->q_append(SPIDER_SQL_IN_BOOLEAN_MODE_STR,

10578

SPIDER_SQL_IN_BOOLEAN_MODE_LEN);

10579

if (item_func_match->flags & FT_EXPAND)

10580

str->q_append(SPIDER_SQL_WITH_QUERY_EXPANSION_STR,

10581

SPIDER_SQL_WITH_QUERY_EXPANSION_LEN);

10872

str->q_append(last_str, last_str_length);

10873

str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);

10582

10874

}

10583

if (str->reserve(last_str_length + SPIDER_SQL_CLOSE_PAREN_LEN))

10584

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10585

str->q_append(last_str, last_str_length);

10586

str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);

10587

10875

DBUG_RETURN(0);

10588

10876

}

10589

10877

10603

10891

#ifdef HANDLER_HAS_TOP_TABLE_FIELDS

10604

10892

if (spider->set_top_table_fields)

10605

10893

{

10606

Field *field = spider->top_table_field[item_ident->cached_field_index];

10607

if (str->reserve(

10608

alias_length +

10609

share->column_name_str[field->field_index].length() +

10610

(SPIDER_SQL_NAME_QUOTE_LEN) * 2))

10611

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10612

str->q_append(alias, alias_length);

10613

spider_db_append_column_name(share, str, field->field_index);

10894

if (str)

10895

{

10896

Field *field = spider->top_table_field[item_ident->cached_field_index];

10897

if (str->reserve(

10898

alias_length +

10899

share->column_name_str[field->field_index].length() +

10900

(SPIDER_SQL_NAME_QUOTE_LEN) * 2))

10901

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10902

str->q_append(alias, alias_length);

10903

spider_db_append_column_name(share, str, field->field_index);

10904

}

10614

10905

} else {

10615

10906

#endif

10616

if (str->reserve(

10617

alias_length +

10618

share->column_name_str[item_ident->cached_field_index].length() +

10619

(SPIDER_SQL_NAME_QUOTE_LEN) * 2))

10620

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10621

str->q_append(alias, alias_length);

10622

spider_db_append_column_name(share, str,

10623

item_ident->cached_field_index);

10907

if (str)

10908

{

10909

if (str->reserve(

10910

alias_length +

10911

share->column_name_str[item_ident->cached_field_index].length() +

10912

(SPIDER_SQL_NAME_QUOTE_LEN) * 2))

10913

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10914

str->q_append(alias, alias_length);

10915

spider_db_append_column_name(share, str,

10916

item_ident->cached_field_index);

10917

}

10624

10918

#ifdef HANDLER_HAS_TOP_TABLE_FIELDS

10625

10919

}

10626

10920

#endif

10627

10921

DBUG_RETURN(0);

10628

10922

}

10629

if (item_ident->field_name)

10630

field_name_length = strlen(item_ident->field_name);

10631

else

10632

field_name_length = 0;

10633

if (spider->share->access_charset->cset == system_charset_info->cset)

10923

if (str)

10634

10924

{

10635

if (str->reserve((SPIDER_SQL_NAME_QUOTE_LEN) * 2 + field_name_length))

10636

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10637

str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);

10638

str->q_append(item_ident->field_name, field_name_length);

10639

str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);

10640

} else {

10641

if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))

10642

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10643

str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);

10644

str->append(item_ident->field_name, field_name_length,

10645

system_charset_info);

10646

if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))

10647

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10648

str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);

10925

if (item_ident->field_name)

10926

field_name_length = strlen(item_ident->field_name);

10927

else

10928

field_name_length = 0;

10929

if (spider->share->access_charset->cset == system_charset_info->cset)

10930

{

10931

if (str->reserve((SPIDER_SQL_NAME_QUOTE_LEN) * 2 + field_name_length))

10932

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10933

str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);

10934

str->q_append(item_ident->field_name, field_name_length);

10935

str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);

10936

} else {

10937

if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))

10938

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10939

str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);

10940

str->append(item_ident->field_name, field_name_length,

10941

system_charset_info);

10942

if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))

10943

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10944

str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);

10945

}

10649

10946

}

10650

10947

DBUG_RETURN(0);

10651

10948

}

10679

10976

#endif

10680

10977

if (field->table->const_table)

10681

10978

{

10682

share = spider->share;

10683

if (str->reserve(

10684

alias_length +

10685

share->column_name_str[field->field_index].length() +

10686

(SPIDER_SQL_NAME_QUOTE_LEN) * 2))

10687

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10688

str->q_append(alias, alias_length);

10689

spider_db_append_column_name(share, str,

10690

field->field_index);

10979

if (str)

10980

{

10981

share = spider->share;

10982

if (str->reserve(

10983

alias_length +

10984

share->column_name_str[field->field_index].length() +

10985

(SPIDER_SQL_NAME_QUOTE_LEN) * 2))

10986

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10987

str->q_append(alias, alias_length);

10988

spider_db_append_column_name(share, str,

10989

field->field_index);

10990

}

10691

10991

DBUG_RETURN(0);

10692

10992

}

10693

10993

}

10712

11012

item_ref->name &&

10713

11013

item_ref->alias_name_used

10714

11014

) {

10715

int name_length = strlen(item_ref->name);

10716

if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2 + name_length))

10717

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10718

str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);

10719

str->q_append(item_ref->name, name_length);

10720

str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);

11015

if (str)

11016

{

11017

int name_length = strlen(item_ref->name);

11018

if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2 + name_length))

11019

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

11020

str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);

11021

str->q_append(item_ref->name, name_length);

11022

str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);

11023

}

10721

11024

DBUG_RETURN(0);

10722

11025

}

10723

11026

DBUG_RETURN(spider_db_print_item_type(*(item_ref->ref), spider, str,

10744

11047

if ((error_num = spider_db_print_item_type(item, spider, str,

10745

11048

alias, alias_length)))

10746

11049

DBUG_RETURN(error_num);

10747

if (str->reserve(SPIDER_SQL_COMMA_LEN))

10748

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10749

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

11050

if (str)

11051

{

11052

if (str->reserve(SPIDER_SQL_COMMA_LEN))

11053

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

11054

str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);

11055

}

10750

11056

}

10751

11057

item = item_row->element_index(roop_count);

10752

11058

if ((error_num = spider_db_print_item_type(item, spider, str,

10762

11068

char *alias,

10763

11069

uint alias_length

10764

11070

) {

10765

char tmp_buf[MAX_FIELD_WIDTH];

10766

String tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset()), *tmp_str2;

10767

11071

DBUG_ENTER("spider_db_open_item_string");

10768

if (

10769

!(tmp_str2 = item->val_str(&tmp_str)) ||

10770

str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN * 2 + tmp_str2->length())

10771

)

10772

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10773

str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);

10774

if (

10775

str->append(*tmp_str2) ||

10776

str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN)

10777

)

10778

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10779

str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);

11072

if (str)

11073

{

11074

char tmp_buf[MAX_FIELD_WIDTH];

11075

String tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset()), *tmp_str2;

11076

if (

11077

!(tmp_str2 = item->val_str(&tmp_str)) ||

11078

str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN * 2 + tmp_str2->length() * 2)

11079

)

11080

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

11081

str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);

11082

if (

11083

append_escaped(str, tmp_str2) ||

11084

str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN)

11085

)

11086

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

11087

str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);

11088

}

10780

11089

DBUG_RETURN(0);

10781

11090

}

10782

11091

10787

11096

char *alias,

10788

11097

uint alias_length

10789

11098

) {

10790

char tmp_buf[MAX_FIELD_WIDTH];

10791

String tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());

10792

11099

DBUG_ENTER("spider_db_open_item_int");

10793

if (str->append(*item->val_str(&tmp_str)))

10794

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

11100

if (str)

11101

{

11102

char tmp_buf[MAX_FIELD_WIDTH];

11103

String tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());

11104

if (str->append(*item->val_str(&tmp_str)))

11105

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

11106

}

10795

11107

DBUG_RETURN(0);

10796

11108

}

10797

11109

11110

int spider_db_open_item_cache(

11111

Item_cache *item_cache,

11112

ha_spider *spider,

11113

String *str,

11114

char *alias,

11115

uint alias_length

11116

) {

11117

DBUG_ENTER("spider_db_open_item_cache");

11118

if (!item_cache->const_item())

11119

DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);

11120

if (item_cache->result_type() == STRING_RESULT)

11121

DBUG_RETURN(spider_db_open_item_string(item_cache, spider, str,

11122

alias, alias_length));

11123

DBUG_RETURN(spider_db_open_item_int(item_cache, spider, str,

11124

alias, alias_length));

11125

}

11126

10798

11127

int spider_db_append_condition_internal(

10799

11128

ha_spider *spider,

10800

11129

String *str,

10807

11136

bool where_pos;

10808

11137

DBUG_ENTER("spider_db_append_condition_internal");

10809

11138

if (sql_kind == SPIDER_SQL_KIND_SQL)

10810

where_pos = (str->length() == spider->result_list.where_pos);

10811

else if (sql_kind == SPIDER_SQL_KIND_HANDLER)

10812

{

10813

where_pos = TRUE;

10814

str = &spider->result_list.ha_sql;

10815

if (spider->active_index == MAX_KEY)

11139

{

11140

if (str)

11141

where_pos = (str->length() == spider->result_list.where_pos);

11142

} else if (sql_kind == SPIDER_SQL_KIND_HANDLER)

11143

{

11144

if (str)

10816

11145

{

10817

spider->result_list.ha_read_pos = str->length();

10818

if (str->reserve(SPIDER_SQL_READ_LEN + SPIDER_SQL_FIRST_LEN))

10819

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10820

str->q_append(SPIDER_SQL_READ_STR, SPIDER_SQL_READ_LEN);

10821

spider->result_list.ha_next_pos = str->length();

10822

str->q_append(SPIDER_SQL_FIRST_STR, SPIDER_SQL_FIRST_LEN);

11146

where_pos = TRUE;

11147

str = &spider->result_list.ha_sql;

11148

if (spider->active_index == MAX_KEY)

11149

{

11150

spider->result_list.ha_read_pos = str->length();

11151

if (str->reserve(SPIDER_SQL_READ_LEN + SPIDER_SQL_FIRST_LEN))

11152

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

11153

str->q_append(SPIDER_SQL_READ_STR, SPIDER_SQL_READ_LEN);

11154

spider->result_list.ha_next_pos = str->length();

11155

str->q_append(SPIDER_SQL_FIRST_STR, SPIDER_SQL_FIRST_LEN);

11156

}

11157

spider->result_list.ha_where_pos = str->length();

10823

11158

}

10824

spider->result_list.ha_where_pos = str->length();

10825

11159

} else

10826

11160

DBUG_RETURN(0);

10827

11161

10828

11162

while (tmp_cond)

10829

11163

{

10830

restart_pos = str->length();

10831

if (where_pos)

11164

if (str)

10832

11165

{

10833

if (str->reserve(SPIDER_SQL_WHERE_LEN))

10834

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10835

str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN);

10836

where_pos = FALSE;

10837

} else {

10838

if (str->reserve(SPIDER_SQL_AND_LEN))

10839

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

10840

str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);

11166

restart_pos = str->length();

11167

if (where_pos)

11168

{

11169

if (str->reserve(SPIDER_SQL_WHERE_LEN))

11170

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

11171

str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN);

11172

where_pos = FALSE;

11173

} else {

11174

if (str->reserve(SPIDER_SQL_AND_LEN))

11175

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

11176

str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);

11177

}

10841

11178

}

10842

11179

if ((error_num = spider_db_print_item_type(

10843

11180

(Item *) tmp_cond->cond, spider, str, alias, alias_length)))

10844

11181

{

10845

if (error_num == ER_SPIDER_COND_SKIP_NUM)

11182

if (str && error_num == ER_SPIDER_COND_SKIP_NUM)

10846

11183

{

10847

11184

DBUG_PRINT("info",("spider COND skip"));

10848

11185

str->length(restart_pos);

10863

11200

) {

10864

11201

int error_num;

10865

11202

DBUG_ENTER("spider_db_append_condition");

10866

if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)

10867

{

10868

if ((error_num = spider_db_append_condition_internal(spider, str,

10869

alias, alias_length, SPIDER_SQL_KIND_SQL)))

10870

DBUG_RETURN(error_num);

10871

}

10872

if (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER)

10873

{

10874

if ((error_num = spider_db_append_condition_internal(spider, str,

10875

alias, alias_length, SPIDER_SQL_KIND_HANDLER)))

10876

DBUG_RETURN(error_num);

11203

if (str)

11204

{

11205

if (spider->sql_kinds & SPIDER_SQL_KIND_SQL)

11206

{

11207

if ((error_num = spider_db_append_condition_internal(spider, str,

11208

alias, alias_length, SPIDER_SQL_KIND_SQL)))

11209

DBUG_RETURN(error_num);

11210

}

11211

if (spider->sql_kinds & SPIDER_SQL_KIND_HANDLER)

11212

{

11213

if ((error_num = spider_db_append_condition_internal(spider, str,

11214

alias, alias_length, SPIDER_SQL_KIND_HANDLER)))

11215

DBUG_RETURN(error_num);

11216

}

11217

} else {

11218

if (spider->cond_check)

11219

DBUG_RETURN(spider->cond_check_error);

11220

spider->cond_check = TRUE;

11221

if ((spider->cond_check_error = spider_db_append_condition_internal(spider,

11222

str, alias, alias_length, SPIDER_SQL_KIND_SQL)))

11223

DBUG_RETURN(spider->cond_check_error);

10877

11224

}

10878

11225

DBUG_RETURN(0);

10879

11226

}

10896

11243

10897

11244

for (roop_count = 0; roop_count < table_share->keys; roop_count++)

10898

11245

{

10899

key_info = &table_share->key_info[roop_count];

10900

if (key_info->algorithm == HA_KEY_ALG_FULLTEXT)

10901

{

11246

key_info = &table->key_info[roop_count];

11247

if (

11248

key_info->algorithm == HA_KEY_ALG_FULLTEXT &&

11249

item_count - 1 == key_info->key_parts

11250

) {

10902

11251

match1 = TRUE;

10903

11252

for (roop_count2 = 1; roop_count2 < item_count; roop_count2++)

10904

11253

{

12777

13126

) {

12778

13127

uint roop_count;

12779

13128

String *element;

12780

DBUG_ENTER("spider_db_clear_dynamic");

13129

DBUG_ENTER("spider_db_free_str_dynamic");

12781

13130

for (roop_count = 0; roop_count < array->elements; roop_count++)

12782

13131

{

12783

13132

get_dynamic(array, (uchar *) &element, roop_count);