← Back to branch summary

~mysql/mysql-server/mysql-6.0

« back to all changes in this revision

Viewing changes to sql/sql_yacc.yy

Merge with 4.0.3
Some simple optimzations, more comments and indentation changes.
Add ` around database in 'use database' in binary log.
Moved max_error_count and max_warning_count to variables struct.
Removed SHOW_WARNS_COUNT and SHOW_ERRORS_COUNT calls.
Changed string functions to use character set of first string argument as default return characterset
(Each string function can change the above assumption if needed)

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/sql_yacc.yy
60
60
  LEX_USER *lex_user;
61
61
  sys_var *variable;
62
62
  Key::Keytype key_type;
 
63
  enum ha_key_alg  key_alg;
63
64
  enum db_type db_type;
64
65
  enum row_type row_type;
65
66
  enum ha_rkey_function ha_rkey_mode;
161
162
%token  BOOL_SYM
162
163
%token  BOOLEAN_SYM
163
164
%token  BOTH
 
165
%token  BTREE_SYM
164
166
%token  BY
165
167
%token  CACHE_SYM
166
168
%token  CASCADE
167
169
%token  CAST_SYM
 
170
%token  CHARSET
168
171
%token  CHECKSUM_SYM
169
172
%token  CHECK_SYM
170
173
%token  CIPHER
171
174
%token  COMMITTED_SYM
 
175
%token  COLLATE_SYM
172
176
%token  COLUMNS
173
177
%token  COLUMN_SYM
174
178
%token  CONCURRENT
206
210
%token  GREATEST_SYM
207
211
%token  GROUP
208
212
%token  HAVING
 
213
%token  HASH_SYM
209
214
%token  HEAP_SYM
210
215
%token  HEX_NUM
211
216
%token  HIGH_PRIORITY
304
309
%token  ROWS_SYM
305
310
%token  ROW_FORMAT_SYM
306
311
%token  ROW_SYM
 
312
%token  RTREE_SYM
307
313
%token  SET
308
314
%token  SERIALIZABLE_SYM
309
315
%token  SESSION_SYM
 
316
%token  SIMPLE_SYM
310
317
%token  SHUTDOWN
311
 
%token  SSL_SYM
 
318
%token  SPATIAL_SYM
 
319
%token  SSL_SYM
312
320
%token  STARTING
313
321
%token  STATUS_SYM
314
322
%token  STRAIGHT_JOIN
322
330
%token  TRAILING
323
331
%token  TRANSACTION_SYM
324
332
%token  TYPE_SYM
 
333
%token  TYPES_SYM
325
334
%token  FUNC_ARG0
326
335
%token  FUNC_ARG1
327
336
%token  FUNC_ARG2
330
339
%token  UDF_SONAME_SYM
331
340
%token  UDF_SYM
332
341
%token  UNCOMMITTED_SYM
 
342
%token  UNDERSCORE_CHARSET
333
343
%token  UNION_SYM
334
344
%token  UNIQUE_SYM
335
345
%token  USAGE
342
352
%token  WITH
343
353
%token  WRITE_SYM
344
354
%token  X509_SYM
345
 
%token  XOR
 
355
%token  XOR
346
356
%token  COMPRESSED_SYM
347
357
 
 
358
%token  ERRORS
 
359
%token  SQL_ERROR_COUNT
 
360
%token  WARNINGS
 
361
%token  SQL_WARNING_COUNT
 
362
 
348
363
%token  BIGINT
349
364
%token  BLOB_SYM
350
365
%token  CHAR_SYM
357
372
%token  ENUM
358
373
%token  FAST_SYM
359
374
%token  FLOAT_SYM
 
375
%token  GEOMETRY_SYM
360
376
%token  INT_SYM
361
377
%token  LIMIT
362
378
%token  LONGBLOB
414
430
%token  FORMAT_SYM
415
431
%token  FOR_SYM
416
432
%token  FROM_UNIXTIME
 
433
%token  GEOMCOLLFROMTEXT
 
434
%token  GEOMFROMTEXT
 
435
%token  GEOMETRYCOLLECTION
417
436
%token  GROUP_UNIQUE_USERS
418
437
%token  HOUR_MINUTE_SYM
419
438
%token  HOUR_SECOND_SYM
424
443
%token  INTERVAL_SYM
425
444
%token  LAST_INSERT_ID
426
445
%token  LEFT
 
446
%token  LINEFROMTEXT
 
447
%token  LINESTRING
427
448
%token  LOCATE
428
449
%token  MAKE_SET_SYM
429
450
%token  MINUTE_SECOND_SYM
431
452
%token  MODE_SYM
432
453
%token  MODIFY_SYM
433
454
%token  MONTH_SYM
 
455
%token  MLINEFROMTEXT
 
456
%token  MPOINTFROMTEXT
 
457
%token  MPOLYFROMTEXT
 
458
%token  MULTILINESTRING
 
459
%token  MULTIPOINT
 
460
%token  MULTIPOLYGON
434
461
%token  NOW_SYM
435
462
%token  PASSWORD
 
463
%token  POINTFROMTEXT
 
464
%token  POLYFROMTEXT
 
465
%token  POLYGON
436
466
%token  POSITION_SYM
437
467
%token  PROCEDURE
438
468
%token  RAND
488
518
%left   XOR
489
519
%left   '^'
490
520
%right  NOT
491
 
%right  BINARY
 
521
%right  BINARY COLLATE_SYM
492
522
 
493
523
%type <lex_str>
494
524
        IDENT TEXT_STRING REAL_NUM FLOAT_NUM NUM LONG_NUM HEX_NUM LEX_HOSTNAME
495
 
        ULONGLONG_NUM field_ident select_alias ident ident_or_text
 
525
        ULONGLONG_NUM field_ident select_alias ident ident_or_text UNDERSCORE_CHARSET
496
526
 
497
527
%type <lex_str_ptr>
498
528
        opt_table_alias
499
529
 
500
530
%type <table>
501
 
        table_ident
 
531
        table_ident references
502
532
 
503
533
%type <simple_string>
504
534
        remember_name remember_end opt_len opt_ident opt_db text_or_password
511
541
        type int_type real_type order_dir opt_field_spec lock_option
512
542
        udf_type if_exists opt_local opt_table_options table_options
513
543
        table_option opt_if_not_exists opt_var_type opt_var_ident_type
 
544
        delete_option
514
545
 
515
546
%type <ulong_num>
516
547
        ULONG_NUM raid_types merge_insert_types
523
554
        simple_ident select_item2 expr opt_expr opt_else sum_expr in_sum_expr
524
555
        table_wild opt_pad no_in_expr expr_expr simple_expr no_and_expr
525
556
        using_list expr_or_default set_expr_or_default
 
557
        param_marker singleval_subselect singleval_subselect_init
 
558
        exists_subselect exists_subselect_init
526
559
 
527
560
%type <item_list>
528
561
        expr_list udf_expr_list when_list ident_list ident_list_arg
530
563
%type <key_type>
531
564
        key_type opt_unique_or_fulltext
532
565
 
 
566
%type <key_alg>
 
567
        key_alg opt_btree_or_rtree
 
568
 
533
569
%type <string_list>
534
570
        key_usage_list
535
571
 
577
613
        opt_precision opt_ignore opt_column opt_restrict
578
614
        grant revoke set lock unlock string_list field_options field_option
579
615
        field_opt_list opt_binary table_lock_list table_lock varchar
580
 
        references opt_on_delete opt_on_delete_list opt_on_delete_item use
 
616
        ref_list opt_on_delete opt_on_delete_list opt_on_delete_item use
581
617
        opt_delete_options opt_delete_option
582
618
        opt_outer table_list table_name opt_option opt_place opt_low_priority
583
619
        opt_attribute opt_attribute_list attribute column_list column_list_id
589
625
        table_to_table_list table_to_table opt_table_list opt_as
590
626
        handler_rkey_function handler_read_or_scan
591
627
        single_multi table_wild_list table_wild_one opt_wild union union_list
592
 
        precision union_option
 
628
        precision union_option opt_on_delete_item subselect_start
 
629
        subselect_end
593
630
END_OF_INPUT
594
631
 
595
632
%type <NONE>
732
769
          bzero((char*) &lex->create_info,sizeof(lex->create_info));
733
770
          lex->create_info.options=$2 | $4;
734
771
          lex->create_info.db_type= (enum db_type) lex->thd->variables.table_type;
 
772
          lex->create_info.table_charset=NULL;
735
773
        }
736
774
        create2
737
775
 
738
 
        | CREATE opt_unique_or_fulltext INDEX ident ON table_ident
 
776
        | CREATE opt_unique_or_fulltext INDEX ident key_alg ON table_ident
739
777
          {
740
778
            LEX *lex=Lex;
741
779
            lex->sql_command= SQLCOM_CREATE_INDEX;
742
 
            if (!add_table_to_list($6,NULL,1))
 
780
            if (!add_table_to_list($7,NULL,1))
743
781
              YYABORT;
744
782
            lex->create_list.empty();
745
783
            lex->key_list.empty();
746
784
            lex->col_list.empty();
747
785
            lex->change=NullS;
748
786
          }
749
 
          '(' key_list ')'
 
787
           '(' key_list ')' 
750
788
          {
751
789
            LEX *lex=Lex;
752
 
            lex->key_list.push_back(new Key($2,$4.str,lex->col_list));
 
790
 
 
791
            lex->key_list.push_back(new Key($2,$4.str, $5, lex->col_list));
753
792
            lex->col_list.empty();
754
793
          }
755
 
        | CREATE DATABASE opt_if_not_exists ident
 
794
        | CREATE DATABASE opt_if_not_exists ident default_charset
756
795
          {
757
796
            LEX *lex=Lex;
758
797
            lex->sql_command=SQLCOM_CREATE_DB;
759
798
            lex->name=$4.str;
760
799
            lex->create_info.options=$3;
 
800
            lex->create_info.table_charset=lex->charset;
761
801
          }
762
802
        | CREATE udf_func_type UDF_SYM ident
763
803
          {
844
884
            table_list->next=0;
845
885
            lex->create_info.used_fields|= HA_CREATE_USED_UNION;
846
886
          }
 
887
        | CHARSET EQ charset_or_nocharset
 
888
          { 
 
889
            Lex->create_info.table_charset=Lex->charset;
 
890
            Lex->create_info.used_fields|= HA_CREATE_USED_CHARSET;
 
891
          }
847
892
        | INSERT_METHOD EQ merge_insert_types   { Lex->create_info.merge_insert_method= $3; Lex->create_info.used_fields|= HA_CREATE_USED_INSERT_METHOD;}
848
893
        | DATA_SYM DIRECTORY_SYM EQ TEXT_STRING { Lex->create_info.data_file_name= $4.str; }
849
894
        | INDEX DIRECTORY_SYM EQ TEXT_STRING    { Lex->create_info.index_file_name= $4.str; };
896
941
          {
897
942
            Lex->col_list.empty();              /* Alloced by sql_alloc */
898
943
          }
899
 
        | key_type opt_ident '(' key_list ')'
 
944
        | key_type opt_ident key_alg '(' key_list ')'
900
945
          {
901
946
            LEX *lex=Lex;
902
 
            lex->key_list.push_back(new Key($1,$2,lex->col_list));
 
947
            lex->key_list.push_back(new Key($1,$2, $3, lex->col_list));
903
948
            lex->col_list.empty();              /* Alloced by sql_alloc */
904
949
          }
905
950
        | opt_constraint FOREIGN KEY_SYM opt_ident '(' key_list ')' references
906
951
          {
907
 
            Lex->col_list.empty();              /* Alloced by sql_alloc */
 
952
            LEX *lex=Lex;
 
953
            lex->key_list.push_back(new foreign_key($4, lex->col_list,
 
954
                                    $8,
 
955
                                    lex->ref_list,
 
956
                                    lex->fk_delete_opt,
 
957
                                    lex->fk_update_opt,
 
958
                                    lex->fk_match_option));
 
959
            lex->col_list.empty();              /* Alloced by sql_alloc */
908
960
          }
909
961
        | opt_constraint CHECK_SYM '(' expr ')'
910
962
          {
920
972
         {
921
973
           LEX *lex=Lex;
922
974
           lex->length=lex->dec=0; lex->type=0; lex->interval=0;
923
 
           lex->default_value=0;
 
975
           lex->default_value=lex->comment=0;
 
976
           lex->charset=NULL;
924
977
         }
925
978
        type opt_attribute
926
979
        {
928
981
          if (add_field_to_list($1.str,
929
982
                                (enum enum_field_types) $3,
930
983
                                lex->length,lex->dec,lex->type,
931
 
                                lex->default_value,lex->change,
932
 
                                lex->interval))
 
984
                                lex->default_value, lex->comment,
 
985
                                lex->change,lex->interval,lex->charset))
933
986
            YYABORT;
934
987
        };
935
988
 
964
1017
                                          $$=FIELD_TYPE_TINY_BLOB; }
965
1018
        | BLOB_SYM                      { Lex->type|=BINARY_FLAG;
966
1019
                                          $$=FIELD_TYPE_BLOB; }
 
1020
        | GEOMETRY_SYM                  { Lex->type|=BINARY_FLAG;
 
1021
                                          $$=FIELD_TYPE_GEOMETRY; }
967
1022
        | MEDIUMBLOB                    { Lex->type|=BINARY_FLAG;
968
1023
                                          $$=FIELD_TYPE_MEDIUM_BLOB; }
969
1024
        | LONGBLOB                      { Lex->type|=BINARY_FLAG;
970
1025
                                          $$=FIELD_TYPE_LONG_BLOB; }
971
1026
        | LONG_SYM VARBINARY            { Lex->type|=BINARY_FLAG;
972
1027
                                          $$=FIELD_TYPE_MEDIUM_BLOB; }
973
 
        | LONG_SYM varchar              { $$=FIELD_TYPE_MEDIUM_BLOB; }
974
 
        | TINYTEXT                      { $$=FIELD_TYPE_TINY_BLOB; }
975
 
        | TEXT_SYM                      { $$=FIELD_TYPE_BLOB; }
976
 
        | MEDIUMTEXT                    { $$=FIELD_TYPE_MEDIUM_BLOB; }
977
 
        | LONGTEXT                      { $$=FIELD_TYPE_LONG_BLOB; }
 
1028
        | LONG_SYM varchar opt_binary   { $$=FIELD_TYPE_MEDIUM_BLOB; }
 
1029
        | TINYTEXT opt_binary           { $$=FIELD_TYPE_TINY_BLOB; }
 
1030
        | TEXT_SYM opt_binary           { $$=FIELD_TYPE_BLOB; }
 
1031
        | MEDIUMTEXT opt_binary         { $$=FIELD_TYPE_MEDIUM_BLOB; }
 
1032
        | LONGTEXT opt_binary           { $$=FIELD_TYPE_LONG_BLOB; }
978
1033
        | DECIMAL_SYM float_options field_options
979
1034
                                        { $$=FIELD_TYPE_DECIMAL;}
980
1035
        | NUMERIC_SYM float_options field_options
1066
1121
        | PRIMARY_SYM KEY_SYM { Lex->type|= PRI_KEY_FLAG | NOT_NULL_FLAG; }
1067
1122
        | UNIQUE_SYM      { Lex->type|= UNIQUE_FLAG; }
1068
1123
        | UNIQUE_SYM KEY_SYM { Lex->type|= UNIQUE_KEY_FLAG; }
1069
 
        | COMMENT_SYM text_literal {};
 
1124
        | COMMENT_SYM text_literal { Lex->comment= $2; };
 
1125
 
 
1126
charset:
 
1127
        ident   
 
1128
        { 
 
1129
          if (!(Lex->charset=get_charset_by_name($1.str,MYF(0))))
 
1130
          {
 
1131
            net_printf(&current_thd->net,ER_UNKNOWN_CHARACTER_SET,$1.str);
 
1132
            YYABORT;
 
1133
          }
 
1134
        };
 
1135
 
 
1136
charset_or_nocharset:
 
1137
        charset
 
1138
        | DEFAULT {Lex->charset=NULL; }
1070
1139
 
1071
1140
opt_binary:
1072
 
        /* empty */     {}
1073
 
        | BINARY        { Lex->type|=BINARY_FLAG; };
 
1141
        /* empty */             { Lex->charset=NULL; }
 
1142
        | BINARY                { Lex->type|=BINARY_FLAG; Lex->charset=NULL; }
 
1143
        | CHAR_SYM SET charset  {/* charset is already in Lex->charset */} ;
 
1144
 
 
1145
default_charset:
 
1146
        /* empty */                     { Lex->charset=NULL; }
 
1147
        | DEFAULT CHAR_SYM SET charset_or_nocharset ;
1074
1148
 
1075
1149
references:
1076
 
        REFERENCES table_ident opt_on_delete {}
1077
 
        | REFERENCES table_ident '(' key_list ')' opt_on_delete
1078
 
          {
1079
 
            Lex->col_list.empty();              /* Alloced by sql_alloc */
1080
 
          };
 
1150
        REFERENCES table_ident
 
1151
        {
 
1152
          LEX *lex=Lex; 
 
1153
          lex->fk_delete_opt= lex->fk_update_opt= lex->fk_match_option= 0;
 
1154
          lex->ref_list.empty();
 
1155
        }
 
1156
        opt_ref_list
 
1157
        {
 
1158
          $$=$2;
 
1159
        };
 
1160
        
 
1161
opt_ref_list:
 
1162
        /* empty */ opt_on_delete {}
 
1163
        | '(' ref_list ')' opt_on_delete {};
 
1164
 
 
1165
ref_list:
 
1166
        ref_list ',' ident      { Lex->ref_list.push_back(new key_part_spec($3.str)); }
 
1167
        | ident                 { Lex->ref_list.push_back(new key_part_spec($1.str)); };
 
1168
 
1081
1169
 
1082
1170
opt_on_delete:
1083
1171
        /* empty */ {}
1087
1175
        opt_on_delete_list opt_on_delete_item {}
1088
1176
        | opt_on_delete_item {};
1089
1177
 
1090
 
 
1091
1178
opt_on_delete_item:
1092
 
        ON DELETE_SYM delete_option {}
1093
 
        | ON UPDATE_SYM delete_option {}
1094
 
        | MATCH FULL    {}
1095
 
        | MATCH PARTIAL {};
 
1179
        ON DELETE_SYM delete_option   { Lex->fk_delete_opt= $3; }
 
1180
        | ON UPDATE_SYM delete_option { Lex->fk_update_opt= $3; }
 
1181
        | MATCH FULL    { Lex->fk_match_option= foreign_key::FK_MATCH_FULL; }
 
1182
        | MATCH PARTIAL { Lex->fk_match_option= foreign_key::FK_MATCH_PARTIAL; }
 
1183
        | MATCH SIMPLE_SYM { Lex->fk_match_option= foreign_key::FK_MATCH_SIMPLE; };
1096
1184
 
1097
1185
delete_option:
1098
 
        RESTRICT         {}
1099
 
        | CASCADE        {}
1100
 
        | SET NULL_SYM {}
1101
 
        | NO_SYM ACTION {}
1102
 
        | SET DEFAULT {};
 
1186
        RESTRICT         { $$= (int) foreign_key::FK_OPTION_RESTRICT; }
 
1187
        | CASCADE        { $$= (int) foreign_key::FK_OPTION_CASCADE; }
 
1188
        | SET NULL_SYM   { $$= (int) foreign_key::FK_OPTION_SET_NULL; }
 
1189
        | NO_SYM ACTION  { $$= (int) foreign_key::FK_OPTION_NO_ACTION; }
 
1190
        | SET DEFAULT    { $$= (int) foreign_key::FK_OPTION_DEFAULT;  };
1103
1191
 
1104
1192
key_type:
1105
1193
        opt_constraint PRIMARY_SYM KEY_SYM  { $$= Key::PRIMARY; }
1106
1194
        | key_or_index                      { $$= Key::MULTIPLE; }
1107
1195
        | FULLTEXT_SYM                      { $$= Key::FULLTEXT; }
1108
1196
        | FULLTEXT_SYM key_or_index         { $$= Key::FULLTEXT; }
 
1197
        | SPATIAL_SYM                       { $$= Key::SPATIAL; }
 
1198
        | SPATIAL_SYM key_or_index          { $$= Key::SPATIAL; }
1109
1199
        | opt_constraint UNIQUE_SYM         { $$= Key::UNIQUE; }
1110
1200
        | opt_constraint UNIQUE_SYM key_or_index { $$= Key::UNIQUE; };
1111
1201
 
1121
1211
opt_unique_or_fulltext:
1122
1212
        /* empty */     { $$= Key::MULTIPLE; }
1123
1213
        | UNIQUE_SYM    { $$= Key::UNIQUE; }
1124
 
        | FULLTEXT_SYM  { $$= Key::FULLTEXT; };
 
1214
        | SPATIAL_SYM   { $$= Key::SPATIAL; };
 
1215
 
 
1216
key_alg:
 
1217
        /* empty */                { $$= HA_KEY_ALG_UNDEF; }
 
1218
        | USING opt_btree_or_rtree { $$= $2; };
 
1219
 
 
1220
opt_btree_or_rtree:
 
1221
        BTREE_SYM       { $$= HA_KEY_ALG_BTREE; }
 
1222
        | RTREE_SYM     { $$= HA_KEY_ALG_RTREE; }
 
1223
        | HASH_SYM      { $$= HA_KEY_ALG_HASH; };
1125
1224
 
1126
1225
key_list:
1127
1226
        key_list ',' key_part order_dir { Lex->col_list.push_back($3); }
1164
1263
          bzero((char*) &lex->create_info,sizeof(lex->create_info));
1165
1264
          lex->create_info.db_type= DB_TYPE_DEFAULT;
1166
1265
          lex->create_info.row_type= ROW_TYPE_NOT_USED;
 
1266
          lex->create_info.table_charset=NULL;
1167
1267
          lex->alter_keys_onoff=LEAVE_AS_IS;
1168
1268
          lex->simple_alter=1;
1169
1269
        }
1170
1270
        alter_list;
1171
 
 
 
1271
 
 
1272
        | ALTER DATABASE ident default_charset
 
1273
          {
 
1274
            LEX *lex=Lex;
 
1275
            lex->sql_command=SQLCOM_ALTER_DB;
 
1276
            lex->name=$3.str;
 
1277
            lex->create_info.table_charset=lex->charset;
 
1278
          }
 
1279
 
 
1280
 
1172
1281
alter_list:
1173
1282
        | alter_list_item
1174
1283
        | alter_list ',' alter_list_item;
1185
1294
             lex->change= $3.str; lex->simple_alter=0;
1186
1295
          }
1187
1296
          field_spec opt_place
1188
 
        | MODIFY_SYM opt_column field_ident
1189
 
          {
1190
 
            LEX *lex=Lex;
1191
 
            lex->length=lex->dec=0; lex->type=0; lex->interval=0;
1192
 
            lex->default_value=0;
 
1297
        | MODIFY_SYM opt_column field_ident
 
1298
          {
 
1299
            LEX *lex=Lex;
 
1300
            lex->length=lex->dec=0; lex->type=0; lex->interval=0;
 
1301
            lex->default_value=lex->comment=0;
1193
1302
            lex->simple_alter=0;
1194
 
          }
1195
 
          type opt_attribute
1196
 
          {
1197
 
            LEX *lex=Lex;
1198
 
            if (add_field_to_list($3.str,
1199
 
                                  (enum enum_field_types) $5,
1200
 
                                  lex->length,lex->dec,lex->type,
1201
 
                                  lex->default_value, $3.str,
1202
 
                                  lex->interval))
1203
 
              YYABORT;
1204
 
          }
1205
 
          opt_place
 
1303
          }
 
1304
          type opt_attribute
 
1305
          {
 
1306
            LEX *lex=Lex;
 
1307
            if (add_field_to_list($3.str,
 
1308
                                  (enum enum_field_types) $5,
 
1309
                                  lex->length,lex->dec,lex->type,
 
1310
                                  lex->default_value, lex->comment,
 
1311
                                  $3.str, lex->interval, lex->charset))
 
1312
               YYABORT;
 
1313
          }
 
1314
          opt_place
1206
1315
        | DROP opt_column field_ident opt_restrict
1207
1316
          {
1208
1317
            LEX *lex=Lex;
1407
1516
select_init:
1408
1517
        SELECT_SYM select_part2 { Select->braces=false; } union
1409
1518
        |
1410
 
        '(' SELECT_SYM  select_part2 ')' { Select->braces=true;} union_opt;
1411
 
 
 
1519
        '(' SELECT_SYM  select_part2 ')' 
 
1520
          { 
 
1521
            SELECT_LEX * sel=Select;
 
1522
            sel->braces=true;
 
1523
            /* select in braces, can't contain global parameters */
 
1524
            sel->master_unit()->global_parameters=
 
1525
                sel->master_unit();
 
1526
          } union_opt;
1412
1527
 
1413
1528
select_part2:
1414
1529
        {
1527
1642
        | '(' ')' {};
1528
1643
 
1529
1644
/* all possible expressions */
1530
 
expr:   expr_expr       {$$ = $1; }
1531
 
        | simple_expr   {$$ = $1; };
 
1645
expr:   expr_expr       { $$= $1; }
 
1646
        | simple_expr   { $$= $1; };
1532
1647
 
1533
1648
/* expressions that begin with 'expr' */
1534
1649
expr_expr:
1570
1685
        | expr '+' INTERVAL_SYM expr interval
1571
1686
          { $$= new Item_date_add_interval($1,$4,$5,0); }
1572
1687
        | expr '-' INTERVAL_SYM expr interval
1573
 
          { $$= new Item_date_add_interval($1,$4,$5,1); };
 
1688
          { $$= new Item_date_add_interval($1,$4,$5,1); }
 
1689
        | expr COLLATE_SYM ident 
 
1690
          { 
 
1691
            if (!(Lex->charset=get_charset_by_name($3.str,MYF(0))))
 
1692
            {
 
1693
              net_printf(&current_thd->net,ER_UNKNOWN_CHARACTER_SET,$3.str);
 
1694
              YYABORT;
 
1695
            }
 
1696
            $$= new Item_func_set_collation($1,Lex->charset);
 
1697
          };
1574
1698
 
1575
1699
/* expressions that begin with 'expr' that do NOT follow IN_SYM */
1576
1700
no_in_expr:
1656
1780
simple_expr:
1657
1781
        simple_ident
1658
1782
        | literal
 
1783
        | param_marker
1659
1784
        | '@' ident_or_text SET_VAR expr
1660
1785
          {
1661
1786
            $$= new Item_func_set_user_var($2,$4);
1677
1802
        | NOT expr %prec NEG    { $$= new Item_func_not($2); }
1678
1803
        | '!' expr %prec NEG    { $$= new Item_func_not($2); }
1679
1804
        | '(' expr ')'          { $$= $2; }
 
1805
        | EXISTS exists_subselect { $$= $2; }
 
1806
        | singleval_subselect   { $$= $1; }
1680
1807
        | '{' ident expr '}'    { $$= $3; }
1681
1808
        | MATCH ident_list_arg AGAINST '(' expr ')'
1682
1809
          { Select->ftfunc_list.push_back((Item_func_match *)
1689
1816
        | CASE_SYM opt_expr WHEN_SYM when_list opt_else END
1690
1817
          { $$= new Item_func_case(* $4, $2, $5 ); }
1691
1818
        | CONVERT_SYM '(' expr ',' cast_type ')'  { $$= create_func_cast($3, $5); }
 
1819
        | CONVERT_SYM '(' expr USING charset ')'
 
1820
          { $$= new Item_func_conv_charset($3,Lex->charset); }
 
1821
        | CONVERT_SYM '(' expr ',' expr ',' expr ')'
 
1822
          { 
 
1823
            $$= new Item_func_conv_charset3($3,$7,$5); 
 
1824
          }
1692
1825
        | FUNC_ARG0 '(' ')'
1693
1826
          { $$= ((Item*(*)(void))($1.symbol->create_func))();}
1694
1827
        | FUNC_ARG1 '(' expr ')'
1703
1836
          { $$= new Item_func_atan($3,$5); }
1704
1837
        | CHAR_SYM '(' expr_list ')'
1705
1838
          { $$= new Item_func_char(*$3); }
 
1839
        | CHARSET '(' expr ')'
 
1840
          { $$= new Item_func_charset($3); }
1706
1841
        | COALESCE '(' expr_list ')'
1707
1842
          { $$= new Item_func_coalesce(* $3); }
1708
1843
        | CONCAT '(' expr_list ')'
1765
1900
          }
1766
1901
        | FIELD_FUNC '(' expr ',' expr_list ')'
1767
1902
          { $$= new Item_func_field($3, *$5); }
 
1903
        | GEOMFROMTEXT '(' expr ')'
 
1904
          { $$= new Item_func_geometry_from_text($3); }
 
1905
        | GEOMFROMTEXT '(' expr ',' expr ')'
 
1906
          { $$= new Item_func_geometry_from_text($3); }
 
1907
        | GEOMETRYCOLLECTION '(' expr_list ')'
 
1908
          { $$= new Item_func_spatial_collection(* $3, 
 
1909
                       Geometry::wkbGeometryCollection, 
 
1910
                       Geometry::wkbPoint); }
1768
1911
        | HOUR_SYM '(' expr ')'
1769
1912
          { $$= new Item_func_hour($3); }
1770
1913
        | IF '(' expr ',' expr ',' expr ')'
1789
1932
          }
1790
1933
        | LEFT '(' expr ',' expr ')'
1791
1934
          { $$= new Item_func_left($3,$5); }
 
1935
        | LINESTRING '(' expr_list ')'
 
1936
          { $$= new Item_func_spatial_collection(* $3, 
 
1937
               Geometry::wkbLineString, Geometry::wkbPoint); }
1792
1938
        | LOCATE '(' expr ',' expr ')'
1793
1939
          { $$= new Item_func_locate($5,$3); }
1794
1940
        | LOCATE '(' expr ',' expr ',' expr ')'
1795
1941
          { $$= new Item_func_locate($5,$3,$7); }
1796
 
        | GREATEST_SYM '(' expr ',' expr_list ')'
 
1942
        | GEOMCOLLFROMTEXT '(' expr ')'
 
1943
          { $$= new Item_func_geometry_from_text($3); }
 
1944
        | GEOMCOLLFROMTEXT '(' expr ',' expr ')'
 
1945
          { $$= new Item_func_geometry_from_text($3); }
 
1946
        | GREATEST_SYM '(' expr ',' expr_list ')'
1797
1947
          { $5->push_front($3); $$= new Item_func_max(*$5); }
1798
1948
        | LEAST_SYM '(' expr ',' expr_list ')'
1799
1949
          { $5->push_front($3); $$= new Item_func_min(*$5); }
1800
1950
        | LOG_SYM '(' expr ')'
1801
 
                { $$= new Item_func_log($3); }
 
1951
          { $$= new Item_func_log($3); }
1802
1952
        | LOG_SYM '(' expr ',' expr ')'
1803
 
                { $$= new Item_func_log($3, $5); }
 
1953
          { $$= new Item_func_log($3, $5); }
 
1954
        | LINEFROMTEXT '(' expr ')'
 
1955
          { $$= new Item_func_geometry_from_text($3); }
 
1956
        | LINEFROMTEXT '(' expr ',' expr ')'
 
1957
          { $$= new Item_func_geometry_from_text($3); }
1804
1958
        | MINUTE_SYM '(' expr ')'
1805
1959
          { $$= new Item_func_minute($3); }
1806
1960
        | MONTH_SYM '(' expr ')'
1807
1961
          { $$= new Item_func_month($3); }
 
1962
        | MULTILINESTRING '(' expr_list ')'
 
1963
          { $$= new Item_func_spatial_collection(* $3, 
 
1964
                    Geometry::wkbMultiLineString, Geometry::wkbLineString); }
 
1965
        | MLINEFROMTEXT '(' expr ')'
 
1966
          { $$= new Item_func_geometry_from_text($3); }
 
1967
        | MLINEFROMTEXT '(' expr ',' expr ')'
 
1968
          { $$= new Item_func_geometry_from_text($3); }
 
1969
        | MPOINTFROMTEXT '(' expr ')'
 
1970
          { $$= new Item_func_geometry_from_text($3); }
 
1971
        | MPOINTFROMTEXT '(' expr ',' expr ')'
 
1972
          { $$= new Item_func_geometry_from_text($3); }
 
1973
        | MPOLYFROMTEXT '(' expr ')'
 
1974
          { $$= new Item_func_geometry_from_text($3); }
 
1975
        | MPOLYFROMTEXT '(' expr ',' expr ')'
 
1976
          { $$= new Item_func_geometry_from_text($3); }
 
1977
        | MULTIPOINT '(' expr_list ')'
 
1978
          { $$= new Item_func_spatial_collection(* $3, 
 
1979
                    Geometry::wkbMultiPoint, Geometry::wkbPoint); }
 
1980
        | MULTIPOLYGON '(' expr_list ')'
 
1981
          { $$= new Item_func_spatial_collection(* $3, 
 
1982
                       Geometry::wkbMultiPolygon, Geometry::wkbPolygon ); }
1808
1983
        | NOW_SYM optional_braces
1809
1984
          { $$= new Item_func_now(); current_thd->safe_to_cache_query=0;}
1810
1985
        | NOW_SYM '(' expr ')'
1813
1988
          {
1814
1989
            $$= new Item_func_password($3);
1815
1990
           }
 
1991
        | POINTFROMTEXT '(' expr ')'
 
1992
          { $$= new Item_func_geometry_from_text($3); }
 
1993
        | POINTFROMTEXT '(' expr ',' expr ')'
 
1994
          { $$= new Item_func_geometry_from_text($3); }
 
1995
        | POLYFROMTEXT '(' expr ')'
 
1996
          { $$= new Item_func_geometry_from_text($3); }
 
1997
        | POLYFROMTEXT '(' expr ',' expr ')'
 
1998
          { $$= new Item_func_geometry_from_text($3); }
 
1999
        | POLYGON '(' expr_list ')'
 
2000
          { $$= new Item_func_spatial_collection(* $3, 
 
2001
                        Geometry::wkbPolygon, Geometry::wkbLineString); }
1816
2002
        | POSITION_SYM '(' no_in_expr IN_SYM expr ')'
1817
2003
          { $$ = new Item_func_locate($5,$3); }
1818
2004
        | RAND '(' expr ')'
1839
2025
        | SUBSTRING_INDEX '(' expr ',' expr ',' expr ')'
1840
2026
          { $$= new Item_func_substr_index($3,$5,$7); }
1841
2027
        | TRIM '(' expr ')'
1842
 
          { $$= new Item_func_trim($3,new Item_string(" ",1)); }
 
2028
          { $$= new Item_func_trim($3,new Item_string(" ",1,default_charset_info)); }
1843
2029
        | TRIM '(' LEADING opt_pad FROM expr ')'
1844
2030
          { $$= new Item_func_ltrim($6,$4); }
1845
2031
        | TRIM '(' TRAILING opt_pad FROM expr ')'
2024
2210
          };
2025
2211
 
2026
2212
opt_pad:
2027
 
        /* empty */ { $$=new Item_string(" ",1); }
 
2213
        /* empty */ { $$=new Item_string(" ",1,default_charset_info); }
2028
2214
        | expr      { $$=$1; };
2029
2215
 
2030
2216
join_table_list:
2087
2273
            YYABORT;
2088
2274
        }
2089
2275
        | '{' ident join_table LEFT OUTER JOIN_SYM join_table ON expr '}'
2090
 
          { add_join_on($7,$9); $7->outer_join|=JOIN_TYPE_LEFT; $$=$7; };
 
2276
          { add_join_on($7,$9); $7->outer_join|=JOIN_TYPE_LEFT; $$=$7; }
 
2277
        | '(' SELECT_SYM select_part3 ')' opt_table_alias 
 
2278
        {
 
2279
          LEX *lex=Lex;
 
2280
          SELECT_LEX_UNIT *unit= lex->select->master_unit();
 
2281
          lex->select= unit->outer_select();
 
2282
          if (!($$= add_table_to_list(new Table_ident(unit),
 
2283
                                      $5,0,TL_UNLOCK)))
 
2284
            YYABORT;
 
2285
        };
 
2286
 
 
2287
select_part3:
 
2288
        {
 
2289
          LEX *lex= Lex;
 
2290
          lex->derived_tables= true;
 
2291
          if (lex->select->linkage == GLOBAL_OPTIONS_TYPE || 
 
2292
              mysql_new_select(lex, 1))
 
2293
            YYABORT;
 
2294
          mysql_init_select(lex);
 
2295
          lex->select->linkage= DERIVED_TABLE_TYPE;
 
2296
        }
 
2297
        select_options select_item_list select_intoto
 
2298
 
 
2299
select_intoto:
 
2300
        limit_clause {}
 
2301
        | select_from
2091
2302
 
2092
2303
opt_outer:
2093
2304
        /* empty */     {}
2114
2325
 
2115
2326
key_usage_list2:
2116
2327
        key_usage_list2 ',' ident
2117
 
        { Select->interval_list.push_back(new String((const char*) $3.str,$3.length)); }
 
2328
        { Select->interval_list.push_back(new String((const char*) $3.str,$3.length,default_charset_info)); }
2118
2329
        | ident
2119
 
        { Select->interval_list.push_back(new String((const char*) $1.str,$1.length)); }
 
2330
        { Select->interval_list.push_back(new String((const char*) $1.str,$1.length,default_charset_info)); }
2120
2331
        | PRIMARY_SYM
2121
 
        { Select->interval_list.push_back(new String("PRIMARY",7)); };
 
2332
        { Select->interval_list.push_back(new String("PRIMARY",7,default_charset_info)); };
2122
2333
 
2123
2334
using_list:
2124
2335
        ident
2235
2446
                       "ORDER BY");
2236
2447
            YYABORT;
2237
2448
          }
2238
 
          lex->select->sort_default=1;
2239
2449
        } order_list;
2240
2450
 
2241
2451
order_list:
2709
2919
            if (!add_table_to_list($3,NULL,0))
2710
2920
              YYABORT;
2711
2921
          }
 
2922
        | COLUMN_SYM TYPES_SYM
 
2923
          {
 
2924
            LEX *lex=Lex;
 
2925
            lex->sql_command= SQLCOM_SHOW_COLUMN_TYPES;
 
2926
          }
 
2927
        | TABLE_SYM TYPES_SYM
 
2928
          {
 
2929
            LEX *lex=Lex;
 
2930
            lex->sql_command= SQLCOM_SHOW_TABLE_TYPES;
 
2931
          }
 
2932
        | PRIVILEGES
 
2933
          {
 
2934
            LEX *lex=Lex;
 
2935
            lex->sql_command= SQLCOM_SHOW_PRIVILEGES;
 
2936
          }
 
2937
        | COUNT_SYM '(' '*' ')' WARNINGS 
 
2938
          { Lex->sql_command = SQLCOM_SHOW_WARNS_COUNT;}
 
2939
        | COUNT_SYM '(' '*' ')' ERRORS 
 
2940
          { Lex->sql_command = SQLCOM_SHOW_ERRORS_COUNT;}
 
2941
        | WARNINGS {Select->offset_limit=0L;} limit_clause
 
2942
          { Lex->sql_command = SQLCOM_SHOW_WARNS;}
 
2943
        | ERRORS {Select->offset_limit=0L;} limit_clause
 
2944
          { Lex->sql_command = SQLCOM_SHOW_ERRORS;}  
2712
2945
        | STATUS_SYM wild
2713
2946
          { Lex->sql_command= SQLCOM_SHOW_STATUS; }
2714
2947
        | INNOBASE_SYM STATUS_SYM
2716
2949
        | opt_full PROCESSLIST_SYM
2717
2950
          { Lex->sql_command= SQLCOM_SHOW_PROCESSLIST;}
2718
2951
        | opt_var_type VARIABLES wild
2719
 
        {
 
2952
          {
2720
2953
            THD *thd= current_thd;
2721
2954
            thd->lex.sql_command= SQLCOM_SHOW_VARIABLES;
2722
2955
            thd->lex.option_type= (enum_var_type) $1;
2723
2956
          }
 
2957
        | CHAR_SYM SET wild
 
2958
          { Lex->sql_command= SQLCOM_SHOW_CHARSETS; }
2724
2959
        | LOGS_SYM
2725
2960
          { Lex->sql_command= SQLCOM_SHOW_LOGS; }
2726
2961
        | GRANTS FOR_SYM user
2730
2965
            lex->grant_user=$3;
2731
2966
            lex->grant_user->password.str=NullS;
2732
2967
          }
 
2968
        | CREATE DATABASE ident
 
2969
          {
 
2970
            Lex->sql_command=SQLCOM_SHOW_CREATE_DB;
 
2971
            Lex->name=$3.str;
 
2972
          }
2733
2973
        | CREATE TABLE_SYM table_ident
2734
2974
          {
2735
2975
            Lex->sql_command = SQLCOM_SHOW_CREATE;
2794
3034
        /* empty */     {}
2795
3035
        | text_string   { Lex->wild= $1; }
2796
3036
        | ident
2797
 
 { Lex->wild= new String((const char*) $1.str,$1.length); };
 
3037
          { Lex->wild= new String((const char*) $1.str,$1.length,default_charset_info); };
2798
3038
 
2799
3039
 
2800
3040
/* flush things */
2861
3101
        KILL_SYM expr
2862
3102
        {
2863
3103
          LEX *lex=Lex;
2864
 
          if ($2->fix_fields(lex->thd,0))
 
3104
          if ($2->fix_fields(lex->thd, 0, &$2))
2865
3105
          { 
2866
3106
            send_error(&lex->thd->net, ER_SET_CONSTANTS_ONLY);
2867
3107
            YYABORT;
2963
3203
/* Common definitions */
2964
3204
 
2965
3205
text_literal:
2966
 
        TEXT_STRING { $$ = new Item_string($1.str,$1.length); }
 
3206
        TEXT_STRING { $$ = new Item_string($1.str,$1.length,default_charset_info); }
 
3207
        | UNDERSCORE_CHARSET TEXT_STRING { $$ = new Item_string($2.str,$2.length,Lex->charset); }
2967
3208
        | text_literal TEXT_STRING
2968
3209
        { ((Item_string*) $1)->append($2.str,$2.length); };
2969
3210
 
2970
3211
text_string:
2971
 
        TEXT_STRING     { $$=  new String($1.str,$1.length); }
 
3212
        TEXT_STRING     { $$=  new String($1.str,$1.length,default_charset_info); }
2972
3213
        | HEX_NUM
2973
3214
          {
2974
 
            Item *tmp = new Item_varbinary($1.str,$1.length);
 
3215
            Item *tmp = new Item_varbinary($1.str,$1.length,default_charset_info);
2975
3216
            $$= tmp ? tmp->val_str((String*) 0) : (String*) 0;
2976
3217
          };
2977
 
 
 
3218
param_marker:
 
3219
        '?' 
 
3220
        {
 
3221
          if(current_thd->prepare_command)
 
3222
          {     
 
3223
            Lex->param_list.push_back($$=new Item_param());      
 
3224
            current_thd->param_count++;
 
3225
          }
 
3226
          else 
 
3227
          {
 
3228
            yyerror("You have an error in your SQL syntax");
 
3229
            YYABORT;
 
3230
          }
 
3231
        }
2978
3232
literal:
2979
3233
        text_literal    { $$ =  $1; }
2980
3234
        | NUM           { $$ =  new Item_int($1.str, (longlong) atol($1.str),$1.length); }
2984
3238
        | FLOAT_NUM     { $$ =  new Item_float($1.str, $1.length); }
2985
3239
        | NULL_SYM      { $$ =  new Item_null();
2986
3240
                          Lex->next_state=STATE_OPERATOR_OR_IDENT;}
2987
 
        | HEX_NUM       { $$ =  new Item_varbinary($1.str,$1.length);}
 
3241
        | HEX_NUM       { $$ =  new Item_varbinary($1.str,$1.length,default_charset_info);}
2988
3242
        | DATE_SYM text_literal { $$ = $2; }
2989
3243
        | TIME_SYM text_literal { $$ = $2; }
2990
3244
        | TIMESTAMP text_literal { $$ = $2; };
3117
3371
        | EXECUTE_SYM           {}
3118
3372
        | EXTENDED_SYM          {}
3119
3373
        | FAST_SYM              {}
3120
 
        | DISABLE_SYM           {}
3121
 
        | ENABLE_SYM            {}
 
3374
        | DISABLE_SYM           {}
 
3375
        | ENABLE_SYM            {}
3122
3376
        | FULL                  {}
3123
3377
        | FILE_SYM              {}
3124
3378
        | FIRST_SYM             {}
3125
3379
        | FIXED_SYM             {}
3126
3380
        | FLUSH_SYM             {}
3127
 
        | GRANTS                {}
 
3381
        | GRANTS                {}
3128
3382
        | GLOBAL_SYM            {}
3129
3383
        | HEAP_SYM              {}
3130
3384
        | HANDLER_SYM           {}
3137
3391
        | ISSUER_SYM            {}
3138
3392
        | INNOBASE_SYM          {}
3139
3393
        | INSERT_METHOD         {}
3140
 
        | IO_THREAD             {}
 
3394
        | IO_THREAD             {}
3141
3395
        | LAST_SYM              {}
3142
3396
        | LEVEL_SYM             {}
3143
3397
        | LOCAL_SYM             {}
3152
3406
        | MASTER_USER_SYM       {}
3153
3407
        | MASTER_PASSWORD_SYM   {}
3154
3408
        | MASTER_CONNECT_RETRY_SYM      {}
3155
 
        | MAX_CONNECTIONS_PER_HOUR       {}
3156
 
        | MAX_QUERIES_PER_HOUR  {}
3157
 
        | MAX_UPDATES_PER_HOUR  {}
 
3409
        | MAX_CONNECTIONS_PER_HOUR       {}
 
3410
        | MAX_QUERIES_PER_HOUR  {}
 
3411
        | MAX_UPDATES_PER_HOUR  {}
3158
3412
        | MEDIUM_SYM            {}
3159
3413
        | MERGE_SYM             {}
3160
3414
        | MINUTE_SYM            {}
3170
3424
        | NO_SYM                {}
3171
3425
        | OPEN_SYM              {}
3172
3426
        | PACK_KEYS_SYM         {}
 
3427
        | PARTIAL               {}
3173
3428
        | PASSWORD              {}
3174
3429
        | PREV_SYM              {}
3175
3430
        | PROCESS               {}
3176
3431
        | PROCESSLIST_SYM       {}
3177
3432
        | QUERY_SYM             {}
3178
3433
        | QUICK                 {}
3179
 
        | RAID_0_SYM            {}
 
3434
        | RAID_0_SYM            {}
3180
3435
        | RAID_CHUNKS           {}
3181
3436
        | RAID_CHUNKSIZE        {}
3182
 
        | RAID_STRIPED_SYM      {}
 
3437
        | RAID_STRIPED_SYM      {}
3183
3438
        | RAID_TYPE             {}
3184
 
        | RELAY_LOG_FILE_SYM    {}
3185
 
        | RELAY_LOG_POS_SYM     {}
 
3439
        | RELAY_LOG_FILE_SYM    {}
 
3440
        | RELAY_LOG_POS_SYM     {}
3186
3441
        | RELOAD                {}
3187
3442
        | REPAIR                {}
3188
3443
        | REPEATABLE_SYM        {}
3199
3454
        | SERIALIZABLE_SYM      {}
3200
3455
        | SESSION_SYM           {}
3201
3456
        | SIGNED_SYM            {}
 
3457
        | SIMPLE_SYM            {}
3202
3458
        | SHARE_SYM             {}
3203
3459
        | SHUTDOWN              {}
3204
 
        | SLAVE                 {}
 
3460
        | SLAVE                 {}
3205
3461
        | SQL_CACHE_SYM         {}
3206
3462
        | SQL_BUFFER_RESULT     {}
3207
3463
        | SQL_NO_CACHE_SYM      {}
3208
 
        | SQL_THREAD            {}
 
3464
        | SQL_THREAD            {}
3209
3465
        | START_SYM             {}
3210
3466
        | STATUS_SYM            {}
3211
3467
        | STOP_SYM              {}
3224
3480
        | USE_FRM               {}
3225
3481
        | VARIABLES             {}
3226
3482
        | WORK_SYM              {}
3227
 
        | YEAR_SYM              {};
 
3483
        | YEAR_SYM              {}
 
3484
        ;
3228
3485
 
3229
3486
/* Option functions */
3230
3487
 
3255
3512
 
3256
3513
opt_var_type:
3257
3514
        /* empty */     { $$=OPT_SESSION; }
 
3515
        | GLOBAL_SYM    { $$=OPT_GLOBAL; }
3258
3516
        | LOCAL_SYM     { $$=OPT_SESSION; }
3259
3517
        | SESSION_SYM   { $$=OPT_SESSION; }
3260
 
        | GLOBAL_SYM    { $$=OPT_GLOBAL; }
3261
3518
        ;
3262
3519
 
3263
3520
opt_var_ident_type:
3264
3521
        /* empty */             { $$=OPT_DEFAULT; }
 
3522
        | GLOBAL_SYM '.'        { $$=OPT_GLOBAL; }
3265
3523
        | LOCAL_SYM '.'         { $$=OPT_SESSION; }
3266
3524
        | SESSION_SYM '.'       { $$=OPT_SESSION; }
3267
 
        | GLOBAL_SYM '.'        { $$=OPT_GLOBAL; }
3268
3525
        ;
3269
3526
 
3270
3527
option_value:
3326
3583
        | REPEATABLE_SYM READ_SYM       { $$= ISO_REPEATABLE_READ; }
3327
3584
        | SERIALIZABLE_SYM              { $$= ISO_SERIALIZABLE; }
3328
3585
        ;
3329
 
 
 
3586
  
3330
3587
text_or_password:
3331
3588
        TEXT_STRING { $$=$1.str;}
3332
3589
        | PASSWORD '(' TEXT_STRING ')'
3632
3889
column_list_id:
3633
3890
        ident
3634
3891
        {
3635
 
          String *new_str = new String((const char*) $1.str,$1.length);
 
3892
          String *new_str = new String((const char*) $1.str,$1.length,default_charset_info);
3636
3893
          List_iterator <LEX_COLUMN> iter(Lex->columns);
3637
3894
          class LEX_COLUMN *point;
3638
3895
          LEX *lex=Lex;
3639
3896
          while ((point=iter++))
3640
3897
          {
3641
 
            if (!my_strcasecmp(point->column.ptr(),new_str->ptr()))
 
3898
            if (!my_strcasecmp(system_charset_info,
 
3899
                               point->column.ptr(), new_str->ptr()))
3642
3900
                break;
3643
3901
          }
3644
3902
          lex->grant_tot_col|= lex->which_columns;
3704
3962
 
3705
3963
 
3706
3964
/*
3707
 
** UNIONS : glue selects together
 
3965
   UNIONS : glue selects together
3708
3966
*/
3709
3967
 
3710
3968
 
3713
3971
        | union_list;
3714
3972
 
3715
3973
union_list:
3716
 
        UNION_SYM union_option
 
3974
        UNION_SYM    union_option
3717
3975
        {
3718
3976
          LEX *lex=Lex;
3719
3977
          if (lex->exchange)
3720
3978
          {
3721
3979
            /* Only the last SELECT can have  INTO...... */
3722
 
            net_printf(&lex->thd->net, ER_WRONG_USAGE,"UNION","INTO");
 
3980
            net_printf(&lex->thd->net, ER_WRONG_USAGE, "UNION", "INTO");
3723
3981
            YYABORT;
3724
 
          }
3725
 
          if (lex->select->linkage == NOT_A_SELECT)
 
3982
          } 
 
3983
          if (lex->select->linkage == GLOBAL_OPTIONS_TYPE)
3726
3984
          {
3727
3985
            send_error(&lex->thd->net, ER_SYNTAX_ERROR);
3728
3986
            YYABORT;
3730
3988
          if (mysql_new_select(lex))
3731
3989
            YYABORT;
3732
3990
          lex->select->linkage=UNION_TYPE;
3733
 
        } 
 
3991
        }
3734
3992
        select_init
3735
3993
        ;
3736
3994
 
3742
4000
        /* empty */ {}
3743
4001
        |
3744
4002
          {
3745
 
            LEX *lex=Lex;
 
4003
            LEX *lex=Lex;
3746
4004
            if (!lex->select->braces)
3747
4005
            {
3748
4006
              send_error(&lex->thd->net, ER_SYNTAX_ERROR);
3749
4007
              YYABORT;
3750
4008
            }
3751
 
            if (mysql_new_select(lex))
3752
 
              YYABORT;
3753
 
            mysql_init_select(lex);
3754
 
            lex->select->linkage=NOT_A_SELECT;
3755
 
            lex->select->select_limit=lex->thd->variables.select_limit;
 
4009
            lex->select->master_unit()->global_parameters= 
 
4010
              lex->select->master_unit();
 
4011
            /*
 
4012
              Following type conversion looks like hack, but all that need
 
4013
              SELECT_LEX fields always check linkage type.
 
4014
            */
 
4015
            lex->select= (SELECT_LEX*)lex->select->master_unit();
 
4016
            lex->select->select_limit=lex->thd->default_select_limit;
3756
4017
          }
3757
 
          opt_order_clause limit_clause
 
4018
        opt_order_clause limit_clause
3758
4019
        ;
3759
4020
 
3760
4021
union_option:
3761
4022
        /* empty */ {}
3762
 
        | ALL { Lex->union_option=1; }
3763
 
        ;
 
4023
        | ALL {Lex->union_option=1;};
 
4024
 
 
4025
singleval_subselect:
 
4026
        subselect_start singleval_subselect_init
 
4027
        subselect_end
 
4028
        {
 
4029
          $$= $2;
 
4030
        };
 
4031
 
 
4032
singleval_subselect_init:
 
4033
        select_init
 
4034
        {
 
4035
          $$= new Item_singleval_subselect(current_thd, Lex->select);
 
4036
        };
 
4037
 
 
4038
exists_subselect:
 
4039
        subselect_start exists_subselect_init
 
4040
        subselect_end
 
4041
        {
 
4042
          $$= $2;
 
4043
        };
 
4044
 
 
4045
exists_subselect_init:
 
4046
        select_init
 
4047
        {
 
4048
          $$= new Item_exists_subselect(current_thd, Lex->select);
 
4049
        };
 
4050
 
 
4051
subselect_start:
 
4052
        '('
 
4053
        {
 
4054
          if (mysql_new_select(Lex, 1))
 
4055
            YYABORT;
 
4056
        };
 
4057
 
 
4058
subselect_end:
 
4059
        ')'
 
4060
        {
 
4061
          LEX *lex=Lex;
 
4062
          lex->select = lex->select->outer_select();
 
4063
        };