~ubuntu-branches/ubuntu/vivid/drizzle/vivid-proposed

{ $stack->push() } SELECT distinct straight_join select_option select_list FROM join WHERE where_list group_by_clause having_clause order_by_clause { $stack->pop(undef) } ;

112

113

simple_select:

114

{ $stack->push() } SELECT distinct straight_join select_option simple_select_list FROM join WHERE where_list optional_group_by having_clause order_by_clause { $stack->pop(undef) } ;

115

116

aggregate_select:

117

{ $stack->push() } SELECT distinct straight_join select_option aggregate_select_list FROM join WHERE where_list optional_group_by having_clause order_by_clause { $stack->pop(undef) } ;

118

119

distinct: DISTINCT | | | | ;

120

121

122

123

124

125

select_list:

126

new_select_item |

127

new_select_item , select_list |

128

new_select_item , select_list ;

129

130

simple_select_list:

131

nonaggregate_select_item |

132

nonaggregate_select_item , simple_select_list |

133

nonaggregate_select_item , simple_select_list ;

134

135

aggregate_select_list:

136

aggregate_select_item | aggregate_select_item |

137

aggregate_select_item, aggregate_select_list ;

138

139

new_select_item:

140

nonaggregate_select_item |

141

nonaggregate_select_item |

142

nonaggregate_select_item |

143

nonaggregate_select_item |

144

nonaggregate_select_item |

145

aggregate_select_item ;

146

147

nonaggregate_select_item:

148

table_alias . int_field_name AS { my $f = "field".++$fields ; push @nonaggregates , $f ; $f } ;

149

150

aggregate_select_item:

151

aggregate table_alias . int_field_name ) AS {"field".++$fields } ;

152

153

join:

154

{ $stack->push() }

155

table_or_join

156

{ $stack->set("left",$stack->get("result")); }

157

left_right outer JOIN table_or_join

158

159

join_condition ;

160

161

join_condition:

162

int_condition | char_condition ;

163

164

int_condition:

165

{ my $left = $stack->get("left"); my %s=map{$_=>1} @$left; my @r=(keys %s); my $table_string = $prng->arrayElement(\@r); my @table_array = split(/AS/, $table_string); $table_array[1] } . int_indexed =

166

{ my $right = $stack->get("result"); my %s=map{$_=>1} @$right; my @r=(keys %s); my $table_string = $prng->arrayElement(\@r); my @table_array = split(/AS/, $table_string); $table_array[1] } . int_indexed

167

{ my $left = $stack->get("left"); my $right = $stack->get("result"); my @n = (); push(@n,@$right); push(@n,@$left); $stack->pop(\@n); return undef } |

168

169

170

{ my $left = $stack->get("left"); my $right = $stack->get("result"); my @n = (); push(@n,@$right); push(@n,@$left); $stack->pop(\@n); return undef } |

171

172

{ my $right = $stack->get("result"); my %s=map{$_=>1} @$right; my @r=(keys %s); my $table_string = $prng->arrayElement(\@r); my @table_array = split(/AS/,

173

$table_string); $table_array[1] } . int_indexed

174

{ my $left = $stack->get("left"); my $right = $stack->get("result"); my @n = (); push(@n,@$right); push(@n,@$left); $stack->pop(\@n); return undef } |

175

176

{ my $right = $stack->get("result"); my %s=map{$_=>1} @$right; my @r=(keys %s); my $table_string = $prng->arrayElement(\@r); my @table_array = split(/AS/,

177

$table_string); $table_array[1] } . int_field_name

178

{ my $left = $stack->get("left"); my $right = $stack->get("result"); my @n = (); push(@n,@$right); push(@n,@$left); $stack->pop(\@n); return undef } ;

179

180

char_condition:

181

182

183

{ my $left = $stack->get("left"); my $right = $stack->get("result"); my @n = (); push(@n,@$right); push(@n,@$left); $stack->pop(\@n); return undef } |

184

185

186

{ my $left = $stack->get("left"); my $right = $stack->get("result"); my @n = (); push(@n,@$right); push(@n,@$left); $stack->pop(\@n); return undef } |

187

188

189

{ my $left = $stack->get("left"); my $right = $stack->get("result"); my @n = (); push(@n,@$right); push(@n,@$left); $stack->pop(\@n); return undef } ;

190

191

where_list:

192

where_item | where_item |

193

( where_list and_or where_item ) ;

194

195

where_item:

196

existing_table_item . `pk` comparison_operator _digit |

197

existing_table_item . `pk` comparison_operator existing_table_item . int_field_name |

198

existing_table_item . int_field_name comparison_operator _digit |

199

existing_table_item . int_field_name comparison_operator existing_table_item . int_field_name |

200

existing_table_item . int_field_name IS not NULL |

201

existing_table_item . int_field_name not IN (number_list) |

202

existing_table_item . int_field_name not BETWEEN _digit[invariant] AND ( _digit[invariant] + _digit );

203

204

number_list:

205

_digit | number_list, _digit ;

206

207

################################################################################

208

# We ensure that a GROUP BY statement includes all nonaggregates. #

209

# This helps to ensure the query is more useful in detecting real errors / #

210

# that the query doesn't lend itself to variable result sets #

211

################################################################################

212

group_by_clause:

213

{ scalar(@nonaggregates) > 0 ? " GROUP BY ".join (', ' , @nonaggregates ) : "" } ;

214

215

optional_group_by:

216

217

218

having_clause:

219

| HAVING having_list;

220

221

having_list:

222

having_item |

223

having_item |

224

(having_list and_or having_item) ;

225

226

having_item:

227

existing_select_item comparison_operator _digit ;

228

229

################################################################################

230

# We use the total_order_by rule when using the LIMIT operator to ensure that #

231

# we have a consistent result set - server1 and server2 should not differ #

232

################################################################################

233

234

order_by_clause:

235

236

ORDER BY total_order_by desc limit |

237

ORDER BY order_by_list ;

238

239

total_order_by:

240

{ join(', ', map { "field".$_ } (1..$fields) ) };

241

242

order_by_list:

243

order_by_item |

244

order_by_item , order_by_list ;

245

246

order_by_item:

247

existing_select_item desc ;

248

249

desc:

250

ASC | | | | | DESC ;

251

252

################################################################################

253

# We mix digit and _digit here. We want to alter the possible values of LIMIT #

254

# To ensure we hit varying EXPLAIN plans, but the OFFSET can be smaller #

255

################################################################################

256

257

limit:

258

| | LIMIT limit_size | LIMIT limit_size OFFSET _digit;

259

260

################################################################################

261

# recommend 8 tables : 2 joins for smaller queries, 6:2 for larger ones

262

################################################################################

263

264

table_or_join:

265

266

table | table | table | join | join ;

267

268

table_disabled:

269

# We use the "AS table" bit here so we can have unique aliases if we use the same table many times

270

{ $stack->push(); my $x = $prng->arrayElement(\@table_set)." AS table".++$tables; my @s=($x); $stack->pop(\@s); $x } ;

271

272

273

table:

274

# We use the "AS table" bit here so we can have unique aliases if we use the same table many times

275

{ $stack->push(); my $x = $prng->arrayElement($executors->[0]->tables())." AS table".++$tables; my @s=($x); $stack->pop(\@s); $x } ;

276

277

int_field_name:

278

`pk` | `col_int_key` | `col_int` ;

279

280

int_indexed:

281

`pk` | `col_int_key` ;

282

283

char_field_name:

284

`col_varchar_10` |

285

`col_varchar_1024_key` |

286

`col_varchar_1024` |

287

`col_varchar_10_key` ;

288

289

char_indexed:

290

`col_varchar_10_key` | `col_varchar_10_key` |

291

`col_varchar_1024_key` |`col_varchar_1024_key` ;

292

293

294

table_alias:

295

296

297

298

other_table:

299

300

301

existing_table_item:

302

{ "table".$prng->int(1,$tables) };

303

304

existing_select_item:

305

{ "field".$prng->int(1,$fields) };

306

307

_digit:

308

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |

309

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | _tinyint_unsigned ;

310

311

312

and_or:

313

AND | AND | OR ;

314

315

comparison_operator:

316

= | > | < | != | <> | <= | >= ;

317

318

aggregate:

319

COUNT( distinct | SUM( distinct | MIN( distinct | MAX( distinct ;

320

321

not:

322

| | | NOT;

323

324

left_right:

325

LEFT | LEFT | LEFT | RIGHT ;

326

327

outer:

328

| | | | OUTER ;

329

330

################################################################################

331

# We define LIMIT_rows in this fashion as LIMIT values can differ depending on #

332

# how large the LIMIT is - LIMIT 2 = LIMIT 9 != LIMIT 19 #

333

################################################################################

334

335

limit_size:

336

1 | 2 | 10 | 100 | 1000;

337

Older »