manual.texi British-ise some -ize words

manual.texi	formatting fixups


Docs/manual.texi:
  British-ise some -ize words

Docs/manual.texi

@@ -14933,7 +14933,7 @@ system.  This section describes how it works.
 Anyone using MySQL on a computer connected to the Internet
 should read this section to avoid the most common security mistakes.
 
-In discussing security, we emphasize the necessity of fully protecting the
+In discussing security, we emphasise the necessity of fully protecting the
 entire server host (not simply the MySQL server) against all types
 of applicable attacks: eavesdropping, altering, playback, and denial of
 service. We do not cover all aspects of availability and fault tolerance
@@ -19647,7 +19647,7 @@ is high, it is a good indication that your queries and tables are properly index
 @item @code{Handler_read_next} @tab Number of requests to read next row in key order. This
 will be incremented if you are querying an index column with a range constraint. This also
 will be incremented if you are doing an index scan.
-@item @code{Handler_read_prev} @tab Number of requests to read previous row in key order.  This is mainly used to optimize @code{ORDER BY ... DESC}.
+@item @code{Handler_read_prev} @tab Number of requests to read previous row in key order.  This is mainly used to optimise @code{ORDER BY ... DESC}.
 @item @code{Handler_read_rnd} @tab Number of requests to read a row based on a fixed position.
 This will be high if you are doing a lot of queries that require sorting of the result.
 @item @code{Handler_read_rnd_next} @tab Number of requests to read the next row in the datafile.
@@ -23672,7 +23672,7 @@ For more details, please see @ref{Replication FAQ}.
 
 If you want to become a real MySQL replication guru, we suggest that you
 begin by studying, pondering, and trying all commands
-mentioned in @ref{Replication SQL}. You should also familiarize yourself
+mentioned in @ref{Replication SQL}. You should also familiarise yourself
 with replication startup options in @file{my.cnf} in
 @ref{Replication Options}.
 
@@ -23960,7 +23960,7 @@ the slave. The other bug is that if the ignored table gets partially
 updated, the slave thread will not notice that the table actually should
 have been ignored and will suspend the replication process. While the
 above bugs are conceptually very simple to fix, we have not yet found a way
-to do this without a sigficant code change that would compromize the stability
+to do this without a significant code change that would compromise the stability
 status of 3.23 branch. There exists a workaround for both if in the rare case
 it happens to affect your application -- use @code{slave-skip-errors}.
 @end itemize
@@ -25473,7 +25473,7 @@ this join type is good.
 Only rows that are in a given range will be retrieved, using an index to
 select the rows.  The @code{key} column indicates which index is used.
 The @code{key_len} contains the longest key part that was used.
-The @code{ref} column will be NULL for this type.
+The @code{ref} column will be @code{NULL} for this type.
 
 @item index
 This is the same as @code{ALL}, except that only the index tree is
@@ -25764,8 +25764,9 @@ Constant condition removal (needed because of constant folding):
 Constant expressions used by indexes are evaluated only once.
 @item
 @code{COUNT(*)} on a single table without a @code{WHERE} is retrieved
-directly from the table information for MyISAM and HEAP tables.  This is
-also done for any @code{NOT NULL} expression when used with only one table.
+directly from the table information for @code{MyISAM} and @code{HEAP} tables.
+This is also done for any @code{NOT NULL} expression when used with only one
+table.
 @item
 Early detection of invalid constant expressions. MySQL quickly
 detects that some @code{SELECT} statements are impossible and returns no rows.
@@ -25876,9 +25877,9 @@ the scanning of the not used tables as soon as it has found the first match.
 SELECT DISTINCT t1.a FROM t1,t2 where t1.a=t2.a;
 @end example
 
-In the case, assuming t1 is used before t2 (check with @code{EXPLAIN}), then
-MySQL will stop reading from t2 (for that particular row in t1)
-when the first row in t2 is found.
+In the case, assuming @code{t1} is used before @code{t2} (check with
+@code{EXPLAIN}), then MySQL will stop reading from @code{t2} (for that
+particular row in @code{t1}) when the first row in @code{t2} is found.
 
 
 @node LEFT JOIN optimisation, ORDER BY optimisation, DISTINCT optimisation, Query Speed
@@ -25996,7 +25997,7 @@ do the @code{ORDER BY}:
 
 @item
 You are joining many tables and the columns you are doing an @code{ORDER
-BY} on are not all from the first not-const table that is used to
+BY} on are not all from the first not-@code{const} table that is used to
 retrieve rows (This is the first table in the @code{EXPLAIN} output which
 doesn't use a @code{const} row fetch method).
 
@@ -26021,7 +26022,7 @@ algorithm:
 @itemize @bullet
 @item
 Read all rows according to key or by table scanning.
-Rows that doesn't match the WHERE clause are skipped.
+Rows that don't match the @code{WHERE} clause are skipped.
 @item
 Store the sort-key in a buffer (of size @code{sort_buffer}).
 @item
@@ -26196,11 +26197,11 @@ flush-tables}.
 
 Note that @code{LOAD DATA INFILE} also does the above optimisation if
 you insert into an empty table; the main difference with the above
-procedure is that you can let myisamchk allocate much more temporary
+procedure is that you can let @code{myisamchk} allocate much more temporary
 memory for the index creation that you may want MySQL to allocate for
 every index recreation.
 
-Since @strong{MySQL 4.0} you can also use
+Since MySQL 4.0 you can also use
 @code{ALTER TABLE tbl_name DISABLE KEYS} instead of
 @code{myisamchk --keys-used=0 -rq /path/to/db/tbl_name} and
 @code{ALTER TABLE tbl_name ENABLE KEYS} instead of
@@ -26303,8 +26304,8 @@ Always check that all your queries really use the indexes you have created
 in the tables. In MySQL you can do this with the @code{EXPLAIN}
 command. @xref{EXPLAIN, Explain, Explain, manual}.
 @item
-Try to avoid complex @code{SELECT} queries on MyISAM tables that are updated a
-lot. This is to avoid problems with table locking.
+Try to avoid complex @code{SELECT} queries on @code{MyISAM} tables that are
+updated a lot. This is to avoid problems with table locking.
 @item
 The new @code{MyISAM} tables can insert rows in a table without deleted
 rows at the same time another table is reading from it.  If this is important
@@ -26312,7 +26313,7 @@ for you, you should consider methods where you don't have to delete rows
 or run @code{OPTIMIZE TABLE} after you have deleted a lot of rows.
 @item
 Use @code{ALTER TABLE ... ORDER BY expr1,expr2...} if you mostly
-retrieve rows in expr1,expr2... order.  By using this option after big
+retrieve rows in @code{expr1,expr2...} order.  By using this option after big
 changes to the table, you may be able to get higher performance.
 @item
 In some cases it may make sense to introduce a column that is 'hashed'
@@ -26342,7 +26343,8 @@ introduce a new table and update the counter in real time. An update of
 type @code{UPDATE table set count=count+1 where index_column=constant}
 is very fast!
 
-This is really important when you use databases like MySQL that
+This is really important when you use MySQL table types like MyISAM and
+ISAM that
 only have table locking (multiple readers / single writers). This will
 also give better performance with most databases, as the row locking
 manager in this case will have less to do.
@@ -26580,7 +26582,7 @@ As updates on tables normally are considered to be more important than
 than statements that retrieve information from a table. This should
 ensure that updates are not 'starved' because one issues a lot of heavy
 queries against a specific table. (You can change this by using
-LOW_PRIORITY with the statement that does the update or
+@code{LOW_PRIORITY} with the statement that does the update or
 @code{HIGH_PRIORITY} with the @code{SELECT} statement.)
 
 Starting from MySQL Version 3.23.7 one can use the
@@ -26625,7 +26627,7 @@ You can give a specific @code{INSERT}, @code{UPDATE}, or @code{DELETE}
 statement lower priority with the @code{LOW_PRIORITY} attribute.
 
 @item
-Start @code{mysqld} with a low value for @strong{max_write_lock_count} to give
+Start @code{mysqld} with a low value for @code{max_write_lock_count} to give
 @code{READ} locks after a certain number of @code{WRITE} locks.
 
 @item
@@ -26750,7 +26752,7 @@ having it on all columns by default.
 If you don't have any variable-length columns (@code{VARCHAR},
 @code{TEXT}, or @code{BLOB} columns), a fixed-size record format is
 used. This is faster but unfortunately may waste some space.
-@xref{MyISAM table formats}.
+@xref{MyISAM table formats, , @code{MyISAM} table formats}.
 
 @item
 The primary index of a table should be as short as possible. This makes
@@ -27079,9 +27081,9 @@ MySQL is multi-threaded, so it may have many queries on the same table
 simultaneously. To minimise the problem with two threads having
 different states on the same file, the table is opened independently by
 each concurrent thread. This takes some memory but will normaly increase
-performance.  Wth ISAM and MyISAM tables this also requires one extra file
-descriptor for the datafile. With these table types the index file
-descriptor is shared between all threads.
+performance.  Wth @code{ISAM} and @code{MyISAM} tables this also requires
+one extra file descriptor for the datafile. With these table types the index
+file descriptor is shared between all threads.
 
 You can read more about this topic in the next section. @xref{Table cache}.
 
@@ -27114,7 +27116,7 @@ Make sure that your operating system can handle the number of open file
 descriptors implied by the @code{table_cache} setting.  If
 @code{table_cache} is set too high, MySQL may run out of file
 descriptors and refuse connections, fail to perform queries, and be very
-unreliable.  You also have to take into account that the MyISAM table
+unreliable.  You also have to take into account that the @code{MyISAM} table
 handler needs two file descriptors for each unique open table. You can
 in increase the number of file descriptors available for MySQL with
 the @code{--open-files-limit=#} startup option. @xref{Not enough file
@@ -27139,7 +27141,7 @@ a thread is no longer using a table.
 When someone executes @code{mysqladmin refresh} or
 @code{mysqladmin flush-tables}.
 @item
-When someone executes 'FLUSH TABLES'
+When someone executes a @code{FLUSH TABLES} statement.
 @end itemize
 
 When the table cache fills up, the server uses the following procedure
@@ -27491,7 +27493,7 @@ threads on a single processor. With more load/CPUs the difference should
 get bigger.
 
 @item
-Running with @code{--log-bin} makes @strong{[MySQL} 1% slower.
+Running with @code{--log-bin} makes MySQL 1% slower.
 
 @item
 Compiling on Linux-x86 using gcc without frame pointers
@@ -27535,8 +27537,8 @@ a query is running, a copy of the current query string is also allocated.
 All threads share the same base memory.
 
 @item
-Only the compressed ISAM / MyISAM tables are memory mapped.  This is
-because the 32-bit memory space of 4GB is not large enough for most
+Only the compressed @code{ISAM} / @code{MyISAM} tables are memory mapped.  This
+is because the 32-bit memory space of 4GB is not large enough for most
 big tables. When systems with a 64-bit address space become more
 common we may add general support for memory mapping.
 
@@ -27551,20 +27553,20 @@ random-read buffer is allocated to avoid disk seeks.
 
 @item
 All joins are done in one pass, and most joins can be done without even
-using a temporary table. Most temporary tables are memory-based (HEAP)
+using a temporary table. Most temporary tables are memory-based (@code{HEAP})
 tables.  Temporary tables with a big record length (calculated as the
 sum of all column lengths) or that contain @code{BLOB} columns are
 stored on disk.
 
-One problem in MySQL versions before Version 3.23.2 is that if a HEAP table
-exceeds the size of @code{tmp_table_size}, you get the error @code{The
+One problem in MySQL versions before Version 3.23.2 is that if a @code{HEAP}
+table exceeds the size of @code{tmp_table_size}, you get the error @code{The
 table tbl_name is full}. In newer versions this is handled by
-automatically changing the in-memory (HEAP) table to a disk-based
-(MyISAM) table as necessary. To work around this problem, you can
+automatically changing the in-memory (@code{HEAP}) table to a disk-based
+(@code{MyISAM}) table as necessary. To work around this problem, you can
 increase the temporary table size by setting the @code{tmp_table_size}
 option to @code{mysqld}, or by setting the SQL option
 @code{BIG_TABLES} in the client program.  @xref{SET OPTION, ,
-@code{SET}}. In MySQL Version 3.20, the maximum size of the
+@code{SET} Syntax}. In MySQL Version 3.20, the maximum size of the
 temporary table was @code{record_buffer*16}, so if you are using this
 version, you have to increase the value of @code{record_buffer}. You can
 also start @code{mysqld} with the @code{--big-tables} option to always
@@ -33529,7 +33531,7 @@ The given @code{key_string} will be used to crypt @code{string_to_encrypt}.
 The return string will be a binary string where the first character
 will be @code{CHAR(128 | key_number)}.
 
-The 128 is added to make it easier to recognize an encrypted key.
+The 128 is added to make it easier to recognise an encrypted key.
 If you use a string key, @code{key_number} will be 127.
 
 On error, this function returns @code{NULL}.
@@ -39798,7 +39800,7 @@ Use less locking: if you can afford a @code{SELECT} to return
 data from an old snapshot, do not add the clause
 @code{FOR UPDATE} or @code{LOCK IN SHARE MODE} to it. 
 @item
-If nothing helps, serialize your transactions with table level
+If nothing helps, serialise your transactions with table level
 locks: @code{LOCK TABLES t1 WRITE, t2 READ, ... ;
 [do something with tables t1 and t2 here]; UNLOCK TABLES.}
 Table level locks make you transactions to queue nicely,