diff --git a/src/grammar/Sqlite3Parser.cpp b/src/grammar/Sqlite3Parser.cpp
index af2bf6b7..0d066120 100644
--- a/src/grammar/Sqlite3Parser.cpp
+++ b/src/grammar/Sqlite3Parser.cpp
@@ -1,4 +1,4 @@
-/* $ANTLR 2.7.7 (20130425): "sqlite3.g" -> "Sqlite3Parser.cpp"$ */
+/* $ANTLR 2.7.7 (20140222): "sqlite3.g" -> "Sqlite3Parser.cpp"$ */
 #include "Sqlite3Parser.hpp"
 #include <antlr/NoViableAltException.hpp>
 #include <antlr/SemanticException.hpp>
@@ -2816,11 +2816,11 @@ void Sqlite3Parser::expr() {
 				}
 			}
 			else {
-				goto _loop154;
+				goto _loop155;
 			}
 			
 		}
-		_loop154:;
+		_loop155:;
 		} // ( ... )*
 		expr_AST = currentAST.root;
 	}
@@ -2959,11 +2959,11 @@ void Sqlite3Parser::foreignkeyclause() {
 					}
 				}
 				else {
-					goto _loop136;
+					goto _loop137;
 				}
 				
 			}
-			_loop136:;
+			_loop137:;
 			} // ( ... )*
 			ANTLR_USE_NAMESPACE(antlr)RefAST tmp164_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
@@ -3146,17 +3146,17 @@ void Sqlite3Parser::foreignkeyclause() {
 			}
 			default:
 			{
-				goto _loop141;
+				goto _loop142;
 			}
 			}
 		}
-		_loop141:;
+		_loop142:;
 		} // ( ... )*
 		{
-		bool synPredMatched144 = false;
+		bool synPredMatched145 = false;
 		if (((LA(1) == NOT) && (LA(2) == DEFERRABLE))) {
-			int _m144 = mark();
-			synPredMatched144 = true;
+			int _m145 = mark();
+			synPredMatched145 = true;
 			inputState->guessing++;
 			try {
 				{
@@ -3165,12 +3165,12 @@ void Sqlite3Parser::foreignkeyclause() {
 				}
 			}
 			catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
-				synPredMatched144 = false;
+				synPredMatched145 = false;
 			}
-			rewind(_m144);
+			rewind(_m145);
 			inputState->guessing--;
 		}
-		if ( synPredMatched144 ) {
+		if ( synPredMatched145 ) {
 			ANTLR_USE_NAMESPACE(antlr)RefAST tmp177_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
 				tmp177_AST = astFactory->create(LT(1));
@@ -3319,6 +3319,29 @@ void Sqlite3Parser::indexedcolumn() {
 		if (inputState->guessing==0) {
 			astFactory->addASTChild( currentAST, returnAST );
 		}
+		{
+		switch ( LA(1)) {
+		case AUTOINCREMENT:
+		{
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp186_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			if ( inputState->guessing == 0 ) {
+				tmp186_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp186_AST);
+			}
+			match(AUTOINCREMENT);
+			break;
+		}
+		case RPAREN:
+		case COMMA:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
 		indexedcolumn_AST = currentAST.root;
 	}
 	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
@@ -3365,40 +3388,40 @@ void Sqlite3Parser::subexpr() {
 		switch ( LA(1)) {
 		case MINUS:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp186_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp187_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp186_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp186_AST);
+				tmp187_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp187_AST);
 			}
 			match(MINUS);
 			break;
 		}
 		case PLUS:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp187_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp188_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp187_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp187_AST);
+				tmp188_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp188_AST);
 			}
 			match(PLUS);
 			break;
 		}
 		case TILDE:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp188_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp189_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp188_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp188_AST);
+				tmp189_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp189_AST);
 			}
 			match(TILDE);
 			break;
 		}
 		case NOT:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp189_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp190_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp189_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp189_AST);
+				tmp190_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp190_AST);
 			}
 			match(NOT);
 			break;
@@ -3455,10 +3478,10 @@ void Sqlite3Parser::subexpr() {
 			switch ( LA(1)) {
 			case EXISTS:
 			{
-				ANTLR_USE_NAMESPACE(antlr)RefAST tmp190_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+				ANTLR_USE_NAMESPACE(antlr)RefAST tmp191_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 				if ( inputState->guessing == 0 ) {
-					tmp190_AST = astFactory->create(LT(1));
-					astFactory->addASTChild(currentAST, tmp190_AST);
+					tmp191_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, tmp191_AST);
 				}
 				match(EXISTS);
 				break;
@@ -3473,10 +3496,10 @@ void Sqlite3Parser::subexpr() {
 			}
 			}
 			}
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp191_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp192_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp191_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp191_AST);
+				tmp192_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp192_AST);
 			}
 			match(LPAREN);
 			{
@@ -3520,10 +3543,10 @@ void Sqlite3Parser::subexpr() {
 			}
 			}
 			}
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp192_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp193_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp192_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp192_AST);
+				tmp193_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp193_AST);
 			}
 			match(RPAREN);
 			break;
@@ -3554,10 +3577,10 @@ void Sqlite3Parser::subexpr() {
 						if (inputState->guessing==0) {
 							astFactory->addASTChild( currentAST, returnAST );
 						}
-						ANTLR_USE_NAMESPACE(antlr)RefAST tmp193_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+						ANTLR_USE_NAMESPACE(antlr)RefAST tmp194_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 						if ( inputState->guessing == 0 ) {
-							tmp193_AST = astFactory->create(LT(1));
-							astFactory->addASTChild(currentAST, tmp193_AST);
+							tmp194_AST = astFactory->create(LT(1));
+							astFactory->addASTChild(currentAST, tmp194_AST);
 						}
 						match(DOT);
 					}
@@ -3590,10 +3613,10 @@ void Sqlite3Parser::subexpr() {
 				if (inputState->guessing==0) {
 					astFactory->addASTChild( currentAST, returnAST );
 				}
-				ANTLR_USE_NAMESPACE(antlr)RefAST tmp194_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+				ANTLR_USE_NAMESPACE(antlr)RefAST tmp195_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 				if ( inputState->guessing == 0 ) {
-					tmp194_AST = astFactory->create(LT(1));
-					astFactory->addASTChild(currentAST, tmp194_AST);
+					tmp195_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, tmp195_AST);
 				}
 				match(LPAREN);
 				{
@@ -3624,10 +3647,10 @@ void Sqlite3Parser::subexpr() {
 					{ // ( ... )*
 					for (;;) {
 						if ((LA(1) == COMMA)) {
-							ANTLR_USE_NAMESPACE(antlr)RefAST tmp195_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+							ANTLR_USE_NAMESPACE(antlr)RefAST tmp196_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 							if ( inputState->guessing == 0 ) {
-								tmp195_AST = astFactory->create(LT(1));
-								astFactory->addASTChild(currentAST, tmp195_AST);
+								tmp196_AST = astFactory->create(LT(1));
+								astFactory->addASTChild(currentAST, tmp196_AST);
 							}
 							match(COMMA);
 							expr();
@@ -3636,11 +3659,11 @@ void Sqlite3Parser::subexpr() {
 							}
 						}
 						else {
-							goto _loop162;
+							goto _loop163;
 						}
 						
 					}
-					_loop162:;
+					_loop163:;
 					} // ( ... )*
 					break;
 				}
@@ -3654,10 +3677,10 @@ void Sqlite3Parser::subexpr() {
 				}
 				}
 				}
-				ANTLR_USE_NAMESPACE(antlr)RefAST tmp196_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+				ANTLR_USE_NAMESPACE(antlr)RefAST tmp197_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 				if ( inputState->guessing == 0 ) {
-					tmp196_AST = astFactory->create(LT(1));
-					astFactory->addASTChild(currentAST, tmp196_AST);
+					tmp197_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, tmp197_AST);
 				}
 				match(RPAREN);
 			}
@@ -3702,10 +3725,10 @@ void Sqlite3Parser::binaryoperator() {
 		switch ( LA(1)) {
 		case OROP:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp197_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp198_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp197_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp197_AST);
+				tmp198_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp198_AST);
 			}
 			match(OROP);
 			binaryoperator_AST = currentAST.root;
@@ -3713,10 +3736,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case STAR:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp198_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp199_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp198_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp198_AST);
+				tmp199_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp199_AST);
 			}
 			match(STAR);
 			binaryoperator_AST = currentAST.root;
@@ -3724,10 +3747,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case SLASH:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp199_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp200_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp199_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp199_AST);
+				tmp200_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp200_AST);
 			}
 			match(SLASH);
 			binaryoperator_AST = currentAST.root;
@@ -3735,10 +3758,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case PERCENT:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp200_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp201_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp200_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp200_AST);
+				tmp201_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp201_AST);
 			}
 			match(PERCENT);
 			binaryoperator_AST = currentAST.root;
@@ -3746,10 +3769,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case PLUS:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp201_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp202_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp201_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp201_AST);
+				tmp202_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp202_AST);
 			}
 			match(PLUS);
 			binaryoperator_AST = currentAST.root;
@@ -3757,10 +3780,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case MINUS:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp202_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp203_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp202_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp202_AST);
+				tmp203_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp203_AST);
 			}
 			match(MINUS);
 			binaryoperator_AST = currentAST.root;
@@ -3768,10 +3791,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case BITWISELEFT:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp203_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp204_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp203_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp203_AST);
+				tmp204_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp204_AST);
 			}
 			match(BITWISELEFT);
 			binaryoperator_AST = currentAST.root;
@@ -3779,10 +3802,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case BITWISERIGHT:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp204_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp205_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp204_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp204_AST);
+				tmp205_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp205_AST);
 			}
 			match(BITWISERIGHT);
 			binaryoperator_AST = currentAST.root;
@@ -3790,10 +3813,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case AMPERSAND:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp205_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp206_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp205_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp205_AST);
+				tmp206_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp206_AST);
 			}
 			match(AMPERSAND);
 			binaryoperator_AST = currentAST.root;
@@ -3801,10 +3824,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case BITOR:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp206_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp207_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp206_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp206_AST);
+				tmp207_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp207_AST);
 			}
 			match(BITOR);
 			binaryoperator_AST = currentAST.root;
@@ -3812,10 +3835,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case LOWER:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp207_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp208_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp207_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp207_AST);
+				tmp208_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp208_AST);
 			}
 			match(LOWER);
 			binaryoperator_AST = currentAST.root;
@@ -3823,10 +3846,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case LOWEREQUAL:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp208_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp209_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp208_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp208_AST);
+				tmp209_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp209_AST);
 			}
 			match(LOWEREQUAL);
 			binaryoperator_AST = currentAST.root;
@@ -3834,10 +3857,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case GREATER:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp209_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp210_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp209_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp209_AST);
+				tmp210_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp210_AST);
 			}
 			match(GREATER);
 			binaryoperator_AST = currentAST.root;
@@ -3845,10 +3868,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case GREATEREQUAL:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp210_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp211_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp210_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp210_AST);
+				tmp211_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp211_AST);
 			}
 			match(GREATEREQUAL);
 			binaryoperator_AST = currentAST.root;
@@ -3856,10 +3879,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case EQUAL:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp211_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp212_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp211_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp211_AST);
+				tmp212_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp212_AST);
 			}
 			match(EQUAL);
 			binaryoperator_AST = currentAST.root;
@@ -3867,10 +3890,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case EQUAL2:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp212_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp213_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp212_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp212_AST);
+				tmp213_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp213_AST);
 			}
 			match(EQUAL2);
 			binaryoperator_AST = currentAST.root;
@@ -3878,10 +3901,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case UNEQUAL:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp213_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp214_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp213_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp213_AST);
+				tmp214_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp214_AST);
 			}
 			match(UNEQUAL);
 			binaryoperator_AST = currentAST.root;
@@ -3889,10 +3912,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case UNEQUAL2:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp214_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp215_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp214_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp214_AST);
+				tmp215_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp215_AST);
 			}
 			match(UNEQUAL2);
 			binaryoperator_AST = currentAST.root;
@@ -3900,10 +3923,10 @@ void Sqlite3Parser::binaryoperator() {
 		}
 		case IS:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp215_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp216_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp215_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp215_AST);
+				tmp216_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp216_AST);
 			}
 			match(IS);
 			binaryoperator_AST = currentAST.root;
@@ -3944,29 +3967,19 @@ void Sqlite3Parser::castexpr() {
 	ANTLR_USE_NAMESPACE(antlr)RefAST castexpr_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 	
 	try {      // for error handling
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp216_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
-		if ( inputState->guessing == 0 ) {
-			tmp216_AST = astFactory->create(LT(1));
-			astFactory->addASTChild(currentAST, tmp216_AST);
-		}
-		match(CAST);
 		ANTLR_USE_NAMESPACE(antlr)RefAST tmp217_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 		if ( inputState->guessing == 0 ) {
 			tmp217_AST = astFactory->create(LT(1));
 			astFactory->addASTChild(currentAST, tmp217_AST);
 		}
-		match(LPAREN);
-		expr();
-		if (inputState->guessing==0) {
-			astFactory->addASTChild( currentAST, returnAST );
-		}
+		match(CAST);
 		ANTLR_USE_NAMESPACE(antlr)RefAST tmp218_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 		if ( inputState->guessing == 0 ) {
 			tmp218_AST = astFactory->create(LT(1));
 			astFactory->addASTChild(currentAST, tmp218_AST);
 		}
-		match(AS);
-		type_name();
+		match(LPAREN);
+		expr();
 		if (inputState->guessing==0) {
 			astFactory->addASTChild( currentAST, returnAST );
 		}
@@ -3975,6 +3988,16 @@ void Sqlite3Parser::castexpr() {
 			tmp219_AST = astFactory->create(LT(1));
 			astFactory->addASTChild(currentAST, tmp219_AST);
 		}
+		match(AS);
+		type_name();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild( currentAST, returnAST );
+		}
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp220_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+		if ( inputState->guessing == 0 ) {
+			tmp220_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, tmp220_AST);
+		}
 		match(RPAREN);
 		castexpr_AST = currentAST.root;
 	}
@@ -3995,10 +4018,10 @@ void Sqlite3Parser::caseexpr() {
 	ANTLR_USE_NAMESPACE(antlr)RefAST caseexpr_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 	
 	try {      // for error handling
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp220_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp221_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 		if ( inputState->guessing == 0 ) {
-			tmp220_AST = astFactory->create(LT(1));
-			astFactory->addASTChild(currentAST, tmp220_AST);
+			tmp221_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, tmp221_AST);
 		}
 		match(CASE_T);
 		{
@@ -4039,23 +4062,23 @@ void Sqlite3Parser::caseexpr() {
 		}
 		}
 		{ // ( ... )+
-		int _cnt170=0;
+		int _cnt171=0;
 		for (;;) {
 			if ((LA(1) == WHEN)) {
-				ANTLR_USE_NAMESPACE(antlr)RefAST tmp221_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+				ANTLR_USE_NAMESPACE(antlr)RefAST tmp222_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 				if ( inputState->guessing == 0 ) {
-					tmp221_AST = astFactory->create(LT(1));
-					astFactory->addASTChild(currentAST, tmp221_AST);
+					tmp222_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, tmp222_AST);
 				}
 				match(WHEN);
 				expr();
 				if (inputState->guessing==0) {
 					astFactory->addASTChild( currentAST, returnAST );
 				}
-				ANTLR_USE_NAMESPACE(antlr)RefAST tmp222_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+				ANTLR_USE_NAMESPACE(antlr)RefAST tmp223_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 				if ( inputState->guessing == 0 ) {
-					tmp222_AST = astFactory->create(LT(1));
-					astFactory->addASTChild(currentAST, tmp222_AST);
+					tmp223_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, tmp223_AST);
 				}
 				match(THEN);
 				expr();
@@ -4064,21 +4087,21 @@ void Sqlite3Parser::caseexpr() {
 				}
 			}
 			else {
-				if ( _cnt170>=1 ) { goto _loop170; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+				if ( _cnt171>=1 ) { goto _loop171; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
 			}
 			
-			_cnt170++;
+			_cnt171++;
 		}
-		_loop170:;
+		_loop171:;
 		}  // ( ... )+
 		{
 		switch ( LA(1)) {
 		case ELSE_T:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp223_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp224_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp223_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp223_AST);
+				tmp224_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp224_AST);
 			}
 			match(ELSE_T);
 			expr();
@@ -4097,10 +4120,10 @@ void Sqlite3Parser::caseexpr() {
 		}
 		}
 		}
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp224_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp225_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 		if ( inputState->guessing == 0 ) {
-			tmp224_AST = astFactory->create(LT(1));
-			astFactory->addASTChild(currentAST, tmp224_AST);
+			tmp225_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, tmp225_AST);
 		}
 		match(END);
 		caseexpr_AST = currentAST.root;
@@ -4122,26 +4145,26 @@ void Sqlite3Parser::raisefunction() {
 	ANTLR_USE_NAMESPACE(antlr)RefAST raisefunction_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 	
 	try {      // for error handling
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp225_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
-		if ( inputState->guessing == 0 ) {
-			tmp225_AST = astFactory->create(LT(1));
-			astFactory->addASTChild(currentAST, tmp225_AST);
-		}
-		match(RAISE);
 		ANTLR_USE_NAMESPACE(antlr)RefAST tmp226_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 		if ( inputState->guessing == 0 ) {
 			tmp226_AST = astFactory->create(LT(1));
 			astFactory->addASTChild(currentAST, tmp226_AST);
 		}
+		match(RAISE);
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp227_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+		if ( inputState->guessing == 0 ) {
+			tmp227_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, tmp227_AST);
+		}
 		match(LPAREN);
 		{
 		switch ( LA(1)) {
 		case IGNORE:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp227_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp228_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp227_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp227_AST);
+				tmp228_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp228_AST);
 			}
 			match(IGNORE);
 			break;
@@ -4154,30 +4177,30 @@ void Sqlite3Parser::raisefunction() {
 			switch ( LA(1)) {
 			case ROLLBACK:
 			{
-				ANTLR_USE_NAMESPACE(antlr)RefAST tmp228_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+				ANTLR_USE_NAMESPACE(antlr)RefAST tmp229_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 				if ( inputState->guessing == 0 ) {
-					tmp228_AST = astFactory->create(LT(1));
-					astFactory->addASTChild(currentAST, tmp228_AST);
+					tmp229_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, tmp229_AST);
 				}
 				match(ROLLBACK);
 				break;
 			}
 			case ABORT:
 			{
-				ANTLR_USE_NAMESPACE(antlr)RefAST tmp229_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+				ANTLR_USE_NAMESPACE(antlr)RefAST tmp230_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 				if ( inputState->guessing == 0 ) {
-					tmp229_AST = astFactory->create(LT(1));
-					astFactory->addASTChild(currentAST, tmp229_AST);
+					tmp230_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, tmp230_AST);
 				}
 				match(ABORT);
 				break;
 			}
 			case FAIL:
 			{
-				ANTLR_USE_NAMESPACE(antlr)RefAST tmp230_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+				ANTLR_USE_NAMESPACE(antlr)RefAST tmp231_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 				if ( inputState->guessing == 0 ) {
-					tmp230_AST = astFactory->create(LT(1));
-					astFactory->addASTChild(currentAST, tmp230_AST);
+					tmp231_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, tmp231_AST);
 				}
 				match(FAIL);
 				break;
@@ -4188,17 +4211,17 @@ void Sqlite3Parser::raisefunction() {
 			}
 			}
 			}
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp231_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
-			if ( inputState->guessing == 0 ) {
-				tmp231_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp231_AST);
-			}
-			match(COMMA);
 			ANTLR_USE_NAMESPACE(antlr)RefAST tmp232_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
 				tmp232_AST = astFactory->create(LT(1));
 				astFactory->addASTChild(currentAST, tmp232_AST);
 			}
+			match(COMMA);
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp233_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			if ( inputState->guessing == 0 ) {
+				tmp233_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp233_AST);
+			}
 			match(STRINGLITERAL);
 			break;
 		}
@@ -4208,10 +4231,10 @@ void Sqlite3Parser::raisefunction() {
 		}
 		}
 		}
-		ANTLR_USE_NAMESPACE(antlr)RefAST tmp233_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+		ANTLR_USE_NAMESPACE(antlr)RefAST tmp234_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 		if ( inputState->guessing == 0 ) {
-			tmp233_AST = astFactory->create(LT(1));
-			astFactory->addASTChild(currentAST, tmp233_AST);
+			tmp234_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, tmp234_AST);
 		}
 		match(RPAREN);
 		raisefunction_AST = currentAST.root;
@@ -4236,10 +4259,10 @@ void Sqlite3Parser::suffixexpr() {
 		switch ( LA(1)) {
 		case COLLATE:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp234_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp235_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp234_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp234_AST);
+				tmp235_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp235_AST);
 			}
 			match(COLLATE);
 			collationname();
@@ -4261,10 +4284,10 @@ void Sqlite3Parser::suffixexpr() {
 			switch ( LA(1)) {
 			case NOT:
 			{
-				ANTLR_USE_NAMESPACE(antlr)RefAST tmp235_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+				ANTLR_USE_NAMESPACE(antlr)RefAST tmp236_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 				if ( inputState->guessing == 0 ) {
-					tmp235_AST = astFactory->create(LT(1));
-					astFactory->addASTChild(currentAST, tmp235_AST);
+					tmp236_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, tmp236_AST);
 				}
 				match(NOT);
 				break;
@@ -4288,10 +4311,10 @@ void Sqlite3Parser::suffixexpr() {
 			switch ( LA(1)) {
 			case BETWEEN:
 			{
-				ANTLR_USE_NAMESPACE(antlr)RefAST tmp236_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+				ANTLR_USE_NAMESPACE(antlr)RefAST tmp237_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 				if ( inputState->guessing == 0 ) {
-					tmp236_AST = astFactory->create(LT(1));
-					astFactory->addASTChild(currentAST, tmp236_AST);
+					tmp237_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, tmp237_AST);
 				}
 				match(BETWEEN);
 				subexpr();
@@ -4335,10 +4358,10 @@ void Sqlite3Parser::suffixexpr() {
 						}
 						case OR:
 						{
-							ANTLR_USE_NAMESPACE(antlr)RefAST tmp237_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+							ANTLR_USE_NAMESPACE(antlr)RefAST tmp238_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 							if ( inputState->guessing == 0 ) {
-								tmp237_AST = astFactory->create(LT(1));
-								astFactory->addASTChild(currentAST, tmp237_AST);
+								tmp238_AST = astFactory->create(LT(1));
+								astFactory->addASTChild(currentAST, tmp238_AST);
 							}
 							match(OR);
 							break;
@@ -4355,16 +4378,16 @@ void Sqlite3Parser::suffixexpr() {
 						}
 					}
 					else {
-						goto _loop181;
+						goto _loop182;
 					}
 					
 				}
-				_loop181:;
+				_loop182:;
 				} // ( ... )*
-				ANTLR_USE_NAMESPACE(antlr)RefAST tmp238_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+				ANTLR_USE_NAMESPACE(antlr)RefAST tmp239_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 				if ( inputState->guessing == 0 ) {
-					tmp238_AST = astFactory->create(LT(1));
-					astFactory->addASTChild(currentAST, tmp238_AST);
+					tmp239_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, tmp239_AST);
 				}
 				match(AND);
 				expr();
@@ -4375,20 +4398,20 @@ void Sqlite3Parser::suffixexpr() {
 			}
 			case IN:
 			{
-				ANTLR_USE_NAMESPACE(antlr)RefAST tmp239_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+				ANTLR_USE_NAMESPACE(antlr)RefAST tmp240_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 				if ( inputState->guessing == 0 ) {
-					tmp239_AST = astFactory->create(LT(1));
-					astFactory->addASTChild(currentAST, tmp239_AST);
+					tmp240_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, tmp240_AST);
 				}
 				match(IN);
 				{
 				switch ( LA(1)) {
 				case LPAREN:
 				{
-					ANTLR_USE_NAMESPACE(antlr)RefAST tmp240_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+					ANTLR_USE_NAMESPACE(antlr)RefAST tmp241_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 					if ( inputState->guessing == 0 ) {
-						tmp240_AST = astFactory->create(LT(1));
-						astFactory->addASTChild(currentAST, tmp240_AST);
+						tmp241_AST = astFactory->create(LT(1));
+						astFactory->addASTChild(currentAST, tmp241_AST);
 					}
 					match(LPAREN);
 					{
@@ -4427,10 +4450,10 @@ void Sqlite3Parser::suffixexpr() {
 						{ // ( ... )*
 						for (;;) {
 							if ((LA(1) == COMMA)) {
-								ANTLR_USE_NAMESPACE(antlr)RefAST tmp241_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+								ANTLR_USE_NAMESPACE(antlr)RefAST tmp242_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 								if ( inputState->guessing == 0 ) {
-									tmp241_AST = astFactory->create(LT(1));
-									astFactory->addASTChild(currentAST, tmp241_AST);
+									tmp242_AST = astFactory->create(LT(1));
+									astFactory->addASTChild(currentAST, tmp242_AST);
 								}
 								match(COMMA);
 								expr();
@@ -4439,11 +4462,11 @@ void Sqlite3Parser::suffixexpr() {
 								}
 							}
 							else {
-								goto _loop185;
+								goto _loop186;
 							}
 							
 						}
-						_loop185:;
+						_loop186:;
 						} // ( ... )*
 						break;
 					}
@@ -4457,10 +4480,10 @@ void Sqlite3Parser::suffixexpr() {
 					}
 					}
 					}
-					ANTLR_USE_NAMESPACE(antlr)RefAST tmp242_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+					ANTLR_USE_NAMESPACE(antlr)RefAST tmp243_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 					if ( inputState->guessing == 0 ) {
-						tmp242_AST = astFactory->create(LT(1));
-						astFactory->addASTChild(currentAST, tmp242_AST);
+						tmp243_AST = astFactory->create(LT(1));
+						astFactory->addASTChild(currentAST, tmp243_AST);
 					}
 					match(RPAREN);
 					break;
@@ -4499,10 +4522,10 @@ void Sqlite3Parser::suffixexpr() {
 				}
 				{
 				if ((LA(1) == ESCAPE) && (_tokenSet_22.member(LA(2)))) {
-					ANTLR_USE_NAMESPACE(antlr)RefAST tmp243_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+					ANTLR_USE_NAMESPACE(antlr)RefAST tmp244_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 					if ( inputState->guessing == 0 ) {
-						tmp243_AST = astFactory->create(LT(1));
-						astFactory->addASTChild(currentAST, tmp243_AST);
+						tmp244_AST = astFactory->create(LT(1));
+						astFactory->addASTChild(currentAST, tmp244_AST);
 					}
 					match(ESCAPE);
 					subexpr();
@@ -4554,10 +4577,10 @@ void Sqlite3Parser::like_operator() {
 		switch ( LA(1)) {
 		case LIKE:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp244_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp245_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp244_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp244_AST);
+				tmp245_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp245_AST);
 			}
 			match(LIKE);
 			like_operator_AST = currentAST.root;
@@ -4565,10 +4588,10 @@ void Sqlite3Parser::like_operator() {
 		}
 		case GLOB:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp245_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp246_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp245_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp245_AST);
+				tmp246_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp246_AST);
 			}
 			match(GLOB);
 			like_operator_AST = currentAST.root;
@@ -4576,10 +4599,10 @@ void Sqlite3Parser::like_operator() {
 		}
 		case REGEXP:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp246_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp247_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp246_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp246_AST);
+				tmp247_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp247_AST);
 			}
 			match(REGEXP);
 			like_operator_AST = currentAST.root;
@@ -4587,10 +4610,10 @@ void Sqlite3Parser::like_operator() {
 		}
 		case MATCH:
 		{
-			ANTLR_USE_NAMESPACE(antlr)RefAST tmp247_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+			ANTLR_USE_NAMESPACE(antlr)RefAST tmp248_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 			if ( inputState->guessing == 0 ) {
-				tmp247_AST = astFactory->create(LT(1));
-				astFactory->addASTChild(currentAST, tmp247_AST);
+				tmp248_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, tmp248_AST);
 			}
 			match(MATCH);
 			like_operator_AST = currentAST.root;
@@ -4624,13 +4647,13 @@ void Sqlite3Parser::between_subexpr() {
 			astFactory->addASTChild( currentAST, returnAST );
 		}
 		{ // ( ... )+
-		int _cnt175=0;
+		int _cnt176=0;
 		for (;;) {
 			if ((LA(1) == AND)) {
-				ANTLR_USE_NAMESPACE(antlr)RefAST tmp248_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
+				ANTLR_USE_NAMESPACE(antlr)RefAST tmp249_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
 				if ( inputState->guessing == 0 ) {
-					tmp248_AST = astFactory->create(LT(1));
-					astFactory->addASTChild(currentAST, tmp248_AST);
+					tmp249_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, tmp249_AST);
 				}
 				match(AND);
 				subexpr();
@@ -4639,12 +4662,12 @@ void Sqlite3Parser::between_subexpr() {
 				}
 			}
 			else {
-				if ( _cnt175>=1 ) { goto _loop175; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+				if ( _cnt176>=1 ) { goto _loop176; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
 			}
 			
-			_cnt175++;
+			_cnt176++;
 		}
-		_loop175:;
+		_loop176:;
 		}  // ( ... )+
 		between_subexpr_AST = currentAST.root;
 	}
@@ -4774,13 +4797,14 @@ const char* Sqlite3Parser::tokenNames[] = {
 	0
 };
 
-const unsigned long Sqlite3Parser::_tokenSet_0_data_[] = { 1904905858UL, 1614211211UL, 4223417345UL, 1791UL, 0UL, 0UL, 0UL, 0UL };
-// EOF "AS" "AND" "OR" "BETWEEN" "CHECK" "COLLATE" "CONSTRAINT" "DEFAULT" 
-// "DEFERRABLE" "ELSE" "END" "ESCAPE" "FOREIGN" "GLOB" "LIKE" "IN" "IS" 
-// "NOT" "NULL" "MATCH" "ON" "PRIMARY" "REFERENCES" "REGEXP" "THEN" "UNIQUE" 
-// "WHEN" DOT ID QUOTEDID QUOTEDLITERAL STRINGLITERAL LPAREN RPAREN COMMA 
-// PLUS MINUS STAR AMPERSAND BITOR OROP EQUAL EQUAL2 GREATER GREATEREQUAL 
-// LOWER LOWEREQUAL UNEQUAL UNEQUAL2 BITWISELEFT BITWISERIGHT SLASH PERCENT 
+const unsigned long Sqlite3Parser::_tokenSet_0_data_[] = { 1904905922UL, 1614211211UL, 4223417345UL, 1791UL, 0UL, 0UL, 0UL, 0UL };
+// EOF "AUTOINCREMENT" "AS" "AND" "OR" "BETWEEN" "CHECK" "COLLATE" "CONSTRAINT" 
+// "DEFAULT" "DEFERRABLE" "ELSE" "END" "ESCAPE" "FOREIGN" "GLOB" "LIKE" 
+// "IN" "IS" "NOT" "NULL" "MATCH" "ON" "PRIMARY" "REFERENCES" "REGEXP" 
+// "THEN" "UNIQUE" "WHEN" DOT ID QUOTEDID QUOTEDLITERAL STRINGLITERAL LPAREN 
+// RPAREN COMMA PLUS MINUS STAR AMPERSAND BITOR OROP EQUAL EQUAL2 GREATER 
+// GREATEREQUAL LOWER LOWEREQUAL UNEQUAL UNEQUAL2 BITWISELEFT BITWISERIGHT 
+// SLASH PERCENT 
 const ANTLR_USE_NAMESPACE(antlr)BitSet Sqlite3Parser::_tokenSet_0(_tokenSet_0_data_,8);
 const unsigned long Sqlite3Parser::_tokenSet_1_data_[] = { 0UL, 0UL, 1024UL, 0UL, 0UL, 0UL, 0UL, 0UL };
 // DOT 
diff --git a/src/grammar/sqlite3.g b/src/grammar/sqlite3.g
index ee1261ae..17f1464d 100644
--- a/src/grammar/sqlite3.g
+++ b/src/grammar/sqlite3.g
@@ -359,11 +359,12 @@ tableconstraint
   )
   {#tableconstraint = #([TABLECONSTRAINT, "TABLECONSTRAINT"], #tableconstraint);}
   ;
-	
+
 indexedcolumn
-  : id	
+  :
+  id (AUTOINCREMENT)?
   ;
-	
+
 conflictclause
   :
   ON CONFLICT
diff --git a/src/sqlitetypes.cpp b/src/sqlitetypes.cpp
index 8f773300..9516ed74 100644
--- a/src/sqlitetypes.cpp
+++ b/src/sqlitetypes.cpp
@@ -318,10 +318,17 @@ Table CreateTableWalker::table()
                         int fieldindex = tab.findField(col);
                         if(fieldindex != -1)
                             tab.fields().at(fieldindex)->setPrimaryKey(true);
-                        do
+
+                        tc = tc->getNextSibling();
+                        if(tc != antlr::nullAST && tc->getType() == sqlite3TokenTypes::AUTOINCREMENT)
+                        {
+                            tab.fields().at(fieldindex)->setAutoIncrement(true);
+                            tc = tc->getNextSibling();
+                        }
+                        while(tc != antlr::nullAST && tc->getType() == sqlite3TokenTypes::COMMA)
                         {
                             tc = tc->getNextSibling(); // skip ident and comma
-                        } while(tc->getType() == sqlite3TokenTypes::COMMA);
+                        }
                     } while(tc != antlr::nullAST && tc->getType() != sqlite3TokenTypes::RPAREN);
                 }
                 break;