-
Notifications
You must be signed in to change notification settings - Fork 0
/
php_egg.pgsql
6231 lines (6002 loc) · 691 KB
/
php_egg.pgsql
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
------------------------------------------------------------------
-- My2Pg $Revision: 1.19 translated dump
--
------------------------------------------------------------------
--
-- Sequences for table BANS
--
CREATE SEQUENCE bans_ban_id_seq;
-- MySQL dump 8.12
--
-- Host: localhost Database: egg_final
----------------------------------------------------------
-- Server version 3.23.33
--
-- Table structure for table 'bans'
--
CREATE TABLE "bans" (
"ban_id" INT4 DEFAULT nextval('bans_ban_id_seq'),
"chan_name" varchar(50) NOT NULL DEFAULT '',
"ban_mask" varchar(100) NOT NULL DEFAULT '',
"set_by" varchar(20) NOT NULL DEFAULT '',
"ban_date" INT4 NOT NULL DEFAULT '0',
PRIMARY KEY ("ban_id")
);
--
-- Dumping data for table 'bans'
--
--
-- Table structure for table 'chan_bans'
--
--
-- Sequences for table CHAN_BANS
--
CREATE SEQUENCE chan_bans_cb_id_seq;
CREATE TABLE "chan_bans" (
"cb_id" INT4 DEFAULT nextval('chan_bans_cb_id_seq'),
"chan" varchar(100) NOT NULL DEFAULT '',
"flag" varchar(10) NOT NULL DEFAULT '',
"host_mask" varchar(255) NOT NULL DEFAULT '',
"created" varchar(15) NOT NULL DEFAULT '',
"last_used" varchar(15) DEFAULT NULL,
"set_by" varchar(20) NOT NULL DEFAULT '',
"reason" varchar(100) NOT NULL DEFAULT '',
PRIMARY KEY ("cb_id")
);
--
-- Dumping data for table 'chan_bans'
--
--
-- Table structure for table 'chan_users'
--
--
-- Sequences for table CHAN_USERS
--
CREATE SEQUENCE chan_users_cu_id_seq;
---
--- Types for table CHAN_USERS
---
CREATE FUNCTION set_chan_users_o_in (opaque)
RETURNS set_chan_users_o
AS '/phpegg/libtypes.so'
LANGUAGE 'c';
CREATE FUNCTION set_chan_users_o_out (opaque)
RETURNS opaque
AS '/phpegg/libtypes.so'
LANGUAGE 'c';
CREATE TYPE set_chan_users_o (
internallength = 2,
input = set_chan_users_o_in,
output = set_chan_users_o_out
);
CREATE FUNCTION set_chan_users_o_eq (set_chan_users_o,set_chan_users_o)
RETURNS bool
AS '/phpegg/libtypes.so'
LANGUAGE 'c';
CREATE FUNCTION find_in_set (set_chan_users_o,set_chan_users_o)
RETURNS bool
AS '/phpegg/libtypes.so'
LANGUAGE 'c';
CREATE OPERATOR = (
leftarg = set_chan_users_o,
rightarg = set_chan_users_o,
commutator = =,
procedure = set_chan_users_o_eq
);
CREATE OPERATOR <> (
leftarg = set_chan_users_o,
rightarg = set_chan_users_o,
commutator = <>,
negator = =,
procedure = set_chan_users_o_eq
);
CREATE TABLE "chan_users" (
"cu_id" INT4 DEFAULT nextval('chan_users_cu_id_seq'),
"chan_name" varchar(20) NOT NULL DEFAULT '',
"nick" varchar(10) NOT NULL DEFAULT '',
"date" TIMESTAMP NOT NULL,
"mode" "set_chan_users_o" DEFAULT NULL,
"reason" varchar(100) DEFAULT NULL,
"ident" varchar(30) DEFAULT NULL,
"host_mask" varchar(60) DEFAULT NULL,
"last_spoke" TIMESTAMP NOT NULL,
PRIMARY KEY ("cu_id")
);
--
-- Dumping data for table 'chan_users'
--
--
-- Table structure for table 'channels'
--
--
-- Sequences for table CHANNELS
--
CREATE SEQUENCE channels_channels_id_seq;
CREATE TABLE "channels" (
"channels_id" INT4 DEFAULT nextval('channels_channels_id_seq'),
"chan_name" varchar(50) NOT NULL DEFAULT '',
"topic" varchar(100) NOT NULL DEFAULT '',
"topic_set_by" varchar(20) NOT NULL DEFAULT '',
"topic_set_date" INT4 NOT NULL DEFAULT '0',
"active" INT4 NOT NULL DEFAULT '1',
"last_in" INT4 DEFAULT NULL,
"in_chan" INT4 NOT NULL DEFAULT '0',
"auto_voice" INT4 NOT NULL DEFAULT '1',
"on_join" INT4 NOT NULL DEFAULT '0',
"on_part" INT4 NOT NULL DEFAULT '0',
PRIMARY KEY ("channels_id")
);
--
-- Dumping data for table 'channels'
--
--
-- Table structure for table 'dcc_connections'
--
--
-- Sequences for table DCC_CONNECTIONS
--
CREATE SEQUENCE dcc_connections_id_seq;
CREATE TABLE "dcc_connections" (
"id" INT4 DEFAULT nextval('dcc_connections_id_seq'),
"nick" "text" NOT NULL,
"time" INT4 NOT NULL DEFAULT '0',
"login" varchar(50) DEFAULT NULL,
"password" INT4 NOT NULL DEFAULT '0',
"hostmask" varchar(255) DEFAULT NULL,
PRIMARY KEY ("id")
);
--
-- Dumping data for table 'dcc_connections'
--
--
-- Table structure for table 'join_msg'
--
--
-- Sequences for table JOIN_MSG
--
CREATE SEQUENCE join_msg_join_msg_id_seq;
CREATE TABLE "join_msg" (
"join_msg_id" INT4 DEFAULT nextval('join_msg_join_msg_id_seq'),
"chan_name" varchar(50) NOT NULL DEFAULT '',
"msg" varchar(255) NOT NULL DEFAULT '',
PRIMARY KEY ("join_msg_id")
);
--
-- Dumping data for table 'join_msg'
--
--
-- Table structure for table 'manual'
--
CREATE TABLE "manual" (
"m_id" INT4 DEFAULT nextval('manual_m_id_seq'),
"search" varchar(255) NOT NULL DEFAULT '',
"help" "text" NOT NULL,
"example" varchar(255) DEFAULT NULL,
"url" varchar(255) DEFAULT NULL,
PRIMARY KEY ("m_id")
);
--
-- Dumping data for table 'manual'
--
INSERT INTO "manual" VALUES (1,'SELECT INTO TABLE','ANSI SQL syntax INSERT INTO ... SELECT ..., which is basically\nthe same thing.\nAlternatively, you can use SELECT INTO OUTFILE... or CREATE\nTABLE ... SELECT to solve your problem.\nAs MySQL does nowadays support transactions, the following\ndiscussion is only valid if you are only using the non-transaction-safe\ntable types. COMMIT.\n','','http://www.mysql.com/doc/C/o/Commit-rollback.html');
INSERT INTO "manual" VALUES (2,'ROLLBACK','The following mostly applies only for ISAM, MyISAM, and\ntables) in an a update, you can do COMMIT and ROLLBACK also\nwith MySQL. COMMIT.\nThe problem with handling COMMIT-ROLLBACK efficiently with\nthe above table types would require a completely different table layout\nthan MySQL uses today. The table type would also need extra\nthreads that do automatic cleanups on the tables, and the disk usage\n','','http://www.mysql.com/doc/C/o/Commit-rollback.html');
INSERT INTO "DEFAULT" nextval('manual_insert_seq') column\nand either the SQL function LAST_INSERT_ID() or the C API function\nAt MySQL AB, we have never had any need for row-level locking because we have\nalways been able to code around it. Some cases really need row\nlocking, but they are very few. If you want row-level locking, you\n','mysql> FLUSH PRIVILEGES;','http://www.mysql.com/doc/P/a/Password_security.html');
INSERT INTO "manual" VALUES (4,'-password option','The @samp{* characters represent your password.\nIt is more secure to enter your password this way than to specify it on the\ncommand line because it is not visible to other users. However, this method\nof entering a password is suitable only for programs that you run\ninteractively. If you want to invoke a client from a script that runs\nnon-interactively, there is no opportunity to enter the password from the\nterminal. On some systems, you may even find that the first line of your\n','mysql> SELECT PI()*2;','http://www.mysql.com/doc/C/o/Connection_access.html');
INSERT INTO "manual" VALUES (5,'PASSWORD()','Non-blank Password values represent encrypted passwords.\nsee. Rather, the password supplied by a user who is attempting to\nconnect is encrypted (using the PASSWORD() function). The\nencrypted password is then used when the client/server is checking if\nthe password is correct (This is done without the encrypted password\never traveling over the connection.) Note that from MySQL\'s\npoint of view the encrypted password is the FLOAT8password, so you should\n','mysql> SET PASSWORD FOR root=PASSWORD(\'new_password\');','http://www.mysql.com/doc/D/e/Default_privileges.html');
INSERT INTO "manual" VALUES (6,'statements, GRANT','You can add users two different ways: by using GRANT statements\nor by manipulating the MySQL grant tables directly. The\npreferred method is to use GRANT statements, because they are\nmore concise and less error-prone.\nThe examples below show how to use the mysql client to set up new\nusers. These examples assume that privileges are set up according to the\nDEFAULTs described in the previous section. This means that to make changes,\n','mysql> GRANT USAGE ON *.* TO dummy@@localhost;','http://www.mysql.com/doc/A/d/Adding_users.html');
INSERT INTO "manual" VALUES (7,'statements, INSERT','You can also add the same user access information directly by issuing\ntables:\nDepending on your MySQL version, you may have to use a different\nnumber of \'Y\' values above (versions prior to Version 3.22.11 had fewer\nprivilege columns). For the admin user, the more readable extended\nNote that to set up a superuser, you need only create a user table\nentry with the privilege fields set to \'Y\'. No db or\n','mysql> FLUSH PRIVILEGES;','http://www.mysql.com/doc/A/d/Adding_users.html');
INSERT INTO "manual" VALUES (8,'SET PASSWORD statement','In most cases you should use GRANT to set up your users/passwords,\nso the following only applies for advanced users. GRANT, , GRANT.\nThe examples in the preceding sections illustrate an important principle:\nwhen you store a non-empty password using INSERT or UPDATE\nstatements, you must use the PASSWORD() function to encrypt it. This\nis because the user table stores passwords in encrypted form, not as\nplaintext. If you forget that fact, you are likely to attempt to set\n','mysql> SELECT * FROM user;','http://www.mysql.com/doc/S/t/String_syntax.html');
INSERT INTO "manual" VALUES (9,'NUL','An ASCII 0 (NUL) character.\n','','http://www.mysql.com/doc/S/t/String_syntax.html');
INSERT INTO "manual" VALUES (10,'newline (\\n)','A newline character.\n','','http://www.mysql.com/doc/S/t/String_syntax.html');
INSERT INTO "manual" VALUES (11,'tab (\\t)','A tab character.\n','','http://www.mysql.com/doc/S/t/String_syntax.html');
INSERT INTO "manual" VALUES (12,'carriage return (\\r)','A carriage return character.\n','','http://www.mysql.com/doc/S/t/String_syntax.html');
INSERT INTO "manual" VALUES (13,'backspace (\\b)','A backspace character.\n','','http://www.mysql.com/doc/S/t/String_syntax.html');
INSERT INTO "manual" VALUES (14,'single quote (\\\')','A single quote (@samp{\') character.\n','','http://www.mysql.com/doc/S/t/String_syntax.html');
INSERT INTO "manual" VALUES (15,'FLOAT8quote (\\\")','A double quote (@samp{\") character.\n','','http://www.mysql.com/doc/S/t/String_syntax.html');
INSERT INTO "manual" VALUES (16,'escape (\\\\)','A backslash (@samp{\\) character.\n','','http://www.mysql.com/doc/S/t/String_syntax.html');
INSERT INTO "manual" VALUES (17,'Wild card character (%)','A @samp{% character. This is used to search for literal instances of\nas a wild-card character. String comparison functions.\n','','http://www.mysql.com/doc/S/t/String_syntax.html');
INSERT INTO "manual" VALUES (18,'Wild card character (_)','A @samp{_ character. This is used to search for literal instances of\nas a wild-card character. String comparison functions.\nNote that if you use @samp{\\% or @samp{\\_ in some string contexts, these\nwill return the strings @samp{\\% and @samp{\\_ and not @samp{% and\nThere are several ways to include quotes within a string:\nA @samp{\' inside a string quoted with @samp{\' may be written as @samp{\'\'.\nA @samp{\" inside a string quoted with @samp{\" may be written as @samp{\"\".\n','mysql> SELECT \"This\\nIs\\nFour\\nlines\";','http://www.mysql.com/doc/S/t/String_syntax.html');
INSERT INTO "manual" VALUES (19,'DBI->quote','If you write C code, you can use the C API function\nstatement. C API function overview. In Perl, you can use the\ncharacters to the proper escape sequences. Perl DBI Class, , Perl\nYou should use an escape function on any string that might contain any of the\nspecial characters listed above!\nIntegers are represented as a sequence of digits. Floats use @samp{. as a\ndecimal separator. Either type of number may be preceded by @samp{- to\n','mysql> select MOD(29,9);','http://www.mysql.com/doc/G/r/Grouping_functions.html');
INSERT INTO "manual" VALUES (20,'parentheses ( and )','Parentheses. Use these to force the order of evaluation in an expression:\nThe usual arithmetic operators are available. Note that in the case of\n','mysql> select (1+2)*3;','http://www.mysql.com/doc/A/r/Arithmetic_functions.html');
INSERT INTO "manual" VALUES (21,'addition (+)','Addition:\n','mysql> select 3+5;','http://www.mysql.com/doc/A/r/Arithmetic_functions.html');
INSERT INTO "manual" VALUES (22,'subtraction (-)','Subtraction:\n','mysql> select 3-5;','http://www.mysql.com/doc/A/r/Arithmetic_functions.html');
INSERT INTO "manual" VALUES (23,'multiplication (*)','Multiplication:\nThe result of the last expression is incorrect because the result of the integer\nmultiplication exceeds the 64-bit range of BIGINT calculations.\n','mysql> select '18014398 509481'984*'18014398 509481'984;','http://www.mysql.com/doc/A/r/Arithmetic_functions.html');
INSERT INTO "manual" VALUES (24,'division (/)','Division:\nDivision by zero produces a NULL result:\nA division will be calculated with BIGINT arithmetic only if performed\nin a context where its result is converted to an integer!\n','mysql> select 102/(1-1);','http://www.mysql.com/doc/A/r/Arithmetic_functions.html');
INSERT INTO "manual" VALUES (25,'functions, bit','these operators have a maximum range of 64 bits.\n','','http://www.mysql.com/doc/B/i/Bit_functions.html');
INSERT INTO "manual" VALUES (26,'OR, bitwise','Bitwise OR:\n','mysql> select 29 | 15;','http://www.mysql.com/doc/B/i/Bit_functions.html');
INSERT INTO "manual" VALUES (27,'AND, bitwise','Bitwise AND:\n','mysql> select 29 & 15;','http://www.mysql.com/doc/B/i/Bit_functions.html');
INSERT INTO "manual" VALUES (28,'<< (left shift)','Shifts a longlong (BIGINT) number to the left:\n','mysql> select 1 << 2','http://www.mysql.com/doc/B/i/Bit_functions.html');
INSERT INTO "manual" VALUES (29,'>> (right shift)','Shifts a longlong (BIGINT) number to the right:\n','mysql> select 4 >> 2','http://www.mysql.com/doc/B/i/Bit_functions.html');
INSERT INTO "manual" VALUES (30,'~','Invert all bits:\n','mysql> select 5 & ~1','http://www.mysql.com/doc/B/i/Bit_functions.html');
INSERT INTO "manual" VALUES (31,'BIT_COUNT()','Returns the number of bits that are set in the argument N:\n','mysql> select BIT_COUNT(29);','http://www.mysql.com/doc/B/i/Bit_functions.html');
INSERT INTO "manual" VALUES (32,'Functions, logical','All logical functions return 1 (TRUE), 0 (FALSE) or\n','','http://www.mysql.com/doc/L/o/Logical_functions.html');
INSERT INTO "manual" VALUES (33,'! (logical NOT)','Logical NOT. Returns 1 if the argument is 0, otherwise returns\nException: NOT NULL returns NULL:\nThe last example returns 1 because the expression evaluates\nthe same way as (!1)+1.\n','mysql> select ! 1+1;','http://www.mysql.com/doc/L/o/Logical_functions.html');
INSERT INTO "manual" VALUES (34,'|| (logical OR)','Logical OR. Returns 1 if either argument is not 0 and not\n','mysql> select 1 || NULL;','http://www.mysql.com/doc/L/o/Logical_functions.html');
INSERT INTO "manual" VALUES (35,'&& (logical AND)','Logical AND. Returns 0 if either argument is 0 or NULL,\notherwise returns 1:\n','mysql> select 1 && 0;','http://www.mysql.com/doc/L/o/Logical_functions.html');
INSERT INTO "manual" VALUES (36,'comparison operators','Comparison operations result in a value of 1 (TRUE), 0 (FALSE),\nor NULL. These functions work for both numbers and strings. Strings\nare automatically converted to numbers and numbers to strings as needed (as\nin Perl).\nrules:\nIf one or both arguments are NULL, the result of the comparison\nis NULL, except for the <=> operator.\n','mysql> SELECT 0 = \'x6\';','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (37,'equal (=)','Equal:\n','mysql> select \'.01\' = 0.01;','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (38,'not equal (!=)','Not equal:\n','mysql> select \'zapp\' <> \'zappp\';','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (39,'less than or equal (<=)','Less than or equal:\n','mysql> select 0.1 <= 2;','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (40,'less than (<)','Less than:\n','mysql> select 2 <= 2;','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (41,'greater than or equal (>=)','Greater than or equal:\n','mysql> select 2 >= 2;','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (42,'greater than (>)','Greater than:\n','mysql> select 2 > 2;','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (43,'<=> (Equal to)','Null safe equal:\n','mysql> select 1 <=> 1, NULL <=> NULL, 1 <=> NULL;','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (44,'IS NOT NULL','Test whether or not a value is or is not NULL:\n','mysql> select 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (45,'BETWEEN ... AND','If expr is greater than or equal to min and expr is\nless than or equal to max, BETWEEN returns 1,\notherwise it returns 0. This is equivalent to the expression\nsame type. The first argument (expr) determines how the\ncomparison is performed as follows:\nIf expr is a TIMESTAMP, DATE, or DATETIME\ncolumn, MIN() and MAX() are formatted to the same format if\n','mysql> select 2 BETWEEN 2 AND \'x-3\';','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (46,'IN','Returns 1 if expr is any of the values in the IN list,\nelse returns 0. If all values are constants, then all values are\nevaluated according to the type of expr and sorted. The search for the\nitem is then done using a binary search. This means IN is very quick\nif the IN value list consists entirely of constants. If expr\nis a case-sensitive string expression, the string comparison is performed in\ncase-sensitive fashion:\n','mysql> select \'wefwf\' IN (0,3,5,\'wefwf\');','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (47,'NOT IN','Same as NOT (expr IN (value,...)).\n','','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (48,'ISNULL()','If expr is NULL, ISNULL() returns 1, otherwise\nit returns 0:\nNote that a comparison of NULL values using = will always be\nfalse!\n','mysql> select ISNULL(1/0);','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (49,'COALESCE()','Returns first non-NULL element in list:\n','mysql> select COALESCE(NULL,NULL,NULL);','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (50,'INTERVAL()','Returns 0 if N < N1, 1 if N < N2\nand so on. All arguments are treated as integers. It is required that\nto work correctly. This is because a binary search is used (very fast):\n','mysql> select INTERVAL(22, 23, 30, 44, 200);','http://www.mysql.com/doc/C/o/Comparison_functions.html');
INSERT INTO "manual" VALUES (51,'functions, string comparison','Normally, if any expression in a string comparison is case sensitive, the\ncomparison is performed in case-sensitive fashion.\n','','http://www.mysql.com/doc/S/t/String_comparison_functions.html');
INSERT INTO "manual" VALUES (52,'LIKE','Pattern matching using\nSQL simple regular expression comparison. Returns 1 (TRUE) or 0\n(FALSE). With LIKE you can use the following two wild-card characters\nin the pattern:\nTo test for literal instances of a wild-card character, precede the character\nwith the escape character. If you don\'t specify the ESCAPE character,\nTo specify a different escape character, use the ESCAPE clause:\n','mysql> select 10 LIKE \'1%\';','http://www.mysql.com/doc/S/t/String_comparison_functions.html');
INSERT INTO "manual" VALUES (53,'NOT LIKE','Same as NOT (expr LIKE pat [ESCAPE \'escape-char\']).\n','','http://www.mysql.com/doc/S/t/String_comparison_functions.html');
INSERT INTO "manual" VALUES (54,'RLIKE','Performs a pattern match of a string expression expr against a pattern\nreturns 0. RLIKE is a synonym for REGEXP, provided for\nsyntax in strings (for example, @samp{\\n), you must FLOAT8any @samp{\\ that\nyou use in your REGEXP strings. As of MySQL Version 3.23.4,\nLatin1 by DEFAULT) when deciding the type of a character.\n','mysql> select \"a\" REGEXP \"^[a-d]\";','http://www.mysql.com/doc/S/t/String_comparison_functions.html');
INSERT INTO "manual" VALUES (55,'NOT REGEXP','Same as NOT (expr REGEXP pat).\n','','http://www.mysql.com/doc/S/t/String_comparison_functions.html');
INSERT INTO "manual" VALUES (56,'STRCMP()','returns 0 if the strings are the same, -1 if the first\nargument is smaller than the second according to the current sort order,\nand 1 otherwise:\n','mysql> select STRCMP(\'text\', \'text\');','http://www.mysql.com/doc/S/t/String_comparison_functions.html');
INSERT INTO "manual" VALUES (57,'MATCH ... AGAINST()','relevance - similarity measure between the text in columns\npositive floating-point number. Zero relevance means no similarity.\nFor MATCH ... AGAINST() to work, a FULLTEXT index\nmust be created first. CREATE TABLE, , CREATE TABLE.\n3.23.23 or later. For details and usage examples\n','','http://www.mysql.com/doc/S/t/String_comparison_functions.html');
INSERT INTO "manual" VALUES (58,'BINARY','The BINARY operator casts the string following it to a binary string.\nThis is an easy way to force a column comparison to be case sensitive even\nif the column isn\'t defined as BINARY or text:\nNote that in some context MySQL will not be able to use the\nindex efficiently when you cast an indexed column to BINARY.\nIf you want to compare a blob case-insensitively you can always convert\nthe blob to upper case before doing the comparison:\n','mysql> select BINARY \"a\" = \"A\";','http://www.mysql.com/doc/C/a/Casts.html');
INSERT INTO "manual" VALUES (59,'IFNULL()','If expr1 is not NULL, IFNULL() returns expr1,\nelse it returns expr2. IFNULL() returns a numeric or string\nvalue, depending on the context in which it is used:\n','mysql> select IFNULL(1/0,\'yes\');','http://www.mysql.com/doc/C/o/Control_flow_functions.html');
INSERT INTO "manual" VALUES (60,'NULLIF()','If expr1 = expr2 is true, return NULL else return expr1.\nThis is the same as CASE WHEN x = y THEN NULL ELSE x END:\nNote that expr1 is evaluated twice in MySQL if the arguments\nare equal.\n','mysql> select NULLIF(1,2);','http://www.mysql.com/doc/C/o/Control_flow_functions.html');
INSERT INTO "manual" VALUES (61,'IF()','If expr1 is TRUE (expr1 <> 0 and expr1 <> NULL) then\nin which it is used:\ntesting floating-point or string values, you should do so using a comparison\noperation:\nIn the first case above, IF(0.1) returns 0 because 0.1\nis converted to an integer value, resulting in a test of IF(0). This\nmay not be what you expect. In the second case, the comparison tests the\n','mysql> select IF(0.1<>0,1,0);','http://www.mysql.com/doc/C/o/Control_flow_functions.html');
INSERT INTO "manual" VALUES (62,'CASE','The first version returns the result where\nthe first condition, which is true. If there was no matching result\nvalue, then the result after ELSE is returned. If there is no\nThe type of the return value (INTEGER, FLOAT8or\nexpression after the first THEN).\n','mysql> SELECT CASE BINARY \"B\" when \"a\" then 1 when \"b\" then 2 END;','http://www.mysql.com/doc/C/o/Control_flow_functions.html');
INSERT INTO "manual" VALUES (63,'functions, mathematical','All mathematical functions return NULL in case of an error.\n','','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (64,'unary minus (-)','Unary minus. Changes the sign of the argument:\nNote that if this operator is used with a BIGINT, the return value is a\nmay have the value of -2^63!\n','mysql> select - 2;','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (65,'ABS()','Returns the absolute value of X:\nThis function is safe to use with BIGINT values.\n','mysql> select ABS(-32);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (66,'SIGN()','Returns the sign of the argument as -1, 0, or 1, depending\non whether X is negative, zero, or positive:\n','mysql> select SIGN(234);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (67,'modulo (%)','Modulo (like the % operator in C).\nReturns the remainder of N divided by M:\nThis function is safe to use with BIGINT values.\n','mysql> select MOD(29,9);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (68,'FLOOR()','Returns the largest integer value not greater than X:\nNote that the return value is converted to a BIGINT!\n','mysql> select FLOOR(-1.23);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (69,'CEILING()','Returns the smallest integer value not less than X:\nNote that the return value is converted to a BIGINT!\n','mysql> select CEILING(-1.23);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (70,'ROUND()','Returns the argument X, rounded to the nearest integer:\n','mysql> select ROUND(1.58);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (71,'ROUND()','Returns the argument X, rounded to a number with D decimals.\nIf D is 0, the result will have no decimal point or fractional\npart:\n','mysql> select ROUND(1.298, 0);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (72,'EXP()','Returns the value of e (the base of natural logarithms) raised to\nthe power of X:\n','mysql> select EXP(-2);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (73,'LOG()','Returns the natural logarithm of X:\nIf you want the log of a number X to some arbitary base B, use\nthe formula LOG(X)/LOG(B).\n','mysql> select LOG(-2);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (74,'LOG10()','Returns the base-10 logarithm of X:\n','mysql> select LOG10(-100);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (75,'POWER()','Returns the value of X raised to the power of Y:\n','mysql> select POW(2,-2);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (76,'SQRT()','Returns the non-negative square root of X:\n','mysql> select SQRT(20);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (77,'PI()','Returns the value of PI:\n','mysql> select PI();','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (78,'COS()','Returns the cosine of X, where X is given in radians:\n','mysql> select COS(PI());','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (79,'SIN()','Returns the sine of X, where X is given in radians:\n','mysql> select SIN(PI());','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (80,'TAN()','Returns the tangent of X, where X is given in radians:\n','mysql> select TAN(PI()+1);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (81,'ACOS()','Returns the arc cosine of X, that is, the value whose cosine is\n','mysql> select ACOS(0);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (82,'ASIN()','Returns the arc sine of X, that is, the value whose sine is\n','mysql> select ASIN(\'foo\');','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (83,'ATAN()','Returns the arc tangent of X, that is, the value whose tangent is\n','mysql> select ATAN(-2);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (84,'ATAN2()','Returns the arc tangent of the two variables X and Y. It is\nsimilar to calculating the arc tangent of Y / X, except that the\nsigns of both arguments are used to determine the quadrant of the\nresult:\n','mysql> select ATAN(PI(),0);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (85,'COT()','Returns the cotangent of X:\n','mysql> select COT(0);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (86,'RAND()','Returns a random floating-point value in the range 0 to 1.0.\nIf an integer argument N is specified, it is used as the seed value:\nYou can\'t use a column with RAND() values in an ORDER BY\nclause, because ORDER BY would evaluate the column multiple times.\nIn MySQL Version 3.23, you can, however, do:\nThis is useful to get a random sample of a set SELECT * FROM\ntable1,table2 WHERE a=b AND c<d ORDER BY RAND() LIMIT 1000.\n','mysql> select RAND();','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (87,'LEAST()','With two or more arguments, returns the smallest (minimum-valued) argument.\nThe arguments are compared using the following rules:\nIf the return value is used in an INTEGER context, or all arguments\nare integer-valued, they are compared as integers.\nIf the return value is used in a FLOAT8context, or all arguments are\nreal-valued, they are compared as reals.\nIf any argument is a case-sensitive string, the arguments are compared\n','mysql> select LEAST(\"B\",\"A\",\"C\");','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (88,'GREATEST()','Returns the largest (maximum-valued) argument.\nThe arguments are compared using the same rules as for LEAST:\nIn MySQL versions prior to Version 3.22.5, you can use MAX()\ninstead of GREATEST.\n','mysql> select GREATEST(\"B\",\"A\",\"C\");','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (89,'DEGREES()','Returns the argument X, converted from radians to degrees:\n','mysql> select DEGREES(PI());','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (90,'RADIANS()','Returns the argument X, converted from degrees to radians:\n','mysql> select RADIANS(90);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (91,'TRUNCATE()','Returns the number X, truncated to D decimals. If D\nis 0, the result will have no decimal point or fractional part:\n','mysql> select TRUNCATE(1.999,0);','http://www.mysql.com/doc/M/a/Mathematical_functions.html');
INSERT INTO "manual" VALUES (92,'functions, string','String-valued functions return NULL if the length of the result would\nbe greater than the max_allowed_packet server parameter. Server\nparameters.\nFor functions that operate on string positions,\nthe first position is numbered 1.\n','','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (93,'ASCII()','Returns the ASCII code value of the leftmost character of the string\nSee also the ORD() function.\n','mysql> select ASCII(\'dx\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (94,'ORD()','If the leftmost character of the string str is a multi-byte character,\nreturns the code of multi-byte character by returning the ASCII code value\nof the character in the format of:\nIf the leftmost character is not a multi-byte character, returns the same\nvalue as the like ASCII() function does:\n','mysql> select ORD(\'2\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (95,'CONV()','Converts numbers between different number bases. Returns a string\nrepresentation of the number N, converted from base from_base\nto base to_base. Returns NULL if any argument is NULL.\nThe argument N is interpreted as an integer, but may be specified as\nan integer or a string. The minimum base is 2 and the maximum base is\nsigned number. Otherwise, N is treated as . CONV works\nwith 64-bit precision:\n','mysql> select CONV(10+\"10\"+\'10\'+0xa,10,10);','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (96,'BIN()','Returns a string representation of the binary value of N, where\n','mysql> select BIN(12);','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (97,'OCT()','Returns a string representation of the octal value of N, where\nReturns NULL if N is NULL:\n','mysql> select OCT(12);','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (98,'HEX()','Returns a string representation of the hexadecimal value of N, where\n','mysql> select HEX(255);','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (99,'CHAR()','consisting of the characters given by the ASCII code values of those\nintegers. NULL values are skipped:\n','mysql> select CHAR(77,77.3,\'77.3\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (100,'CONCAT()','Returns the string that results from concatenating the arguments. Returns\nA numeric argument is converted to the equivalent string form:\n','mysql> select CONCAT(14.3);','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (101,'CONCAT_WS()','arguments. The separator can be a string as well as the rest of the\narguments. If the separator is NULL, the result will be NULL.\nThe function will skip any NULLs and empty strings, after the\nseparator argument. The separator will be added between the strings to be\nconcatenated:\n','mysql> select CONCAT_WS(\",\",\"First name\",NULL,\"Last Name\");','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (102,'CHARACTER_LENGTH()','Returns the length of the string str:\nNote that for CHAR_LENGTH(), multi-byte characters are only counted\nonce.\n','mysql> select OCTET_LENGTH(\'text\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (103,'POSITION()','Returns the position of the first occurrence of substring substr\nin string str. Returns 0 if substr is not in str:\nThis function is multi-byte safe.\n','mysql> select LOCATE(\'xbar\', \'foobar\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (104,'LOCATE()','Returns the position of the first occurrence of substring substr in\nstring str, starting at position pos.\nReturns 0 if substr is not in str:\nThis function is multi-byte safe.\n','mysql> select LOCATE(\'bar\', \'foobarbar\',5);','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (105,'INSTR()','Returns the position of the first occurrence of substring substr in\nstring str. This is the same as the two-argument form of\nThis function is multi-byte safe.\n','mysql> select INSTR(\'xbar\', \'foobar\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (106,'LPAD()','Returns the string str, left-padded with the string padstr\nuntil str is len characters long. If str is longer\nthan len\' then it will be shortened to len characters.\n','mysql> select LPAD(\'hi\',4,\'??\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (107,'RPAD()','Returns the string str, right-padded with the string\n','mysql> select RPAD(\'hi\',5,\'?\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (108,'LEFT()','Returns the leftmost len characters from the string str:\nThis function is multi-byte safe.\n','mysql> select LEFT(\'foobarbar\', 5);','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (109,'RIGHT()','Returns the rightmost len characters from the string str:\nThis function is multi-byte safe.\n','mysql> select RIGHT(\'foobarbar\', 4);','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (110,'MID()','Returns a substring len characters long from string str,\nstarting at position pos.\nThe variant form that uses FROM is ANSI SQL92 syntax:\nThis function is multi-byte safe.\n','mysql> select SUBSTRING(\'Quadratically\',5,6);','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (111,'SUBSTRING()','Returns a substring from string str starting at position pos:\nThis function is multi-byte safe.\n','mysql> select SUBSTRING(\'foobarbar\' FROM 4);','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (112,'SUBSTRING_INDEX()','Returns the substring from string str before count\noccurrences of the delimiter delim.\nIf count is positive, everything to the left of the final delimiter\n(counting from the left) is returned.\nIf count is negative, everything to the right of the final delimiter\n(counting from the right) is returned:\nThis function is multi-byte safe.\n','mysql> select SUBSTRING_INDEX(\'www.mysql.com\', \'.\', -2);','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (113,'LTRIM()','Returns the string str with leading space characters removed:\n','mysql> select LTRIM(\' barbar\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (114,'RTRIM()','Returns the string str with trailing space characters removed:\nThis function is multi-byte safe.\n','mysql> select RTRIM(\'barbar \');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (115,'TRIM()','Returns the string str with all remstr prefixes and/or suffixes\nremoved. If none of the specifiers BOTH, LEADING or\nspecified, spaces are removed:\nThis function is multi-byte safe.\n','mysql> select TRIM(TRAILING \'xyz\' FROM \'barxxyz\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (116,'SOUNDEX()','Returns a soundex string from str. Two strings that sound almost the\nsame should have identical soundex strings. A standard soundex string\nis 4 characters long, but the SOUNDEX() function returns an\narbitrarily long string. You can use SUBSTRING() on the result to get\na standard soundex string. All non-alphanumeric characters are ignored\nin the given string. All international alpha characters outside the A-Z range\nare treated as vowels:\n','mysql> select SOUNDEX(\'Quadratically\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (117,'SPACE()','Returns a string consisting of N space characters:\n','mysql> select SPACE(6);','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (118,'REPLACE()','Returns the string str with all all occurrences of the string\nThis function is multi-byte safe.\n','mysql> select REPLACE(\'www.mysql.com\', \'w\', \'Ww\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (119,'REPEAT()','Returns a string consisting of the string str repeated count\ntimes. If count <= 0, returns an empty string. Returns NULL if\n','mysql> select REPEAT(\'MySQL\', 3);','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (120,'REVERSE()','Returns the string str with the order of the characters reversed:\nThis function is multi-byte safe.\n','mysql> select REVERSE(\'abc\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (121,'INSERT()','Returns the string str, with the substring beginning at position\nThis function is multi-byte safe.\n','mysql> select INSERT(\'Quadratic\', 3, 4, \'What\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (122,'ELT()','Returns str1 if N = 1, str2 if N =\nor greater than the number of arguments. ELT() is the complement of\n','mysql> select ELT(4, \'ej\', \'Heja\', \'hej\', \'foo\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (123,'FIELD()','Returns the index of str in the str1, str2,\nReturns 0 if str is not found.\n','mysql> select FIELD(\'fo\', \'Hej\', \'ej\', \'Heja\', \'hej\', \'foo\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (124,'FIND_IN_SET()','Returns a value 1 to N if the string str is in the list\ncomposed of substrings separated by @samp{, characters. If the first\nargument is a constant string and the second is a column of type SET,\nthe FIND_IN_SET() function is optimized to use bit arithmetic!\nReturns 0 if str is not in strlist or if strlist\nis the empty string. Returns NULL if either argument is NULL.\nThis function will not work properly if the first argument contains a\n','mysql> SELECT FIND_IN_SET(\'b\',\'a,b,c,d\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (125,'MAKE_SET()','Returns a set (a string containing substrings separated by @samp{,\ncharacters) consisting of the strings that have the corresponding bit in\netc. NULL strings in str1, str2, ...\nare not appended to the result:\n','mysql> SELECT MAKE_SET(0,\'a\',\'b\',\'c\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (126,'EXPORT_SET()','Returns a string where for every bit set in \'bit\', you get an \'on\' string\nand for every reset bit you get an \'off\' string. Each string is separated\nwith \'separator\' (DEFAULT \',\') and only \'number_of_bits\' (default 64) of\n\'bits\' is used:\n','mysql> select EXPORT_SET(5,\'Y\',\'N\',\',\',4)','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (127,'LOWER()','Returns the string str with all characters changed to lowercase\naccording to the current character set mapping (the DEFAULT is ISO-8859-1\nLatin1):\nThis function is multi-byte safe.\n','mysql> select LCASE(\'QUADRATICALLY\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (128,'UPPER()','Returns the string str with all characters changed to uppercase\naccording to the current character set mapping (the DEFAULT is ISO-8859-1\nLatin1):\nThis function is multi-byte safe.\n','mysql> select UCASE(\'Hej\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (129,'LOAD_FILE()','Reads the file and returns the file contents as a string. The file\nmust be on the server, you must specify the full pathname to the\nfile, and you must have the file privilege. The file must\nbe readable by all and be smaller than max_allowed_packet.\nIf the file doesn\'t exist or can\'t be read due to one of the above reasons,\nthe function returns NULL:\nIf you are not using MySQL Version 3.23, you have to do the reading\n','mysql> SELECT CONCAT(2,\' test\');','http://www.mysql.com/doc/S/t/String_functions.html');
INSERT INTO "manual" VALUES (130,'functions, date and time','See Date and time types for a description of the range of values\neach type has and the valid formats in which date and time values may be\nspecified.\nHere is an example that uses date functions. The query below selects\nall records with a date_col value from within the last 30 days:\n','mysql> SELECT something FROM table','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (131,'DAYOFWEEK()','Returns the weekday index\nfor date (1 = Sunday, 2 = Monday, ... 7 =\nSaturday). These index values correspond to the ODBC standard:\n','mysql> select DAYOFWEEK(\'1998-02-03\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (132,'WEEKDAY()','Returns the weekday index for\n','mysql> select WEEKDAY(\'1997-11-05\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (133,'DAYOFMONTH()','Returns the day of the month for date, in the range 1 to\n','mysql> select DAYOFMONTH(\'1998-02-03\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (134,'DAYOFYEAR()','Returns the day of the year for date, in the range 1 to\n','mysql> select DAYOFYEAR(\'1998-02-03\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (135,'MONTH()','Returns the month for date, in the range 1 to 12:\n','mysql> select MONTH(\'1998-02-03\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (136,'DAYNAME()','Returns the name of the weekday for date:\n','mysql> select DAYNAME(\"1998-02-05\");','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (137,'MONTHNAME()','Returns the name of the month for date:\n','mysql> select MONTHNAME(\"1998-02-05\");','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (138,'QUARTER()','Returns the quarter of the year for date, in the range 1\nto 4:\n','mysql> select QUARTER(\'98-04-01\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (139,'WEEK()','With a single argument, returns the week for date, in the range\nfor locations where Sunday is the first day of the week. The\ntwo-argument form of WEEK() allows you to specify whether the\nweek starts on Sunday or Monday. The week starts on Sunday if the\nsecond argument is 0, on Monday if the second argument is\n','mysql> select WEEK(\'1998-12-31\',1);','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (140,'YEAR()','Returns the year for date, in the range 1000 to 9999:\nReturns year and week for a date. The second arguments works exactly\nlike the second argument to WEEK(). Note that the year may be\ndifferent from the year in the date argument for the first and the last\nweek of the year:\n','mysql> select YEARWEEK(\'1987-01-01\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (141,'HOUR()','Returns the hour for time, in the range 0 to 23:\n','mysql> select HOUR(\'10:05:03\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (142,'MINUTE()','Returns the minute for time, in the range 0 to 59:\n','mysql> select MINUTE(\'98-02-03 10:05:03\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (143,'SECOND()','Returns the second for time, in the range 0 to 59:\n','mysql> select SECOND(\'10:05:03\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (144,'PERIOD_ADD()','Adds N months to period P (in the format YYMM or\nNote that the period argument P is not a date value:\n','mysql> select PERIOD_ADD(9801,2);','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (145,'PERIOD_DIFF()','Returns the number of months between periods P1 and P2.\nNote that the period arguments P1 and P2 are not\ndate values:\n','mysql> select PERIOD_DIFF(9802,199703);','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (146,'EXTRACT(type FROM date)','These functions perform date arithmetic. They are new for MySQL\nVersion 3.22. ADDDATE() and SUBDATE() are synonyms for\nIn MySQL Version 3.23, you can use + and - instead of\na date or TIMESTAMP column. (See example)\ndate. expr is an expression specifying the interval value to be added\nor substracted from the starting date. expr is a string; it may start\nwith a @samp{- for negative intervals. type is a keyword indicating\n','mysql> select DATE_ADD(\'1998-01-30\', Interval 1 month);','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (147,'TO_DAYS()','Given a date date, returns a daynumber (the number of days since year\n0):\nof the Gregorian calendar (1582), because it doesn\'t take into account the\ndays that were lost when the calender was changed.\n','mysql> select TO_DAYS(\'1997-10-07\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (148,'FROM_DAYS()','Given a daynumber N, returns a DATE value:\nadvent of the Gregorian calendar (1582), because it doesn\'t take into account\nthe days that were lost when the calender was changed.\n','mysql> select FROM_DAYS(729669);','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (149,'DATE_FORMAT()','Formats the date value according to the format string. The\nfollowing specifiers may be used in the format string:\nAll other characters are just copied to the result without interpretation:\nAs of MySQL Version 3.23, the @samp{% character is required before\nformat specifier characters. In earlier versions of MySQL,\n','mysql> select DATE_FORMAT(\'1999-01-01\', \'%X %V\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (150,'TIME_FORMAT()','This is used like the DATE_FORMAT() function above, but the\nhours, minutes, and seconds. Other specifiers produce a NULL value or\n','','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (151,'CURRENT_DATE','Returns today\'s date as a value in \'YYYY-MM-DD\' or YYYYMMDD\nformat, depending on whether the function is used in a string or numeric\ncontext:\n','mysql> select CURDATE() + 0;','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (152,'CURRENT_TIME','Returns the current time as a value in \'HH:MM:SS\' or HHMMSS\nformat, depending on whether the function is used in a string or numeric\ncontext:\n','mysql> select CURTIME() + 0;','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (153,'CURRENT_TIMESTAMP','Returns the current date and time as a value in \'YYYY-MM-DD HH:MM:SS\'\nor YYYYMMDDHHMMSS format, depending on whether the function is used in\na string or numeric context:\n','mysql> select NOW() + 0;','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (154,'UNIX_TIMESTAMP()','If called with no argument, returns a Unix timestamp (seconds since\na date argument, it returns the value of the argument as seconds since\na DATETIME string, a TIMESTAMP, or a number in the format\nWhen UNIX_TIMESTAMP is used on a TIMESTAMP column, the function\nwill receive the value directly, with no implicit\n``string-to-unix-timestamp\'\' conversion.\nIf you give UNIX_TIMESTAMP() a wrong or out-of-range date, it will\n','mysql> select UNIX_TIMESTAMP(\'1997-10-04 22:23:00\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (155,'FROM_UNIXTIME()','Returns a representation of the unix_timestamp argument as a value in\nwhether the function is used in a string or numeric context:\n','mysql> select FROM_UNIXTIME(875996580) + 0;','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (156,'FROM_UNIXTIME()','Returns a string representation of the Unix timestamp, formatted according to\nthe format string. format may contain the same specifiers as\nthose listed in the entry for the DATE_FORMAT() function:\n','mysql> select FROM_UNIXTIME(UNIX_TIMESTAMP(),','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (157,'SEC_TO_TIME()','Returns the seconds argument, converted to hours, minutes, and seconds,\nas a value in \'HH:MM:SS\' or HHMMSS format, depending on whether\nthe function is used in a string or numeric context:\n','mysql> select SEC_TO_TIME(2378) + 0;','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (158,'TIME_TO_SEC()','Returns the time argument, converted to seconds:\n','mysql> select TIME_TO_SEC(\'00:39:38\');','http://www.mysql.com/doc/D/a/Date_and_time_functions.html');
INSERT INTO "manual" VALUES (159,'DATABASE()','Returns the current database name:\nIf there is no current database, DATABASE() returns the empty string.\n','mysql> select DATABASE();','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (160,'SESSION_USER()','Returns the current MySQL user name:\nIn MySQL Version 3.22.11 or later, this includes the client hostname\nas well as the user name. You can extract just the user name part like this\n(which works whether or not the value includes a hostname part):\n','mysql> select substring_index(USER(),\"@@\",1);','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (161,'PASSWORD()','Calculates a password string from the plaintext password str. This is\nthe function that is used for encrypting MySQL passwords for storage\nin the Password column of the user grant table:\nUnix passwords are encrypted. You should not assume that if your Unix\npassword and your MySQL password are the same, PASSWORD()\nwill result in the same encrypted value as is stored in the Unix password\nfile. See ENCRYPT().\n','mysql> select PASSWORD(\'badpwd\');','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (162,'ENCRYPT()','Encrypt str using the Unix crypt() system call. The\n(As of MySQL Version 3.22.16, salt may be longer than two characters.):\nIf crypt() is not available on your system, ENCRYPT() always\nreturns NULL.\nleast on some systems. This will be determined by the behavior of the\nunderlying crypt() system call.\n','mysql> select ENCRYPT(\"hello\");','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (163,'ENCODE()','Encrypt str using pass_str as the password.\nTo decrypt the result, use DECODE().\nThe results is a binary string of the same length as string.\nIf you want to save it in a column, use a text column type.\n','','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (164,'DECODE()','Descrypts the encrypted string crypt_str using pass_str as the\npassword. crypt_str should be a string returned from\n','','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (165,'MD5()','Calculates a MD5 checksum for the string. Value is returned as a 32 long\nhex number that may, for example, be used as a hash key:\nThis is an \"RSA Data Security, Inc. MD5 Message-Digest Algorithm\".\n','mysql> select MD5(\"testing\")','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "DEFAULT" nextval('') column with a\nnon-magic value (that is, a value that is not NULL and not 0).\nIf expr is given as an argument to LAST_INSERT_ID() in an\nFirst create the table:\n','mysql> update sequence set id=LAST_INSERT_ID(id+1);','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (167,'FORMAT()','Formats the number X to a format like \'#,###,###.##\', rounded\nto D decimals. If D is 0, the result will have no\ndecimal point or fractional part:\n','mysql> select FORMAT(12332.2,0);','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (168,'VERSION()','Returns a string indicating the MySQL server version:\nNote that if your version ends with -log this means that logging is\nenabled.\n','mysql> select VERSION();','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (169,'CONNECTION_ID()','Returns the connection id (thread_id) for the connection.\nEvery connection has its own unique id:\n','mysql> select CONNECTION_ID();','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (170,'GET_LOCK()','Tries to obtain a lock with a name given by the string str, with a\ntimeout of timeout seconds. Returns 1 if the lock was obtained\nsuccessfully, 0 if the attempt timed out, or NULL if an error\noccurred (such as running out of memory or the thread was killed with\nterminates. This function can be used to implement application locks or to\nsimulate record locks. It blocks requests by other clients for locks with\nthe same name; clients that agree on a given lock string name can use the\n','mysql> select RELEASE_LOCK(\"lock1\");','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (171,'RELEASE_LOCK()','Releases the lock named by the string str that was obtained with\nlock wasn\'t locked by this thread (in which case the lock is not released),\nand NULL if the named lock didn\'t exist. The lock will not exist if\nit was never obtained by a call to GET_LOCK() or if it already has\nbeen released.\n','','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (172,'BENCHMARK()','The BENCHMARK() function executes the expression expr\nrepeatedly count times. It may be used to time how fast MySQL\nprocesses the expression. The result value is always 0. The intended\nuse is in the mysql client, which reports query execution times:\nThe time reported is elapsed time on the client end, not CPU time on the\nserver end. It may be advisable to execute BENCHMARK() several\ntimes, and interpret the result with regard to how heavily loaded the\n','mysql> select BENCHMARK(1000000,encode(\"hello\",\"goodbye\"));','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (173,'INET_NTOA()','Returns the network address (4 or 8 byte) for the numeric expression:\n','mysql> select INET_NTOA(3520061480);','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (174,'INET_ATON()','Returns an integer that represents the numeric value for a network address.\nAddresses may be 4 or 8 byte addresses:\n','mysql> select INET_ATON(\"209.207.224.40\");','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (175,'MASTER_POS_WAIT()','Blocks until the slave reaches the specified position in the master log during\nreplication. If master information is not initialized, returns NULL. If the\nslave is not running, will block and wait until it is started and goes to or\npast\nthe specified postion. If the slave is already past the specified postion,\nreturns immediately. The return value is the number of log events it had to\nwait to get to the specified position, or NULL in case of error. Useful for\n','','http://www.mysql.com/doc/M/i/Miscellaneous_functions.html');
INSERT INTO "manual" VALUES (176,'functions, GROUP BY','If you use a group function in a statement containing no GROUP BY\nclause, it is equivalent to grouping on all rows.\n','','http://www.mysql.com/doc/G/r/Group_by_functions.html');
INSERT INTO "manual" VALUES (177,'COUNT()','Returns a count of the number of non-NULL values in the rows\nretrieved by a SELECT statement:\nthe number of rows retrieved, whether or not they contain NULL\nvalues.\nreturn very quickly if the SELECT retrieves from one table, no\nother columns are retrieved, and there is no WHERE clause.\nFor example:\n','mysql> select COUNT(*) from student;','http://www.mysql.com/doc/G/r/Group_by_functions.html');
INSERT INTO "manual" VALUES (178,'DISTINCT','Returns a count of the number of different non-NULL values:\nIn MySQL you can get the number of distinct expression\ncombinations that don\'t contain NULL by giving a list of expressions.\nIn ANSI SQL you would have to do a concatenation of all expressions\ninside CODE(DISTINCT ..).\n','mysql> select COUNT(DISTINCT results) from student;','http://www.mysql.com/doc/G/r/Group_by_functions.html');
INSERT INTO "manual" VALUES (179,'AVG()','Returns the average value of expr:\n','mysql> select student_name, AVG(test_score)','http://www.mysql.com/doc/G/r/Group_by_functions.html');
INSERT INTO "manual" VALUES (180,'MAX()','Returns the minimum or maximum value of expr. MIN() and\nminimum or maximum string value. MySQL indexes.\n','mysql> select student_name, MIN(test_score), MAX(test_score)','http://www.mysql.com/doc/G/r/Group_by_functions.html');
INSERT INTO "manual" VALUES (181,'SUM()','Returns the sum of expr. Note that if the return set has no rows,\nit returns NULL!\n','','http://www.mysql.com/doc/G/r/Group_by_functions.html');
INSERT INTO "manual" VALUES (182,'STDDEV()','Returns the standard deviation of expr. This is an extension to\nANSI SQL. The STDDEV() form of this function is provided for Oracle\ncompatability.\n','','http://www.mysql.com/doc/G/r/Group_by_functions.html');
INSERT INTO "manual" VALUES (183,'BIT_OR()','Returns the bitwise OR of all bits in expr. The calculation is\nperformed with 64-bit (BIGINT) precision.\n','','http://www.mysql.com/doc/G/r/Group_by_functions.html');
INSERT INTO "manual" VALUES (184,'BIT_AND()','Returns the bitwise AND of all bits in expr. The calculation is\nperformed with 64-bit (BIGINT) precision.\ncalculations in the SELECT expressions that don\'t appear in\nthe GROUP BY part. This stands for any possible value for this\ngroup. You can use this to get better performance by avoiding sorting and\ngrouping on unnecessary items. For example, you don\'t need to group on\nIn ANSI SQL, you would have to add customer.name to the GROUP\n','mysql> SELECT id,FLOOR(value/100) FROM tbl_name ORDER BY RAND();','http://www.mysql.com/doc/G/r/Group_by_functions.html');
INSERT INTO "manual" VALUES (185,'CREATE DATABASE','allowable database names are given in Legal names. An error occurs if\nthe database already exists and you didn\'t specify IF NOT EXISTS.\nDatabases in MySQL are implemented as directories containing files\nthat correspond to tables in the database. Because there are no tables in a\ndatabase when it is initially created, the CREATE DATABASE statement\nonly creates a directory under the MySQL data directory.\nYou can also create databases with mysqladmin.\n','','http://www.mysql.com/doc/C/R/CREATE_DATABASE.html');
INSERT INTO "manual" VALUES (186,'DROP DATABASE','database. If you do a DROP DATABASE on a symbolic linked\ndatabase, both the link and the original database is deleted. Be\nVERY careful with this command!\nthe database directory. Normally, this is three times the number of\ntables, because normally each table corresponds to a .MYD file, a\nThe DROP DATABASE command removes from the given database\ndirectory all files with the following extensions:\n','','http://www.mysql.com/doc/D/R/DROP_DATABASE.html');
INSERT INTO "DEFAULT" nextval(''),','http://www.mysql.com/doc/S/i/Silent_column_changes.html');
INSERT INTO "manual" VALUES (188,'ALTER TABLE','For example, you can add or delete columns, create or destroy indexes, change\nthe type of existing columns, or rename columns or the table itself. You can\nalso change the comment for the table and type of the table.\nIf you use ALTER TABLE to change a column specification but\npossible that MySQL ignored your modification for one of the reasons\ndescribed in Silent column changes. For example, if you try to change\na VARCHAR column to CHAR, MySQL will still use\n','mysql> ALTER TABLE t1 MODIFY b BIGINT NOT NULL;','http://www.mysql.com/doc/A/L/ALTER_TABLE.html');
INSERT INTO "manual" VALUES (189,'ALTER COLUMN','or removes the old DEFAULT value.\nIf the old default is removed and the column can be NULL, the new\ndefault is NULL. If the column cannot be NULL, MySQL\nassigns a default value.\nDefault value assignment is described in\n','','http://www.mysql.com/doc/A/L/ALTER_TABLE.html');
INSERT INTO "manual" VALUES (190,'DROP INDEX','ANSI SQL92.\nIf columns are dropped from a table, the columns are also removed from any\nindex of which they are a part. If all columns that make up an index are\ndropped, the index is dropped as well.\n','','http://www.mysql.com/doc/A/L/ALTER_TABLE.html');
INSERT INTO "manual" VALUES (191,'DROP PRIMARY KEY','index exists, it drops the first UNIQUE index in the table.\n(MySQL marks the first UNIQUE key as the PRIMARY KEY\nif no PRIMARY KEY was specified explicitly.)\n','','http://www.mysql.com/doc/A/L/ALTER_TABLE.html');
INSERT INTO "manual" VALUES (192,'ORDER BY','specific order. Note that the table will not remain in this order after\ninserts and deletes. In some cases, it may make sorting easier for\norder it by later. This option is mainly useful when you know that you\nare mostly going to query the rows in a certain order; By using this\noption after big changes to the table, you may be able to get higher\nperformance.\n','','http://www.mysql.com/doc/A/L/ALTER_TABLE.html');
INSERT INTO "manual" VALUES (193,'ALTER TABLE','If you use ALTER TABLE on a MyISAM table, all non-unique\nindexes are created in a separate batch (like in REPAIR).\nThis should make ALTER TABLE much faster when you have many indexes.\n','','http://www.mysql.com/doc/A/L/ALTER_TABLE.html');
INSERT INTO "DEFAULT" nextval(''),','http://www.mysql.com/doc/A/L/ALTER_TABLE.html');
INSERT INTO "manual" VALUES (195,'RENAME TABLE','The rename is done atomically, which means that no other thread can\naccess any of the tables while the rename is running. This makes it\npossible to replace a table with an empty one:\nThe rename is done from left to right, which means that if you want to\nswap two tables names, you have to:\nAs long as two databases are on the same disk you can also rename\nfrom one database to another:\n','','http://www.mysql.com/doc/R/E/RENAME_TABLE.html');
INSERT INTO "manual" VALUES (196,'DROP TABLE','definition are removed, so be careful with this command!\nIn MySQL Version 3.22 or later, you can use the keywords\nexist.\nFor the moment they don\'t do anything.\nautomaticly commit any active transactions.\n','','http://www.mysql.com/doc/D/R/DROP_TABLE.html');
INSERT INTO "manual" VALUES (197,'OPTIMIZE TABLE','table or if you have made many changes to a table with variable-length rows\n(tables that have VARCHAR, text, or TEXT columns).\nDeleted records are maintained in a linked list and subsequent INSERT\noperations reuse old record positions. You can use OPTIMIZE TABLE to\nreclaim the unused space and to defragment the data file.\nFor the moment OPTIMIZE TABLE only works on MyISAM and\ncurrently mapped to ANALYZE TABLE. ANALYZE TABLE.\n','','http://www.mysql.com/doc/O/P/OPTIMIZE_TABLE.html');
INSERT INTO "manual" VALUES (198,'CHECK TABLE','table_name on the table.\nIf you don\'t specify any option MEDIUM is used.\nChecks the table(s) for errors. For MyISAM tables the key statistics\nis updated. The command returns a table with the following columns:\nNote that you can get many rows of information for each checked\ntable. The last row will be of Msg_type status and should\nnormally be OK. If you don\'t get OK, or Not\n','','http://www.mysql.com/doc/C/H/CHECK_TABLE.html');
INSERT INTO "manual" VALUES (199,'BACKUP TABLE','Make a copy of all the table files to the backup directory that are the\nminimum needed to restore it. Currenlty only works for MyISAM\ntables. For MyISAM table, copies .frm (definition) and\nDuring the backup, read lock will be held for each table, one at time,\nas they are being backed up. If you want to backup several tables as\na snapshot, you must first issue LOCK TABLES obtaining a read\nlock for each table in the group.\n','','http://www.mysql.com/doc/B/A/BACKUP_TABLE.html');
INSERT INTO "manual" VALUES (200,'RESTORE TABLE','Restores the table(s) from the backup that was made with\ntry to restore over an existing table, you will get an error. Restore\nwill take longer than BACKUP due to the need to rebuilt the index. The\nmore keys you have, the longer it is going to take. Just as\nThe command returns a table with the following columns:\n','','http://www.mysql.com/doc/R/E/RESTORE_TABLE.html');
INSERT INTO "manual" VALUES (201,'ANALYZE TABLE','Analyze and store the key distribution for the table. During the\nanalyze the table is locked with a read lock. This works on\nThis is equivalent to running myisamchk -a on the table.\ntables should be joined when one does a join on something else than a\nconstant.\nThe command returns a table with the following columns:\nYou can check the stored key distribution with the SHOW INDEX command.\n','','http://www.mysql.com/doc/A/N/ANALYZE_TABLE.html');
INSERT INTO "manual" VALUES (202,'REPAIR TABLE','as running myisamchk -r table_name on the table.\nRepair the corrupted table. The command returns a table with the following\ncolumns:\nNote that you can get many rows of information for each repaired\ntable. The last one row will be of Msg_type status and should\nnormally be OK. If you don\'t get OK, you should try\nrepairing the table with myisamchk -o, as REPAIR TABLE\n','','http://www.mysql.com/doc/R/E/REPAIR_TABLE.html');
INSERT INTO "manual" VALUES (203,'DELETE','given by where_definition, and returns the number of records deleted.\nIf you issue a DELETE with no WHERE clause, all rows are\ndeleted. If you do this in AUTOCOMMIT mode, this works as\nthis will be fixed in 4.0.\nIf you really want to know how many records are deleted when you are deleting\nall rows, and are willing to suffer a speed penalty, you can use a\nNote that this is MUCH slower than DELETE FROM tbl_name with no\n','mysql> DELETE FROM tbl_name WHERE 1>0;','http://www.mysql.com/doc/D/E/DELETE.html');
INSERT INTO "manual" VALUES (204,'TRUNCATE','Is in 3.23 and the same thing as DELETE FROM table_name. DELETE.\nThe differences are:\nImplemented as a drop and re-create of the table, which makes this\nmuch faster when deleting many rows.\nNot transaction-safe; TRUNCATE TABLE will automaticly end the current\ntransaction as if COMMIT would have been called.\nDoesn\'t return the number of deleted rows.\n','','http://www.mysql.com/doc/T/R/TRUNCATE.html');
INSERT INTO "manual" VALUES (205,'SELECT','any table. For example:\nAll keywords used must be given in exactly the order shown above. For example,\na HAVING clause must come after any GROUP BY clause and before\nany ORDER BY clause.\nA SELECT expression may be given an alias using AS. The alias\nis used as the expression\'s column name and can be used with\nThe FROM table_references clause indicates the tables from which to\n','mysql> select * from table LIMIT 5; # Retrieve first 5 rows','http://www.mysql.com/doc/S/E/SELECT.html');
INSERT INTO "manual" VALUES (206,'DUMPFILE','If you use INTO DUMPFILE instead of INTO OUTFILE, MySQL\nwill only write one row into the file, without any column or line\nterminations and without any escaping. This is useful if you want to\nstore a text in a file.\n','','http://www.mysql.com/doc/S/E/SELECT.html');
INSERT INTO "manual" VALUES (207,'STRAIGHT_JOIN','Where table_reference is defined as:\nand join_condition is defined as:\nNote that in versions before Version 3.23.16, the INNER JOIN didn\'t take\na join condition!\nThe last LEFT OUTER JOIN syntax shown above exists only for\ncompatibility with ODBC:\nA table reference may be aliased using tbl_name AS alias_name or\n','mysql> select * from table1 IGNORE INDEX (key3) WHERE key1=1 and key2=2 AND','http://www.mysql.com/doc/J/O/JOIN.html');
INSERT INTO "manual" VALUES (208,'INSERT','VALUES form of the statement inserts rows based on explicitly specified\nvalues. The INSERT ... SELECT form inserts rows selected from another\ntable or tables. The INSERT ... VALUES form with multiple value lists\nis supported in MySQL Version 3.22.5 or later. The\nlater.\nname list or the SET clause indicates which columns the statement\nspecifies values for:\n','mysql> INSERT INTO tbl_name (col1,col2) VALUES(col2*2,15);','http://www.mysql.com/doc/I/N/INSERT.html');
INSERT INTO "manual" VALUES (209,'mysql_info()','If you use INSERT ... SELECT or an INSERT ... VALUES\nstatement with multiple value lists, you can use the C API function\ninformation string is shown below:\nbecause they would duplicate some existing unique index value.\nwere problematic in some way. Warnings can occur under any of the following\nconditions:\nInserting NULL into a column that has been declared NOT NULL.\n','','http://www.mysql.com/doc/I/N/INSERT.html');
INSERT INTO "manual" VALUES (210,'DELAYED','The DELAYED option\nfor the\nuseful if you have clients that can\'t wait for the INSERT to complete.\nThis is a common problem when you use MySQL for logging and you also\nperiodically run SELECT statements that take a long time to complete.\nWhen you use INSERT DELAYED, the client will get an OK at once\nand the row will be inserted when the table is not in use by any other thread.\n','','http://www.mysql.com/doc/I/N/INSERT.html');
INSERT INTO "manual" VALUES (211,'REPLACE','record in the table has the same value as a new record on a unique index,\nthe old record is deleted before the new record is inserted.\nIn other words, you can\'t access the values of the old row from a\nlike you could do this, but that was a bug that has been corrected.\n','','http://www.mysql.com/doc/R/E/REPLACE.html');
INSERT INTO "manual" VALUES (212,'LOAD DATA INFILE','The LOAD DATA INFILE statement reads rows from a text file into a\ntable at a very high speed. If the LOCAL keyword is specified, the\nfile is read from the client host. If LOCAL is not specified, the\nfile must be located on the server. (LOCAL is available in\nFor security reasons, when reading text files located on the server, the\nfiles must either reside in the database directory or be readable by all.\nAlso, to use LOAD DATA INFILE on server files, you must have the\n','mysql> LOAD DATA INFILE \'persondata.txt\'','http://www.mysql.com/doc/L/O/LOAD_DATA.html');
INSERT INTO "manual" VALUES (213,'mysql_info()','If you are using the C API, you can get information about the query by\ncalling the API function mysql_info() when the LOAD DATA INFILE\nquery finishes. The format of the information string is shown below:\nWarnings occur under the same circumstances as when values are inserted\nvia the INSERT statement (@pxref{INSERT, , INSERT), except\nthat LOAD DATA INFILE also generates warnings when there are too few\nor too many fields in the input row. The warnings are not stored anywhere;\n','','http://www.mysql.com/doc/L/O/LOAD_DATA.html');
INSERT INTO "manual" VALUES (214,'UPDATE','The SET clause indicates which columns to modify and the values\nthey should be given. The WHERE clause, if given, specifies\nwhich rows should be updated. Otherwise all rows are updated. If the\norder that is specified.\nIf you specify the keyword LOW_PRIORITY, execution of the\nIf you specify the keyword IGNORE, the update statement will not\nabort even if we get duplicate key errors during the update. Rows that\n','mysql> UPDATE persondata SET age=age*2, age=age+1;','http://www.mysql.com/doc/U/P/UPDATE.html');
INSERT INTO "manual" VALUES (215,'mysql_info()','In MySQL Version 3.22 or later, the C API function mysql_info()\nreturns the number of rows that were matched and updated and the number of\nwarnings that occurred during the UPDATE.\nIn MySQL Version 3.23, you can use LIMIT # to ensure that\nonly a given number of rows are changed.\n','','http://www.mysql.com/doc/U/P/UPDATE.html');
INSERT INTO "manual" VALUES (216,'USE','The USE db_name statement tells MySQL to use the db_name\ndatabase as the DEFAULT database for subsequent queries. The database remains\ncurrent until the end of the session or until another USE statement\nis issued:\nMaking a particular database current by means of the USE statement\ndoes not preclude you from accessing tables in other databases. The example\nbelow accesses the author table from the db1 database and the\n','mysql> SELECT author_name,editor_name FROM author,db2.editor','http://www.mysql.com/doc/U/S/USE.html');
INSERT INTO "manual" VALUES (217,'FLUSH','You should use the FLUSH command if you want to clear some of the\ninternal caches MySQL uses. To execute FLUSH, you must have\nthe reload privilege.\nhost tables if some of your hosts change IP number or if you get the\nerror message Host ... is blocked. When more than\nconnection to the MySQL server, MySQL assumes\nsomething is wrong and blocks the host from further connection requests.\n','','http://www.mysql.com/doc/F/L/FLUSH.html');
INSERT INTO "manual" VALUES (218,'KILL','Each connection to mysqld runs in a separate thread. You can see\nwhich threads are running with the SHOW PROCESSLIST command and kill\na thread with the KILL thread_id command.\nIf you have the process privilege, you can see and kill all threads.\nOtherwise, you can see and kill only your own threads.\nYou can also use the mysqladmin processlist and mysqladmin kill\ncommands to examine and kill threads.\n','','http://www.mysql.com/doc/K/I/KILL.html');
INSERT INTO "manual" VALUES (219,'SHOW CREATE TABLE','status information about the server. If the LIKE wild part is\nused, the wild string can be a string that uses the SQL @samp{%\nand @samp{_ wild-card characters.\n','','http://www.mysql.com/doc/S/H/SHOW.html');
INSERT INTO "manual" VALUES (327,'make_binary_distribution','Makes a binary release of a compiled MySQL. This could be sent by FTP to `/pub/mysql/Incoming\' on support.mysql.com for the convenience of other MySQL users.',NULL,NULL);
INSERT INTO "manual" VALUES (220,'SHOW KEYS','* SHOW DATABASE INFO:: \n* SHOW TABLE STATUS:: \n* SHOW STATUS:: \n* SHOW VARIABLES:: \n* SHOW LOGS:: \n* SHOW PROCESSLIST:: \n* SHOW GRANTS:: \n','mysql> SHOW INDEX FROM mydb.mytable;','http://www.mhttp://www.mysql.com/doc/S/H/SHOW_LOGS.html');
INSERT INTO "manual" VALUES (221,'PROCESSLIST','also get this information using the mysqladmin processlist\ncommand. If you have the process privilege, you can see all\nthreads. Otherwise, you can see only your own threads. KILL, ,\nthe first 100 characters of each query will be shown.\nThis command is very useful if you get the \'too many connections\' error\nmessage and want to find out what\'s going on. MySQL reserves\none extra connection for a client with the Process_priv privilege\n','mysql> show create table t\\G','http://www.mysql.com/doc/S/H/SHOW_CREATE_TABLE.html');
INSERT INTO "manual" VALUES (222,'SELECT, optimizing','When you precede a SELECT statement with the keyword EXPLAIN,\ninformation about how tables are joined and in which order.\nWith the help of EXPLAIN, you can see when you must add indexes\nto tables to get a faster SELECT that uses indexes to find the\nrecords. You can also see if the optimizer joins the tables in an optimal\norder. To force the optimizer to use a specific join order for a\nFor non-simple joins, EXPLAIN returns a row of information for each\n','mysql> ALTER TABLE tt MODIFY AssignedPC VARCHAR(15),','http://www.mysql.com/doc/E/X/EXPLAIN.html');
INSERT INTO "manual" VALUES (223,'DESCRIBE','may be a column name or a string containing the SQL @samp{% and @samp{_\nwild-card characters.\nIf the column types are different than you expect them to be based on a\nchanges column types. Silent column changes.\nThis statement is provided for Oracle compatibility.\nThe SHOW statement provides similar information.\n','','http://www.mysql.com/doc/D/E/DESCRIBE.html');
INSERT INTO "manual" VALUES (224,'ROLLBACK','By DEFAULT, MySQL runs in autocommit mode. This means that\nas soon as you execute an update, MySQL will store the update on\ndisk.\nIf you are using BDB tables, you can put MySQL into\nnon-autocommit mode with the following command:\nAfter this you must use COMMIT to store your changes to disk or\nthe beginning of your transaction.\n','','http://www.mysql.com/doc/C/O/COMMIT.html');
INSERT INTO "manual" VALUES (225,'UNLOCK TABLES','TABLES releases any locks held by the current thread. All tables that\nare locked by the current thread are automatically unlocked when the\nthread issues another LOCK TABLES, or when the connection to the\nserver is closed.\nIf a thread obtains a READ lock on a table, that thread (and all other\nthreads) can only read from the table. If a thread obtains a WRITE\nlock on a table, then only the thread holding the lock can READ from\n','mysql> UNLOCK TABLES;','http://www.mysql.com/doc/L/O/LOCK_TABLES.html');
INSERT INTO "manual" VALUES (226,'SET OPTION','server or your client. Any option you set remains in effect until the\ncurrent session ends, or until you set the option to a different value.\nThis maps all strings from and to the client with the given mapping.\nCurrently the only option for character_set_name is\nDEFAULT mapping can be restored by using a character_set_name value of\nNote that the syntax for setting the CHARACTER SET option differs\nfrom the syntax for setting the other options.\n','mysql> UPDATE mysql.user SET password=PASSWORD(\"newpass\") where user=\"bob\' and host=\"%.loc.gov\";','http://www.mysql.com/doc/S/E/SET_OPTION.html');
INSERT INTO "manual" VALUES (227,'REVOKE','earlier MySQL versions, the GRANT statement does nothing.\nThe GRANT and REVOKE commands allow system administrators to\ngrant and revoke rights to MySQL users at four privilege levels:\nGlobal privileges apply to all databases on a given server. These privileges\nare stored in the mysql.user table.\nDatabase privileges apply to all tables in a given database. These privileges\nare stored in the mysql.db and mysql.host tables.\n','mysql> SELECT Host,User FROM mysql.user WHERE User=\'\';','http://www.mysql.com/doc/G/R/GRANT.html');
INSERT INTO "manual" VALUES (228,'CREATE INDEX','The CREATE INDEX statement doesn\'t do anything in MySQL prior\nto Version 3.22. In Version 3.22 or later, CREATE INDEX is mapped to an\nNormally, you create all indexes on a table at the time the table itself\nis created with CREATE TABLE.\nA column list of the form (col1,col2,...) creates a multiple-column\nindex. Index values are formed by concatenating the values of the given\ncolumns.\n','mysql> CREATE INDEX part_of_name ON customer (name(10));','http://www.mysql.com/doc/C/R/CREATE_INDEX.html');
INSERT INTO "manual" VALUES (229,'DROP INDEX','prior to Version 3.22. In Version 3.22 or later, DROP INDEX is mapped to an\n','','http://www.mysql.com/doc/D/R/DROP_INDEX.html');
INSERT INTO "manual" VALUES (230,'Comment syntax','The MySQL server supports the # to end of line, --\nto end of line and /* in-line or multiple-line */ comment\nstyles:\nNote that the -- comment style requires you to have at least one space\nafter the --!\nAlthough the server understands the comment syntax just described,\nthere are some limitations on the way that the mysql client\n','mysql> select 1+','http://www.mysql.com/doc/C/o/Comments.html');
INSERT INTO "manual" VALUES (231,'Functions, user-defined','A user-definable function (UDF) is a way to extend MySQL with a new\nfunction that works like native (built in) MySQL functions such as\nname in the mysql.func system table. You must have the\nto create and drop functions.\nAll active functions are reloaded each time the server starts, unless\nyou start mysqld with the --skip-grant-tables option. In\nthis case, UDF initialization is skipped and UDFs are unavailable.\n','mysql> SELECT * FROM shop;','http://www.mysql.com/doc/U/s/Using_foreign_keys.html');
INSERT INTO "manual" VALUES (232,'UNION','keys combined with OR (Searching on one key with different OR\nparts is optimized quite good):\nThe reason is that we haven\'t yet had time to come up with an efficient\nway to handle this in the general case. (The AND handling is,\nin comparison, now completely general and works very well).\nFor the moment you can solve this very efficently by using a\nyou are using very complicated queries where the SQL server does the\n','mysql> SELECT owner FROM pet;','http://www.mysql.com/doc/R/e/Retrieving_information_from_a_table.html');
INSERT INTO "manual" VALUES (233,'DISTINCT','However, notice that the query simply retrieves the owner field from\neach record, and some of them appear more than once. To minimize the output,\nretrieve each unique output record just once by adding the keyword\nYou can use a WHERE clause to combine row selection with column\nselection. For example, to get birth dates for dogs and cats only,\nuse this query:\nYou may have noticed in the preceding examples that the result rows are\n','mysql> SELECT name, birth FROM pet','http://www.mysql.com/doc/R/e/Retrieving_information_from_a_table.html');
INSERT INTO "manual" VALUES (234,'NULL','The NULL value can be surprising until you get used to it.\nConceptually, NULL means missing value or unknown value and it\nis treated somewhat differently than other values. To test for NULL,\nyou cannot use the arithmetic comparison operators such as =, <,\nor !=. To demonstrate this for yourself, try the following query:\nClearly you get no meaningful results from these comparisons. Use\nthe IS NULL and IS NOT NULL operators instead:\n','mysql> SELECT p1.name, p1.sex, p2.name, p2.sex, p1.species','http://www.mysql.com/doc/U/s/Using_more_than_one_table.html');
INSERT INTO "manual" VALUES (235,'DESCRIBE','What if you forget the name of a database or table, or what the structure of\na given table is (for example, what its columns are called)? MySQL\naddresses this problem through several statements that provide information\nabout the databases and tables it supports.\nYou have already seen SHOW DATABASES, which lists the databases\nmanaged by the server. To find out which database is currently selected,\nuse the DATABASE() function:\n','mysql> DESCRIBE pet;','http://www.mysql.com/doc/T/u/Tuning_server_parameters.html');
INSERT INTO "manual" VALUES (236,'table_cache','affect the maximum number of files the server keeps open. If you\nincrease one or both of these values, you may run up against a limit\nimposed by your operating system on the per-process number of open file\ndescriptors. However, you can increase the limit on many systems.\nConsult your OS documentation to find out how to do this, because the\nmethod for changing the limit varies widely from system to system.\nfor 200 concurrent running connections, you should have a table cache of\n','mysql> SELECT * FROM tbl_name WHERE col2=val2 AND col3=val3;','http://www.mysql.com/doc/H/o/How_mysql_uses_indexes.html');
INSERT INTO "manual" VALUES (237,'LIKE, and wildcards','to LIKE is a constant string that doesn\'t start with a wild-card\ncharacter. For example, the following SELECT statements use indexes:\nIn the first statement, only rows with \"Patrick\" <= key_col <\n\"Patricl\" are considered. In the second statement, only rows with\nThe following SELECT statements will not use indexes:\nIn the first statement, the LIKE value begins with a wild-card\ncharacter. In the second statement, the LIKE value is not a\n','mysql> select * from tbl_name where key_col LIKE other_col;','http://www.mysql.com/doc/H/o/How_mysql_uses_indexes.html');
INSERT INTO "manual" VALUES (238,'IS NULL, and indexes','Searching using column_name IS NULL will use indexes if column_name\nis an index.\nindex is used for columns that you compare with the following operators:\nAny index that doesn\'t span all AND levels in the WHERE clause\nis not used to optimize the query. In other words: To be able to use an\nindex, a prefix of the index must be used in every AND group.\nThe following WHERE clauses use indexes:\n','mysql> select benchmark(1000000,1+1);','http://www.mysql.com/doc/E/s/Estimating_query_performance.html');
INSERT INTO "manual" VALUES (239,'SELECT speed','In general, when you want to make a slow SELECT ... WHERE faster, the\nfirst thing to check is whether or not you can add an index. MySQL\nindexes, , MySQL indexes. All references between different tables\nshould usually be done with indexes. You can use the EXPLAIN command\nto determine which indexes are used for a SELECT.\nSome general tips:\nTo help MySQL optimize queries better, run myisamchk\n','','http://www.mysql.com/doc/S/p/Speed_of_select_queries.html');
INSERT INTO "manual" VALUES (240,'WHERE','The WHERE optimizations are put in the SELECT part here because\nthey are mostly used with SELECT, but the same optimizations apply for\nAlso note that this section is incomplete. MySQL does many\noptimizations, and we have not had time to document them all.\nSome of the optimizations performed by MySQL are listed below:\nRemoval of unnecessary parentheses:\nConstant folding:\n','mysql> SELECT ... FROM tbl_name ORDER BY key_part1 DESC,key_part2 DESC,...','http://www.mysql.com/doc/H/o/How_mysql_optimizes_where_clauses.html');
INSERT INTO "manual" VALUES (241,'DISTINCT','need a temporary table.\nWhen combining LIMIT # with DISTINCT, MySQL will stop\nas soon as it finds # unique rows.\nIf you don\'t use columns from all used tables, MySQL will stop\nthe scanning of the not used tables as soon as it has found the first match.\nIn the case, assuming t1 is used before t2 (check with EXPLAIN), then\nwhen the first row in t2 is found.\n','','http://www.mysql.com/doc/H/o/How_mysql_optimizes_distinct.html');
INSERT INTO "manual" VALUES (242,'LEFT JOIN','The table B is set to be dependent on table A and all tables\nthat A is dependent on.\nThe table A is set to be dependent on all tables (except B)\nthat are used in the LEFT JOIN condition.\nAll LEFT JOIN conditions are moved to the WHERE clause.\nAll standard join optimizations are done, with the exception that a table is\nalways read after all tables it is dependent on. If there is a circular\n','','http://www.mysql.com/doc/H/o/How_mysql_optimizes_left_join_and_right_join.html');
INSERT INTO "manual" VALUES (243,'LIMIT','In some cases MySQL will handle the query differently when you are\nusing LIMIT # and not using HAVING:\nIf you are selecting only a few rows with LIMIT, MySQL\nwill use indexes in some cases when it normally would prefer to do a\nfull table scan.\nIf you use LIMIT # with ORDER BY, MySQL will end the\nsorting as soon as it has found the first # lines instead of sorting\n','mysql> DROP FUNCTION reverse_lookup;','http://www.mysql.com/doc/I/g/Ignoring_user_error.html');
INSERT INTO "manual" VALUES (244,'PASSWORD()','You have specified a password in the user table without using the\nfunction:\nIf you get the error Table \'xxx\' doesn\'t exist or Can\'t\nfind file: \'xxx\' (errno: 2), this means that no table exists\nin the current database with the name xxx.\nNote that as MySQL uses directories and files to store databases and\ntables, the database and table names are case sensitive!\n','mysql> update user set password=PASSWORD(\'your password\')','http://www.mysql.com/doc/F/i/File_not_found.html');
INSERT INTO "manual" VALUES (245,'DATE','The format of a DATE value is \'YYYY-MM-DD\'. According to ANSI\nSQL, no other format is allowed. You should use this format in UPDATE\nexpressions and in the WHERE clause of SELECT statements. For\nexample:\nAs a convenience, MySQL automatically converts a date to a number if\nthe date is used in a numeric context (and vice versa). It is also smart\nenough to allow a ``relaxed\'\' string form when updating and in a WHERE\n','mysql> SELECT * FROM my_table WHERE phone = \"\";','http://www.mysql.com/doc/P/r/Problems_with_null_values.html');
INSERT INTO "manual" VALUES (246,'LOAD DATA INFILE','When reading data with LOAD DATA INFILE, empty columns are updated\nwith \'\'. If you want a NULL value in a column, you should use\nunder some circumstances.\nWhen using ORDER BY, NULL values are presented first. If you\nsort in descending order using DESC, NULL values are presented\nlast. When using GROUP BY, all NULL values are regarded as\nequal.\n','mysql> SELECT * FROM table_name WHERE float_column between 3.45 and 3.55;','http://www.mysql.com/doc/C/ /C_api_function_descriptions.html');
INSERT INTO "manual" VALUES (247,'mysql_affected_rows()','Returns the number of rows affected (changed) by the last UPDATE,\nstatements. For SELECT statements, mysql_affected_rows()\nworks like mysql_num_rows().\nAn integer greater than zero indicates the number of rows affected or\nretrieved. Zero indicates that no records matched the WHERE clause in\nthe query or that no query has yet been executed. -1 indicates that the\nquery returned an error or that, for a SELECT query,\n','','http://www.mysql.com/doc/m/y/mysql_affected_rows.html');
INSERT INTO "manual" VALUES (248,'mysql_close()','Closes a previously opened connection. mysql_close() also deallocates\nthe connection handle pointed to by mysql if the handle was allocated\nautomatically by mysql_init() or mysql_connect().\nNone.\nNone.\n','','http://www.mysql.com/doc/m/y/mysql_close.html');
INSERT INTO "manual" VALUES (249,'mysql_connect()','This function is deprecated. It is preferable to use\ndatabase engine running on host. mysql_connect() must complete\nsuccessfully before you can execute any of the other API functions, with the\nexception of mysql_get_client_info().\nThe meanings of the parameters are the same as for the corresponding\nparameters for mysql_real_connect() with the difference that the\nconnection parameter may be NULL. In this case the C API\n','','http://www.mysql.com/doc/m/y/mysql_connect.html');
INSERT INTO "manual" VALUES (250,'mysql_change_user()','char *password, const char *db)\nChanges the user and causes the database specified by db to\nbecome the DEFAULT (current) database on the connection specified by\ntable references that do not include an explicit database specifier.\nThis function was introduced in MySQL Version 3.23.3.\nauthenticated or if he doesn\'t have permission to use the database. In\nthis case the user and database are not changed\n','','http://www.mysql.com/doc/m/y/mysql_change_user.html');
INSERT INTO "manual" VALUES (251,'mysql_character_set_name()','Returns the DEFAULT character set for the current connection.\nThe default character set\nNone.\n','','http://www.mysql.com/doc/m/y/mysql_character_set_name.html');
INSERT INTO "manual" VALUES (252,'mysql_create_db()','Creates the database named by the db parameter.\nThis function is deprecated. It is preferable to use mysql_query()\nto issue a SQL CREATE DATABASE statement instead.\nZero if the database was created successfully. Non-zero if an error\noccurred.\nCommands were executed in an improper order.\nThe MySQL server has gone away.\n','','http://www.mysql.com/doc/m/y/mysql_create_db.html');
INSERT INTO "manual" VALUES (253,'mysql_data_seek()','Seeks to an arbitrary row in a query result set. This requires that the\nresult set structure contains the entire result of the query, so\nThe offset should be a value in the range from 0 to\nNone.\nNone.\n','','http://www.mysql.com/doc/m/y/mysql_data_seek.html');
INSERT INTO "manual" VALUES (254,'mysql_debug()','Does a DBUG_PUSH with the given string. mysql_debug() uses the\nFred Fish debug library. To use this function, you must compile the client\nlibrary to support debugging.\nNone.\nNone.\nThe call shown below causes the client library to generate a trace file in\n','','http://www.mysql.com/doc/m/y/mysql_debug.html');
INSERT INTO "manual" VALUES (255,'mysql_drop_db()','Drops the database named by the db parameter.\nThis function is deprecated. It is preferable to use mysql_query()\nto issue a SQL DROP DATABASE statement instead.\nZero if the database was dropped successfully. Non-zero if an error\noccurred.\nCommands were executed in an improper order.\nThe MySQL server has gone away.\n','','http://www.mysql.com/doc/m/y/mysql_drop_db.html');
INSERT INTO "manual" VALUES (256,'mysql_dump_debug_info()','Instructs the server to write some debug information to the log. The\nconnected user must have the process privilege for this to work.\nZero if the command was successful. Non-zero if an error occurred.\nCommands were executed in an improper order.\nThe MySQL server has gone away.\nThe connection to the server was lost during the query.\nAn unknown error occurred.\n','','http://www.mysql.com/doc/M/y/Mysql_dump_debug_info.html');
INSERT INTO "manual" VALUES (257,'mysql_eof()','This function is deprecated. mysql_errno() or mysql_error()\nmay be used instead.\nset has been read.\nIf you acquire a result set from a successful call to\noperation. In this case, a NULL return from mysql_fetch_row()\nalways means the end of the result set has been reached and it is\nunnecessary to call mysql_eof().\n','','http://www.mysql.com/doc/M/y/Mysql_eof.html');
INSERT INTO "manual" VALUES (258,'mysql_errno()','For the connection specified by mysql, mysql_errno() returns\nthe error code for the most recently invoked API function that can succeed\nor fail. A return value of zero means that no error occurred. Client error\nmessage numbers are listed in the MySQL errmsg.h header file.\nServer error message numbers are listed in mysqld_error.h. In the\nerror messages and error numbers in the file Docs/mysqld_error.txt.\nAn error code value. Zero if no error occurred.\n','','http://www.mysql.com/doc/M/y/Mysql_errno.html');
INSERT INTO "manual" VALUES (259,'mysql_error()','For the connection specified by mysql, mysql_error() returns\nthe error message for the most recently invoked API function that can succeed\nor fail. An empty string (\"\") is returned if no error occurred.\nThis means the following two tests are equivalent:\nThe language of the client error messages may be changed by\nrecompiling the MySQL client library. Currently you can choose\nerror messages in several different languages.\n','','http://www.mysql.com/doc/M/y/Mysql_error.html');
INSERT INTO "manual" VALUES (260,'mysql_escape_string()','You should use mysql_real_escape_string() instead!\nThis is identical to mysql_real_escape_string() except that it takes\nthe connection as the first argument. mysql_real_escape_string()\nwill escape the string according to the current character set while mysql_escape_string()\ndoes not respect the current charset setting.\n','','http://www.mysql.com/doc/M/y/Mysql_escape_string.html');
INSERT INTO "manual" VALUES (261,'mysql_fetch_field()','Returns the definition of one column of a result set as a MYSQL_FIELD\nstructure. Call this function repeatedly to retrieve information about all\ncolumns in the result set. mysql_fetch_field() returns NULL\nwhen no more fields are left.\nfield each time you execute a new SELECT query. The field returned by\nIf you\'ve called mysql_query() to perform a SELECT on a table\nbut have not called mysql_store_result(), MySQL returns the\n','','http://www.mysql.com/doc/M/y/Mysql_fetch_field.html');
INSERT INTO "manual" VALUES (262,'mysql_fetch_fields()','Returns an array of all MYSQL_FIELD structures for a result set.\nEach structure provides the field definition for one column of the result\nset.\nAn array of MYSQL_FIELD structures for all columns of a result set.\nNone.\n','','http://www.mysql.com/doc/M/y/Mysql_fetch_fields.html');
INSERT INTO "manual" VALUES (263,'mysql_fetch_field_direct()','Given a field number fieldnr for a column within a result set, returns\nthat column\'s field definition as a MYSQL_FIELD structure. You may use\nthis function to retrieve the definition for an arbitrary column. The value\nof fieldnr should be in the range from 0 to\nThe MYSQL_FIELD structure for the specified column.\nNone.\n','','http://www.mysql.com/doc/M/y/Mysql_fetch_field_direct.html');
INSERT INTO "manual" VALUES (264,'mysql_fetch_lengths()','Returns the lengths of the columns of the current row within a result set.\nIf you plan to copy field values, this length information is also useful for\noptimization, because you can avoid calling strlen(). In addition, if\nthe result set contains binary data, you must use this function to\ndetermine the size of the data, because strlen() returns incorrect\nresults for any field containing null characters.\nThe length for empty columns and for columns containing NULL values is\n','','http://www.mysql.com/doc/M/y/Mysql_fetch_lengths.html');
INSERT INTO "manual" VALUES (265,'mysql_fetch_row()','Retrieves the next row of a result set. When used after\nwhen there are no more rows to retrieve. When used after\nthere are no more rows to retrieve or if an error occurred.\nThe number of values in the row is given by mysql_num_fields(result).\nIf row holds the return value from a call to mysql_fetch_row(),\npointers to the values are accessed as row[0] to\nindicated by NULL pointers.\n','','http://www.mysql.com/doc/M/y/Mysql_fetch_row.html');
INSERT INTO "manual" VALUES (266,'mysql_field_count()','If you are using a version of MySQL earlier than Version 3.22.24, you\nshould use int mysql_num_fields(MYSQL *mysql) instead.\nReturns the number of columns for the most recent query on the connection.\nThe normal use of this function is when mysql_store_result()\nreturned NULL (and thus you have no result set pointer).\nIn this case, you can call mysql_field_count() to\ndetermine whether or not mysql_store_result() should have produced a\n','','http://www.mysql.com/doc/M/y/Mysql_field_count.html');
INSERT INTO "manual" VALUES (267,'mysql_field_seek()','Sets the field cursor to the given offset. The next call to\nassociated with that offset.\nTo seek to the beginning of a row, pass an offset value of zero.\nThe previous value of the field cursor.\nNone.\n','','http://www.mysql.com/doc/M/y/Mysql_field_seek.html');
INSERT INTO "manual" VALUES (268,'mysql_field_tell()','Returns the position of the field cursor used for the last\nThe current offset of the field cursor.\nNone.\n','','http://www.mysql.com/doc/M/y/Mysql_field_tell.html');
INSERT INTO "manual" VALUES (269,'mysql_free_result()','Frees the memory allocated for a result set by mysql_store_result(),\nwith a result set, you must free the memory it uses by calling\nNone.\nNone.\n','','http://www.mysql.com/doc/M/y/Mysql_free_result.html');
INSERT INTO "manual" VALUES (270,'mysql_get_client_info()','Returns a string that represents the client library version.\nA character string that represents the MySQL client library version.\nNone.\n','','http://www.mysql.com/doc/M/y/Mysql_get_client_info.html');
INSERT INTO "manual" VALUES (271,'mysql_get_host_info()','Returns a string describing the type of connection in use, including the\nserver host name.\nA character string representing the server host name and the connection type.\nNone.\n','','http://www.mysql.com/doc/M/y/Mysql_get_host_info.html');
INSERT INTO "manual" VALUES (272,'mysql_get_proto_info()','Returns the protocol version used by current connection.\nAn integer representing the protocol version used by the current\nconnection.\nNone.\n','','http://www.mysql.com/doc/M/y/Mysql_get_proto_info.html');
INSERT INTO "manual" VALUES (273,'mysql_get_server_info()','Returns a string that represents the server version number.\nA character string that represents the server version number.\nNone.\n','','http://www.mysql.com/doc/M/y/Mysql_get_server_info.html');
INSERT INTO "manual" VALUES (274,'mysql_info()','Retrieves a string providing information about the most recently executed\nquery, but only for the statements listed below. For other statements,\ndepending on the type of query, as described below. The numbers are\nillustrative only; the string will contain values appropriate for the query.\nString format: Records: 100 Duplicates: 0 Warnings: 0\nString format: Records: 3 Duplicates: 0 Warnings: 0\nString format: Records: 1 Deleted: 0 Skipped: 0 Warnings: 0\n','','http://www.mysql.com/doc/M/y/Mysql_info.html');
INSERT INTO "manual" VALUES (275,'mysql_init()','Allocates or initializes a MYSQL object suitable for\nfunction allocates, initializes, and returns a new object. Otherwise the\nobject is initialized and the address of the object is returned. If\nAn initialized MYSQL* handle. NULL if there was\ninsufficient memory to allocate a new object.\nIn case of insufficient memory, NULL is returned.\n','','http://www.mysql.com/doc/M/y/Mysql_init.html');
INSERT INTO "DEFAULT" nextval('') value. If you need to save\nthe value for later, be sure to call mysql_insert_id() immediately\nafter the query that generates the value.\n','','http://www.mysql.com/doc/M/y/Mysql_insert_id.html');
INSERT INTO "manual" VALUES (277,'mysql_kill()','Asks the server to kill the thread specified by pid.\nZero for success. Non-zero if an error occurred.\nCommands were executed in an improper order.\nThe MySQL server has gone away.\nThe connection to the server was lost during the query.\nAn unknown error occurred.\n','','http://www.mysql.com/doc/M/y/Mysql_kill.html');
INSERT INTO "manual" VALUES (278,'mysql_list_dbs()','Returns a result set consisting of database names on the server that match\nthe simple regular expression specified by the wild parameter.\nbe a NULL pointer to match all databases. Calling\ndatabases [LIKE wild].\nYou must free the result set with mysql_free_result().\nA MYSQL_RES result set for success. NULL if an error occurred.\nCommands were executed in an improper order.\n','','http://www.mysql.com/doc/M/y/Mysql_list_dbs.html');
INSERT INTO "manual" VALUES (279,'mysql_list_fields()','Returns a result set consisting of field names in the given table that match\nthe simple regular expression specified by the wild parameter.\nbe a NULL pointer to match all fields. Calling\nCOLUMNS FROM tbl_name [LIKE wild].\nNote that it\'s recommended that you use SHOW COLUMNS FROM tbl_name\ninstead of mysql_list_fields().\nYou must free the result set with mysql_free_result().\n','','http://www.mysql.com/doc/ /m/_mysql_list_fields.html');
INSERT INTO "manual" VALUES (280,'mysql_list_processes()','Returns a result set describing the current server threads. This is the same\nkind of information as that reported by mysqladmin processlist or\na SHOW PROCESSLIST query.\nYou must free the result set with mysql_free_result().\nA MYSQL_RES result set for success. NULL if an error occurred.\nCommands were executed in an improper order.\nThe MySQL server has gone away.\n','','http://www.mysql.com/doc/M/y/Mysql_list_processes.html');
INSERT INTO "manual" VALUES (281,'mysql_list_tables()','Returns a result set consisting of table names in the current database that\nmatch the simple regular expression specified by the wild parameter.\nbe a NULL pointer to match all tables. Calling\ntables [LIKE wild].\nYou must free the result set with mysql_free_result().\nA MYSQL_RES result set for success. NULL if an error occurred.\nCommands were executed in an improper order.\n','','http://www.mysql.com/doc/M/y/Mysql_list_tables.html');
INSERT INTO "manual" VALUES (282,'mysql_field_count()','or\nThe second form doesn\'t work on MySQL Version 3.22.24 or newer. To pass a\nReturns the number of columns in a result set.\nNote that you can get the number of columns either from a pointer to a result\nset or to a connection handle. You would use the connection handle if\ncall mysql_field_count() to determine whether or not\nallows the client program to take proper action without knowing whether or\n','','http://www.mysql.com/doc/M/y/Mysql_num_fields.html');
INSERT INTO "manual" VALUES (283,'mysql_num_rows()','Returns the number of rows in the result set.\nThe use of mysql_num_rows() depends on whether you use\nset. If you use mysql_store_result(), mysql_num_rows() may be\ncalled immediately. If you use mysql_use_result(),\nin the result set have been retrieved.\nThe number of rows in the result set.\nNone.\n','','http://www.mysql.com/doc/M/y/Mysql_num_rows.html');
INSERT INTO "manual" VALUES (284,'mysql_options()','Can be used to set extra connect options and affect behavior for a connection.\nThis function may be called multiple times to set several options.\nThe option argument is the option that you want to set; the arg\nargument is the value for the option. If the option is an integer, then\nPossible options values:\nNote that the group client is always read if you use\nThe specified group in the option file may contain the following options:\n','','http://www.mysql.com/doc/M/y/Mysql_options.html');
INSERT INTO "manual" VALUES (285,'mysql_ping()','Checks whether or not the connection to the server is working. If it has gone\ndown, an automatic reconnection is attempted.\nThis function can be used by clients that remain idle for a long while,\nto check whether or not the server has closed the connection and reconnect\nif necessary.\nZero if the server is alive. Non-zero if an error occurred.\nCommands were executed in an improper order.\n','','http://www.mysql.com/doc/M/y/Mysql_ping.html');
INSERT INTO "manual" VALUES (286,'mysql_query()','Executes the SQL query pointed to by the null-terminated string query.\nThe query must consist of a single SQL statement. You should not add\na terminating semicolon (@samp{;) or \\g to the statement.\nshould use mysql_real_query() instead. (Binary data may contain the\nquery string.)\nIf you want to know if the query should return a result set or not, you can\nuse mysql_field_count() to check for this.\n','','http://www.mysql.com/doc/M/y/Mysql_query.html');
INSERT INTO "manual" VALUES (287,'mysql_real_connect()',' const char *user, const char *passwd, const char *db,\n int port, const char *unix_socket,\n unsigned int client_flag)\nany of the other API functions, with the exception of\nThe parameters are specified as follows:\nThe first parameter should be the address of an existing MYSQL\nstructure. Before calling mysql_real_connect() you must call\n','','http://www.mysql.com/doc/M/y/Mysql_real_connect.html');
INSERT INTO "manual" VALUES (288,'mysql_real_escape_string()','Encodes the string in from to an escaped SQL string, taking into\naccount the current charset of the connection, that can be sent to the\nserver in a SQL statement, places the result in to, and adds a\nterminating null byte. Characters encoded are NUL (ASCII 0),\n(@pxref{Literals).\nThe string pointed to by from must be length bytes long. You\nmust allocate the to buffer to be at least length*2+1 bytes\n','','http://www.mysql.com/doc/M/y/Mysql_real_escape_string.html');
INSERT INTO "manual" VALUES (289,'mysql_real_query()','Executes the SQL query pointed to by query, which should be a string\nYou should not add a terminating semicolon (@samp{;) or \\g to the\nstatement.\nYou must use mysql_real_query() rather than\nmay contain the @samp{\\0 character. In addition, mysql_real_query()\nis faster than mysql_query() because it does not call strlen() on\nthe query string.\n','','http://www.mysql.com/doc/M/y/Mysql_real_query.html');
INSERT INTO "manual" VALUES (290,'mysql_reload()','Asks the MySQL server to reload the grant tables. The\nconnected user must have the reload privilege.\nThis function is deprecated. It is preferable to use mysql_query()\nto issue a SQL FLUSH PRIVILEGES statement instead.\nZero for success. Non-zero if an error occurred.\nCommands were executed in an improper order.\nThe MySQL server has gone away.\n','','http://www.mysql.com/doc/M/y/Mysql_reload.html');
INSERT INTO "manual" VALUES (291,'mysql_row_seek()','Sets the row cursor to an arbitrary row in a query result set. This requires\nthat the result set structure contains the entire result of the query, so\nThe offset should be a value returned from a call to mysql_row_tell()\nor to mysql_row_seek(). This value is not simply a row number; if you\nwant to seek to a row within a result set using a row number, use\nThe previous value of the row cursor. This value may be passed to a\nsubsequent call to mysql_row_seek().\n','','http://www.mysql.com/doc/M/y/Mysql_row_seek.html');
INSERT INTO "manual" VALUES (292,'mysql_row_tell()','Returns the current position of the row cursor for the last\nYou should use mysql_row_tell() only after mysql_store_result(),\nnot after mysql_use_result().\nThe current offset of the row cursor.\nNone.\n','','http://www.mysql.com/doc/M/y/Mysql_row_tell.html');
INSERT INTO "manual" VALUES (293,'mysql_select_db()','Causes the database specified by db to become the DEFAULT (current)\ndatabase on the connection specified by mysql. In subsequent queries,\nthis database is the default for table references that do not include an\nexplicit database specifier.\nas having permission to use the database.\nZero for success. Non-zero if an error occurred.\nCommands were executed in an improper order.\n','','http://www.mysql.com/doc/M/y/Mysql_select_db.html');
INSERT INTO "manual" VALUES (294,'mysql_shutdown()','Asks the database server to shut down. The connected user must have\nZero for success. Non-zero if an error occurred.\nCommands were executed in an improper order.\nThe MySQL server has gone away.\nThe connection to the server was lost during the query.\nAn unknown error occurred.\n','','http://www.mysql.com/doc/M/y/Mysql_shutdown.html');
INSERT INTO "manual" VALUES (295,'mysql_stat()','Returns a character string containing information similar to that provided by\nthe mysqladmin status command. This includes uptime in seconds and\nthe number of running threads, questions, reloads, and open tables.\nA character string describing the server status. NULL if an\nerror occurred.\nCommands were executed in an improper order.\nThe MySQL server has gone away.\n','','http://www.mysql.com/doc/M/y/Mysql_stat.html');
INSERT INTO "manual" VALUES (296,'mysql_store_result()','You must call mysql_store_result() or mysql_use_result()\nfor every query that successfully retrieves data (SELECT,\nIf you want to know if the query should return a result set or not, you can\nuse mysql_field_count() to check for this.\nallocates a MYSQL_RES structure, and places the result into this\nstructure.\na result set (if the query was, for example, an INSERT statement).\n','','http://www.mysql.com/doc/M/y/Mysql_store_result.html');
INSERT INTO "manual" VALUES (297,'mysql_thread_id()','Returns the thread ID of the current connection. This value can be used as\nan argument to mysql_kill() to kill the thread.\nIf the connection is lost and you reconnect with mysql_ping(), the\nthread ID will change. This means you should not get the thread ID and store\nit for later. You should get it when you need it.\nThe thread ID of the current connection.\nNone.\n','','http://www.mysql.com/doc/M/y/Mysql_thread_id.html');
INSERT INTO "manual" VALUES (298,'mysql_use_result()','You must call mysql_store_result() or mysql_use_result() for\nevery query that successfully retrieves data (SELECT, SHOW,\nactually read the result set into the client like mysql_store_result()\ndoes. Instead, each row must be retrieved individually by making calls to\nserver without storing it in a temporary table or local buffer, which is\nsomewhat faster and uses much less memory than mysql_store_result().\nThe client will only allocate memory for the current row and a communication\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (299,'connect() DBI method','Use the connect method to make a database connection to the data\nsource. The $data_source value should begin with\nExample uses of connect with the DBD::mysql driver:\nIf the user name and/or password are undefined, DBI uses the\nvalues of the DBI_USER and DBI_PASS environment variables,\nrespectively. If you don\'t specify a hostname, it DEFAULTs to\ndefault MySQL port (@value{default_port).\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (300,'disconnect DBI method','The disconnect method disconnects the database handle from the database.\nThis is typically called right before you exit from the program.\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (301,'prepare() DBI method','Prepares a SQL statement for execution by the database engine\nand returns a statement handle ($sth), which you can use to invoke\nthe execute method.\nTypically you handle SELECT statements (and SELECT-like statements\nsuch as SHOW, DESCRIBE, and EXPLAIN) by means of\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (302,'execute DBI method','The execute method executes a prepared statement. For\nnon-SELECT statements, execute returns the number of rows\naffected. If no rows are affected, execute returns \"0E0\",\nwhich Perl treats as zero but regards as true. If an error occurs,\nof the fetch_* methods described below to retrieve the data.\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (303,'do() DBI method','The do method prepares and executes a SQL statement and returns the\nnumber of rows affected. If no rows are affected, do returns\ngenerally used for non-SELECT statements that cannot be prepared in\nadvance (due to driver limitations) or that do not need to be executed more\nthan once (inserts, deletes, etc.). Example:\nGenerally the \'do\' statement is MUCH faster (and is preferable)\nthan prepare/execute for statements that don\'t contain parameters.\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (304,'quote() DBI method','The quote method is used to \"escape\" any special characters contained in\nthe string and to add the required outer quotation marks.\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (305,'fetchrow_array DBI method','This method fetches the next row of data and returns it as an array of\nfield values. Example:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (306,'fetchrow_arrayref DBI method','This method fetches the next row of data and returns it as a reference\nto an array of field values. Example:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (307,'fetchrow_hashref DBI method','This method fetches a row of data and returns a reference to a hash\ntable containing field name/value pairs. This method is not nearly as\nefficient as using array references as demonstrated above. Example:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (308,'fetchall_arrayref DBI method','This method is used to get all the data (rows) to be returned from the\nSQL statement. It returns a reference to an array of references to arrays\nfor each row. You access or print the data by using a nested\nloop. Example:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (309,'finish DBI method','Indicates that no more data will be fetched from this statement\nhandle. You call this method to free up the statement handle and any\nsystem resources associated with it. Example:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (310,'rows DBI method','Returns the number of rows changed (updated, deleted, etc.) by the last\ncommand. This is usually used after a non-SELECT execute\nstatement. Example:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (311,'NULLABLE DBI method','Returns a reference to an array of boolean values; for each element of\nthe array, a value of TRUE indicates that this\ncolumn may contain NULL values.\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (312,'NUM_OF_FIELDS DBI method','This attribute indicates\nthe number of fields returned by a SELECT or SHOW FIELDS\nstatement. You may use this for checking whether a statement returned a\nresult: A zero value indicates a non-SELECT statement like\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (313,'data_sources() DBI method','This method returns an array containing names of databases available to the\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (314,'ChopBlanks DBI method','This attribute determines whether the fetchrow_* methods will chop\nleading and trailing blanks from the returned values.\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (315,'trace DBI method','The trace method enables or disables tracing. When invoked as a\na database or statement handle method, it affects tracing for the given\nhandle (and any future children of the handle). Setting $trace_level\nto 2 provides detailed trace information. Setting $trace_level to 0\ndisables tracing. Trace output goes to the standard error output by\nDEFAULT. If $trace_filename is specified, the file is opened in\nappend mode and output for all traced handles is written to that\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "DEFAULT" nextval('') feature of MySQL, the new\nauto-incremented values will be stored here.\nExample:\nAs an alternative, you can use $dbh->@{\'mysql_insertid\'@.\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (317,'text DBI method','Returns a reference to an array of boolean values; for each element of the\narray, a value of TRUE indicates that the\nrespective column is a BLOB.\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (318,'is_key DBI method','Returns a reference to an array of boolean values; for each element of the\narray, a value of TRUE indicates that the\nrespective column is a key.\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (319,'is_num DBI method','Returns a reference to an array of boolean values; for each element of the\narray, a value of TRUE indicates that the\nrespective column contains numeric values.\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (320,'is_pri_key DBI method','Returns a reference to an array of boolean values; for each element of the\narray, a value of TRUE indicates that the respective column is a primary key.\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (321,'is_not_null DBI method','Returns a reference to an array of boolean values; for each element of the\narray, a value of FALSE indicates that this column may contain NULL\nvalues.\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (322,'max_length DBI method','Each of these methods returns a reference to an array of column sizes. The\nbe (as declared in the table description). The max_length array\nindicates the maximum sizes actually present in the result table. Example:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (323,'NAME DBI method','Returns a reference to an array of column names.\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (324,'table DBI method','Returns a reference to an array of table names.\nExample:\n','','http://www.mysql.com/doc/T/h/The_dbi_interface.html');
INSERT INTO "manual" VALUES (325,'type DBI method','Returns a reference to an array of column types.\nExample:\nYou can use the perldoc command to get more information about\nYou can also use the pod2man, pod2html, etc., tools to\ntranslate to other formats.\nYou can find the latest DBI information at\nthe DBI Web page:\n','mysql> UPDATE tbl_name SET KEY=KEY+1 WHERE KEY+0 > 100;','http://www.mysql.com/doc/M/y/Mysql_test_suite.html');
INSERT INTO "manual" VALUES (326,'trace DBI method','If you are using the Perl DBI interface, you can turn on\ndebugging information by using the trace method or by\nsetting the DBI_TRACE environment variable.\nOn some operating systems, the error log will contain a stack trace if\nmaybe why) mysqld died. Error log. To get a stack trace,\nyou should NOT compile mysqld with the\nIf the error file contains something like the following:\n','mysql> select \"weeknights\" REGEXP \"^(wee|week)(knights|nights)$\"; -> 1','http://www.mysql.com/doc/M/y/Mysql_test_suite.html');
INSERT INTO "manual" VALUES (328,'msql2mysql','A shell script that converts mSQL programs to MySQL. It doesn\'t handle all cases, but it gives a good start when converting. ',NULL,NULL);
INSERT INTO "manual" VALUES (329,'mysqlaccess','A script that checks the access privileges for a host, user, and database combination.',NULL,NULL);
INSERT INTO "manual" VALUES (330,'mysqladmin','Utility for performing administrative operations, such as creating or dropping databases, reloading the grant tables, flushing tables to disk, and reopening log files. mysqladmin can also be used to retrieve version, process, and status information from the server. See section 14.5 Administering a MySQL Server. ',NULL,NULL);
INSERT INTO "manual" VALUES (331,'mysqlbug','The MySQL bug report script. This script should always be used when filing a bug report to the MySQL list.',NULL,NULL);
INSERT INTO "manual" VALUES (332,'mysqld','The SQL daemon. This should always be running.',NULL,NULL);
INSERT INTO "manual" VALUES (333,'mysqldump','Dumps a MySQL database into a file as SQL statements or as tab-separated text files. Enhanced freeware originally by Igor Romanenko. See section 14.6 Dumping the Structure and\n Data from MySQL Databases and Tables. ',NULL,NULL);
INSERT INTO "manual" VALUES (334,'mysqlimport','Imports text files into their respective tables using LOAD DATA INFILE. See section 14.8 Importing Data from Text Files. ',NULL,NULL);
INSERT INTO "manual" VALUES (335,'mysqlshow','Displays information about databases, tables, columns, and indexes.',NULL,NULL);
INSERT INTO "manual" VALUES (336,'mysql_install_db','Creates the MySQL grant tables with DEFAULT privileges. This is usually executed only once, when first installing MySQL on a system. ',NULL,NULL);
INSERT INTO "manual" VALUES (337,'replace','A utility program that is used by msql2mysql, but that has more general applicability as well. replace changes strings in place in files or on the standard input. Uses a finite state machine to match longer strings first. Can be used to swap strings. For example, this command swaps a and b in the given files: ',NULL,NULL);
--
-- Table structure for table 'mode_data'
--
--
-- Sequences for table MODE_DATA
--
CREATE SEQUENCE mode_data_mode_data_id_seq;
CREATE TABLE "mode_data" (
"mode_data_id" INT4 DEFAULT nextval('mode_data_mode_data_id_seq'),
"chan_name" varchar(100) NOT NULL DEFAULT '',
"action" varchar(100) NOT NULL DEFAULT '',
"date_inserted" TIMESTAMP NOT NULL,
"added_by" varchar(100) DEFAULT NULL,
PRIMARY KEY ("mode_data_id")
);
--
-- Dumping data for table 'mode_data'
--
--
-- Table structure for table 'module_binds'
--
--
-- Sequences for table MODULE_BINDS
--
CREATE SEQUENCE module_binds_module_binds_id;
CREATE TABLE "module_binds" (
"module_binds_id" INT4 DEFAULT nextval('module_binds_module_binds_id'),
"token" char(10),
"bind" varchar(255) NOT NULL DEFAULT '',
PRIMARY KEY ("module_binds_id")
);
--
-- Dumping data for table 'module_binds'
--
INSERT INTO "module_binds" VALUES (1,'','MODE');
INSERT INTO "module_binds" VALUES (2,'','TOPIC');
INSERT INTO "module_binds" VALUES (3,'','PRIVMSG');
INSERT INTO "module_binds" VALUES (4,'','CHANMSG');
INSERT INTO "module_binds" VALUES (5,'/msg','BOTMSG');
INSERT INTO "module_binds" VALUES (6,'','NOTICE');
INSERT INTO "module_binds" VALUES (7,'','PART');
INSERT INTO "module_binds" VALUES (8,'','QUIT');
INSERT INTO "module_binds" VALUES (9,'','JOIN');
INSERT INTO "module_binds" VALUES (10,'','NICK');
INSERT INTO "module_binds" VALUES (11,'','BOT_JOIN_TOPIC_SETBY');
INSERT INTO "module_binds" VALUES (12,'','BOT_JOIN_TOPIC');
INSERT INTO "module_binds" VALUES (13,'','BOT_JOIN_NAMES');
INSERT INTO "module_binds" VALUES (14,'!','!_COMMAND');
INSERT INTO "module_binds" VALUES (15,'?','?_COMMAND');
INSERT INTO "module_binds" VALUES (16,'','SHOW');
INSERT INTO "module_binds" VALUES (17,'','ONKICK');
INSERT INTO "module_binds" VALUES (18,'','DCC');
--
-- Table structure for table 'modules'
--
--
-- Sequences for table MODULES
--
CREATE SEQUENCE modules_modules_id_seq;
CREATE TABLE "modules" (
"modules_id" INT4 DEFAULT nextval('modules_modules_id_seq'),
"module_binds_id" INT4 NOT NULL DEFAULT '0',
"module_name" varchar(255) NOT NULL DEFAULT '',
"module_desc" varchar(255) NOT NULL DEFAULT '',
"module_file_name" varchar(255) NOT NULL DEFAULT '',
PRIMARY KEY ("modules_id")
);
--
-- Dumping data for table 'modules'
--
INSERT INTO "modules" VALUES (1,14,'die','forces the bot to quit irc close db connection and exits the script','modules/die.mdl');
INSERT INTO "modules" VALUES (2,5,'ctcp','controls all ctcp commands','modules/ctcp.mdl');
INSERT INTO "modules" VALUES (3,1,'server_msgs','mode part quit and some others','modules/server_msgs.mdl');
INSERT INTO "modules" VALUES (7,7,'server_msgs','mode part quit and some others','modules/server_msgs.mdl');
INSERT INTO "modules" VALUES (8,8,'server_msgs','mode part quit and some others','modules/server_msgs.mdl');
INSERT INTO "modules" VALUES (9,9,'server_msgs','mode part quit and some others','modules/server_msgs.mdl');
INSERT INTO "modules" VALUES (10,10,'server_msgs','mode part quit and some others','modules/server_msgs.mdl');
INSERT INTO "modules" VALUES (11,11,'server_msgs','mode part quit and some others','modules/server_msgs.mdl');
INSERT INTO "modules" VALUES (12,12,'server_msgs','mode part quit and some others','modules/server_msgs.mdl');
INSERT INTO "modules" VALUES (13,13,'server_msgs','mode part quit and some others','modules/server_msgs.mdl');
INSERT INTO "modules" VALUES (14,15,'help','?php ?mysql and ?perl','modules/help.mdl');
INSERT INTO "modules" VALUES (15,9,'auto_voice','auto voices people with v and f global or chan level in chans they join if the chan is set to auto voice','modules/auto_voice.mdl');
INSERT INTO "modules" VALUES (16,18,'dot_functions','all the functions that start with a .','modules/dot_functions.mdl');
INSERT INTO "modules" VALUES (17,14,'chanel_commands','all the channel commands that start with a !','modules/channel_commands.mdl');
INSERT INTO "modules" VALUES (18,9,'tclbotautoop','ops bots set with bo global only matches nick against user and hostmask to be sure.','modules/tclbotautoop.mdl');
INSERT INTO "modules" VALUES (19,16,'help_show','converts all the show php show mysql and show perl to to user sending show command','modules/helpshow.mdl');
INSERT INTO "modules" VALUES (20,17,'onkick','updates chan users when someone gets kicked','modules/onkick.mdl');
INSERT INTO "modules" VALUES (21,5,'msg_help','sends nice little help on all the msg functions','modules/msghelp.mdl');
INSERT INTO "modules" VALUES (22,5,'msgcommands','goes with all the msgs in helpmsg','modules/msgcommands.mdl');
--
-- Table structure for table 'part_msg'
--
--
-- Sequences for table PART_MSG
--
CREATE SEQUENCE part_msg_part_msg_id_seq;
CREATE TABLE "part_msg" (
"part_msg_id" INT4 DEFAULT nextval('part_msg_part_msg_id_seq'),
"chan_name" varchar(50) NOT NULL DEFAULT '',
"msg" varchar(255) NOT NULL DEFAULT '',
PRIMARY KEY ("part_msg_id")
);
--
-- Dumping data for table 'part_msg'
--
--
-- Table structure for table 'perl_manual'
--
--
-- Sequences for table PERL_MANUAL
--
CREATE SEQUENCE perl_manual_id_seq;
CREATE TABLE "perl_manual" (
ID INT4 DEFAULT nextval('perl_manual_id_seq'),
"command" varchar(255) NOT NULL DEFAULT '',
"dscr" varchar(255) NOT NULL DEFAULT '',
"ex" varchar(255) DEFAULT NULL,
PRIMARY KEY ("ID")
);
--
-- Dumping data for table 'perl_manual'
--
INSERT INTO "perl_manual" VALUES (1,'$!','If used in a numeric context, yields the current value of errno, with all the usual caveats, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (2,'$#','The output format for printed numbers, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (3,'$#array','the last index of @array. scalar(@array) returns the length of the array (scalar(@array) == $#array - $[ + 1). Which means that scalar(@array) is equivalent to the next available index of the array. http://www.perl.com/CPAN-local/doc/manual/html/pod/perld',NULL);
INSERT INTO "perl_manual" VALUES (4,'$$','The process number of the Perl running this script, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (5,'$%','The current page number of the currently selected output channel, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (6,'$&','The string matched by the last successful pattern match (not counting any matches hidden within a BLOCK or eval() enclosed by the current BLOCK), http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (7,'$\'','The string following whatever was matched by the last successful pattern match, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (8,'$(','The FLOAT8gid of this process, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (9,'$)','The effective gid of this process, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (10,'$*','Set to 1 to do multi-line matching within a string, 0 to tell Perl that it can assume that strings contain a single line, for the purpose of optimizing pattern matches, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for patte',NULL);
INSERT INTO "perl_manual" VALUES (11,'$+','The last bracket matched by the last search pattern, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (12,'$,','The output field separator for the print operator, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (13,'$-','The number of lines left on the page of the currently selected output channel, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (14,'$.','The current input line number for the last file handle from which you read (or performed a seek or tell on), http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (15,'$/','The input record separator, newline by DEFAULT, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (16,'$0','Contains the name of the file containing the Perl script being executed, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (17,'$:','The current set of characters after which a string may be broken to fill continuation fields (starting with ^) in a format, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (18,'$;','The subscript separator for multidimensional array emulation, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (19,'$<','The FLOAT8uid of this process, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (20,'$=','The current page length (printable lines) of the currently selected output channel, DEFAULT is 60, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (21,'$>','The effective uid of this process, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (22,'$?','The status returned by the last pipe close, backtick (``) command, or system() operator, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (23,'$@','The Perl syntax error message from the last eval() command, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (24,'$[','The index of the first element in an array, and of the first character in a substring, DEFAULT is 0, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (25,'$','The output record separator for the print operator, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (26,'$]','The version + patchlevel / 1000 of the Perl interpreter, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html',NULL);
INSERT INTO "perl_manual" VALUES (27,'$^','The name of the current top-of-page format for the currently selected output channel, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (28,'$^a','The current value of the write() accumulator for format() lines, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (29,'$^d','The current value of the debugging flags, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (30,'$^e','Error information specific to the current operating system, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (31,'$^f','The maximum system file descriptor, ordinarily 2, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (32,'$^h','The current set of syntax checks enabled by use strict and other block scoped compiler hints, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (33,'$^i','The current value of the inplace-edit extension, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (34,'$^l','What formats output to perform a form feed. Default is f, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (35,'$^o','The name of the operating system under which this copy of Perl was built, as determined during the configuration process, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (36,'$^p','The internal variable for debugging support, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (37,'$^r','The result of evaluation of the last successful (?{ code }) regular expression assertion, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (38,'$^s','Current state of the interpreter, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (39,'$^t','The time at which the script began running, in seconds since the epoch (beginning of 1970), http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (40,'$^w','The current value of the warning switch, either TRUE or FALSE, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (41,'$^x','The name that the Perl binary itself was executed, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (42,'$_','The DEFAULT input and pattern-searching space, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (43,'$`','The string preceding whatever was matched by the last successful pattern match, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (44,'$arg','The DEFAULT input and pattern-searching space, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (45,'$argv','Contains the name of the current file when reading from <>, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (46,'$|','If set to nonzero, forces a flush right away and after every write or print on the currently selected output channel, DEFAULT is 0, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (47,'$~','The name of the current report format for the currently selected output channel, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html (Search page for pattern)\n',NULL);
INSERT INTO "perl_manual" VALUES (48,'%env','Hash that holds environmental variables accessible for perl. (To see what is available on you server get http://www.dgits.com/scripts/misc/env.txt -> upload cgi-bin as env.cgi -> chmod 755 -> access with browser), http://www.dgits.com/cgi-local/etc/env.cg',NULL);
INSERT INTO "perl_manual" VALUES (49,'%inc','The hash %INC contains entries for each filename that has been included via do or require, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html\n',NULL);
INSERT INTO "perl_manual" VALUES (50,'%sig','The hash %SIG is used to set signal handlers for various signals, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html\n',NULL);
INSERT INTO "perl_manual" VALUES (51,'-a','Perl command line options: turns on autosplit mode when used with a -n or -p. An implicit split command to the @F array is done as the first thing inside the implicit while loop produced by the -n or -p, http://www.perl.com/CPAN-local/doc/manual/html/pod/',NULL);
INSERT INTO "perl_manual" VALUES (52,'-c','Perl command line options: causes Perl to check the syntax of the script and then exit without executing it. Actually, it will execute BEGIN, END, and use blocks, because these are considered as occurring outside the execution of your program, http://www.',NULL);
INSERT INTO "perl_manual" VALUES (53,'-d','Perl command line options: runs the script under the Perl debugger. See the perldebug manpage, http://www.perl.com/CPAN-local/doc/manual/html/pod/perldebug.html\n',NULL);
INSERT INTO "perl_manual" VALUES (54,'-e','Perl command line options: may be used to enter one line of script. If -e is given, Perl will not look for a script filename in the argument list. Multiple -e commands may be given to build up a multi-line script. Make sure to use semicolons where you wou',NULL);
INSERT INTO "perl_manual" VALUES (55,'-l','Perl command line options (-l [octnum]): enables automatic line-ending processing - assigns $ (the output record separator) to have the value of [octnum] or automatically chops $/ (the input record separator) if used with -n or -p, http://www.perl.com/CPA',NULL);
INSERT INTO "perl_manual" VALUES (56,'-m','Perl command line options: -Mmodule executes use module ; before executing your script. You can use quotes to add extra code after the module name, e.g., -M\'module qw(foo bar)\', http://www.perl.com/CPAN-local/doc/manual/html/pod/perlrun.html\n',NULL);
INSERT INTO "perl_manual" VALUES (57,'-n','Perl command line options: causes Perl to assume the following loop around your script, which makes it iterate over filename arguments somewhat like sed -n or awk: while (<>) { ... }, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlrun.html\n',NULL);
INSERT INTO "perl_manual" VALUES (58,'-s','Perl command line options: enables some rudimentary switch parsing for switches on the command line after the script name but before any filename arguments (or before a --), http://www.perl.com/CPAN-local/doc/manual/html/pod/perlrun.html\n',NULL);
INSERT INTO "perl_manual" VALUES (59,'-t','Perl command line options: forces ``taint\'\' checks to be turned on so you can test them, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlrun.html\n',NULL);
INSERT INTO "perl_manual" VALUES (60,'-w','Perl command line options: prints warnings about variable names that are mentioned only once, and scalar variables that are used before being set. Also warns about redefined subroutines, and references to undefined filehandles or filehandles opened read-o',NULL);
INSERT INTO "perl_manual" VALUES (61,'-x','Test associated file for various conditions, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/_X.html\n',NULL);
INSERT INTO "perl_manual" VALUES (62,'500','a general server error, which occurs when script cannot be compiled for one reason or another. The reason might be wrong upload mode (must be \'ascii\') or syntax error (for scripts written in perl or other interpreted languages), invalid file permissions (',NULL);
INSERT INTO "perl_manual" VALUES (63,';','the symbol that signifies the end of a command. The most common syntax error is missing a \';\' on a previous line. You may have to check back a couple of lines, but you\'re probably missing one somewhere.\n',NULL);
INSERT INTO "perl_manual" VALUES (64,'<>','Null filehandle, which can be used to emulate the behavior of sed and awk. Input comes either from standard input, or from each file listed on the command line, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlop.html#I_O_Operators\n',NULL);
INSERT INTO "perl_manual" VALUES (65,'<keyword>','replace <keyword> with what you want help on. :)\n',NULL);
INSERT INTO "perl_manual" VALUES (66,'=~','the Perl binding operator. It binds a scalar expression to a pattern match, substitution, or translation.\n',NULL);
INSERT INTO "perl_manual" VALUES (67,'@_','the array within a subroutine containing the parameters passed to the subroutine (see perlsub), http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html\n',NULL);
INSERT INTO "perl_manual" VALUES (68,'@argv','The array @ARGV contains the command line arguments intended for the script, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html\n',NULL);
INSERT INTO "perl_manual" VALUES (69,'@inc','Array which contains the list of places to look for Perl scripts to be evaluated by the do EXPR, require, or use constructs, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlvar.html\n',NULL);
INSERT INTO "perl_manual" VALUES (70,'q','Quote and Quote-like Operators, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlop.html#Quote_and_Quote_like_Operators\n',NULL);
INSERT INTO "perl_manual" VALUES (71,'abs','Absolute value function, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/abs.html\n',NULL);
INSERT INTO "perl_manual" VALUES (72,'accept','Accept an incoming socket connect, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/accept.html\n',NULL);
INSERT INTO "perl_manual" VALUES (73,'accessprobe','nice log analyzer, http://www.accessprobe.com\n',NULL);
INSERT INTO "perl_manual" VALUES (74,'activeperl','Perl for win32 platforms, http://www.activestate.com\n',NULL);
INSERT INTO "perl_manual" VALUES (75,'alarm','Schedule a SIGALRM, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/alarm.html\n',NULL);
INSERT INTO "perl_manual" VALUES (76,'ansi c','ANSI C Reference, http://slique.net/vikrum/reference/c,\n',NULL);
INSERT INTO "perl_manual" VALUES (77,'anydbm_file','Provide framework for multiple DBMs, http://www.perl.com/CPAN-local/doc/manual/html/lib/AnyDBM_File.html\n',NULL);
INSERT INTO "perl_manual" VALUES (78,'apache','Apache server perl modules, http://theory.uwinnipeg.ca/CPAN/by-category/23_Miscellaneous_Modules.html\n',NULL);
INSERT INTO "perl_manual" VALUES (79,'apache binaries','Location to download apache server binaries for various platforms, http://www.apache.org/dist/binaries/\n',NULL);
INSERT INTO "perl_manual" VALUES (80,'apache dso','Apache Dynamic Shared Object (DSO) Support, http://www.apache.org/docs/dso.html\n',NULL);
INSERT INTO "perl_manual" VALUES (81,'apache faq','Frequently Asked Questions for Apache Web server, http://www.apache.org/docs/misc/FAQ.html\n',NULL);
INSERT INTO "perl_manual" VALUES (82,'apache java','Apache Java support - the Jakarta project, http://jakarta.apache.org/index.html\n',NULL);
INSERT INTO "perl_manual" VALUES (83,'apache log format','Apache 1.3 HTTP access log format documentation (mod_log_config), http://www.apache.org/docs/mod/mod_log_config.html\n',NULL);
INSERT INTO "perl_manual" VALUES (84,'apache modules','Apache server modules, http://www.apache.org/docs/mod/index.html\n',NULL);
INSERT INTO "perl_manual" VALUES (85,'apache performance','Hints on running Apache as high-performance web server, http://www.apache.org/docs/misc/perf.html\n',NULL);
INSERT INTO "perl_manual" VALUES (86,'apache runtime','Apache\'s run-time configuration directives, http://www.apache.org/docs/\n',NULL);
INSERT INTO "perl_manual" VALUES (87,'apache security','Security tips for Apache server configuration, http://www.apache.org/docs/misc/security_tips.html\n',NULL);
INSERT INTO "perl_manual" VALUES (88,'apache server','Most popular webserver for UNIX (also available for Win32 platform), http://www.apache.org\n',NULL);
INSERT INTO "perl_manual" VALUES (89,'apache ssi','Q: How do I enable SSI execution on my Apache server?, http://www.apache.org/docs/misc/FAQ.html#ssi-part-i\n',NULL);
INSERT INTO "perl_manual" VALUES (90,'apache tricks','Cool Tricks With Perl and Apache, http://stein.cshl.org/WWW/docs/handout.html\n',NULL);
INSERT INTO "perl_manual" VALUES (91,'apache tuning','Some Apache webserver performance tuning tips, http://www.apache.org/docs/misc/perf-tuning.html\n',NULL);
INSERT INTO "perl_manual" VALUES (92,'apache tutorials','a collection of tutorials, written by third-parties, to help configure and run Apache. http://www.apache.org/docs/misc/tutorials.html\n',NULL);
INSERT INTO "perl_manual" VALUES (93,'apache::dbi','Initiate a persistent database connection with perl and Apache server, http://search.cpan.org/doc/MERGL/ApacheDBI-0.88/DBI.pm\n',NULL);
INSERT INTO "perl_manual" VALUES (94,'apache::ssi','Perl module to implement Server Side Includes in Perl, http://theoryx5.uwinnipeg.ca/CPAN/data/Apache-SSI/SSI.html\n',NULL);
INSERT INTO "perl_manual" VALUES (95,'aquitaine','a #cgi channel regular from India whose rye comments often risk getting himself kicked\n',NULL);
INSERT INTO "perl_manual" VALUES (96,'archive::zip','a perl library to provide an interface to ZIP archive files, http://theoryx5.uwinnipeg.ca/CPAN/data/Archive-Zip/Archive/Zip.html\n',NULL);
INSERT INTO "perl_manual" VALUES (97,'ascii set','The ASCII Character Set table, http://www.cis.udel.edu/~totten/ascii/\n',NULL);
INSERT INTO "perl_manual" VALUES (98,'ask','\'...Don\'t ask to ask.. just ask!..\'\n',NULL);
INSERT INTO "perl_manual" VALUES (99,'atan2','Arctangent of Y/X, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/atan2.html\n',NULL);
INSERT INTO "perl_manual" VALUES (100,'attrs','Set/get attributes of a subroutine, http://www.perl.com/CPAN-local/doc/manual/html/lib/attrs.html\n',NULL);
INSERT INTO "perl_manual" VALUES (101,'audio','Audio related perl modules, http://theory.uwinnipeg.ca/CPAN/by-category/23_Miscellaneous_Modules.html\n',NULL);
INSERT INTO "perl_manual" VALUES (102,'autoloader','Load subroutines only on demand, http://www.perl.com/CPAN-local/doc/manual/html/lib/AutoLoader.html\n',NULL);
INSERT INTO "perl_manual" VALUES (103,'autosplit','Split a package for autoloading, http://www.perl.com/CPAN-local/doc/manual/html/lib/AutoSplit.html\n',NULL);
INSERT INTO "perl_manual" VALUES (104,'autouse','Postpone load of modules until a function is used, http://www.perl.com/CPAN-local/doc/manual/html/lib/autouse.html\n',NULL);
INSERT INTO "perl_manual" VALUES (105,'b','The module used for <A, http://www.perl.com/CPAN-local/doc/manual/html/lib/B.html\n',NULL);
INSERT INTO "perl_manual" VALUES (106,'b::asmdata','Autogenerated data about Perl ops, used to generate bytecode, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/Asmdata.html\n',NULL);
INSERT INTO "perl_manual" VALUES (107,'b::assembler','Assemble Perl bytecode, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/Assembler.html\n',NULL);
INSERT INTO "perl_manual" VALUES (108,'b::bblock','Walk basic blocks, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/Bblock.html\n',NULL);
INSERT INTO "perl_manual" VALUES (109,'b::bytecode','Perl compiler\'s bytecode backend, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/Bytecode.html\n',NULL);
INSERT INTO "perl_manual" VALUES (110,'b::c','Perl compiler\'s C backend, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/C.html\n',NULL);
INSERT INTO "perl_manual" VALUES (111,'b::cc','Perl compiler\'s optimized C translation backend, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/CC.html\n',NULL);
INSERT INTO "perl_manual" VALUES (112,'b::debug','Walk Perl syntax tree, printing debug info about ops, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/Debug.html\n',NULL);
INSERT INTO "perl_manual" VALUES (113,'b::deparse','Perl compiler backend to produce perl code, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/Deparse.html\n',NULL);
INSERT INTO "perl_manual" VALUES (114,'b::disassembler','Disassemble Perl bytecode, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/Disassembler.html\n',NULL);
INSERT INTO "perl_manual" VALUES (115,'b::lint','Perl lint, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/Lint.html\n',NULL);
INSERT INTO "perl_manual" VALUES (116,'b::showlex','Show lexical variables used in functions or files, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/Showlex.html\n',NULL);
INSERT INTO "perl_manual" VALUES (117,'b::stackobj','Helper module for CC backend, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/Stackobj.html\n',NULL);
INSERT INTO "perl_manual" VALUES (118,'b::terse','Walk Perl syntax tree, printing terse info about ops, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/Terse.html\n',NULL);
INSERT INTO "perl_manual" VALUES (119,'b::xref','Generates cross reference reports for Perl programs, http://www.perl.com/CPAN-local/doc/manual/html/lib/B/Xref.html\n',NULL);
INSERT INTO "perl_manual" VALUES (120,'babelfish','WWW::Babelfish - Perl extension for translation via babelfish, http://theory.uwinnipeg.ca/CPAN/data/WWW-Babelfish/Babelfish.html\n',NULL);
INSERT INTO "perl_manual" VALUES (121,'backtracking','Explanation on bactracking, http://ftp.digital.com/pub/plan/perl/CPAN/doc/FMTEYEWTK/back.html\n',NULL);
INSERT INTO "perl_manual" VALUES (122,'bad code','How To Write Unmaintainable Code and can be found at http://mindprod.com/unmain.html\n',NULL);
INSERT INTO "perl_manual" VALUES (123,'bad habits','Sex, drugs, rock\'n\'roll and American dream... geez, who writes this stuff\n',NULL);
INSERT INTO "perl_manual" VALUES (124,'base','Establish , http://www.perl.com/CPAN-local/doc/manual/html/lib/base.html\n',NULL);
INSERT INTO "perl_manual" VALUES (125,'bash','Bourne Again Shell (Overview Documentation for Bash), http://wwwinfo.cern.ch/dis/texi2html/gnu/bash-1.14.6/features_toc.html\n',NULL);
INSERT INTO "perl_manual" VALUES (126,'benchmark','Benchmark running times of code, http://www.perl.com/CPAN-local/doc/manual/html/lib/Benchmark.html\n',NULL);
INSERT INTO "perl_manual" VALUES (127,'best perl book','\'Object Oriented Perl\' by Damian Conway',NULL);
INSERT INTO "perl_manual" VALUES (128,'biglug th','is a test\n',NULL);
INSERT INTO "perl_manual" VALUES (129,'bind','Binds an address to a socket, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/bind.html\n',NULL);
INSERT INTO "perl_manual" VALUES (130,'binmode','Prepare binary files on old systems, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/binmode.html\n',NULL);
INSERT INTO "perl_manual" VALUES (131,'bitchx','IRC (Internet Relay Chat) client, http://www.bitchx.org/\n',NULL);
INSERT INTO "perl_manual" VALUES (132,'blackbox','simplistic, laconic yet functional window manager for the Open Group\'s X Window System, with professionally finished interface design and very low memory consumption, http://blackbox.alug.org/\n',NULL);
INSERT INTO "perl_manual" VALUES (133,'bless','Create an object, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/bless.html\n',NULL);
INSERT INTO "perl_manual" VALUES (134,'blib','Use MakeMaker\'s uninstalled version of a package, http://www.perl.com/CPAN-local/doc/manual/html/lib/blib.html\n',NULL);
INSERT INTO "perl_manual" VALUES (135,'bofh','Bastard Operator From Hel\n',NULL);
INSERT INTO "perl_manual" VALUES (136,'books','O\'Reilly and Associates publishing, http://perl.ora.com - there is also a reasonable book on cgi available online at http://www.itknowledge.com/reference/archive/1575211963/ewtoc.html\n',NULL);
INSERT INTO "perl_manual" VALUES (137,'browsers','Web Browsers OpenFAQ, http://www.boutell.com/openfaq/browsers/\n',NULL);
INSERT INTO "perl_manual" VALUES (138,'business','Business related perl modules, http://theory.uwinnipeg.ca/CPAN/by-category/23_Miscellaneous_Modules.html\n',NULL);
INSERT INTO "perl_manual" VALUES (139,'caller','Get context of the current subroutine call, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/caller.html\n',NULL);
INSERT INTO "perl_manual" VALUES (140,'camel','either of two large ruminant mammals (genus Camelus) used as draft and saddle animals in desert regions especially of Africa and Asia: the one-humped camel (Camelus dromedarius) extant only as a domestic or feral animal - called also dromedary',NULL);
INSERT INTO "perl_manual" VALUES (141,'carp','Warn of errors (from perspective of caller), http://www.perl.com/CPAN-local/doc/manual/html/lib/Carp.html\n',NULL);
INSERT INTO "perl_manual" VALUES (142,'cgi','Common Gateway Interface standard for external gateway programs to interface with information servers such as HTTP servers, http://hoohoo.ncsa.uiuc.edu/cgi/overview.html',NULL);
INSERT INTO "perl_manual" VALUES (143,'cgi c/c++','Some CGI programming resources in C/C++, http://cgi.resourceindex.com/Documentation/Programming_in_C_and_C++/\n',NULL);
INSERT INTO "perl_manual" VALUES (144,'cgi faq','CGI Programming OpenFAQ, http://www.boutell.com/openfaq/cgi/\n',NULL);
INSERT INTO "perl_manual" VALUES (145,'cgi on','qick tip on How to enable CGI execution under Apache server: Add the following line to httpd.conf - AddHandler cgi-scrip *.cgi - (http://httpd.apache.org/docs/mod/mod_mime.html#addhandler), restart server.\n',NULL);
INSERT INTO "perl_manual" VALUES (146,'cgi security','CGI Security FAQ which is at http://www.w3.org/Security/Faq/www-security-faq.html and http://www.insecure.org/news/P55-07.txt\n',NULL);
INSERT INTO "perl_manual" VALUES (147,'cgi subdomain','How to setup subdomain redirection with CGI, http://library.thinkquest.org/26297/perl/subdomainsCGI.shtml\n',NULL);
INSERT INTO "perl_manual" VALUES (148,'cgi-lib.pl','is outdated perl library consists of common CGI-related routines. The new standard CGI library (part of the perl\'s core since version 5) is CGI.pm... Nonetheless, you can still find cgi-lib and its documentation at http://cgi-lib.berkeley.edu/.\n',NULL);
INSERT INTO "perl_manual" VALUES (149,'cgi.pm','perl Object-Oriented interface to the most common CGI routines (form generation and parsing, cookies, file upload, etc.), http://stein.cshl.org/WWW/software/CGI/cgi_docs.html',NULL);
INSERT INTO "perl_manual" VALUES (150,'cgi.pm cookies','Using CGI.pm cookie processing features..., http://stein.cshl.org/WWW/software/CGI/cgi_docs.html#cookies\n',NULL);
INSERT INTO "perl_manual" VALUES (151,'cgi::apache','Make things work with CGI.pm against Perl-Apache API, http://www.perl.com/CPAN-local/doc/manual/html/lib/CGI/Apache.html\n',NULL);
INSERT INTO "perl_manual" VALUES (152,'cgi::carp','CGI routines for writing to the HTTPD (or other) error log, http://www.perl.com/CPAN-local/doc/manual/html/lib/CGI/Carp.html\n',NULL);
INSERT INTO "perl_manual" VALUES (153,'cgi::cookie','Interface to Netscape Cookies, http://www.perl.com/CPAN-local/doc/manual/html/lib/CGI/Cookie.html\n',NULL);
INSERT INTO "perl_manual" VALUES (154,'cgi::fast','CGI Interface for Fast CGI, http://www.perl.com/CPAN-local/doc/manual/html/lib/CGI/Fast.html\n',NULL);
INSERT INTO "perl_manual" VALUES (155,'cgi::lite','Perl module to process and decode WWW forms and cookies, http://theoryx5.uwinnipeg.ca/CPAN/data/CGI-Lite/Lite.html\n',NULL);
INSERT INTO "perl_manual" VALUES (156,'cgi::pretty','Module to produce nicely formatted HTML code (part of CGI.pm bundle), http://theoryx5.uwinnipeg.ca/CPAN/data/CGI.pm/CGI/Pretty.html\n',NULL);
INSERT INTO "perl_manual" VALUES (157,'cgi::push','Simple Interface to Server Push, http://www.perl.com/CPAN-local/doc/manual/html/lib/CGI/Push.html\n',NULL);
INSERT INTO "perl_manual" VALUES (158,'cgi::switch','Try more than one constructors and return the first object available, http://www.perl.com/CPAN-local/doc/manual/html/lib/CGI/Switch.html\n',NULL);
INSERT INTO "perl_manual" VALUES (159,'cgicc','A C++ class library for writing CGI applications, http://www.gnu.org/software/cgicc/cgicc.html\n',NULL);
INSERT INTO "perl_manual" VALUES (160,'cgiwrap','CGIWrap is a gateway program that allows general users to use CGI scripts and HTML forms without compromising the security of the http server, http://www.unixtools.org/cgiwrap/\n',NULL);
INSERT INTO "perl_manual" VALUES (161,'chdir','Change your current working directory, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/chdir.html\n',NULL);
INSERT INTO "perl_manual" VALUES (162,'chmod','Changes the permissions on a list of files, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/chmod.html\n',NULL);
INSERT INTO "perl_manual" VALUES (163,'choices','1. You can search the web and try to find something that is close to what you need; 2. You can learn cgi and try to write whatever you need yourself; 3. You can pay someone to write it for you. And, of course, choice is always yours..\n',NULL);
INSERT INTO "perl_manual" VALUES (164,'chomp','Remove a trailing record separator from a string, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/chomp.html\n',NULL);
INSERT INTO "perl_manual" VALUES (165,'chop','Remove the last character from a string, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/chop.html\n',NULL);
INSERT INTO "perl_manual" VALUES (166,'chown','Change the owership on a list of files, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/chown.html\n',NULL);
INSERT INTO "perl_manual" VALUES (167,'chr','Get character this number represents, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/chr.html\n',NULL);
INSERT INTO "perl_manual" VALUES (168,'chroot','Make directory new root for path lookups, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/chroot.html\n',NULL);
INSERT INTO "perl_manual" VALUES (169,'class::struct','Declare struct-like datatypes as Perl classes, http://www.perl.com/CPAN-local/doc/manual/html/lib/Class/Struct.html\n',NULL);
INSERT INTO "perl_manual" VALUES (170,'close','Close file (or pipe or socket) handle, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/close.html\n',NULL);
INSERT INTO "perl_manual" VALUES (171,'closedir','Close directory handle, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/closedir.html\n',NULL);
INSERT INTO "perl_manual" VALUES (172,'cmcd','',NULL);
INSERT INTO "perl_manual" VALUES (173,'codemagic','Useful win32 source code editor, http://www.petes-place.com/codemagic.html\n',NULL);
INSERT INTO "perl_manual" VALUES (174,'coder_','An op in Undernet #cgi and is a developer for CodeMagic (Blue Square Group). He can be reached via email @ [email protected] or icq (6639976)., http://coder.axess.com/\n',NULL);
INSERT INTO "perl_manual" VALUES (175,'coder_ sex','Slap her leg up on your shoulder... she\'ll definitely like that\n',NULL);
INSERT INTO "perl_manual" VALUES (176,'compress','Archiving and Compression, http://theory.uwinnipeg.ca/CPAN/by-category/17_Archiving_and_Compression.html\n',NULL);
INSERT INTO "perl_manual" VALUES (177,'config','Access Perl configuration information, http://www.perl.com/CPAN-local/doc/manual/html/lib/Config.html\n',NULL);
INSERT INTO "perl_manual" VALUES (178,'config::inifiles','a module for reading .ini-style configuration files. http://dev.rcbowen.com/iniconf/\n',NULL);
INSERT INTO "perl_manual" VALUES (179,'connect','Connect to a remove socket, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/connect.html\n',NULL);
INSERT INTO "perl_manual" VALUES (180,'conseal','Windows 95/98/NT Firewall, http://www.signal9.com/\n',NULL);
INSERT INTO "perl_manual" VALUES (181,'constant','Perl pragma to declare constants, http://www.perl.com/CPAN-local/doc/manual/html/lib/constant.html\n',NULL);
INSERT INTO "perl_manual" VALUES (182,'continue','Optional trailing block in a while or foreach, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/continue.html\n',NULL);
INSERT INTO "perl_manual" VALUES (183,'convert','the standard Unix image conversion program. It converts images from different formats, optionally performing standard image manipulation operations on it. It\'s synopsis is convert [ options ... ] file [ file... ] file - see section 1 of your Unix manual\n',NULL);
INSERT INTO "perl_manual" VALUES (184,'cookie-lib','is a perl library, written in the spirit of cgi-lib.pl to help developers use cookies in web applications and can be found at http://www.egr.uri.edu/~kovacsp/cookie-lib\n',NULL);
INSERT INTO "perl_manual" VALUES (185,'cookies','HTTP Cookies related resources, http://www.cgi101.com/class/ch15/, http://cgi.resourceindex.com/Documentation/HTTP_Cookies/, http://www.freeperlcode.com/guide/Cookies/',NULL);
INSERT INTO "perl_manual" VALUES (186,'corba','The Common Object Request Broker Architecture, http://www.cs.wustl.edu/~schmidt/corba.html\n',NULL);
INSERT INTO "perl_manual" VALUES (187,'corba tutorials','Collection of CORBA (Common Object Request Broker Architecture) tutorials, http://www.cs.wustl.edu/~schmidt/tutorials-corba.html\n',NULL);
INSERT INTO "perl_manual" VALUES (188,'cos','Cosine function, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/cos.html\n',NULL);
INSERT INTO "perl_manual" VALUES (189,'cpan','Comprehensive Perl Archive Network, http://www.cpan.org (search CPAN database at http://theory.uwinnipeg.ca/search/cpan-search.html)\n',NULL);
INSERT INTO "perl_manual" VALUES (190,'cpan module','Query, download and build perl modules from CPAN sites, http://www.perl.com/CPAN-local/doc/manual/html/lib/CPAN.html\n',NULL);
INSERT INTO "perl_manual" VALUES (191,'cpan::firsttime','Utility for CPAN::Config file Initialization, http://www.perl.com/CPAN-local/doc/manual/html/lib/CPAN/FirstTime.html\n',NULL);
INSERT INTO "perl_manual" VALUES (192,'cpan::nox','Wrapper around CPAN.pm without using any XS module, http://www.perl.com/CPAN-local/doc/manual/html/lib/CPAN/Nox.html\n',NULL);
INSERT INTO "perl_manual" VALUES (193,'crc','Method for checking the accuracy of a digital transmission over a communications link, http://www.rad.com/networks/1994/err_con/crc.htm\n',NULL);
INSERT INTO "perl_manual" VALUES (194,'cron','Program that allows users to create jobs that will run at a given time, http://nerc-online.com/support/www/crontab.html\n',NULL);
INSERT INTO "perl_manual" VALUES (195,'crontab','the cron daemon is a long-running process that executes commands at specific dates and times and can be found at http://kb.indiana.edu/data/afiz.html',NULL);
INSERT INTO "perl_manual" VALUES (196,'crypt','One-way passwd-style encryption, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/crypt.html\n',NULL);
INSERT INTO "perl_manual" VALUES (197,'crypto','Security and Encryption, http://theory.uwinnipeg.ca/CPAN/by-category/14_Security_and_Encryption.html\n',NULL);
INSERT INTO "perl_manual" VALUES (198,'css','Cascading Style Sheets, http://www.wdvl.com/Authoring/Style/Sheets/\n',NULL);
INSERT INTO "perl_manual" VALUES (199,'css reference','Cascading Style Sheets reference table, http://www.builder.com/Authoring/CSS/table.html\n',NULL);
INSERT INTO "perl_manual" VALUES (200,'cvsi','Compilation vs. Interpretation, http://ftp.digital.com/pub/plan/perl/CPAN/doc/FMTEYEWTK/comp-vs-interp.html\n',NULL);
INSERT INTO "perl_manual" VALUES (201,'cwd','Get pathname of current working directory, http://www.perl.com/CPAN-local/doc/manual/html/lib/Cwd.html\n',NULL);
INSERT INTO "perl_manual" VALUES (202,'data::dumper','Stringified perl data structures, suitable for both printing and eval, http://www.perl.com/CPAN-local/doc/manual/html/lib/Data/Dumper.html\n',NULL);
INSERT INTO "perl_manual" VALUES (203,'database design','Fundamentals of Database Design, http://www.citilink.com/~jgarrick/vbasic/database/fundamentals.html\n',NULL);
INSERT INTO "perl_manual" VALUES (204,'datatype','Data Type Utilities, http://theory.uwinnipeg.ca/CPAN/by-category/06_Data_Type_Utilities.html\n',NULL);
INSERT INTO "perl_manual" VALUES (205,'date::calc','Gregorian calendar date calculations, http://theoryx5.uwinnipeg.ca/CPAN/data/Date-Calc/Calc.html\n',NULL);
INSERT INTO "perl_manual" VALUES (206,'date::manip','Date manipulation routines, http://theoryx5.uwinnipeg.ca/CPAN/data/DateManip/Manip.html\n',NULL);
INSERT INTO "perl_manual" VALUES (207,'db','Database Interfaces, http://theory.uwinnipeg.ca/CPAN/by-category/07_Database_Interfaces.html\n',NULL);
INSERT INTO "perl_manual" VALUES (208,'db_file','Perl5 access to Berkeley DB version 1.x, http://www.perl.com/CPAN-local/doc/manual/html/lib/DB_File.html\n',NULL);
INSERT INTO "perl_manual" VALUES (209,'dbd::odbc','ODBC driver for DBI, http://theoryx5.uwinnipeg.ca/CPAN/data/DBD-ODBC/ODBC.html\n',NULL);
INSERT INTO "perl_manual" VALUES (210,'dbi','Various SQL databases access perl modules and drivers, http://www.symbolstone.org/technology/perl/DBI/index.html\n',NULL);
INSERT INTO "perl_manual" VALUES (211,'dbi info','DBI tutorial, http://www.opensourceit.com/url/990426perl.html\n',NULL);
INSERT INTO "perl_manual" VALUES (212,'dbi tutorial','CodeData\'s Perl/DBI tutorial: http://codedata.box.sk/perl/tut1/13.txt\n',NULL);
INSERT INTO "perl_manual" VALUES (213,'dbm','DB_File - Perl5 access to Berkeley DB version 1.x, ftp://ftp.ou.edu/mirrors/CPAN/doc/manual/html/lib/DB_File.html\n',NULL);
INSERT INTO "perl_manual" VALUES (214,'dbmclose','Breaks binding on a tied dbm file, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/dbmclose.html\n',NULL);
INSERT INTO "perl_manual" VALUES (215,'dbmopen','Create binding on a tied dbm file, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/dbmopen.html\n',NULL);
INSERT INTO "perl_manual" VALUES (216,'defined','Test whether a value, variable, or function is defined, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/defined.html\n',NULL);
INSERT INTO "perl_manual" VALUES (217,'delete','Deletes a value from a hash, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/delete.html\n',NULL);
INSERT INTO "perl_manual" VALUES (218,'devel','Development Support, http://theory.uwinnipeg.ca/CPAN/by-category/03_Development_Support.html\n',NULL);
INSERT INTO "perl_manual" VALUES (219,'devel::selfstubber','Generate stubs for a SelfLoading module, http://www.perl.com/CPAN-local/doc/manual/html/lib/Devel/SelfStubber.html\n',NULL);
INSERT INTO "perl_manual" VALUES (220,'diagnostics','Perl compiler pragma to force verbose warning diagnostics, http://www.perl.com/CPAN-local/doc/manual/html/lib/diagnostics.html\n',NULL);
INSERT INTO "perl_manual" VALUES (221,'die','Raise an exception or bail out, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/die.html\n',NULL);
INSERT INTO "perl_manual" VALUES (222,'dirhandle','Supply object methods for directory handles, http://www.perl.com/CPAN-local/doc/manual/html/lib/DirHandle.html\n',NULL);
INSERT INTO "perl_manual" VALUES (223,'do','Turn a BLOCK into a TERM, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/do.html\n',NULL);
INSERT INTO "perl_manual" VALUES (224,'dprof','a Perl code profiler, http://search.cpan.org/search?dist=DProf\n',NULL);
INSERT INTO "perl_manual" VALUES (225,'dsl','Digital Subscriber Line and its variations, , info: http://whatis.com/dsl.htm\n',NULL);
INSERT INTO "perl_manual" VALUES (226,'dump','Create an immediate core dump, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/dump.html\n',NULL);
INSERT INTO "perl_manual" VALUES (227,'dynaloader','Dynamically load C libraries into Perl code, http://www.perl.com/CPAN-local/doc/manual/html/lib/DynaLoader.html\n',NULL);
INSERT INTO "perl_manual" VALUES (228,'each','Retrieve the next key/value pair from a hash, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/each.html\n',NULL);
INSERT INTO "perl_manual" VALUES (229,'easy','\'..This is not about to make it easy - this is about to make it right!..\'\n',NULL);
INSERT INTO "perl_manual" VALUES (230,'editpad','a replacement for the standard windows Notepad (much much better) and can be found at http://www.editpadpro.com/editpadclassic.html\n',NULL);
INSERT INTO "perl_manual" VALUES (231,'efnet #perl','A channel full of the \'3 great virtues of a programmer\' 1) Laziness 2) Impatience 3) Hubris.. AND MORE!! part there today!\n',NULL);
INSERT INTO "perl_manual" VALUES (232,'email check','How do I check a valid mail address?, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfaq9.html#How_do_I_check_a_valid_mail_addr\n',NULL);
INSERT INTO "perl_manual" VALUES (233,'embedperl','Embed Perl in Your HTML documents, http://perl.apache.org/embperl/\n',NULL);
INSERT INTO "perl_manual" VALUES (234,'encrypt','a simple utility to generate strings using UNIX style one-way encryption mechanism, http://www.dgits.com/cgi-local/etc/encrypt.cgi or http://www.beatnik.uklinux.net/webcrypt.html\n',NULL);
INSERT INTO "perl_manual" VALUES (235,'endgrent','Be done using group file, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/endgrent.html\n',NULL);
INSERT INTO "perl_manual" VALUES (236,'endhostent','Be done using hosts file, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/endhostent.html\n',NULL);
INSERT INTO "perl_manual" VALUES (237,'endnetent','Be done using networks file, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/endnetent.html\n',NULL);
INSERT INTO "perl_manual" VALUES (238,'endprotoent','Be done using protocols file, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/endprotoent.html\n',NULL);
INSERT INTO "perl_manual" VALUES (239,'endpwent','Be done using passwd file, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/endpwent.html\n',NULL);
INSERT INTO "perl_manual" VALUES (240,'endservent','Be done using services file, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/endservent.html\n',NULL);
INSERT INTO "perl_manual" VALUES (241,'english','Use nice English (or awk) names for ugly punctuation variables, http://www.perl.com/CPAN-local/doc/manual/html/lib/English.html\n',NULL);
INSERT INTO "perl_manual" VALUES (242,'env','Perl module that imports environment variables, http://www.perl.com/CPAN-local/doc/manual/html/lib/Env.html\n',NULL);
INSERT INTO "perl_manual" VALUES (243,'env vars','Environmental variable accessible for cgi. (To see what is available on your server get http://www.dgits.com/scripts/misc/env.txt -> upload in cgi-bin as env.cgi -> chmod 755 -> access with browser), http://www.dgits.com/cgi-local/etc/env.cgi\n',NULL);
INSERT INTO "perl_manual" VALUES (244,'env.cgi','Environment variables are a series of hidden values that the web server sends to every CGI you run',NULL);
INSERT INTO "perl_manual" VALUES (245,'eof','Test a filehandle for its end, http://www.perl.com/CPAN-local/doc/manual/html/pod/perlfunc/eof.html\n',NULL);
INSERT INTO "perl_manual" VALUES (246,'errno','System errno constants, http://www.perl.com/CPAN-local/doc/manual/html/lib/Errno.html\n',NULL);
INSERT INTO "perl_manual" VALUES (247,'error check','the way to output errors into the browser window - just add the following line right after #!/usr/bin/perl (or whatever path to perl you have): use CGI::Carp qw/fatalsToBrowser/; (requires perl 5+, see CGI::Carp for more info), http://www.perl.com/CPAN-lo',NULL);