| CHECK constraints |  | CHECK constraints are parsed but they are not
                  enforced. NOT NULL and UNIQUE constraints are enforced,
                  however. | 
              
                | Variable subqueries |  | Subqueries must be static. They are evaluated
                  only once. They may not, therefore, refer to variables in the
                  main query. | 
              
                | FOREIGN KEY constraints |  | FOREIGN KEY constraints are parsed but are not
                  enforced. | 
              
                | Complete trigger support |  | There is some support for triggers but it is
                  not complete. Missing subfeatures include FOR EACH STATEMENT
                  triggers (currently all triggers must be FOR EACH ROW),
                  INSTEAD OF triggers on tables (currently INSTEAD OF triggers
                  are only allowed on views), and recursive triggers - triggers
                  that trigger themselves. | 
              
                | ALTER TABLE |  | To change a table you have to delete it (saving
                  its contents to a temporary table) and recreate it from
                  scratch. | 
              
                | Nested transactions |  | The current implementation only allows a single
                  active transaction. | 
              
                | The COUNT(DISTINCT X) function |  | You can accomplish the same thing using a
                  subquery, like this: SELECT count(x) FROM (SELECT DISTINCT x FROM tbl);
 | 
              
                | RIGHT and FULL OUTER JOIN |  | LEFT OUTER JOIN is implemented, but not RIGHT
                  OUTER JOIN or FULL OUTER JOIN. | 
              
                | Writing to VIEWs |  | VIEWs in SQLite are read-only. You may not
                  execute a DELETE, INSERT, or UPDATE statement on a view. But
                  you can create a trigger that fires on an attempt to DELETE,
                  INSERT, or UPDATE a view and do what you need in the body of
                  the trigger. | 
              
                | GRANT and REVOKE |  | Since SQLite reads and writes an ordinary disk
                  file, the only access permissions that can be applied are the
                  normal file access permissions of the underlying operating
                  system. The GRANT and REVOKE commands commonly found on
                  client/server RDBMSes are not implemented because they would
                  be meaningless for an embedded database engine. |