1.9. MySQL Standards Compliance

MySQL 5.0

1.9. MySQL Standards Compliance

This section describes how MySQL relates to the ANSI/ISO SQL standards. MySQL Server has many extensions to the SQL standard, and here you can find out what they are and how to use them. You can also find information about functionality missing from MySQL Server, and how to work around some of the differences.

The SQL standard has been evolving since 1986 and several versions exist. In this manual, “SQL-92” refers to the standard released in 1992, “SQL:1999” refers to the standard released in 1999, and “SQL:2003” refers to the current version of the standard. We use the phrase “the SQL standard” or “standard SQL” to mean the current version of the SQL Standard at any time.

One of our main goals with the product is to continue to work toward compliance with the SQL standard, but without sacrificing speed or reliability. We are not afraid to add extensions to SQL or support for non-SQL features if this greatly increases the usability of MySQL Server for a large segment of our user base. The interface is an example of this strategy. See Section 13.2.3, “ Syntax”.

We continue to support transactional and non-transactional databases to satisfy both mission-critical 24/7 usage and heavy Web or logging usage.

MySQL Server was originally designed to work with medium-sized databases (10-100 million rows, or about 100MB per table) on small computer systems. Today MySQL Server handles terabyte-sized databases, but the code can also be compiled in a reduced version suitable for hand-held and embedded devices. The compact design of the MySQL server makes development in both directions possible without any conflicts in the source tree.

Currently, we are not targeting real-time support, although MySQL replication capabilities offer significant functionality.

MySQL supports high-availability database clustering using the storage engine. See Chapter 15, MySQL Cluster.

XML support is to be implemented in a future version of the database server.

1.9.1. What Standards MySQL Follows

Our aim is to support the full ANSI/ISO SQL standard, but without making concessions to speed and quality of the code.

ODBC levels 0-3.51.

1.9.2. Selecting SQL Modes

The MySQL server can operate in different SQL modes, and can apply these modes differentially for different clients. This capability enables each application to tailor the server's operating mode to its own requirements.

SQL modes control aspects of server operation such as what SQL syntax MySQL should support and what kind of data validation checks it should perform. This makes it easier to use MySQL in different environments and to use MySQL together with other database servers.

You can set the default SQL mode by starting mysqld with the " option. Beginning with MySQL 4.1, you can also change the mode at runtime by setting the system variable with a ' statement.

For more information on setting the SQL mode, see Section 5.2.5, “The Server SQL Mode”.

1.9.3. Running MySQL in ANSI Mode

You can tell mysqld to run in ANSI mode with the startup option. Running the server in ANSI mode is the same as starting it with the following options:

--transaction-isolation=SERIALIZABLE --sql-mode=ANSI

As of MySQL 4.1.1, you can achieve the same effect at runtime by executing these two statements:

SET GLOBAL sql_mode = 'ANSI';

You can see that setting the system variable to enables all SQL mode options that are relevant for ANSI mode as follows:


Note that running the server in ANSI mode with is not quite the same as setting the SQL mode to . The option affects the SQL mode and also sets the transaction isolation level. Setting the SQL mode to has no effect on the isolation level.

See Section 5.2.1, “mysqld Command Options”, and Section 1.9.2, “Selecting SQL Modes”.

1.9.4. MySQL Extensions to Standard SQL

MySQL Server supports some extensions that you probably won't find in other SQL DBMSs. Be warned that if you use them, your code won't be portable to other SQL servers. In some cases, you can write code that includes MySQL extensions, but is still portable, by using comments of the following form:

/*!  */

In this case, MySQL Server parses and executes the code within the comment as it would any other SQL statement, but other SQL servers will ignore the extensions. For example, MySQL Server recognizes the keyword in the following statement, but other servers will not:

SELECT /*! STRAIGHT_JOIN */ col1 FROM table1,table2 WHERE ...

If you add a version number after the ‘’ character, the syntax within the comment is executed only if the MySQL version is greater than or equal to the specified version number. The keyword in the following comment is executed only by servers from MySQL 3.23.02 or higher:


The following descriptions list MySQL extensions, organized by category.

  • Organization of data on disk

    MySQL Server maps each database to a directory under the MySQL data directory, and maps tables within a database to filenames in the database directory. This has a few implications:

    • Database and table names are case sensitive in MySQL Server on operating systems that have case-sensitive filenames (such as most Unix systems). See Section 9.2.2, “Identifier Case Sensitivity”.

    • You can use standard system commands to back up, rename, move, delete, and copy tables that are managed by the storage engine. For example, it is possible to rename a table by renaming the , , and files to which the table corresponds. (Nevertheless, it is preferable to use or and let the server rename the files.)

    Database and table names cannot contain pathname separator characters (‘’, ‘’).

  • General language syntax

    • By default, strings can be enclosed by either ‘’ or ‘’, not just by ‘’. (If the SQL mode is enabled, strings can be enclosed only by ‘’ and the server interprets strings enclosed by ‘’ as identifiers.)

    • ’ is the escape character in strings.

    • In SQL statements, you can access tables from different databases with the syntax. Some SQL servers provide the same functionality but call this . MySQL Server doesn't support tablespaces such as used in statements like this: .

  • SQL statement syntax

  • Data types

    • The , , and data types, and the various and data types.

    • The , , , , and data type attributes.

  • Functions and operators

    • To make it easier for users who migrate from other SQL environments, MySQL Server supports aliases for many functions. For example, all string functions support both standard SQL syntax and ODBC syntax.

    • MySQL Server understands the and operators to mean logical OR and AND, as in the C programming language. In MySQL Server, and are synonyms, as are and . Because of this nice syntax, MySQL Server doesn't support the standard SQL operator for string concatenation; use instead. Because takes any number of arguments, it's easy to convert use of the operator to MySQL Server.

    • Use of ) where has more than one element.

    • String comparisons are case-insensitive by default, with sort ordering determined by collation of the current character set, which is (cp1252 West European) by default. If you don't like this, you should declare your columns with the attribute or use the cast, which causes comparisons to be done using the underlying character code values rather then a lexical ordering.

    • The operator is a synonym for . That is, % is equivalent to ,). is supported for C programmers and for compatibility with PostgreSQL.

    • The , , ,, ,, , , , , , or operators may be used in expressions in the output column list (to the left of the ) in statements. For example:

    • The function returns the most recent value. See Section 12.9.3, “Information Functions”.

    • is allowed on numeric values.

    • The and extended regular expression operators.

    • or with one argument or more than two arguments. (In MySQL Server, these functions can take a variable number of arguments.)

    • The , , , , , , , , , , , , , , and functions.

    • Use of to trim substrings. Standard SQL supports removal of single characters only.

    • The functions , , , , and . See Section 12.10, “Functions and Modifiers for Use with Clauses”.

For a prioritized list indicating when new extensions are added to MySQL Server, you should consult the online MySQL development roadmap at http://dev.mysql.com/doc/mysql/en/roadmap.html.

1.9.5. MySQL Differences from Standard SQL

We try to make MySQL Server follow the ANSI SQL standard and the ODBC SQL standard, but MySQL Server performs operations differently in some cases:

  • For columns, trailing spaces are removed when the value is stored. (This is fixed in MySQL 5.0.3). See Section A.8, “Known Issues in MySQL”.

  • In some cases, columns are silently converted to columns when you define a table or alter its structure. (This is fixed in MySQL 5.0.3). See Section, “Silent Column Specification Changes”.

  • There are several differences between the MySQL and standard SQL privilege systems. For example, in MySQL, privileges for a table are not automatically revoked when you delete a table. You must explicitly issue a statement to revoke privileges for a table. For more information, see Section, “ Syntax”.

  • The function does not support cast to or . See Section 12.8, “Cast Functions and Operators”.

  • Standard SQL requires that a clause in a statement be able to refer to columns in the clause. This cannot be done before MySQL 5.0.2. Subquery Support

MySQL 4.1 and up supports subqueries and derived tables. A “subquery” is a statement nested within another statement. A “derived table” (an unnamed view) is a subquery in the clause of another statement. See Section 13.2.8, “Subquery Syntax”.

For MySQL versions older than 4.1, most subqueries can be rewritten using joins or other methods. See Section, “Rewriting Subqueries as Joins for Earlier MySQL Versions”, for examples that show how to do this. 

MySQL Server doesn't support the Sybase SQL extension. Instead, MySQL Server supports the standard SQL syntax, which is basically the same thing. See Section, “ Syntax”. For example:

INSERT INTO tbl_temp2 (fld_id)
    SELECT tbl_temp1.fld_order_id
    FROM tbl_temp1 WHERE tbl_temp1.fld_order_id > 100;

Alternatively, you can use or .

As of MySQL 5.0, you can use with user-defined variables. The same syntax can also be used inside stored routines using cursors and local variables. See Section, “ Statement”. Transactions and Atomic Operations

MySQL Server (version 3.23-max and all versions 4.0 and above) supports transactions with the and transactional storage engines. provides full compliance. See Chapter 14, Storage Engines and Table Types. For information about differences from standard SQL with regard to treatment of transaction errors, see Section 14.2.15, “ Error Handling”.

The other non-transactional storage engines in MySQL Server (such as ) follow a different paradigm for data integrity called “atomic operations.” In transactional terms, tables effectively always operate in mode. Atomic operations often offer comparable integrity with higher performance.

Because MySQL Server supports both paradigms, you can decide whether your applications are best served by the speed of atomic operations or the use of transactional features. This choice can be made on a per-table basis.

As noted, the trade-off for transactional versus non-transactional storage engines lies mostly in performance. Transactional tables have significantly higher memory and disk space requirements, and more CPU overhead. On the other hand, transactional storage engines such as also offer many significant features. MySQL Server's modular design allows the concurrent use of different storage engines to suit different requirements and deliver optimum performance in all situations.

But how do you use the features of MySQL Server to maintain rigorous integrity even with the non-transactional tables, and how do these features compare with the transactional storage engines?

  • If your applications are written in a way that is dependent on being able to call rather than in critical situations, transactions are more convenient. Transactions also ensure that unfinished updates or corrupting activities are not committed to the database; the server is given the opportunity to do an automatic rollback and your database is saved.

    If you use non-transactional tables, MySQL Server in almost all cases allows you to resolve potential problems by including simple checks before updates and by running simple scripts that check the databases for inconsistencies and automatically repair or warn if such an inconsistency occurs. Note that just by using the MySQL log or even adding one extra log, you can normally fix tables perfectly with no data integrity loss.

  • More often than not, critical transactional updates can be rewritten to be atomic. Generally speaking, all integrity problems that transactions solve can be done with or atomic updates, ensuring that there are no automatic aborts from the server, which is a common problem with transactional database systems.

  • To be safe with MySQL Server, regardless of whether you use transactional tables, you only need to have backups and have binary logging turned on. When that is true, you can recover from any situation that you could with any other transactional database system. It is always good to have backups, regardless of which database system you use.

The transactional paradigm has its benefits and its drawbacks. Many users and application developers depend on the ease with which they can code around problems where an abort appears to be necessary, or is necessary. However, even if you are new to the atomic operations paradigm, or more familiar with transactions, do consider the speed benefit that non-transactional tables can offer on the order of three to five times the speed of the fastest and most optimally tuned transactional tables.

In situations where integrity is of highest importance, MySQL Server offers transaction-level reliability and integrity even for non-transactional tables. If you lock tables with , all updates stall until integrity checks are made. If you obtain a lock (as opposed to a write lock) for a table that allows concurrent inserts at the end of the table, reads are allowed, as are inserts by other clients. The newly inserted records are not be seen by the client that has the read lock until it releases the lock. With , you can write inserts that go into a local queue until the locks are released, without having the client wait for the insert to complete. See Section 7.3.3, “Concurrent Inserts”, and Section, “ Syntax”.

Atomic,” in the sense that we mean it, is nothing magical. It only means that you can be sure that while each specific update is running, no other user can interfere with it, and there can never be an automatic rollback (which can happen with transactional tables if you are not very careful). MySQL Server also guarantees that there are no dirty reads.

Following are some techniques for working with non-transactional tables:

  • Loops that need transactions normally can be coded with the help of , and you don't need cursors to update records on the fly.

  • To avoid using , you can employ the following strategy:

    1. Use to lock all the tables you want to access.

    2. Test the conditions that must be true before performing the update.

    3. Update if the conditions are satisfied.

    4. Use to release your locks.

    This is usually a much faster method than using transactions with possible rollbacks, although not always. The only situation this solution doesn't handle is when someone kills the threads in the middle of an update. In that case, all locks are released but some of the updates may not have been executed.

  • You can also use functions to update records in a single operation. You can get a very efficient application by using the following techniques:

    • Modify columns relative to their current value.

    • Update only those columns that actually have changed.

    For example, when we are updating customer information, we update only the customer data that has changed and test only that none of the changed data, or data that depends on the changed data, has changed compared to the original row. The test for changed data is done with the clause in the statement. If the record wasn't updated, we give the client a message: “Some of the data you have changed has been changed by another user.” Then we show the old row versus the new row in a window so that the user can decide which version of the customer record to use.

    This gives us something that is similar to column locking but is actually even better because we only update some of the columns, using values that are relative to their current values. This means that typical statements look something like these:

    UPDATE tablename SET pay_back=pay_back+125;
    UPDATE customer
        address='new address',
        phone='new phone',
        customer_id=id AND address='old address' AND phone='old phone';

    This is very efficient and works even if another client has changed the values in the or columns.

  • In many cases, users have wanted or for the purpose of managing unique identifiers. This can be handled much more efficiently without locking or rolling back by using an column and either the SQL function or the C API function. See Section 12.9.3, “Information Functions”, and Section, “.

    You can generally code around the need for row-level locking. Some situations really do need it, and tables support row-level locking. Otherwise, with tables, you can use a flag column in the table and do something like the following:

    UPDATE  SET row_flag=1 WHERE id=ID;

    MySQL returns for the number of affected rows if the row was found and wasn't in the original row. You can think of this as though MySQL Server changed the preceding statement to:

    UPDATE  SET row_flag=1 WHERE id=ID AND row_flag <> 1; Stored Routines and Triggers

Stored procedures and functions are implemented beginning with MySQL 5.0. See Chapter 17, Stored Procedures and Functions.

Basic trigger functionality is implemented beginning with MySQL 5.0.2, with further development planned for MySQL 5.1. See Chapter 18, Triggers. Foreign Keys

In MySQL Server 3.23.44 and up, the storage engine supports checking of foreign key constraints, including , , and . See Section, “ Constraints”.

For storage engines other than , MySQL Server parses the syntax in statements, but does not use or store it. In the future, the implementation will be extended to store this information in the table specification file so that it may be retrieved by mysqldump and ODBC. At a later stage, foreign key constraints will be implemented for tables as well.

Foreign key enforcement offers several benefits to database developers:

  • Assuming proper design of the relationships, foreign key constraints make it more difficult for a programmer to introduce an inconsistency into the database.

  • Centralized checking of constraints by the database server makes it unnecessary to perform these checks on the application side. This eliminates the possibility that different applications may not all check the constraints in the same way.

  • Using cascading updates and deletes can simplify the application code.

  • Properly designed foreign key rules aid in documenting relationships between tables.

Do keep in mind that these benefits come at the cost of additional overhead for the database server to perform the necessary checks. Additional checking by the server affects performance, which for some applications may be sufficiently undesirable as to be avoided if possible. (Some major commercial applications have coded the foreign key logic at the application level for this reason.)

MySQL gives database developers the choice of which approach to use. If you don't need foreign keys and want to avoid the overhead associated with enforcing referential integrity, you can choose another storage engine instead, such as . (For example, the storage engine offers very fast performance for applications that perform only and operations. In this case, the table has no holes in the middle and the inserts can be performed concurrently with retrievals. See Section 7.3.3, “Concurrent Inserts”.)

If you choose not to take advantage of referential integrity checks, keep the following considerations in mind:

  • In the absence of server-side foreign key relationship checking, the application itself must handle relationship issues. For example, it must take care to insert rows into tables in the proper order, and to avoid creating orphaned child records. It must also be able to recover from errors that occur in the middle of multiple-record insert operations.

  • If is the only referential integrity capability an application needs, you can achieve a similar effect as of MySQL Server 4.0 by using multiple-table statements to delete rows from many tables with a single statement. See Section 13.2.1, “ Syntax”.

  • A workaround for the lack of is to add the appropriate statements to your application when you delete records from a table that has a foreign key. In practice, this is often as quick as using foreign keys and is more portable.

Be aware that the use of foreign keys can sometimes lead to problems:

  • Foreign key support addresses many referential integrity issues, but it is still necessary to design key relationships carefully to avoid circular rules or incorrect combinations of cascading deletes.

  • It is not uncommon for a DBA to create a topology of relationships that makes it difficult to restore individual tables from a backup. (MySQL alleviates this difficulty by allowing you to temporarily disable foreign key checks when reloading a table that depends on other tables. See Section, “ Constraints”. As of MySQL 4.1.1, mysqldump generates dump files that take advantage of this capability automatically when they are reloaded.)

Note that foreign keys in SQL are used to check and enforce referential integrity, not to join tables. If you want to get results from multiple tables from a statement, you do this by performing a join between them:

SELECT * FROM t1 INNER JOIN t2 ON t1.id = t2.id;

See Section, “ Syntax”, and Section 3.6.6, “Using Foreign Keys”.

The syntax without is often used by ODBC applications to produce automatic clauses. Views

Views (including updatable views) are implemented beginning with MySQL Server 5.0.1. See Chapter 19, Views.

Views are useful for allowing users to access a set of relations (tables) as if it were a single table, and limiting their access to just that. Views can also be used to restrict access to rows (a subset of a particular table). For access control to columns, you can also use the sophisticated privilege system in MySQL Server. See Section 5.8, “The MySQL Access Privilege System”.

In designing an implementation of views, our ambitious goal, as much as is possible within the confines of SQL, has been full compliance with “Codd's Rule #6” for relational database systems: “All views that are theoretically updatable, should in practice also be updatable. '' as the Start of a Comment

Standard SQL uses the C syntax for comments, and MySQL Server supports this syntax as well. MySQL also support extensions to this syntax that allow MySQL-specific SQL to be embedded in the comment, as described in Section 9.4, “Comment Syntax”.

Standard SQL uses ‘’ as a start-comment sequence. MySQL Server uses ‘’ as the start comment character. MySQL Server 3.23.3 and up also supports a variant of the ‘’ comment style. That is, the ‘’ start-comment sequence must be followed by a space (or by a control character such as a newline). The space is required to prevent problems with automatically generated SQL queries that use constructs such as the following, where we automatically insert the value of the payment for :

UPDATE account SET credit=credit-payment

Consider about what happens if has a negative value such as :

UPDATE account SET credit=credit--1

is a legal expression in SQL, but ‘’ is interpreted as the start of a comment, part of the expression is discarded. The result is a statement that has a completely different meaning than intended:

UPDATE account SET credit=credit

The statement produces no change in value at all. This illustrates that allowing comments to start with ‘’ can have serious consequences.

Using our implementation requires a space following the ‘’ in order for it to be recognized as a start-comment sequence in MySQL Server 3.23.3 and newer. Therefore, is safe to use.

Another safe feature is that the mysql command-line client ignores lines that start with ‘’.

The following information is relevant only if you are running a MySQL version earlier than 3.23.3:

If you have an SQL script in a text file that contains ‘’ comments, you should use the replace utility as follows to convert the comments to use ‘’ characters before executing the script:


That is safer than executing the script in the usual way:

shell>  < text-file-with-funny-comments.sql

You can also edit the script file “in place” to change the ‘’ comments to ‘’ comments:


Change them back with this command:


See Section 8.18, “replace — A String-Replacement Utility”.

1.9.6. How MySQL Deals with Constraints

MySQL allows you to work both with transactional tables that allow rollback and with non-transactional tables that do not. Because of this, constraint handling is a bit different in MySQL than in other DBMSs. We must handle the case when you have inserted or updated a lot of rows in a non-transactional table for which changes cannot be rolled back when an error occurs.

The basic philosophy is that MySQL Server tries to produce an error for anything that it can detect while parsing a statement to be executed, and tries to recover from any errors that occur while executing the statement. We do this in most cases, but not yet for all.

The options MySQL has when an error occurs are to stop the statement in the middle or to recover as well as possible from the problem and continue. By default, the server follows the latter course. This means, for example, that the server may coerce illegal values to the closest legal values.

Beginning with MySQL 5.0.2, several SQL mode options are available to provide greater control over handling of bad data values and whether to continue statement execution or abort when errors occur. Using these options, you can configure MySQL Server to act in a more traditional fashion that is like other DBMSs that reject improper input. The SQL mode can be set globally at server startup to affect all clients. Individual clients can set the SQL mode at runtime, which enables each client to select the behavior most appropriate for its requirements. See Section 5.2.5, “The Server SQL Mode”.

The following sections describe how MySQL Server handles different types of constraints.  and Index Constraints

Normally, an error occurs when you try to or a row that causes a primary key, unique key, or foreign key violation. If you are using a transactional storage engine such as , MySQL automatically rolls back the statement. If you are using a non-transactional storage engine, MySQL stops processing the statement at the row for which the error occurred and leaves any remaining rows unprocessed.

If you want to ignore such key violations, MySQL supports an keyword for and . In this case, MySQL ignores any key violations and continues processing with the next row. See Section 13.2.4, “ Syntax”, and Section 13.2.10, “ Syntax”.

You can get information about the number of rows actually inserted or updated with the C API function. In MySQL 4.1 and up, you also can use the statement. See Section, “, and Section, “ Syntax”.

Currently, only tables support foreign keys. See Section, “ Constraints”. Foreign key support in tables is scheduled for implementation in MySQL 5.2. See Section 1.6, “MySQL Development Roadmap”. Constraints on Invalid Data

Before MySQL 5.0.2, MySQL is forgiving of illegal or improper data values and coerces them to legal values for data entry. In MySQL 5.0.2 and up, that remains the default behavior, but you can change the server SQL mode to select more traditional treatment of bad values such that the server rejects them and aborts the statement in which they occur. Section 5.2.5, “The Server SQL Mode”.

This section describes the default (forgiving) behavior of MySQL, as well as the newer strict SQL mode and how it differs.

If you are not using strict mode, then whenever you insert an “incorrect” value into a column, such as a into a column or a too-large numeric value into a numeric column, MySQL sets the column to the “best possible value” instead of producing an error: The following rules describe in more detail how this works:

  • If you try to store an out of range value into a numeric column, MySQL Server instead stores zero, the smallest possible value, or the largest possible value, whichever is closest to the invalid value.

  • For strings, MySQL stores either the empty string or as much of the string as can be stored in the column.

  • If you try to store a string that doesn't start with a number into a numeric column, MySQL Server stores 0.

  • Invalid values for and columns ae handled as described in Section, “ and Constraints”.

  • MySQL allows you to store certain incorrect date values into and columns (such as or ). The idea is that it's not the job of the SQL server to validate dates. If MySQL can store a date value and retrieve exactly the same value, MySQL stores it as given. If the date is totally wrong (outside the server's ability to store it), the special “zero” date value is stored in the column instead.

  • If you try to store into a column that doesn't take values, an error occurs for single-row statements. For multiple-row statements or for statements, MySQL Server stores the implicit default value for the column data type. In general, this is for numeric types, the empty string () for string types, and the “zero” value for date and time types. Implicit default values are discussed in Section 11.1.4, “Data Type Default Values”.

  • If an statement specifies no value for a column, MySQL inserts its default value if the column definition includes an explicit clause. If the definition has no such clause, MySQL inserts the implicit default value for the column data type.

The reason for using the preceding rules in non-strict mode is that we can't check these conditions until the statement has begun executing. We can't just roll back if we encounter a problem after updating a few rows, because the storage engine may not support rollback. The option of terminating the statement is not that good; in this case, the update would be “half done,” which is probably the worst possible scenario. In this case, it's better to “do the best you can” and then continue as if nothing happened.

In MySQL 5.0.2 and up, you can select stricter treatment of input values by using the or SQL modes:


enables strict mode for transactional storage engines, and also to some extent for non-transactional engines. It works like this:

  • For transactional storage engines, bad data values occurring anywhere in a statement cause the statement to abort and roll back.

  • For non-transactional storage engines, a statement aborts if the error occurs in the first row to be inserted or updated. (When the error occurs in the first row, the statement can be aborted to leave the table unchanged, just as for a transactional table.) Errors in rows after the first do not abort the statement, because the table has already been changed by the first row. Instead, bad data values are adjusted and result in warnings rather than errors. In other words, with , a wrong value causes MySQL to roll back all updates done so far, if that can be done without changing the table. But once the table has been changed, further errors result in adjustments and warnings.

For even stricter checking, enable . This is the same as except that for non-transactional storage engines, errors abort the statement even for bad data in rows following the first row. This means that if an error occurs partway through a multiple-row insert or update for a non-transactional table, a partial update results. Earlier rows are inserted or updated, but those from the point of the error on are not. To avoid this for non-transactional tables, either use single-row statements or else use if conversion warnings rather than errors are acceptable. To avoid problems in the first place, do not use MySQL to check column content. It is safest (and often faster) to let the application ensure that it passes only legal values to the database.

With either of the strict mode options, you can cause errors to be treated as warnings by using or rather than or without .  and Constraints

and columns provide an efficient way to define columns that can contain only a given set of values. See Section 11.4.4, “The Type”, and Section 11.4.5, “The Type”. However, before MySQL 5.0.2, and columns do not provide true constraints on entry of invalid data:

  • columns always have a default value. If you specify no default value, then it is for columns that can have , otherwise it is the first enumeration value in the column definition.

  • If you insert an incorrect value into an column or if you force a value into an column with , it is set to the reserved enumeration value of , which is displayed as an empty string in string context.

  • If you insert an incorrect value into a column, the incorrect value is ignored. For example, if the column can contain the values , , and , an attempt to assign results in a value of .

As of MySQL 5.0.2, you can configure the server to use strict SQL mode. See Section 5.2.5, “The Server SQL Mode”. With strict mode enabled, the definition of a or column does act as a constraint on values entered into the column. An error occurs for values that do not satisfy these conditions:

  • An value must be one of those listed in the column definition, or the internal numeric equivalent thereof. The value cannot be the error value (that is, 0 or the empty string). For a column defined as , values such as , , or are illegal and are rejected.

  • A value must be the empty string or a value consisting only of the values listed in the column definition separated by commas. For a column defined as , values such as or are illegal and are rejected.

Errors for invalid values can be suppressed in strict mode if you use or . In this case, a warning is generated rather than an error. For , the value is inserted as the error member (). For , the value is inserted as given except that any invalid substrings are deleted. For example, results in a value of .