| 1 | #include "benchmark_runner.hpp" |
| 2 | #include "compare_result.hpp" |
| 3 | #include "duckdb_benchmark_macro.hpp" |
| 4 | #include "imdb.hpp" |
| 5 | |
| 6 | using namespace duckdb; |
| 7 | using namespace std; |
| 8 | |
| 9 | #define IMDB_QUERY_BODY(QNR) \ |
| 10 | virtual void Load(DuckDBBenchmarkState *state) { \ |
| 11 | imdb::dbgen(state->db); \ |
| 12 | } \ |
| 13 | virtual string GetQuery() { \ |
| 14 | return imdb::get_query(QNR); \ |
| 15 | } \ |
| 16 | virtual string VerifyResult(QueryResult *result) { \ |
| 17 | if (!result->success) { \ |
| 18 | return result->error; \ |
| 19 | } /* FIXME */ \ |
| 20 | return ""; /*return compare_csv(*result, tpch::get_answer(SF, QNR), \ |
| 21 | true); */ \ |
| 22 | } \ |
| 23 | virtual string BenchmarkInfo() { \ |
| 24 | return StringUtil::Format("IMDB (JOB) Q%d: %s", QNR, imdb::get_query(QNR).c_str()); \ |
| 25 | } |
| 26 | |
| 27 | DUCKDB_BENCHMARK(IMDBQ001, "[imdb]" ) |
| 28 | IMDB_QUERY_BODY(1); |
| 29 | FINISH_BENCHMARK(IMDBQ001); |
| 30 | |
| 31 | DUCKDB_BENCHMARK(IMDBQ002, "[imdb]" ) |
| 32 | IMDB_QUERY_BODY(2); |
| 33 | FINISH_BENCHMARK(IMDBQ002); |
| 34 | |
| 35 | DUCKDB_BENCHMARK(IMDBQ003, "[imdb]" ) |
| 36 | IMDB_QUERY_BODY(3); |
| 37 | FINISH_BENCHMARK(IMDBQ003); |
| 38 | |
| 39 | DUCKDB_BENCHMARK(IMDBQ004, "[imdb]" ) |
| 40 | IMDB_QUERY_BODY(4); |
| 41 | FINISH_BENCHMARK(IMDBQ004); |
| 42 | |
| 43 | DUCKDB_BENCHMARK(IMDBQ005, "[imdb]" ) |
| 44 | IMDB_QUERY_BODY(5); |
| 45 | FINISH_BENCHMARK(IMDBQ005); |
| 46 | |
| 47 | DUCKDB_BENCHMARK(IMDBQ006, "[imdb]" ) |
| 48 | IMDB_QUERY_BODY(6); |
| 49 | FINISH_BENCHMARK(IMDBQ006); |
| 50 | |
| 51 | DUCKDB_BENCHMARK(IMDBQ007, "[imdb]" ) |
| 52 | IMDB_QUERY_BODY(7); |
| 53 | FINISH_BENCHMARK(IMDBQ007); |
| 54 | |
| 55 | DUCKDB_BENCHMARK(IMDBQ008, "[imdb]" ) |
| 56 | IMDB_QUERY_BODY(8); |
| 57 | FINISH_BENCHMARK(IMDBQ008); |
| 58 | |
| 59 | DUCKDB_BENCHMARK(IMDBQ009, "[imdb]" ) |
| 60 | IMDB_QUERY_BODY(9); |
| 61 | FINISH_BENCHMARK(IMDBQ009); |
| 62 | |
| 63 | DUCKDB_BENCHMARK(IMDBQ010, "[imdb]" ) |
| 64 | IMDB_QUERY_BODY(10); |
| 65 | FINISH_BENCHMARK(IMDBQ010); |
| 66 | |
| 67 | DUCKDB_BENCHMARK(IMDBQ011, "[imdb]" ) |
| 68 | IMDB_QUERY_BODY(11); |
| 69 | FINISH_BENCHMARK(IMDBQ011); |
| 70 | |
| 71 | DUCKDB_BENCHMARK(IMDBQ012, "[imdb]" ) |
| 72 | IMDB_QUERY_BODY(12); |
| 73 | FINISH_BENCHMARK(IMDBQ012); |
| 74 | |
| 75 | DUCKDB_BENCHMARK(IMDBQ013, "[imdb]" ) |
| 76 | IMDB_QUERY_BODY(13); |
| 77 | FINISH_BENCHMARK(IMDBQ013); |
| 78 | |
| 79 | DUCKDB_BENCHMARK(IMDBQ014, "[imdb]" ) |
| 80 | IMDB_QUERY_BODY(14); |
| 81 | FINISH_BENCHMARK(IMDBQ014); |
| 82 | |
| 83 | DUCKDB_BENCHMARK(IMDBQ015, "[imdb]" ) |
| 84 | IMDB_QUERY_BODY(15); |
| 85 | FINISH_BENCHMARK(IMDBQ015); |
| 86 | |
| 87 | DUCKDB_BENCHMARK(IMDBQ016, "[imdb]" ) |
| 88 | IMDB_QUERY_BODY(16); |
| 89 | FINISH_BENCHMARK(IMDBQ016); |
| 90 | |
| 91 | DUCKDB_BENCHMARK(IMDBQ017, "[imdb]" ) |
| 92 | IMDB_QUERY_BODY(17); |
| 93 | FINISH_BENCHMARK(IMDBQ017); |
| 94 | |
| 95 | DUCKDB_BENCHMARK(IMDBQ018, "[imdb]" ) |
| 96 | IMDB_QUERY_BODY(18); |
| 97 | FINISH_BENCHMARK(IMDBQ018); |
| 98 | |
| 99 | DUCKDB_BENCHMARK(IMDBQ019, "[imdb]" ) |
| 100 | IMDB_QUERY_BODY(19); |
| 101 | FINISH_BENCHMARK(IMDBQ019); |
| 102 | |
| 103 | DUCKDB_BENCHMARK(IMDBQ020, "[imdb]" ) |
| 104 | IMDB_QUERY_BODY(20); |
| 105 | FINISH_BENCHMARK(IMDBQ020); |
| 106 | |
| 107 | DUCKDB_BENCHMARK(IMDBQ021, "[imdb]" ) |
| 108 | IMDB_QUERY_BODY(21); |
| 109 | FINISH_BENCHMARK(IMDBQ021); |
| 110 | |
| 111 | DUCKDB_BENCHMARK(IMDBQ022, "[imdb]" ) |
| 112 | IMDB_QUERY_BODY(22); |
| 113 | FINISH_BENCHMARK(IMDBQ022); |
| 114 | |
| 115 | DUCKDB_BENCHMARK(IMDBQ023, "[imdb]" ) |
| 116 | IMDB_QUERY_BODY(23); |
| 117 | FINISH_BENCHMARK(IMDBQ023); |
| 118 | |
| 119 | DUCKDB_BENCHMARK(IMDBQ024, "[imdb]" ) |
| 120 | IMDB_QUERY_BODY(24); |
| 121 | FINISH_BENCHMARK(IMDBQ024); |
| 122 | |
| 123 | DUCKDB_BENCHMARK(IMDBQ025, "[imdb]" ) |
| 124 | IMDB_QUERY_BODY(25); |
| 125 | FINISH_BENCHMARK(IMDBQ025); |
| 126 | |
| 127 | DUCKDB_BENCHMARK(IMDBQ026, "[imdb]" ) |
| 128 | IMDB_QUERY_BODY(26); |
| 129 | FINISH_BENCHMARK(IMDBQ026); |
| 130 | |
| 131 | DUCKDB_BENCHMARK(IMDBQ027, "[imdb]" ) |
| 132 | IMDB_QUERY_BODY(27); |
| 133 | FINISH_BENCHMARK(IMDBQ027); |
| 134 | |
| 135 | DUCKDB_BENCHMARK(IMDBQ028, "[imdb]" ) |
| 136 | IMDB_QUERY_BODY(28); |
| 137 | FINISH_BENCHMARK(IMDBQ028); |
| 138 | |
| 139 | DUCKDB_BENCHMARK(IMDBQ029, "[imdb]" ) |
| 140 | IMDB_QUERY_BODY(29); |
| 141 | FINISH_BENCHMARK(IMDBQ029); |
| 142 | |
| 143 | DUCKDB_BENCHMARK(IMDBQ030, "[imdb]" ) |
| 144 | IMDB_QUERY_BODY(30); |
| 145 | FINISH_BENCHMARK(IMDBQ030); |
| 146 | |
| 147 | DUCKDB_BENCHMARK(IMDBQ031, "[imdb]" ) |
| 148 | IMDB_QUERY_BODY(31); |
| 149 | FINISH_BENCHMARK(IMDBQ031); |
| 150 | |
| 151 | DUCKDB_BENCHMARK(IMDBQ032, "[imdb]" ) |
| 152 | IMDB_QUERY_BODY(32); |
| 153 | FINISH_BENCHMARK(IMDBQ032); |
| 154 | |
| 155 | DUCKDB_BENCHMARK(IMDBQ033, "[imdb]" ) |
| 156 | IMDB_QUERY_BODY(33); |
| 157 | FINISH_BENCHMARK(IMDBQ033); |
| 158 | |
| 159 | DUCKDB_BENCHMARK(IMDBQ034, "[imdb]" ) |
| 160 | IMDB_QUERY_BODY(34); |
| 161 | FINISH_BENCHMARK(IMDBQ034); |
| 162 | |
| 163 | DUCKDB_BENCHMARK(IMDBQ035, "[imdb]" ) |
| 164 | IMDB_QUERY_BODY(35); |
| 165 | FINISH_BENCHMARK(IMDBQ035); |
| 166 | |
| 167 | DUCKDB_BENCHMARK(IMDBQ036, "[imdb]" ) |
| 168 | IMDB_QUERY_BODY(36); |
| 169 | FINISH_BENCHMARK(IMDBQ036); |
| 170 | |
| 171 | DUCKDB_BENCHMARK(IMDBQ037, "[imdb]" ) |
| 172 | IMDB_QUERY_BODY(37); |
| 173 | FINISH_BENCHMARK(IMDBQ037); |
| 174 | |
| 175 | DUCKDB_BENCHMARK(IMDBQ038, "[imdb]" ) |
| 176 | IMDB_QUERY_BODY(38); |
| 177 | FINISH_BENCHMARK(IMDBQ038); |
| 178 | |
| 179 | DUCKDB_BENCHMARK(IMDBQ039, "[imdb]" ) |
| 180 | IMDB_QUERY_BODY(39); |
| 181 | FINISH_BENCHMARK(IMDBQ039); |
| 182 | |
| 183 | DUCKDB_BENCHMARK(IMDBQ040, "[imdb]" ) |
| 184 | IMDB_QUERY_BODY(40); |
| 185 | FINISH_BENCHMARK(IMDBQ040); |
| 186 | |
| 187 | DUCKDB_BENCHMARK(IMDBQ041, "[imdb]" ) |
| 188 | IMDB_QUERY_BODY(41); |
| 189 | FINISH_BENCHMARK(IMDBQ041); |
| 190 | |
| 191 | DUCKDB_BENCHMARK(IMDBQ042, "[imdb]" ) |
| 192 | IMDB_QUERY_BODY(42); |
| 193 | FINISH_BENCHMARK(IMDBQ042); |
| 194 | |
| 195 | DUCKDB_BENCHMARK(IMDBQ043, "[imdb]" ) |
| 196 | IMDB_QUERY_BODY(43); |
| 197 | FINISH_BENCHMARK(IMDBQ043); |
| 198 | |
| 199 | DUCKDB_BENCHMARK(IMDBQ044, "[imdb]" ) |
| 200 | IMDB_QUERY_BODY(44); |
| 201 | FINISH_BENCHMARK(IMDBQ044); |
| 202 | |
| 203 | DUCKDB_BENCHMARK(IMDBQ045, "[imdb]" ) |
| 204 | IMDB_QUERY_BODY(45); |
| 205 | FINISH_BENCHMARK(IMDBQ045); |
| 206 | |
| 207 | DUCKDB_BENCHMARK(IMDBQ046, "[imdb]" ) |
| 208 | IMDB_QUERY_BODY(46); |
| 209 | FINISH_BENCHMARK(IMDBQ046); |
| 210 | |
| 211 | DUCKDB_BENCHMARK(IMDBQ047, "[imdb]" ) |
| 212 | IMDB_QUERY_BODY(47); |
| 213 | FINISH_BENCHMARK(IMDBQ047); |
| 214 | |
| 215 | DUCKDB_BENCHMARK(IMDBQ048, "[imdb]" ) |
| 216 | IMDB_QUERY_BODY(48); |
| 217 | FINISH_BENCHMARK(IMDBQ048); |
| 218 | |
| 219 | DUCKDB_BENCHMARK(IMDBQ049, "[imdb]" ) |
| 220 | IMDB_QUERY_BODY(49); |
| 221 | FINISH_BENCHMARK(IMDBQ049); |
| 222 | |
| 223 | DUCKDB_BENCHMARK(IMDBQ050, "[imdb]" ) |
| 224 | IMDB_QUERY_BODY(50); |
| 225 | FINISH_BENCHMARK(IMDBQ050); |
| 226 | |
| 227 | DUCKDB_BENCHMARK(IMDBQ051, "[imdb]" ) |
| 228 | IMDB_QUERY_BODY(51); |
| 229 | FINISH_BENCHMARK(IMDBQ051); |
| 230 | |
| 231 | DUCKDB_BENCHMARK(IMDBQ052, "[imdb]" ) |
| 232 | IMDB_QUERY_BODY(52); |
| 233 | FINISH_BENCHMARK(IMDBQ052); |
| 234 | |
| 235 | DUCKDB_BENCHMARK(IMDBQ053, "[imdb]" ) |
| 236 | IMDB_QUERY_BODY(53); |
| 237 | FINISH_BENCHMARK(IMDBQ053); |
| 238 | |
| 239 | DUCKDB_BENCHMARK(IMDBQ054, "[imdb]" ) |
| 240 | IMDB_QUERY_BODY(54); |
| 241 | FINISH_BENCHMARK(IMDBQ054); |
| 242 | |
| 243 | DUCKDB_BENCHMARK(IMDBQ055, "[imdb]" ) |
| 244 | IMDB_QUERY_BODY(55); |
| 245 | FINISH_BENCHMARK(IMDBQ055); |
| 246 | |
| 247 | DUCKDB_BENCHMARK(IMDBQ056, "[imdb]" ) |
| 248 | IMDB_QUERY_BODY(56); |
| 249 | FINISH_BENCHMARK(IMDBQ056); |
| 250 | |
| 251 | DUCKDB_BENCHMARK(IMDBQ057, "[imdb]" ) |
| 252 | IMDB_QUERY_BODY(57); |
| 253 | FINISH_BENCHMARK(IMDBQ057); |
| 254 | |
| 255 | DUCKDB_BENCHMARK(IMDBQ058, "[imdb]" ) |
| 256 | IMDB_QUERY_BODY(58); |
| 257 | FINISH_BENCHMARK(IMDBQ058); |
| 258 | |
| 259 | DUCKDB_BENCHMARK(IMDBQ059, "[imdb]" ) |
| 260 | IMDB_QUERY_BODY(59); |
| 261 | FINISH_BENCHMARK(IMDBQ059); |
| 262 | |
| 263 | DUCKDB_BENCHMARK(IMDBQ060, "[imdb]" ) |
| 264 | IMDB_QUERY_BODY(60); |
| 265 | FINISH_BENCHMARK(IMDBQ060); |
| 266 | |
| 267 | DUCKDB_BENCHMARK(IMDBQ061, "[imdb]" ) |
| 268 | IMDB_QUERY_BODY(61); |
| 269 | FINISH_BENCHMARK(IMDBQ061); |
| 270 | |
| 271 | DUCKDB_BENCHMARK(IMDBQ062, "[imdb]" ) |
| 272 | IMDB_QUERY_BODY(62); |
| 273 | FINISH_BENCHMARK(IMDBQ062); |
| 274 | |
| 275 | DUCKDB_BENCHMARK(IMDBQ063, "[imdb]" ) |
| 276 | IMDB_QUERY_BODY(63); |
| 277 | FINISH_BENCHMARK(IMDBQ063); |
| 278 | |
| 279 | DUCKDB_BENCHMARK(IMDBQ064, "[imdb]" ) |
| 280 | IMDB_QUERY_BODY(64); |
| 281 | FINISH_BENCHMARK(IMDBQ064); |
| 282 | |
| 283 | DUCKDB_BENCHMARK(IMDBQ065, "[imdb]" ) |
| 284 | IMDB_QUERY_BODY(65); |
| 285 | FINISH_BENCHMARK(IMDBQ065); |
| 286 | |
| 287 | DUCKDB_BENCHMARK(IMDBQ066, "[imdb]" ) |
| 288 | IMDB_QUERY_BODY(66); |
| 289 | FINISH_BENCHMARK(IMDBQ066); |
| 290 | |
| 291 | DUCKDB_BENCHMARK(IMDBQ067, "[imdb]" ) |
| 292 | IMDB_QUERY_BODY(67); |
| 293 | FINISH_BENCHMARK(IMDBQ067); |
| 294 | |
| 295 | DUCKDB_BENCHMARK(IMDBQ068, "[imdb]" ) |
| 296 | IMDB_QUERY_BODY(68); |
| 297 | FINISH_BENCHMARK(IMDBQ068); |
| 298 | |
| 299 | DUCKDB_BENCHMARK(IMDBQ069, "[imdb]" ) |
| 300 | IMDB_QUERY_BODY(69); |
| 301 | FINISH_BENCHMARK(IMDBQ069); |
| 302 | |
| 303 | DUCKDB_BENCHMARK(IMDBQ070, "[imdb]" ) |
| 304 | IMDB_QUERY_BODY(70); |
| 305 | FINISH_BENCHMARK(IMDBQ070); |
| 306 | |
| 307 | DUCKDB_BENCHMARK(IMDBQ071, "[imdb]" ) |
| 308 | IMDB_QUERY_BODY(71); |
| 309 | FINISH_BENCHMARK(IMDBQ071); |
| 310 | |
| 311 | DUCKDB_BENCHMARK(IMDBQ072, "[imdb]" ) |
| 312 | IMDB_QUERY_BODY(72); |
| 313 | FINISH_BENCHMARK(IMDBQ072); |
| 314 | |
| 315 | DUCKDB_BENCHMARK(IMDBQ073, "[imdb]" ) |
| 316 | IMDB_QUERY_BODY(73); |
| 317 | FINISH_BENCHMARK(IMDBQ073); |
| 318 | |
| 319 | DUCKDB_BENCHMARK(IMDBQ074, "[imdb]" ) |
| 320 | IMDB_QUERY_BODY(74); |
| 321 | FINISH_BENCHMARK(IMDBQ074); |
| 322 | |
| 323 | DUCKDB_BENCHMARK(IMDBQ075, "[imdb]" ) |
| 324 | IMDB_QUERY_BODY(75); |
| 325 | FINISH_BENCHMARK(IMDBQ075); |
| 326 | |
| 327 | DUCKDB_BENCHMARK(IMDBQ076, "[imdb]" ) |
| 328 | IMDB_QUERY_BODY(76); |
| 329 | FINISH_BENCHMARK(IMDBQ076); |
| 330 | |
| 331 | DUCKDB_BENCHMARK(IMDBQ077, "[imdb]" ) |
| 332 | IMDB_QUERY_BODY(77); |
| 333 | FINISH_BENCHMARK(IMDBQ077); |
| 334 | |
| 335 | DUCKDB_BENCHMARK(IMDBQ078, "[imdb]" ) |
| 336 | IMDB_QUERY_BODY(78); |
| 337 | FINISH_BENCHMARK(IMDBQ078); |
| 338 | |
| 339 | DUCKDB_BENCHMARK(IMDBQ079, "[imdb]" ) |
| 340 | IMDB_QUERY_BODY(79); |
| 341 | FINISH_BENCHMARK(IMDBQ079); |
| 342 | |
| 343 | DUCKDB_BENCHMARK(IMDBQ080, "[imdb]" ) |
| 344 | IMDB_QUERY_BODY(80); |
| 345 | FINISH_BENCHMARK(IMDBQ080); |
| 346 | |
| 347 | DUCKDB_BENCHMARK(IMDBQ081, "[imdb]" ) |
| 348 | IMDB_QUERY_BODY(81); |
| 349 | FINISH_BENCHMARK(IMDBQ081); |
| 350 | |
| 351 | DUCKDB_BENCHMARK(IMDBQ082, "[imdb]" ) |
| 352 | IMDB_QUERY_BODY(82); |
| 353 | FINISH_BENCHMARK(IMDBQ082); |
| 354 | |
| 355 | DUCKDB_BENCHMARK(IMDBQ083, "[imdb]" ) |
| 356 | IMDB_QUERY_BODY(83); |
| 357 | FINISH_BENCHMARK(IMDBQ083); |
| 358 | |
| 359 | DUCKDB_BENCHMARK(IMDBQ084, "[imdb]" ) |
| 360 | IMDB_QUERY_BODY(84); |
| 361 | FINISH_BENCHMARK(IMDBQ084); |
| 362 | |
| 363 | DUCKDB_BENCHMARK(IMDBQ085, "[imdb]" ) |
| 364 | IMDB_QUERY_BODY(85); |
| 365 | FINISH_BENCHMARK(IMDBQ085); |
| 366 | |
| 367 | DUCKDB_BENCHMARK(IMDBQ086, "[imdb]" ) |
| 368 | IMDB_QUERY_BODY(86); |
| 369 | FINISH_BENCHMARK(IMDBQ086); |
| 370 | |
| 371 | DUCKDB_BENCHMARK(IMDBQ087, "[imdb]" ) |
| 372 | IMDB_QUERY_BODY(87); |
| 373 | FINISH_BENCHMARK(IMDBQ087); |
| 374 | |
| 375 | DUCKDB_BENCHMARK(IMDBQ088, "[imdb]" ) |
| 376 | IMDB_QUERY_BODY(88); |
| 377 | FINISH_BENCHMARK(IMDBQ088); |
| 378 | |
| 379 | DUCKDB_BENCHMARK(IMDBQ089, "[imdb]" ) |
| 380 | IMDB_QUERY_BODY(89); |
| 381 | FINISH_BENCHMARK(IMDBQ089); |
| 382 | |
| 383 | DUCKDB_BENCHMARK(IMDBQ090, "[imdb]" ) |
| 384 | IMDB_QUERY_BODY(90); |
| 385 | FINISH_BENCHMARK(IMDBQ090); |
| 386 | |
| 387 | DUCKDB_BENCHMARK(IMDBQ091, "[imdb]" ) |
| 388 | IMDB_QUERY_BODY(91); |
| 389 | FINISH_BENCHMARK(IMDBQ091); |
| 390 | |
| 391 | DUCKDB_BENCHMARK(IMDBQ092, "[imdb]" ) |
| 392 | IMDB_QUERY_BODY(92); |
| 393 | FINISH_BENCHMARK(IMDBQ092); |
| 394 | |
| 395 | DUCKDB_BENCHMARK(IMDBQ093, "[imdb]" ) |
| 396 | IMDB_QUERY_BODY(93); |
| 397 | FINISH_BENCHMARK(IMDBQ093); |
| 398 | |
| 399 | DUCKDB_BENCHMARK(IMDBQ094, "[imdb]" ) |
| 400 | IMDB_QUERY_BODY(94); |
| 401 | FINISH_BENCHMARK(IMDBQ094); |
| 402 | |
| 403 | DUCKDB_BENCHMARK(IMDBQ095, "[imdb]" ) |
| 404 | IMDB_QUERY_BODY(95); |
| 405 | FINISH_BENCHMARK(IMDBQ095); |
| 406 | |
| 407 | DUCKDB_BENCHMARK(IMDBQ096, "[imdb]" ) |
| 408 | IMDB_QUERY_BODY(96); |
| 409 | FINISH_BENCHMARK(IMDBQ096); |
| 410 | |
| 411 | DUCKDB_BENCHMARK(IMDBQ097, "[imdb]" ) |
| 412 | IMDB_QUERY_BODY(97); |
| 413 | FINISH_BENCHMARK(IMDBQ097); |
| 414 | |
| 415 | DUCKDB_BENCHMARK(IMDBQ098, "[imdb]" ) |
| 416 | IMDB_QUERY_BODY(98); |
| 417 | FINISH_BENCHMARK(IMDBQ098); |
| 418 | |
| 419 | DUCKDB_BENCHMARK(IMDBQ099, "[imdb]" ) |
| 420 | IMDB_QUERY_BODY(99); |
| 421 | FINISH_BENCHMARK(IMDBQ099); |
| 422 | |
| 423 | DUCKDB_BENCHMARK(IMDBQ100, "[imdb]" ) |
| 424 | IMDB_QUERY_BODY(100); |
| 425 | FINISH_BENCHMARK(IMDBQ100); |
| 426 | |
| 427 | DUCKDB_BENCHMARK(IMDBQ101, "[imdb]" ) |
| 428 | IMDB_QUERY_BODY(101); |
| 429 | FINISH_BENCHMARK(IMDBQ101); |
| 430 | |
| 431 | DUCKDB_BENCHMARK(IMDBQ102, "[imdb]" ) |
| 432 | IMDB_QUERY_BODY(102); |
| 433 | FINISH_BENCHMARK(IMDBQ102); |
| 434 | |
| 435 | DUCKDB_BENCHMARK(IMDBQ103, "[imdb]" ) |
| 436 | IMDB_QUERY_BODY(103); |
| 437 | FINISH_BENCHMARK(IMDBQ103); |
| 438 | |
| 439 | DUCKDB_BENCHMARK(IMDBQ104, "[imdb]" ) |
| 440 | IMDB_QUERY_BODY(104); |
| 441 | FINISH_BENCHMARK(IMDBQ104); |
| 442 | |
| 443 | DUCKDB_BENCHMARK(IMDBQ105, "[imdb]" ) |
| 444 | IMDB_QUERY_BODY(105); |
| 445 | FINISH_BENCHMARK(IMDBQ105); |
| 446 | |
| 447 | DUCKDB_BENCHMARK(IMDBQ106, "[imdb]" ) |
| 448 | IMDB_QUERY_BODY(106); |
| 449 | FINISH_BENCHMARK(IMDBQ106); |
| 450 | |
| 451 | DUCKDB_BENCHMARK(IMDBQ107, "[imdb]" ) |
| 452 | IMDB_QUERY_BODY(107); |
| 453 | FINISH_BENCHMARK(IMDBQ107); |
| 454 | |
| 455 | DUCKDB_BENCHMARK(IMDBQ108, "[imdb]" ) |
| 456 | IMDB_QUERY_BODY(108); |
| 457 | FINISH_BENCHMARK(IMDBQ108); |
| 458 | |
| 459 | DUCKDB_BENCHMARK(IMDBQ109, "[imdb]" ) |
| 460 | IMDB_QUERY_BODY(109); |
| 461 | FINISH_BENCHMARK(IMDBQ109); |
| 462 | |
| 463 | DUCKDB_BENCHMARK(IMDBQ110, "[imdb]" ) |
| 464 | IMDB_QUERY_BODY(110); |
| 465 | FINISH_BENCHMARK(IMDBQ110); |
| 466 | |
| 467 | DUCKDB_BENCHMARK(IMDBQ111, "[imdb]" ) |
| 468 | IMDB_QUERY_BODY(111); |
| 469 | FINISH_BENCHMARK(IMDBQ111); |
| 470 | |
| 471 | DUCKDB_BENCHMARK(IMDBQ112, "[imdb]" ) |
| 472 | IMDB_QUERY_BODY(112); |
| 473 | FINISH_BENCHMARK(IMDBQ112); |
| 474 | |
| 475 | DUCKDB_BENCHMARK(IMDBQ113, "[imdb]" ) |
| 476 | IMDB_QUERY_BODY(113); |
| 477 | FINISH_BENCHMARK(IMDBQ113); |
| 478 | |
| 479 | DUCKDB_BENCHMARK(IMDBQ114, "[imdb]" ) |
| 480 | IMDB_QUERY_BODY(114); |
| 481 | FINISH_BENCHMARK(IMDBQ114); |
| 482 | |