Repository: tomarrell/lbadd
Pull request #96 (2020-03-26 14:14:31)

implements more statements branching from create table
This PR completes the implementation of many statements branching from create table, as specified in #66.


Patch:
diff --git a/go.mod b/go.mod
index 2526f1a..6c38e21 100644
--- a/go.mod
+++ b/go.mod
@@ -11,7 +11,7 @@ require (
 	github.com/spf13/cobra v0.0.6
 	github.com/stretchr/testify v1.4.0
 	golang.org/x/text v0.3.2
-	golang.org/x/tools v0.0.0-20190828213141-aed303cbaa74
+	golang.org/x/tools v0.0.0-20200328031815-3db5fc6bac03
 	gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect
 	gopkg.in/yaml.v2 v2.2.8 // indirect
 )
diff --git a/go.sum b/go.sum
index cb562ef..71ab1ed 100644
--- a/go.sum
+++ b/go.sum
@@ -118,6 +118,7 @@ github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1
 github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/zenazn/goji v0.9.0/go.mod h1:7S9M489iMyHBNxwZnk9/EHS098H4/F6TATF2mIxtB1Q=
 go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
@@ -125,10 +126,13 @@ go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200311171314-f7b00557c8c4 h1:QmwruyY+bKbDDL0BaglrbZABEali68eoMFhTZpCjYVA=
 golang.org/x/crypto v0.0.0-20200311171314-f7b00557c8c4/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/mod v0.2.0 h1:KU7oHjnv3XNWfa5COkzUifxZmxp1TyI7ImMXqFxLwvQ=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -136,11 +140,13 @@ golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -161,7 +167,11 @@ golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190828213141-aed303cbaa74 h1:4cFkmztxtMslUX2SctSl+blCyXfpzhGOy9LhKAqSMA4=
 golang.org/x/tools v0.0.0-20190828213141-aed303cbaa74/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200328031815-3db5fc6bac03 h1:XpToik3MpT5iW3iHgNwnh3a8QwugfomvxOlyDnaOils=
+golang.org/x/tools v0.0.0-20200328031815-3db5fc6bac03/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
diff --git a/internal/parser/ast/statement.go b/internal/parser/ast/statement.go
index c3a00fb..5e20a02 100644
--- a/internal/parser/ast/statement.go
+++ b/internal/parser/ast/statement.go
@@ -661,28 +661,33 @@ type (
 
 	// ForeignKeyClause as in the SQLite grammar.
 	ForeignKeyClause struct {
-		References   token.Token
-		ForeignTable token.Token
-		LeftParen    token.Token
-		ColumnName   []token.Token
-		RightParen   token.Token
-		On           token.Token
-		Delete       token.Token
-		Update       token.Token
-		Set          token.Token
-		Null         token.Token
-		Default      token.Token
-		Cascade      token.Token
-		Restrict     token.Token
-		No           token.Token
-		Action       token.Token
-		Match        token.Token
-		Name         token.Token
-		Not          token.Token
-		Deferrable   token.Token
-		Initially    token.Token
-		Deferred     token.Token
-		Immediate    token.Token
+		References           token.Token
+		ForeignTable         token.Token
+		LeftParen            token.Token
+		ColumnName           []token.Token
+		RightParen           token.Token
+		ForeignKeyClauseCore []*ForeignKeyClauseCore
+		Not                  token.Token
+		Deferrable           token.Token
+		Initially            token.Token
+		Deferred             token.Token
+		Immediate            token.Token
+	}
+
+	// ForeignKeyClauseCore as in the SQLite grammar.
+	ForeignKeyClauseCore struct {
+		On       token.Token
+		Delete   token.Token
+		Update   token.Token
+		Set      token.Token
+		Null     token.Token
+		Default  token.Token
+		Cascade  token.Token
+		Restrict token.Token
+		No       token.Token
+		Action   token.Token
+		Match    token.Token
+		Name     token.Token
 	}
 
 	// CommonTableExpression as in the SQLite grammar.
@@ -784,7 +789,7 @@ type (
 		Expr             *Expr
 		RightParen       token.Token
 		Default          token.Token
-		SignedNumber     token.Token
+		SignedNumber     *SignedNumber
 		LiteralValue     token.Token
 		Collate          token.Token
 		CollationName    token.Token
diff --git a/internal/parser/scanner/ruleset/ruleset_default.go b/internal/parser/scanner/ruleset/ruleset_default.go
index 1d7e68e..b1bbcf6 100644
--- a/internal/parser/scanner/ruleset/ruleset_default.go
+++ b/internal/parser/scanner/ruleset/ruleset_default.go
@@ -57,6 +57,7 @@ var (
 		FuncRule(defaultQuotedLiteralRule),
 		FuncRule(defaultNumericLiteralRule),
 		FuncRule(defaultUnquotedLiteralRule),
+		FuncRule(defaultDecimalPointRule),
 	}
 )
 
@@ -193,6 +194,7 @@ func defaultNumericLiteralRule(s RuneScanner) (token.Type, bool) {
 	decimalPointFlag := false
 	exponentFlag := false
 	exponentOperatorFlag := false
+	numericLiteralFlag := false
 	// Checking whether the first element is a number or a decimal point.
 	// If neither, an unknown token error is raised.
 	next, ok := s.Lookahead()
@@ -203,6 +205,9 @@ func defaultNumericLiteralRule(s RuneScanner) (token.Type, bool) {
 	if defaultDecimalPoint.Matches(next) {
 		decimalPointFlag = true
 	}
+	if defaultNumericLiteral.Matches(next) {
+		numericLiteralFlag = true
+	}
 	s.ConsumeRune()
 	// case of hexadecimal numbers
 	if next == '0' {
@@ -213,17 +218,30 @@ func defaultNumericLiteralRule(s RuneScanner) (token.Type, bool) {
 			}
 			if next == 'x' {
 				s.ConsumeRune()
-				return defaultUnquotedLiteralRule(s)
+				if next, ok := s.Lookahead(); !(ok && defaultLiteral.Matches(next)) {
+					return token.Unknown, false
+				}
+				s.ConsumeRune()
+
+				for {
+					next, ok := s.Lookahead()
+					if !(ok && defaultLiteral.Matches(next)) {
+						break
+					}
+					s.ConsumeRune()
+				}
+				return token.LiteralNumeric, true
 			}
 		}
 	}
+
 	for {
 		// in the above case, if there was a `0.34` as a part of the string to read,
 		// the loop would have broken without consuming the rune; because the above
 		// loop consumes only hexadecimals of form `0xNUMBER`. Since all other cases
 		// are not consumed, the `LookAhead` below, gets the previous rune conveniently.
 		next, ok := s.Lookahead()
-		// continue on cases where the decimal point/exponent/exponent opeartor is already not found or not this particular rune.
+		// continue in case the decimal point/exponent/exponent operator is already not found or not this particular rune.
 		if !(ok && (defaultNumericLiteral.Matches(next) || (!decimalPointFlag && defaultDecimalPoint.Matches(next)) || (!exponentFlag && defaultExponent.Matches(next)) || (!exponentOperatorFlag && defaultExponentOperator.Matches(next)))) {
 			break
 		}
@@ -248,7 +266,23 @@ func defaultNumericLiteralRule(s RuneScanner) (token.Type, bool) {
 		if defaultDecimalPoint.Matches(next) {
 			decimalPointFlag = true
 		}
+		if defaultNumericLiteral.Matches(next) {
+			numericLiteralFlag = true
+		}
 		s.ConsumeRune()
 	}
+	// This case checks for "." passing as numericLiterals
+	if decimalPointFlag && !numericLiteralFlag {
+		return token.Unknown, false
+	}
+	return token.LiteralNumeric, true
+}
+
+func defaultDecimalPointRule(s RuneScanner) (token.Type, bool) {
+	next, ok := s.Lookahead()
+	if !(ok && defaultDecimalPoint.Matches(next)) {
+		return token.Unknown, false
+	}
+	s.ConsumeRune()
 	return token.Literal, true
 }
diff --git a/internal/parser/scanner/ruleset/ruleset_default_keyword_trie.go b/internal/parser/scanner/ruleset/ruleset_default_keyword_trie.go
index f86fb1d..2715857 100644
--- a/internal/parser/scanner/ruleset/ruleset_default_keyword_trie.go
+++ b/internal/parser/scanner/ruleset/ruleset_default_keyword_trie.go
@@ -1,4 +1,4 @@
-// Code generated; DO NOT EDIT.
+// Code generated with internal/tool/generate/keywordtrie; DO NOT EDIT.
 
 package ruleset
 
@@ -3179,6 +3179,10 @@ func scanKeywordG(s RuneScanner) (token.Type, bool) {
 	}
 	switch next {
 	
+	case 'E', 'e':
+		s.ConsumeRune()
+		return scanKeywordGE(s)
+	
 	case 'L', 'l':
 		s.ConsumeRune()
 		return scanKeywordGL(s)
@@ -3190,6 +3194,108 @@ func scanKeywordG(s RuneScanner) (token.Type, bool) {
 	return token.Unknown, false
 }
 
+func scanKeywordGE(s RuneScanner) (token.Type, bool) {
+	next, ok := s.Lookahead()
+	if !ok {
+		return token.Unknown, false
+	}
+	switch next {
+	
+	case 'N', 'n':
+		s.ConsumeRune()
+		return scanKeywordGEN(s)
+	}
+	return token.Unknown, false
+}
+
+func scanKeywordGEN(s RuneScanner) (token.Type, bool) {
+	next, ok := s.Lookahead()
+	if !ok {
+		return token.Unknown, false
+	}
+	switch next {
+	
+	case 'E', 'e':
+		s.ConsumeRune()
+		return scanKeywordGENE(s)
+	}
+	return token.Unknown, false
+}
+
+func scanKeywordGENE(s RuneScanner) (token.Type, bool) {
+	next, ok := s.Lookahead()
+	if !ok {
+		return token.Unknown, false
+	}
+	switch next {
+	
+	case 'R', 'r':
+		s.ConsumeRune()
+		return scanKeywordGENER(s)
+	}
+	return token.Unknown, false
+}
+
+func scanKeywordGENER(s RuneScanner) (token.Type, bool) {
+	next, ok := s.Lookahead()
+	if !ok {
+		return token.Unknown, false
+	}
+	switch next {
+	
+	case 'A', 'a':
+		s.ConsumeRune()
+		return scanKeywordGENERA(s)
+	}
+	return token.Unknown, false
+}
+
+func scanKeywordGENERA(s RuneScanner) (token.Type, bool) {
+	next, ok := s.Lookahead()
+	if !ok {
+		return token.Unknown, false
+	}
+	switch next {
+	
+	case 'T', 't':
+		s.ConsumeRune()
+		return scanKeywordGENERAT(s)
+	}
+	return token.Unknown, false
+}
+
+func scanKeywordGENERAT(s RuneScanner) (token.Type, bool) {
+	next, ok := s.Lookahead()
+	if !ok {
+		return token.Unknown, false
+	}
+	switch next {
+	
+	case 'E', 'e':
+		s.ConsumeRune()
+		return scanKeywordGENERATE(s)
+	}
+	return token.Unknown, false
+}
+
+func scanKeywordGENERATE(s RuneScanner) (token.Type, bool) {
+	next, ok := s.Lookahead()
+	if !ok {
+		return token.Unknown, false
+	}
+	switch next {
+	
+	case 'D', 'd':
+		s.ConsumeRune()
+		return scanKeywordGENERATED(s)
+	}
+	return token.Unknown, false
+}
+
+func scanKeywordGENERATED(s RuneScanner) (token.Type, bool) {
+	return token.KeywordGenerated, true
+}
+
 func scanKeywordGL(s RuneScanner) (token.Type, bool) {
 	next, ok := s.Lookahead()
 	if !ok {
diff --git a/internal/parser/scanner/token/type.go b/internal/parser/scanner/token/type.go
index 98d06b5..02599d3 100644
--- a/internal/parser/scanner/token/type.go
+++ b/internal/parser/scanner/token/type.go
@@ -170,6 +170,7 @@ const (
 	KeywordWithout
 
 	Literal
+	LiteralNumeric
 
 	UnaryOperator
 	BinaryOperator
diff --git a/internal/parser/scanner/token/type_string.go b/internal/parser/scanner/token/type_string.go
index 21f710b..081f2ff 100644
--- a/internal/parser/scanner/token/type_string.go
+++ b/internal/parser/scanner/token/type_string.go
@@ -159,14 +159,15 @@ func _() {
 	_ = x[KeywordWith-148]
 	_ = x[KeywordWithout-149]
 	_ = x[Literal-150]
-	_ = x[UnaryOperator-151]
-	_ = x[BinaryOperator-152]
-	_ = x[Delimiter-153]
+	_ = x[LiteralNumeric-151]
+	_ = x[UnaryOperator-152]
+	_ = x[BinaryOperator-153]
+	_ = x[Delimiter-154]
 }
 
-const _Type_name = "UnknownErrorEOFStatementSeparatorKeywordAbortKeywordActionKeywordAddKeywordAfterKeywordAllKeywordAlterKeywordAlwaysKeywordAnalyzeKeywordAndKeywordAsKeywordAscKeywordAttachKeywordAutoincrementKeywordBeforeKeywordBeginKeywordBetweenKeywordByKeywordCascadeKeywordCaseKeywordCastKeywordCheckKeywordCollateKeywordColumnKeywordCommitKeywordConflictKeywordConstraintKeywordCreateKeywordCrossKeywordCurrentKeywordCurrentDateKeywordCurrentTimeKeywordCurrentTimestampKeywordDatabaseKeywordDefaultKeywordDeferrableKeywordDeferredKeywordDeleteKeywordDescKeywordDetachKeywordDistinctKeywordDoKeywordDropKeywordEachKeywordElseKeywordEndKeywordEscapeKeywordExceptKeywordExcludeKeywordExclusiveKeywordExistsKeywordExplainKeywordFailKeywordFilterKeywordFirstKeywordFollowingKeywordForKeywordForeignKeywordFromKeywordFullKeywordGeneratedKeywordGlobKeywordGroupKeywordGroupsKeywordHavingKeywordIfKeywordIgnoreKeywordImmediateKeywordInKeywordIndexKeywordIndexedKeywordInitiallyKeywordInnerKeywordInsertKeywordInsteadKeywordIntersectKeywordIntoKeywordIsKeywordIsnullKeywordJoinKeywordKeyKeywordLastKeywordLeftKeywordLikeKeywordLimitKeywordMatchKeywordNaturalKeywordNoKeywordNotKeywordNothingKeywordNotnullKeywordNullKeywordNullsKeywordOfKeywordOffsetKeywordOnKeywordOrKeywordOrderKeywordOthersKeywordOuterKeywordOverKeywordPartitionKeywordPlanKeywordPragmaKeywordPrecedingKeywordPrimaryKeywordQueryKeywordRaiseKeywordRangeKeywordRecursiveKeywordReferencesKeywordRegexpKeywordReindexKeywordReleaseKeywordRenameKeywordReplaceKeywordRestrictKeywordRightKeywordRollbackKeywordRowKeywordRowsKeywordSavepointKeywordSelectKeywordSetKeywordStoredKeywordTableKeywordTempKeywordTemporaryKeywordThenKeywordTiesKeywordToKeywordTransactionKeywordTriggerKeywordUnboundedKeywordUnionKeywordUniqueKeywordUpdateKeywordUsingKeywordVacuumKeywordValuesKeywordViewKeywordVirtualKeywordWhenKeywordWhereKeywordWindowKeywordWithKeywordWithoutLiteralUnaryOperatorBinaryOperatorDelimiter"
+const _Type_name = "UnknownErrorEOFStatementSeparatorKeywordAbortKeywordActionKeywordAddKeywordAfterKeywordAllKeywordAlterKeywordAlwaysKeywordAnalyzeKeywordAndKeywordAsKeywordAscKeywordAttachKeywordAutoincrementKeywordBeforeKeywordBeginKeywordBetweenKeywordByKeywordCascadeKeywordCaseKeywordCastKeywordCheckKeywordCollateKeywordColumnKeywordCommitKeywordConflictKeywordConstraintKeywordCreateKeywordCrossKeywordCurrentKeywordCurrentDateKeywordCurrentTimeKeywordCurrentTimestampKeywordDatabaseKeywordDefaultKeywordDeferrableKeywordDeferredKeywordDeleteKeywordDescKeywordDetachKeywordDistinctKeywordDoKeywordDropKeywordEachKeywordElseKeywordEndKeywordEscapeKeywordExceptKeywordExcludeKeywordExclusiveKeywordExistsKeywordExplainKeywordFailKeywordFilterKeywordFirstKeywordFollowingKeywordForKeywordForeignKeywordFromKeywordFullKeywordGeneratedKeywordGlobKeywordGroupKeywordGroupsKeywordHavingKeywordIfKeywordIgnoreKeywordImmediateKeywordInKeywordIndexKeywordIndexedKeywordInitiallyKeywordInnerKeywordInsertKeywordInsteadKeywordIntersectKeywordIntoKeywordIsKeywordIsnullKeywordJoinKeywordKeyKeywordLastKeywordLeftKeywordLikeKeywordLimitKeywordMatchKeywordNaturalKeywordNoKeywordNotKeywordNothingKeywordNotnullKeywordNullKeywordNullsKeywordOfKeywordOffsetKeywordOnKeywordOrKeywordOrderKeywordOthersKeywordOuterKeywordOverKeywordPartitionKeywordPlanKeywordPragmaKeywordPrecedingKeywordPrimaryKeywordQueryKeywordRaiseKeywordRangeKeywordRecursiveKeywordReferencesKeywordRegexpKeywordReindexKeywordReleaseKeywordRenameKeywordReplaceKeywordRestrictKeywordRightKeywordRollbackKeywordRowKeywordRowsKeywordSavepointKeywordSelectKeywordSetKeywordStoredKeywordTableKeywordTempKeywordTemporaryKeywordThenKeywordTiesKeywordToKeywordTransactionKeywordTriggerKeywordUnboundedKeywordUnionKeywordUniqueKeywordUpdateKeywordUsingKeywordVacuumKeywordValuesKeywordViewKeywordVirtualKeywordWhenKeywordWhereKeywordWindowKeywordWithKeywordWithoutLiteralLiteralNumericUnaryOperatorBinaryOperatorDelimiter"
 
-var _Type_index = [...]uint16{0, 7, 12, 15, 33, 45, 58, 68, 80, 90, 102, 115, 129, 139, 148, 158, 171, 191, 204, 216, 230, 239, 253, 264, 275, 287, 301, 314, 327, 342, 359, 372, 384, 398, 416, 434, 457, 472, 486, 503, 518, 531, 542, 555, 570, 579, 590, 601, 612, 622, 635, 648, 662, 678, 691, 705, 716, 729, 741, 757, 767, 781, 792, 803, 819, 830, 842, 855, 868, 877, 890, 906, 915, 927, 941, 957, 969, 982, 996, 1012, 1023, 1032, 1045, 1056, 1066, 1077, 1088, 1099, 1111, 1123, 1137, 1146, 1156, 1170, 1184, 1195, 1207, 1216, 1229, 1238, 1247, 1259, 1272, 1284, 1295, 1311, 1322, 1335, 1351, 1365, 1377, 1389, 1401, 1417, 1434, 1447, 1461, 1475, 1488, 1502, 1517, 1529, 1544, 1554, 1565, 1581, 1594, 1604, 1617, 1629, 1640, 1656, 1667, 1678, 1687, 1705, 1719, 1735, 1747, 1760, 1773, 1785, 1798, 1811, 1822, 1836, 1847, 1859, 1872, 1883, 1897, 1904, 1917, 1931, 1940}
+var _Type_index = [...]uint16{0, 7, 12, 15, 33, 45, 58, 68, 80, 90, 102, 115, 129, 139, 148, 158, 171, 191, 204, 216, 230, 239, 253, 264, 275, 287, 301, 314, 327, 342, 359, 372, 384, 398, 416, 434, 457, 472, 486, 503, 518, 531, 542, 555, 570, 579, 590, 601, 612, 622, 635, 648, 662, 678, 691, 705, 716, 729, 741, 757, 767, 781, 792, 803, 819, 830, 842, 855, 868, 877, 890, 906, 915, 927, 941, 957, 969, 982, 996, 1012, 1023, 1032, 1045, 1056, 1066, 1077, 1088, 1099, 1111, 1123, 1137, 1146, 1156, 1170, 1184, 1195, 1207, 1216, 1229, 1238, 1247, 1259, 1272, 1284, 1295, 1311, 1322, 1335, 1351, 1365, 1377, 1389, 1401, 1417, 1434, 1447, 1461, 1475, 1488, 1502, 1517, 1529, 1544, 1554, 1565, 1581, 1594, 1604, 1617, 1629, 1640, 1656, 1667, 1678, 1687, 1705, 1719, 1735, 1747, 1760, 1773, 1785, 1798, 1811, 1822, 1836, 1847, 1859, 1872, 1883, 1897, 1904, 1918, 1931, 1945, 1954}
 
 func (i Type) String() string {
 	if i >= Type(len(_Type_index)-1) {
diff --git a/internal/parser/simple_parser_rules.go b/internal/parser/simple_parser_rules.go
index 1da21f7..8bc2d78 100644
--- a/internal/parser/simple_parser_rules.go
+++ b/internal/parser/simple_parser_rules.go
@@ -98,6 +98,8 @@ func (p *simpleParser) parseSQLStatement(r reporter) (stmt *ast.SQLStmt) {
 	return
 }
 
+// parseAlterTableStmt parses the alter-table stmt as defined in:
+// https://sqlite.org/lang_altertable.html
 func (p *simpleParser) parseAlterTableStmt(r reporter) (stmt *ast.AlterTableStmt) {
 	stmt = &ast.AlterTableStmt{}
 
@@ -258,6 +260,8 @@ func (p *simpleParser) parseAlterTableStmt(r reporter) (stmt *ast.AlterTableStmt
 	return
 }
 
+// parseColumnDef parses the column-def stmt as defined in:
+// https://sqlite.org/syntax/column-def.html
 func (p *simpleParser) parseColumnDef(r reporter) (def *ast.ColumnDef) {
 	def = &ast.ColumnDef{}
 
@@ -282,6 +286,7 @@ func (p *simpleParser) parseColumnDef(r reporter) (def *ast.ColumnDef) {
 				next.Type() == token.KeywordDefault ||
 				next.Type() == token.KeywordCollate ||
 				next.Type() == token.KeywordGenerated ||
+				next.Type() == token.KeywordAs ||
 				next.Type() == token.KeywordReferences {
 				def.ColumnConstraint = append(def.ColumnConstraint, p.parseColumnConstraint(r))
 			} else {
@@ -292,6 +297,8 @@ func (p *simpleParser) parseColumnDef(r reporter) (def *ast.ColumnDef) {
 	return
 }
 
+// parseTypeName parses the type-name stmt as defined in:
+// https://sqlite.org/syntax/type-name.html
 func (p *simpleParser) parseTypeName(r reporter) (name *ast.TypeName) {
 	name = &ast.TypeName{}
 
@@ -346,10 +353,11 @@ func (p *simpleParser) parseTypeName(r reporter) (name *ast.TypeName) {
 	} else {
 		return
 	}
-
 	return
 }
 
+// parseSignedNumber parses the signed-number stmt as defined in:
+// https://sqlite.org/syntax/signed-number.html
 func (p *simpleParser) parseSignedNumber(r reporter) (num *ast.SignedNumber) {
 	num = &ast.SignedNumber{}
 
@@ -366,21 +374,23 @@ func (p *simpleParser) parseSignedNumber(r reporter) (num *ast.SignedNumber) {
 		if !ok {
 			return
 		}
-		if next.Type() != token.Literal {
-			r.unexpectedToken(token.Literal)
+		if next.Type() != token.LiteralNumeric {
+			r.unexpectedToken(token.LiteralNumeric)
 			return
 		}
 		fallthrough
-	case token.Literal:
+	case token.LiteralNumeric:
 		num.NumericLiteral = next
 		p.consumeToken()
 	default:
-		r.unexpectedToken(token.UnaryOperator, token.Literal)
+		r.unexpectedToken(token.UnaryOperator, token.LiteralNumeric)
 		return
 	}
 	return
 }
 
+// parseColumnConstraint parses the column-constraint stmt as defined in:
+// https://sqlite.org/syntax/column-constraint.html
 func (p *simpleParser) parseColumnConstraint(r reporter) (constr *ast.ColumnConstraint) {
 	constr = &ast.ColumnConstraint{}
 
@@ -535,42 +545,317 @@ func (p *simpleParser) parseColumnConstraint(r reporter) (constr *ast.ColumnCons
 			// assume that the opening paren has been omitted, report the
 			// error but proceed as if it was found
 		}
-
 	case token.KeywordDefault:
 		constr.Default = next
 		p.consumeToken()
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.UnaryOperator || next.Type() == token.LiteralNumeric {
+			constr.SignedNumber = p.parseSignedNumber(r)
+		}
+		// Only either of the 3 cases can exist, thus, if one of the cases is found, return.
+		if constr.SignedNumber != nil {
+			return
+		}
+
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.Literal {
+			constr.LiteralValue = next
+			p.consumeToken()
+		}
+		if constr.LiteralValue != nil {
+			return
+		}
 
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.Delimiter && next.Value() == "(" {
+			constr.LeftParen = next
+			p.consumeToken()
+			constr.Expr = p.parseExpression(r)
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Type() == token.Delimiter && next.Value() == ")" {
+				constr.RightParen = next
+				p.consumeToken()
+			} else {
+				r.unexpectedSingleRuneToken(')')
+			}
+		}
 	case token.KeywordCollate:
 		constr.Collate = next
 		p.consumeToken()
-
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.Literal {
+			constr.CollationName = next
+			p.consumeToken()
+		}
+	case token.KeywordReferences:
+		constr.ForeignKeyClause = p.parseForeignKeyClause(r)
 	case token.KeywordGenerated:
 		constr.Generated = next
 		p.consumeToken()
 
-	case token.KeywordReferences:
-		constr.ForeignKeyClause = p.parseForeignKeyClause(r)
+		next, ok := p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.KeywordAlways {
+			constr.Always = next
+			p.consumeToken()
+		}
+		fallthrough
+	case token.KeywordAs:
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.KeywordAs {
+			constr.As = next
+			p.consumeToken()
+		}
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.Delimiter && next.Value() == "(" {
+			constr.LeftParen = next
+			p.consumeToken()
+			constr.Expr = p.parseExpression(r)
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Type() == token.Delimiter && next.Value() == ")" {
+				constr.RightParen = next
+				p.consumeToken()
+			} else {
+				r.unexpectedSingleRuneToken(')')
+			}
+		}
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.KeywordStored {
+			constr.Stored = next
+			p.consumeToken()
+		}
+		if next.Type() == token.KeywordVirtual {
+			constr.Virtual = next
+			p.consumeToken()
+		}
 	default:
-		r.unexpectedToken(token.KeywordPrimary, token.KeywordNot, token.KeywordUnique, token.KeywordCheck, token.KeywordDefault, token.KeywordCollate, token.KeywordGenerated, token.KeywordReferences)
+		r.unexpectedToken(token.KeywordPrimary, token.KeywordNot, token.KeywordUnique, token.KeywordCheck, token.KeywordDefault, token.KeywordCollate, token.KeywordGenerated, token.KeywordAs, token.KeywordReferences)
 	}
-
 	return
 }
 
-// parseForeignKeyClause is not implemented yet and will always result in an
-// unsupported construct error.
+// parseForeignKeyClause parses the foreign-key-clause stmt as defined in:
+// https://sqlite.org/syntax/foreign-key-clause.html
 func (p *simpleParser) parseForeignKeyClause(r reporter) (clause *ast.ForeignKeyClause) {
 	clause = &ast.ForeignKeyClause{}
+	next, ok := p.lookahead(r)
+	if !ok {
+		return
+	}
+	if next.Type() == token.KeywordReferences {
+		clause.References = next
+		p.consumeToken()
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.Literal {
+			clause.ForeignTable = next
+			p.consumeToken()
+		}
 
+		next, ok = p.optionalLookahead(r)
+		if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {
+			return
+		}
+		if next.Type() == token.Delimiter && next.Value() == "(" {
+			clause.LeftParen = next
+			p.consumeToken()
+			for {
+				next, ok = p.lookahead(r)
+				if !ok {
+					return
+				}
+				if next.Type() == token.Literal {
+					clause.ColumnName = append(clause.ColumnName, next)
+					p.consumeToken()
+					next, ok = p.lookahead(r)
+					if !ok {
+						return
+					}
+					if next.Value() == "," {
+						p.consumeToken()
+					}
+					if next.Value() == ")" {
+						clause.RightParen = next
+						p.consumeToken()
+						break
+					}
+				} else {
+					break
+				}
+			}
+		}
+
+		next, ok = p.optionalLookahead(r)
+		if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {
+			return
+		}
+		for {
+			if next.Type() == token.KeywordOn || next.Type() == token.KeywordMatch {
+				clause.ForeignKeyClauseCore = append(clause.ForeignKeyClauseCore, p.parseForeignKeyClauseCore(r))
+			} else {
+				break
+			}
+			next, ok = p.optionalLookahead(r)
+			if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {
+				return
+			}
+		}
+
+		next, ok = p.optionalLookahead(r)
+		if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {
+			return
+		}
+		if next.Type() == token.KeywordNot {
+			clause.Not = next
+			p.consumeToken()
+		}
+
+		next, ok = p.optionalLookahead(r)
+		if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {
+			return
+		}
+		if next.Type() == token.KeywordDeferrable {
+			clause.Deferrable = next
+			p.consumeToken()
+		}
+
+		next, ok = p.optionalLookahead(r)
+		if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {
+			return
+		}
+		if next.Type() == token.KeywordInitially {
+			clause.Initially = next
+			p.consumeToken()
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Type() == token.KeywordImmediate {
+				clause.Immediate = next
+				p.consumeToken()
+			} else if next.Type() == token.KeywordDeferred {
+				clause.Deferred = next
+				p.consumeToken()
+			}
+		}
+	} else {
+		return
+	}
+	return
+}
+
+func (p *simpleParser) parseForeignKeyClauseCore(r reporter) (stmt *ast.ForeignKeyClauseCore) {
+	stmt = &ast.ForeignKeyClauseCore{}
 	next, ok := p.lookahead(r)
 	if !ok {
 		return
 	}
-	r.unsupportedConstruct(next)
-	p.searchNext(r, token.StatementSeparator, token.EOF)
+	if next.Type() == token.KeywordOn {
+		stmt.On = next
+		p.consumeToken()
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.KeywordDelete {
+			stmt.Delete = next
+			p.consumeToken()
+		} else if next.Type() == token.KeywordUpdate {
+			stmt.Update = next
+			p.consumeToken()
+		}
+
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		switch next.Type() {
+		case token.KeywordSet:
+			stmt.Set = next
+			p.consumeToken()
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Type() == token.KeywordNull {
+				stmt.Null = next
+				p.consumeToken()
+			} else if next.Type() == token.KeywordDefault {
+				stmt.Default = next
+				p.consumeToken()
+			}
+		case token.KeywordCascade:
+			stmt.Cascade = next
+			p.consumeToken()
+		case token.KeywordRestrict:
+			stmt.Restrict = next
+			p.consumeToken()
+		case token.KeywordNo:
+			stmt.No = next
+			p.consumeToken()
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Type() == token.KeywordAction {
+				stmt.Action = next
+				p.consumeToken()
+			} else {
+				r.unexpectedToken(token.KeywordAction)
+			}
+		}
+
+	} else if next.Type() == token.KeywordMatch {
+		stmt.Match = next
+		p.consumeToken()
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.Literal {
+			stmt.Name = next
+			p.consumeToken()
+		} else {
+			r.unexpectedToken(token.Literal)
+		}
+	}
 	return
+
 }
 
+// parseConflictClause parses conflict-clause stmt as defined in:
+// https://sqlite.org/syntax/conflict-clause.html
 func (p *simpleParser) parseConflictClause(r reporter) (clause *ast.ConflictClause) {
 	clause = &ast.ConflictClause{}
 
@@ -1146,6 +1431,8 @@ func (p *simpleParser) parseCreateIndexStmt(createToken token.Token, r reporter)
 	return
 }
 
+// parseIndexedColumn parses the indexed-column statement as defined in:
+// https://sqlite.org/syntax/indexed-column.html
 func (p *simpleParser) parseIndexedColumn(r reporter) (stmt *ast.IndexedColumn) {
 	stmt = &ast.IndexedColumn{}
 	next, ok := p.lookahead(r)
@@ -1178,31 +1465,166 @@ func (p *simpleParser) parseIndexedColumn(r reporter) (stmt *ast.IndexedColumn)
 		}
 	}
 
-	next, ok = p.optionalLookahead(r)
-	if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {
+	next, ok = p.optionalLookahead(r)
+	if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {
+		return
+	}
+	if next.Type() == token.KeywordAsc {
+		stmt.Asc = next
+		p.consumeToken()
+	}
+	if next.Type() == token.KeywordDesc {
+		stmt.Desc = next
+		p.consumeToken()
+	}
+	return
+}
+
+func (p *simpleParser) parseCreateTableStmt(createToken, tempToken, temporaryToken token.Token, r reporter) (stmt *ast.CreateTableStmt) {
+	stmt = &ast.CreateTableStmt{}
+	stmt.Create = createToken
+	stmt.Temp = tempToken
+	stmt.Temporary = temporaryToken
+	next, ok := p.lookahead(r)
+	if !ok {
+		return
+	}
+	if next.Type() == token.KeywordTable {
+		stmt.Table = next
+		p.consumeToken()
+	} else {
+		r.unexpectedToken(token.KeywordTable)
+	}
+
+	next, ok = p.lookahead(r)
+	if !ok {
+		return
+	}
+	if next.Type() == token.KeywordIf {
+		stmt.If = next
+		p.consumeToken()
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.KeywordNot {
+			stmt.Not = next
+			p.consumeToken()
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Type() == token.KeywordExists {
+				stmt.Exists = next
+				p.consumeToken()
+			} else {
+				r.unexpectedToken(token.KeywordExists)
+			}
+		} else {
+			r.unexpectedToken(token.KeywordNot)
+		}
+	}
+
+	next, ok = p.lookahead(r)
+	if !ok {
+		return
+	}
+	if next.Type() == token.Literal {
+		stmt.SchemaName = next
+		stmt.TableName = next
+		p.consumeToken()
+	}
+
+	next, ok = p.lookahead(r)
+	if !ok {
+		return
+	}
+	if next.Value() == "." {
+		stmt.Period = next
+		p.consumeToken()
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.Literal {
+			stmt.TableName = next
+			p.consumeToken()
+		} else {
+			r.unexpectedToken(token.Literal)
+		}
+	} else {
+		stmt.SchemaName = nil
+	}
+
+	next, ok = p.lookahead(r)
+	if !ok {
 		return
 	}
-	if next.Type() == token.KeywordAsc {
-		stmt.Asc = next
+	switch next.Type() {
+	case token.Delimiter:
+		stmt.LeftParen = next
 		p.consumeToken()
-	}
-	if next.Type() == token.KeywordDesc {
-		stmt.Desc = next
+		for {
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Type() == token.Literal {
+				stmt.ColumnDef = append(stmt.ColumnDef, p.parseColumnDef(r))
+			} else {
+				break
+			}
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Value() == "," {
+				p.consumeToken()
+				next, ok = p.lookahead(r)
+				if !ok {
+					return
+				}
+				for {
+					if next.Type() == token.KeywordConstraint ||
+						next.Type() == token.KeywordPrimary ||
+						next.Type() == token.KeywordUnique ||
+						next.Type() == token.KeywordCheck ||
+						next.Type() == token.KeywordForeign {
+						stmt.TableConstraint = append(stmt.TableConstraint, p.parseTableConstraint(r))
+					} else {
+						break
+					}
+					next, ok = p.lookahead(r)
+					if !ok {
+						return
+					}
+					if next.Value() == "," {
+						p.consumeToken()
+					}
+					if next.Value() == ")" {
+						stmt.RightParen = next
+						break
+					}
+				}
+			}
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Value() == ")" {
+				stmt.RightParen = next
+				p.consumeToken()
+				break
+			}
+		}
+	case token.KeywordAs:
+		stmt.As = next
 		p.consumeToken()
+		stmt.SelectStmt = p.parseSelectStmt(r)
 	}
 	return
 }
 
-func (p *simpleParser) parseCreateTableStmt(createToken, tempToken, temporaryToken token.Token, r reporter) (stmt *ast.CreateTableStmt) {
-	next, ok := p.lookahead(r)
-	if !ok {
-		return
-	}
-	r.unsupportedConstruct(next)
-	p.searchNext(r, token.StatementSeparator, token.EOF)
-	return
-}
-
 func (p *simpleParser) parseCreateTriggerStmt(createToken, tempToken, temporaryToken token.Token, r reporter) (stmt *ast.CreateTriggerStmt) {
 	next, ok := p.lookahead(r)
 	if !ok {
@@ -1298,7 +1720,13 @@ func (p *simpleParser) parseWithClause(r reporter) (withClause *ast.WithClause)
 		p.consumeToken()
 	}
 	for {
-		withClause.RecursiveCte = append(withClause.RecursiveCte, p.parseRecursiveCte(r))
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.Literal {
+			withClause.RecursiveCte = append(withClause.RecursiveCte, p.parseRecursiveCte(r))
+		}
 		next, ok = p.lookahead(r)
 		if !ok {
 			return
@@ -1358,8 +1786,10 @@ func (p *simpleParser) parseCteTableName(r reporter) (cteTableName *ast.CteTable
 	if !ok {
 		return
 	}
-	cteTableName.TableName = next
-	p.consumeToken()
+	if next.Type() == token.Literal {
+		cteTableName.TableName = next
+		p.consumeToken()
+	}
 
 	next, ok = p.optionalLookahead(r)
 	if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {
@@ -1378,6 +1808,7 @@ func (p *simpleParser) parseCteTableName(r reporter) (cteTableName *ast.CteTable
 				p.consumeToken()
 			} else {
 				r.unexpectedToken(token.Literal)
+				break
 			}
 
 			next, ok = p.lookahead(r)
@@ -1421,44 +1852,41 @@ func (p *simpleParser) parseSelectStmt(r reporter) (stmt *ast.SelectStmt) {
 			stmt.Recursive = next
 			p.consumeToken()
 		}
-		next, ok = p.lookahead(r)
-		if !ok {
-			return
-		}
-		if next.Type() == token.Literal {
-			for {
+
+		for {
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Type() == token.Literal {
 				stmt.CommonTableExpression = append(stmt.CommonTableExpression, p.parseCommonTableExpression(r))
-				next, ok = p.lookahead(r)
-				if !ok {
-					return
-				}
-				if next.Value() == "," {
-					p.consumeToken()
-				} else {
-					break
-				}
+			} else {
+				break
+			}
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Value() == "," {
+				p.consumeToken()
+			} else {
+				break
 			}
-		} else {
-			r.unexpectedToken(token.Literal)
 		}
 	}
 
-	next, ok = p.lookahead(r)
-	if !ok {
-		return
-	}
 	// Keep looping and searching for the select core until its exhausted.
 	// We are sure that a select core starts here as its the type of stmt we expect.
 	for {
-		if !(next.Type() == token.KeywordSelect || next.Type() == token.KeywordValues) {
-			break
-		}
-		stmt.SelectCore = append(stmt.SelectCore, p.parseSelectCore(r))
-
 		next, ok = p.optionalLookahead(r)
 		if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {
 			return
 		}
+		if next.Type() == token.KeywordSelect || next.Type() == token.KeywordValues {
+			stmt.SelectCore = append(stmt.SelectCore, p.parseSelectCore(r))
+		} else {
+			break
+		}
 	}
 
 	next, ok = p.optionalLookahead(r)
@@ -1735,8 +2163,8 @@ func (p *simpleParser) parseSelectCore(r reporter) (stmt *ast.SelectCore) {
 
 		for {
 			stmt.ResultColumn = append(stmt.ResultColumn, p.parseResultColumn(r))
-			next, ok = p.lookahead(r)
-			if !ok {
+			next, ok = p.optionalLookahead(r)
+			if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {
 				return
 			}
 			if next.Value() == "," {
@@ -2047,6 +2475,10 @@ func (p *simpleParser) parseWindowDefn(r reporter) (stmt *ast.WindowDefn) {
 		} else {
 			r.unexpectedToken(token.KeywordBy)
 		}
+		// possible area of error
+		// When there are statements that arent parsed by ordering term, they might loop here forever.
+		// Fix might be to check for expr existing in the beginning, which is not possible due to the
+		// vastness of expr.
 		for {
 			stmt.OrderingTerm = append(stmt.OrderingTerm, p.parseOrderingTerm(r))
 			next, ok = p.lookahead(r)
@@ -2550,11 +2982,20 @@ func (p *simpleParser) parseTableOrSubquery(r reporter) (stmt *ast.TableOrSubque
 			stmt.JoinClause = p.parseJoinClause(r)
 			if stmt.JoinClause == nil {
 				for {
-					stmt.TableOrSubquery = append(stmt.TableOrSubquery, p.parseTableOrSubquery(r))
 					next, ok := p.lookahead(r)
 					if !ok {
 						return
 					}
+					if next.Type() == token.Delimiter || next.Type() == token.Literal {
+						stmt.TableOrSubquery = append(stmt.TableOrSubquery, p.parseTableOrSubquery(r))
+					} else {
+						break
+					}
+
+					next, ok = p.lookahead(r)
+					if !ok {
+						return
+					}
 					if next.Value() == "," {
 						p.consumeToken()
 					}
@@ -2617,10 +3058,16 @@ func (p *simpleParser) parseJoinClause(r reporter) (stmt *ast.JoinClause) {
 		if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {
 			return
 		}
-		if !((next.Type() == token.KeywordNatural) || (next.Type() == token.KeywordJoin) || (next.Value() == ",") || (next.Type() == token.KeywordLeft) || (next.Type() == token.KeywordInner) || (next.Type() == token.KeywordCross)) {
+		if next.Type() == token.KeywordNatural ||
+			next.Type() == token.KeywordJoin ||
+			next.Value() == "," ||
+			next.Type() == token.KeywordLeft ||
+			next.Type() == token.KeywordInner ||
+			next.Type() == token.KeywordCross {
+			stmt.JoinClausePart = p.parseJoinClausePart(r)
+		} else {
 			break
 		}
-		stmt.JoinClausePart = p.parseJoinClausePart(r)
 	}
 	return
 }
@@ -2760,3 +3207,143 @@ func (p *simpleParser) parseJoinOperator(r reporter) (stmt *ast.JoinOperator) {
 	}
 	return
 }
+
+func (p *simpleParser) parseTableConstraint(r reporter) (stmt *ast.TableConstraint) {
+	stmt = &ast.TableConstraint{}
+	next, ok := p.lookahead(r)
+	if !ok {
+		return
+	}
+	if next.Type() == token.KeywordConstraint {
+		stmt.Constraint = next
+		p.consumeToken()
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Type() == token.Literal {
+			stmt.Name = next
+			p.consumeToken()
+		} else {
+			r.unexpectedToken(token.Literal)
+		}
+	}
+
+	next, ok = p.lookahead(r)
+	if !ok {
+		return
+	}
+	if next.Type() == token.KeywordPrimary || next.Type() == token.KeywordUnique {
+		if next.Type() == token.KeywordPrimary {
+			stmt.Primary = next
+			p.consumeToken()
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Type() == token.KeywordKey {
+				stmt.Key = next
+				p.consumeToken()
+			}
+		} else {
+			stmt.Unique = next
+			p.consumeToken()
+		}
+
+		next, ok = p.lookahead(r)
+		if !ok {
+			return
+		}
+		if next.Value() == "(" {
+			stmt.LeftParen = next
+			p.consumeToken()
+		}
+		for {
+			stmt.IndexedColumn = append(stmt.IndexedColumn, p.parseIndexedColumn(r))
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Value() == "," {
+				p.consumeToken()
+			}
+			if next.Value() == ")" {
+				stmt.RightParen = next
+				p.consumeToken()
+				break
+			}
+		}
+
+		next, ok = p.optionalLookahead(r)
+		if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {
+			return
+		}
+		if next.Type() == token.KeywordOn {
+			stmt.ConflictClause = p.parseConflictClause(r)
+		}
+	} else {
+		if next.Type() == token.KeywordCheck {
+			stmt.Check = next
+			p.consumeToken()
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Value() == "(" {
+				stmt.LeftParen = next
+				p.consumeToken()
+			}
+			stmt.Expr = p.parseExpression(r)
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Value() == ")" {
+				stmt.RightParen = next
+				p.consumeToken()
+			}
+		}
+		if next.Type() == token.KeywordForeign {
+			stmt.Foreign = next
+			p.consumeToken()
+			next, ok = p.lookahead(r)
+			if !ok {
+				return
+			}
+			if next.Type() == token.KeywordKey {
+				stmt.Key = next
+				p.consumeToken()
+				next, ok = p.lookahead(r)
+				if !ok {
+					return
+				}
+				if next.Value() == "(" {
+					stmt.LeftParen = next
+					p.consumeToken()
+				}
+				for {
+					next, ok = p.lookahead(r)
+					if !ok {
+						return
+					}
+					if next.Type() == token.Literal {
+						stmt.ColumnName = append(stmt.ColumnName, next)
+						p.consumeToken()
+					}
+					if next.Value() == "," {
+						p.consumeToken()
+					}
+					if next.Value() == ")" {
+						stmt.RightParen = next
+						p.consumeToken()
+						break
+					}
+				}
+				stmt.ForeignKeyClause = p.parseForeignKeyClause(r)
+			} else {
+				r.unexpectedToken(token.KeywordKey)
+			}
+		}
+	}
+	return
+}
diff --git a/internal/tool/generate/keywordtrie/keywords.go b/internal/tool/generate/keywordtrie/keywords.go
index ba50375..197316d 100644
--- a/internal/tool/generate/keywordtrie/keywords.go
+++ b/internal/tool/generate/keywordtrie/keywords.go
@@ -65,6 +65,7 @@ var (
 		"FOREIGN":           token.KeywordForeign,
 		"FROM":              token.KeywordFrom,
 		"FULL":              token.KeywordFull,
+		"GENERATED":         token.KeywordGenerated,
 		"GLOB":              token.KeywordGlob,
 		"GROUP":             token.KeywordGroup,
 		"GROUPS":            token.KeywordGroups,


Test patch:
diff --git a/internal/parser/parser_test.go b/internal/parser/parser_test.go
index 7e0f1a1..3c57222 100644
--- a/internal/parser/parser_test.go
+++ b/internal/parser/parser_test.go
@@ -78,7 +78,7 @@ func TestSingleStatementParse(t *testing.T) {
 							},
 							LeftParen: token.New(1, 41, 40, 1, token.Delimiter, "("),
 							SignedNumber1: &ast.SignedNumber{
-								NumericLiteral: token.New(1, 42, 41, 2, token.Literal, "15"),
+								NumericLiteral: token.New(1, 42, 41, 2, token.LiteralNumeric, "15"),
 							},
 							RightParen: token.New(1, 44, 43, 1, token.Delimiter, ")"),
 						},
@@ -118,7 +118,7 @@ func TestSingleStatementParse(t *testing.T) {
 							},
 							LeftParen: token.New(1, 34, 33, 1, token.Delimiter, "("),
 							SignedNumber1: &ast.SignedNumber{
-								NumericLiteral: token.New(1, 35, 34, 2, token.Literal, "15"),
+								NumericLiteral: token.New(1, 35, 34, 2, token.LiteralNumeric, "15"),
 							},
 							RightParen: token.New(1, 37, 36, 1, token.Delimiter, ")"),
 						},
@@ -4463,6 +4463,1485 @@ func TestSingleStatementParse(t *testing.T) {
 				},
 			},
 		},
+		{
+			`CREATE TABLE basic with basic select`,
+			"CREATE TABLE myTable AS SELECT *",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					As:        token.New(1, 22, 21, 2, token.KeywordAs, "AS"),
+					SelectStmt: &ast.SelectStmt{
+						SelectCore: []*ast.SelectCore{
+							&ast.SelectCore{
+								Select: token.New(1, 25, 24, 6, token.KeywordSelect, "SELECT"),
+								ResultColumn: []*ast.ResultColumn{
+									&ast.ResultColumn{
+										Asterisk: token.New(1, 32, 31, 1, token.BinaryOperator, "*"),
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`CREATE TABLE with TEMP`,
+			"CREATE TEMP TABLE myTable AS SELECT *",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Temp:      token.New(1, 8, 7, 4, token.KeywordTemp, "TEMP"),
+					Table:     token.New(1, 13, 12, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 19, 18, 7, token.Literal, "myTable"),
+					As:        token.New(1, 27, 26, 2, token.KeywordAs, "AS"),
+					SelectStmt: &ast.SelectStmt{
+						SelectCore: []*ast.SelectCore{
+							&ast.SelectCore{
+								Select: token.New(1, 30, 29, 6, token.KeywordSelect, "SELECT"),
+								ResultColumn: []*ast.ResultColumn{
+									&ast.ResultColumn{
+										Asterisk: token.New(1, 37, 36, 1, token.BinaryOperator, "*"),
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`CREATE TABLE with TEMPORARY`,
+			"CREATE TEMPORARY TABLE myTable AS SELECT *",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Temporary: token.New(1, 8, 7, 9, token.KeywordTemporary, "TEMPORARY"),
+					Table:     token.New(1, 18, 17, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 24, 23, 7, token.Literal, "myTable"),
+					As:        token.New(1, 32, 31, 2, token.KeywordAs, "AS"),
+					SelectStmt: &ast.SelectStmt{
+						SelectCore: []*ast.SelectCore{
+							&ast.SelectCore{
+								Select: token.New(1, 35, 34, 6, token.KeywordSelect, "SELECT"),
+								ResultColumn: []*ast.ResultColumn{
+									&ast.ResultColumn{
+										Asterisk: token.New(1, 42, 41, 1, token.BinaryOperator, "*"),
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`CREATE TABLE with IF NOT EXISTS`,
+			"CREATE TABLE IF NOT EXISTS myTable AS SELECT *",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					If:        token.New(1, 14, 13, 2, token.KeywordIf, "IF"),
+					Not:       token.New(1, 17, 16, 3, token.KeywordNot, "NOT"),
+					Exists:    token.New(1, 21, 20, 6, token.KeywordExists, "EXISTS"),
+					TableName: token.New(1, 28, 27, 7, token.Literal, "myTable"),
+					As:        token.New(1, 36, 35, 2, token.KeywordAs, "AS"),
+					SelectStmt: &ast.SelectStmt{
+						SelectCore: []*ast.SelectCore{
+							&ast.SelectCore{
+								Select: token.New(1, 39, 38, 6, token.KeywordSelect, "SELECT"),
+								ResultColumn: []*ast.ResultColumn{
+									&ast.ResultColumn{
+										Asterisk: token.New(1, 46, 45, 1, token.BinaryOperator, "*"),
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`CREATE TABLE with schema and table name`,
+			"CREATE TABLE mySchema.myTable AS SELECT *",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:     token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:      token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					SchemaName: token.New(1, 14, 13, 8, token.Literal, "mySchema"),
+					Period:     token.New(1, 22, 21, 1, token.Literal, "."),
+					TableName:  token.New(1, 23, 22, 7, token.Literal, "myTable"),
+					As:         token.New(1, 31, 30, 2, token.KeywordAs, "AS"),
+					SelectStmt: &ast.SelectStmt{
+						SelectCore: []*ast.SelectCore{
+							&ast.SelectCore{
+								Select: token.New(1, 34, 33, 6, token.KeywordSelect, "SELECT"),
+								ResultColumn: []*ast.ResultColumn{
+									&ast.ResultColumn{
+										Asterisk: token.New(1, 41, 40, 1, token.BinaryOperator, "*"),
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def`,
+			"CREATE TABLE myTable (myColumn)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+						},
+					},
+					RightParen: token.New(1, 31, 30, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with multiple basic column-def`,
+			"CREATE TABLE myTable (myColumn1,myColumn2)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 33, 32, 9, token.Literal, "myColumn2"),
+						},
+					},
+					RightParen: token.New(1, 42, 41, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and basic table-constraint`,
+			"CREATE TABLE myTable (myColumn1,CHECK (myExpr))",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Check:     token.New(1, 33, 32, 5, token.KeywordCheck, "CHECK"),
+							LeftParen: token.New(1, 39, 38, 1, token.Delimiter, "("),
+							Expr: &ast.Expr{
+								LiteralValue: token.New(1, 40, 39, 6, token.Literal, "myExpr"),
+							},
+							RightParen: token.New(1, 46, 45, 1, token.Delimiter, ")"),
+						},
+					},
+					RightParen: token.New(1, 47, 46, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and CONSTRAINT`,
+			"CREATE TABLE myTable (myColumn1,CONSTRAINT myConstraint CHECK (myExpr))",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Constraint: token.New(1, 33, 32, 10, token.KeywordConstraint, "CONSTRAINT"),
+							Name:       token.New(1, 44, 43, 12, token.Literal, "myConstraint"),
+							Check:      token.New(1, 57, 56, 5, token.KeywordCheck, "CHECK"),
+							LeftParen:  token.New(1, 63, 62, 1, token.Delimiter, "("),
+							Expr: &ast.Expr{
+								LiteralValue: token.New(1, 64, 63, 6, token.Literal, "myExpr"),
+							},
+							RightParen: token.New(1, 70, 69, 1, token.Delimiter, ")"),
+						},
+					},
+					RightParen: token.New(1, 71, 70, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and PRIMARY KEY with single indexed-column`,
+			"CREATE TABLE myTable (myColumn1,PRIMARY KEY (myExpr))",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Primary:   token.New(1, 33, 32, 7, token.KeywordPrimary, "PRIMARY"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							IndexedColumn: []*ast.IndexedColumn{
+								&ast.IndexedColumn{
+									ColumnName: token.New(1, 46, 45, 6, token.Literal, "myExpr"),
+								},
+							},
+							RightParen: token.New(1, 52, 51, 1, token.Delimiter, ")"),
+						},
+					},
+					RightParen: token.New(1, 53, 52, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and PRIMARY KEY with single indexed-column and conflict-clause with ROLLBACK`,
+			"CREATE TABLE myTable (myColumn1,PRIMARY KEY (myExpr) ON CONFLICT ROLLBACK)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Primary:   token.New(1, 33, 32, 7, token.KeywordPrimary, "PRIMARY"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							IndexedColumn: []*ast.IndexedColumn{
+								&ast.IndexedColumn{
+									ColumnName: token.New(1, 46, 45, 6, token.Literal, "myExpr"),
+								},
+							},
+							RightParen: token.New(1, 52, 51, 1, token.Delimiter, ")"),
+							ConflictClause: &ast.ConflictClause{
+								On:       token.New(1, 54, 53, 2, token.KeywordOn, "ON"),
+								Conflict: token.New(1, 57, 56, 8, token.KeywordConflict, "CONFLICT"),
+								Rollback: token.New(1, 66, 65, 8, token.KeywordRollback, "ROLLBACK"),
+							},
+						},
+					},
+					RightParen: token.New(1, 74, 73, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and PRIMARY KEY with single indexed-column and conflict-clause with ABORT`,
+			"CREATE TABLE myTable (myColumn1,PRIMARY KEY (myExpr) ON CONFLICT ABORT)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Primary:   token.New(1, 33, 32, 7, token.KeywordPrimary, "PRIMARY"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							IndexedColumn: []*ast.IndexedColumn{
+								&ast.IndexedColumn{
+									ColumnName: token.New(1, 46, 45, 6, token.Literal, "myExpr"),
+								},
+							},
+							RightParen: token.New(1, 52, 51, 1, token.Delimiter, ")"),
+							ConflictClause: &ast.ConflictClause{
+								On:       token.New(1, 54, 53, 2, token.KeywordOn, "ON"),
+								Conflict: token.New(1, 57, 56, 8, token.KeywordConflict, "CONFLICT"),
+								Abort:    token.New(1, 66, 65, 5, token.KeywordAbort, "ABORT"),
+							},
+						},
+					},
+					RightParen: token.New(1, 71, 70, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and PRIMARY KEY with single indexed-column and conflict-clause with FAIL`,
+			"CREATE TABLE myTable (myColumn1,PRIMARY KEY (myExpr) ON CONFLICT FAIL)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Primary:   token.New(1, 33, 32, 7, token.KeywordPrimary, "PRIMARY"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							IndexedColumn: []*ast.IndexedColumn{
+								&ast.IndexedColumn{
+									ColumnName: token.New(1, 46, 45, 6, token.Literal, "myExpr"),
+								},
+							},
+							RightParen: token.New(1, 52, 51, 1, token.Delimiter, ")"),
+							ConflictClause: &ast.ConflictClause{
+								On:       token.New(1, 54, 53, 2, token.KeywordOn, "ON"),
+								Conflict: token.New(1, 57, 56, 8, token.KeywordConflict, "CONFLICT"),
+								Fail:     token.New(1, 66, 65, 4, token.KeywordFail, "FAIL"),
+							},
+						},
+					},
+					RightParen: token.New(1, 70, 69, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and PRIMARY KEY with single indexed-column and conflict-clause with IGNORE`,
+			"CREATE TABLE myTable (myColumn1,PRIMARY KEY (myExpr) ON CONFLICT IGNORE)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Primary:   token.New(1, 33, 32, 7, token.KeywordPrimary, "PRIMARY"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							IndexedColumn: []*ast.IndexedColumn{
+								&ast.IndexedColumn{
+									ColumnName: token.New(1, 46, 45, 6, token.Literal, "myExpr"),
+								},
+							},
+							RightParen: token.New(1, 52, 51, 1, token.Delimiter, ")"),
+							ConflictClause: &ast.ConflictClause{
+								On:       token.New(1, 54, 53, 2, token.KeywordOn, "ON"),
+								Conflict: token.New(1, 57, 56, 8, token.KeywordConflict, "CONFLICT"),
+								Ignore:   token.New(1, 66, 65, 6, token.KeywordIgnore, "IGNORE"),
+							},
+						},
+					},
+					RightParen: token.New(1, 72, 71, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and PRIMARY KEY with single indexed-column and conflict-clause with REPLACE`,
+			"CREATE TABLE myTable (myColumn1,PRIMARY KEY (myExpr) ON CONFLICT REPLACE)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Primary:   token.New(1, 33, 32, 7, token.KeywordPrimary, "PRIMARY"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							IndexedColumn: []*ast.IndexedColumn{
+								&ast.IndexedColumn{
+									ColumnName: token.New(1, 46, 45, 6, token.Literal, "myExpr"),
+								},
+							},
+							RightParen: token.New(1, 52, 51, 1, token.Delimiter, ")"),
+							ConflictClause: &ast.ConflictClause{
+								On:       token.New(1, 54, 53, 2, token.KeywordOn, "ON"),
+								Conflict: token.New(1, 57, 56, 8, token.KeywordConflict, "CONFLICT"),
+								Replace:  token.New(1, 66, 65, 7, token.KeywordReplace, "REPLACE"),
+							},
+						},
+					},
+					RightParen: token.New(1, 73, 72, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and UNIQUE`,
+			"CREATE TABLE myTable (myColumn1,UNIQUE (myExpr))",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Unique:    token.New(1, 33, 32, 6, token.KeywordUnique, "UNIQUE"),
+							LeftParen: token.New(1, 40, 39, 1, token.Delimiter, "("),
+							IndexedColumn: []*ast.IndexedColumn{
+								&ast.IndexedColumn{
+									ColumnName: token.New(1, 41, 40, 6, token.Literal, "myExpr"),
+								},
+							},
+							RightParen: token.New(1, 47, 46, 1, token.Delimiter, ")"),
+						},
+					},
+					RightParen: token.New(1, 48, 47, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name and basic foreign key clause`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+							},
+						},
+					},
+					RightParen: token.New(1, 78, 77, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and multiple column name and basic foreign key clause`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol1,myCol2) REFERENCES myForeignTable)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 6, token.Literal, "myCol1"),
+								token.New(1, 53, 52, 6, token.Literal, "myCol2"),
+							},
+							RightParen: token.New(1, 59, 58, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 61, 60, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 72, 71, 14, token.Literal, "myForeignTable"),
+							},
+						},
+					},
+					RightParen: token.New(1, 86, 85, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name, foreign key clause with single column name`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable (myNewCol))",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								LeftParen:    token.New(1, 79, 78, 1, token.Delimiter, "("),
+								ColumnName: []token.Token{
+									token.New(1, 80, 79, 8, token.Literal, "myNewCol"),
+								},
+								RightParen: token.New(1, 88, 87, 1, token.Delimiter, ")"),
+							},
+						},
+					},
+					RightParen: token.New(1, 89, 88, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name, foreign key clause with mutiple column name`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable (myNewCol1,myNewCol2))",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								LeftParen:    token.New(1, 79, 78, 1, token.Delimiter, "("),
+								ColumnName: []token.Token{
+									token.New(1, 80, 79, 9, token.Literal, "myNewCol1"),
+									token.New(1, 90, 89, 9, token.Literal, "myNewCol2"),
+								},
+								RightParen: token.New(1, 99, 98, 1, token.Delimiter, ")"),
+							},
+						},
+					},
+					RightParen: token.New(1, 100, 99, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name and foreign key clause(fkc) with variations of fkc core - ON DELETE SET NULL`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable ON DELETE SET NULL)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								ForeignKeyClauseCore: []*ast.ForeignKeyClauseCore{
+									&ast.ForeignKeyClauseCore{
+										On:     token.New(1, 79, 78, 2, token.KeywordOn, "ON"),
+										Delete: token.New(1, 82, 81, 6, token.KeywordDelete, "DELETE"),
+										Set:    token.New(1, 89, 88, 3, token.KeywordSet, "SET"),
+										Null:   token.New(1, 93, 92, 4, token.KeywordNull, "NULL"),
+									},
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 97, 96, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name and foreign key clause(fkc) with variations of fkc core - ON DELETE SET DEFAULT`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable ON DELETE SET DEFAULT)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								ForeignKeyClauseCore: []*ast.ForeignKeyClauseCore{
+									&ast.ForeignKeyClauseCore{
+										On:      token.New(1, 79, 78, 2, token.KeywordOn, "ON"),
+										Delete:  token.New(1, 82, 81, 6, token.KeywordDelete, "DELETE"),
+										Set:     token.New(1, 89, 88, 3, token.KeywordSet, "SET"),
+										Default: token.New(1, 93, 92, 7, token.KeywordDefault, "DEFAULT"),
+									},
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 100, 99, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name and foreign key clause(fkc) with variations of fkc core - ON DELETE CASCADE`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable ON DELETE CASCADE)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								ForeignKeyClauseCore: []*ast.ForeignKeyClauseCore{
+									&ast.ForeignKeyClauseCore{
+										On:      token.New(1, 79, 78, 2, token.KeywordOn, "ON"),
+										Delete:  token.New(1, 82, 81, 6, token.KeywordDelete, "DELETE"),
+										Cascade: token.New(1, 89, 88, 7, token.KeywordCascade, "CASCADE"),
+									},
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 96, 95, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name and foreign key clause(fkc) with variations of fkc core - ON DELETE RESTRICT`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable ON DELETE RESTRICT)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								ForeignKeyClauseCore: []*ast.ForeignKeyClauseCore{
+									&ast.ForeignKeyClauseCore{
+										On:       token.New(1, 79, 78, 2, token.KeywordOn, "ON"),
+										Delete:   token.New(1, 82, 81, 6, token.KeywordDelete, "DELETE"),
+										Restrict: token.New(1, 89, 88, 8, token.KeywordRestrict, "RESTRICT"),
+									},
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 97, 96, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name and foreign key clause(fkc) with variations of fkc core - ON DELETE NO ACTION`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable ON DELETE NO ACTION)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								ForeignKeyClauseCore: []*ast.ForeignKeyClauseCore{
+									&ast.ForeignKeyClauseCore{
+										On:     token.New(1, 79, 78, 2, token.KeywordOn, "ON"),
+										Delete: token.New(1, 82, 81, 6, token.KeywordDelete, "DELETE"),
+										No:     token.New(1, 89, 88, 2, token.KeywordNo, "NO"),
+										Action: token.New(1, 92, 91, 6, token.KeywordAction, "ACTION"),
+									},
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 98, 97, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name and foreign key clause(fkc) with variations of fkc core - ON UPDATE NO ACTION`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable ON UPDATE NO ACTION)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								ForeignKeyClauseCore: []*ast.ForeignKeyClauseCore{
+									&ast.ForeignKeyClauseCore{
+										On:     token.New(1, 79, 78, 2, token.KeywordOn, "ON"),
+										Update: token.New(1, 82, 81, 6, token.KeywordUpdate, "UPDATE"),
+										No:     token.New(1, 89, 88, 2, token.KeywordNo, "NO"),
+										Action: token.New(1, 92, 91, 6, token.KeywordAction, "ACTION"),
+									},
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 98, 97, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name and foreign key clause(fkc) with variations of fkc core - ON UPDATE NO ACTION`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable MATCH myMatch)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								ForeignKeyClauseCore: []*ast.ForeignKeyClauseCore{
+									&ast.ForeignKeyClauseCore{
+										Match: token.New(1, 79, 78, 5, token.KeywordMatch, "MATCH"),
+										Name:  token.New(1, 85, 84, 7, token.Literal, "myMatch"),
+									},
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 92, 91, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name and foreign key clause(fkc) with multple fkc cores`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable MATCH myMatch ON DELETE NO ACTION)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								ForeignKeyClauseCore: []*ast.ForeignKeyClauseCore{
+									&ast.ForeignKeyClauseCore{
+										Match: token.New(1, 79, 78, 5, token.KeywordMatch, "MATCH"),
+										Name:  token.New(1, 85, 84, 7, token.Literal, "myMatch"),
+									},
+									&ast.ForeignKeyClauseCore{
+										On:     token.New(1, 93, 92, 2, token.KeywordOn, "ON"),
+										Delete: token.New(1, 96, 95, 6, token.KeywordDelete, "DELETE"),
+										No:     token.New(1, 103, 102, 2, token.KeywordNo, "NO"),
+										Action: token.New(1, 106, 105, 6, token.KeywordAction, "ACTION"),
+									},
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 112, 111, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name and foreign key clause(fkc) with DEFERRABLE`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable DEFERRABLE)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								Deferrable:   token.New(1, 79, 78, 10, token.KeywordDeferrable, "DEFERRABLE"),
+							},
+						},
+					},
+					RightParen: token.New(1, 89, 88, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name and foreign key clause(fkc) with NOT DEFERRABLE`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable NOT DEFERRABLE)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								Not:          token.New(1, 79, 78, 3, token.KeywordNot, "NOT"),
+								Deferrable:   token.New(1, 83, 82, 10, token.KeywordDeferrable, "DEFERRABLE"),
+							},
+						},
+					},
+					RightParen: token.New(1, 93, 92, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name and foreign key clause(fkc) with DEFERRABLE INITIALLY DEFERRED`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable DEFERRABLE INITIALLY DEFERRED)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								Deferrable:   token.New(1, 79, 78, 10, token.KeywordDeferrable, "DEFERRABLE"),
+								Initially:    token.New(1, 90, 89, 9, token.KeywordInitially, "INITIALLY"),
+								Deferred:     token.New(1, 100, 99, 8, token.KeywordDeferred, "DEFERRED"),
+							},
+						},
+					},
+					RightParen: token.New(1, 108, 107, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single basic column-def and table-constraint and FOREIGN KEY and single column name and foreign key clause(fkc) with DEFERRABLE INITIALLY IMMEDIATE`,
+			"CREATE TABLE myTable (myColumn1,FOREIGN KEY (myCol) REFERENCES myForeignTable DEFERRABLE INITIALLY IMMEDIATE)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 9, token.Literal, "myColumn1"),
+						},
+					},
+					TableConstraint: []*ast.TableConstraint{
+						&ast.TableConstraint{
+							Foreign:   token.New(1, 33, 32, 7, token.KeywordForeign, "FOREIGN"),
+							Key:       token.New(1, 41, 40, 3, token.KeywordKey, "KEY"),
+							LeftParen: token.New(1, 45, 44, 1, token.Delimiter, "("),
+							ColumnName: []token.Token{
+								token.New(1, 46, 45, 5, token.Literal, "myCol"),
+							},
+							RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+							ForeignKeyClause: &ast.ForeignKeyClause{
+								References:   token.New(1, 53, 52, 10, token.KeywordReferences, "REFERENCES"),
+								ForeignTable: token.New(1, 64, 63, 14, token.Literal, "myForeignTable"),
+								Deferrable:   token.New(1, 79, 78, 10, token.KeywordDeferrable, "DEFERRABLE"),
+								Initially:    token.New(1, 90, 89, 9, token.KeywordInitially, "INITIALLY"),
+								Immediate:    token.New(1, 100, 99, 9, token.KeywordImmediate, "IMMEDIATE"),
+							},
+						},
+					},
+					RightParen: token.New(1, 109, 108, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint NOT NULL`,
+			"CREATE TABLE myTable (myColumn CONSTRAINT myConstraint NOT NULL)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									Constraint: token.New(1, 32, 31, 10, token.KeywordConstraint, "CONSTRAINT"),
+									Name:       token.New(1, 43, 42, 12, token.Literal, "myConstraint"),
+									Not:        token.New(1, 56, 55, 3, token.KeywordNot, "NOT"),
+									Null:       token.New(1, 60, 59, 4, token.KeywordNull, "NULL"),
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 64, 63, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint UNIQUE`,
+			"CREATE TABLE myTable (myColumn CONSTRAINT myConstraint UNIQUE)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									Constraint: token.New(1, 32, 31, 10, token.KeywordConstraint, "CONSTRAINT"),
+									Name:       token.New(1, 43, 42, 12, token.Literal, "myConstraint"),
+									Unique:     token.New(1, 56, 55, 6, token.KeywordUnique, "UNIQUE"),
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 62, 61, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint CHECK`,
+			"CREATE TABLE myTable (myColumn CONSTRAINT myConstraint CHECK (myExpr))",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									Constraint: token.New(1, 32, 31, 10, token.KeywordConstraint, "CONSTRAINT"),
+									Name:       token.New(1, 43, 42, 12, token.Literal, "myConstraint"),
+									Check:      token.New(1, 56, 55, 5, token.KeywordCheck, "CHECK"),
+									LeftParen:  token.New(1, 62, 61, 1, token.Delimiter, "("),
+									Expr: &ast.Expr{
+										LiteralValue: token.New(1, 63, 62, 6, token.Literal, "myExpr"),
+									},
+									RightParen: token.New(1, 69, 68, 1, token.Delimiter, ")"),
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 70, 69, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint COLLATE`,
+			"CREATE TABLE myTable (myColumn COLLATE myCollation)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									Collate:       token.New(1, 32, 31, 7, token.KeywordCollate, "COLLATE"),
+									CollationName: token.New(1, 40, 39, 11, token.Literal, "myCollation"),
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint fkc`,
+			"CREATE TABLE myTable (myColumn REFERENCES myForeignTable)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									ForeignKeyClause: &ast.ForeignKeyClause{
+										References:   token.New(1, 32, 31, 10, token.KeywordReferences, "REFERENCES"),
+										ForeignTable: token.New(1, 43, 42, 14, token.Literal, "myForeignTable"),
+									},
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 57, 56, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint PRIMARY KEY basic`,
+			"CREATE TABLE myTable (myColumn PRIMARY KEY)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									Primary: token.New(1, 32, 31, 7, token.KeywordPrimary, "PRIMARY"),
+									Key:     token.New(1, 40, 39, 3, token.KeywordKey, "KEY"),
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 43, 42, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint PRIMARY KEY with ASC and AUTOINCREMENT`,
+			"CREATE TABLE myTable (myColumn PRIMARY KEY ASC AUTOINCREMENT)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									Primary:       token.New(1, 32, 31, 7, token.KeywordPrimary, "PRIMARY"),
+									Key:           token.New(1, 40, 39, 3, token.KeywordKey, "KEY"),
+									Asc:           token.New(1, 44, 43, 3, token.KeywordAsc, "ASC"),
+									Autoincrement: token.New(1, 48, 47, 13, token.KeywordAutoincrement, "AUTOINCREMENT"),
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 61, 60, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint PRIMARY KEY with DESC and AUTOINCREMENT`,
+			"CREATE TABLE myTable (myColumn PRIMARY KEY DESC AUTOINCREMENT)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									Primary:       token.New(1, 32, 31, 7, token.KeywordPrimary, "PRIMARY"),
+									Key:           token.New(1, 40, 39, 3, token.KeywordKey, "KEY"),
+									Desc:          token.New(1, 44, 43, 4, token.KeywordDesc, "DESC"),
+									Autoincrement: token.New(1, 49, 48, 13, token.KeywordAutoincrement, "AUTOINCREMENT"),
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 62, 61, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint GENERATED ALWAYS and AS`,
+			"CREATE TABLE myTable (myColumn GENERATED ALWAYS AS (myExpr))",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									Generated: token.New(1, 32, 31, 9, token.KeywordGenerated, "GENERATED"),
+									Always:    token.New(1, 42, 41, 6, token.KeywordAlways, "ALWAYS"),
+									As:        token.New(1, 49, 48, 2, token.KeywordAs, "AS"),
+									LeftParen: token.New(1, 52, 51, 1, token.Delimiter, "("),
+									Expr: &ast.Expr{
+										LiteralValue: token.New(1, 53, 52, 6, token.Literal, "myExpr"),
+									},
+									RightParen: token.New(1, 59, 58, 1, token.Delimiter, ")"),
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 60, 59, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint AS and STORED`,
+			"CREATE TABLE myTable (myColumn AS (myExpr) STORED)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									As:        token.New(1, 32, 31, 2, token.KeywordAs, "AS"),
+									LeftParen: token.New(1, 35, 34, 1, token.Delimiter, "("),
+									Expr: &ast.Expr{
+										LiteralValue: token.New(1, 36, 35, 6, token.Literal, "myExpr"),
+									},
+									RightParen: token.New(1, 42, 41, 1, token.Delimiter, ")"),
+									Stored:     token.New(1, 44, 43, 6, token.KeywordStored, "STORED"),
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 50, 49, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint AS and VIRTUAL`,
+			"CREATE TABLE myTable (myColumn AS (myExpr) VIRTUAL)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									As:        token.New(1, 32, 31, 2, token.KeywordAs, "AS"),
+									LeftParen: token.New(1, 35, 34, 1, token.Delimiter, "("),
+									Expr: &ast.Expr{
+										LiteralValue: token.New(1, 36, 35, 6, token.Literal, "myExpr"),
+									},
+									RightParen: token.New(1, 42, 41, 1, token.Delimiter, ")"),
+									Virtual:    token.New(1, 44, 43, 7, token.KeywordVirtual, "VIRTUAL"),
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 51, 50, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint DEFAULT and expr`,
+			"CREATE TABLE myTable (myColumn DEFAULT (myExpr))",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									Default:   token.New(1, 32, 31, 7, token.KeywordDefault, "DEFAULT"),
+									LeftParen: token.New(1, 40, 39, 1, token.Delimiter, "("),
+									Expr: &ast.Expr{
+										LiteralValue: token.New(1, 41, 40, 6, token.Literal, "myExpr"),
+									},
+									RightParen: token.New(1, 47, 46, 1, token.Delimiter, ")"),
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 48, 47, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint DEFAULT and positive signed number 1`,
+			"CREATE TABLE myTable (myColumn DEFAULT +91)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									Default: token.New(1, 32, 31, 7, token.KeywordDefault, "DEFAULT"),
+									SignedNumber: &ast.SignedNumber{
+										Sign:           token.New(1, 40, 39, 1, token.UnaryOperator, "+"),
+										NumericLiteral: token.New(1, 41, 40, 2, token.LiteralNumeric, "91"),
+									},
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 43, 42, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint DEFAULT and negative signed number 1`,
+			"CREATE TABLE myTable (myColumn DEFAULT -91)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									Default: token.New(1, 32, 31, 7, token.KeywordDefault, "DEFAULT"),
+									SignedNumber: &ast.SignedNumber{
+										Sign:           token.New(1, 40, 39, 1, token.UnaryOperator, "-"),
+										NumericLiteral: token.New(1, 41, 40, 2, token.LiteralNumeric, "91"),
+									},
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 43, 42, 1, token.Delimiter, ")"),
+				},
+			},
+		},
+		{
+			`CREATE TABLE with single column-def with column constraint DEFAULT and negative signed number 1`,
+			"CREATE TABLE myTable (myColumn DEFAULT myLiteral)",
+			&ast.SQLStmt{
+				CreateTableStmt: &ast.CreateTableStmt{
+					Create:    token.New(1, 1, 0, 6, token.KeywordCreate, "CREATE"),
+					Table:     token.New(1, 8, 7, 5, token.KeywordTable, "TABLE"),
+					TableName: token.New(1, 14, 13, 7, token.Literal, "myTable"),
+					LeftParen: token.New(1, 22, 21, 1, token.Delimiter, "("),
+					ColumnDef: []*ast.ColumnDef{
+						&ast.ColumnDef{
+							ColumnName: token.New(1, 23, 22, 8, token.Literal, "myColumn"),
+							ColumnConstraint: []*ast.ColumnConstraint{
+								&ast.ColumnConstraint{
+									Default:      token.New(1, 32, 31, 7, token.KeywordDefault, "DEFAULT"),
+									LiteralValue: token.New(1, 40, 39, 9, token.Literal, "myLiteral"),
+								},
+							},
+						},
+					},
+					RightParen: token.New(1, 49, 48, 1, token.Delimiter, ")"),
+				},
+			},
+		},
 	}
 	for _, input := range inputs {
 		t.Run(input.Name, func(t *testing.T) {
diff --git a/internal/parser/scanner/rule_based_scanner_test.go b/internal/parser/scanner/rule_based_scanner_test.go
index 357d5a5..168dfcc 100644
--- a/internal/parser/scanner/rule_based_scanner_test.go
+++ b/internal/parser/scanner/rule_based_scanner_test.go
@@ -59,8 +59,8 @@ func TestRuleBasedScanner(t *testing.T) {
 				token.New(1, 18, 17, 2, token.BinaryOperator, "||"),
 				token.New(1, 21, 20, 1, token.BinaryOperator, "&"),
 				token.New(1, 23, 22, 1, token.UnaryOperator, "+"),
-				token.New(1, 24, 23, 1, token.Literal, "7"),
-				token.New(1, 26, 25, 1, token.Literal, "5"),
+				token.New(1, 24, 23, 1, token.LiteralNumeric, "7"),
+				token.New(1, 26, 25, 1, token.LiteralNumeric, "5"),
 				token.New(1, 28, 27, 8, token.Literal, "\"foobar\""),
 				token.New(1, 36, 35, 0, token.EOF, ""),
 			},
@@ -75,8 +75,8 @@ func TestRuleBasedScanner(t *testing.T) {
 				token.New(1, 18, 17, 2, token.BinaryOperator, "||"),
 				token.New(1, 21, 20, 1, token.BinaryOperator, "&"),
 				token.New(1, 23, 22, 1, token.UnaryOperator, "+"),
-				token.New(1, 24, 23, 1, token.Literal, "7"),
-				token.New(1, 26, 25, 3, token.Literal, "5.9"),
+				token.New(1, 24, 23, 1, token.LiteralNumeric, "7"),
+				token.New(1, 26, 25, 3, token.LiteralNumeric, "5.9"),
 				token.New(1, 30, 29, 8, token.Literal, "\"foobar\""),
 				token.New(1, 38, 37, 0, token.EOF, ""),
 			},
@@ -172,17 +172,17 @@ func TestRuleBasedScanner(t *testing.T) {
 			"7 7.5 8.9.8 8.0 0.4 10 10000 18907.890 1890976.09.977",
 			ruleset.Default,
 			[]token.Token{
-				token.New(1, 1, 0, 1, token.Literal, "7"),
-				token.New(1, 3, 2, 3, token.Literal, "7.5"),
-				token.New(1, 7, 6, 3, token.Literal, "8.9"),
-				token.New(1, 10, 9, 2, token.Literal, ".8"),
-				token.New(1, 13, 12, 3, token.Literal, "8.0"),
-				token.New(1, 17, 16, 3, token.Literal, "0.4"),
-				token.New(1, 21, 20, 2, token.Literal, "10"),
-				token.New(1, 24, 23, 5, token.Literal, "10000"),
-				token.New(1, 30, 29, 9, token.Literal, "18907.890"),
-				token.New(1, 40, 39, 10, token.Literal, "1890976.09"),
-				token.New(1, 50, 49, 4, token.Literal, ".977"),
+				token.New(1, 1, 0, 1, token.LiteralNumeric, "7"),
+				token.New(1, 3, 2, 3, token.LiteralNumeric, "7.5"),
+				token.New(1, 7, 6, 3, token.LiteralNumeric, "8.9"),
+				token.New(1, 10, 9, 2, token.LiteralNumeric, ".8"),
+				token.New(1, 13, 12, 3, token.LiteralNumeric, "8.0"),
+				token.New(1, 17, 16, 3, token.LiteralNumeric, "0.4"),
+				token.New(1, 21, 20, 2, token.LiteralNumeric, "10"),
+				token.New(1, 24, 23, 5, token.LiteralNumeric, "10000"),
+				token.New(1, 30, 29, 9, token.LiteralNumeric, "18907.890"),
+				token.New(1, 40, 39, 10, token.LiteralNumeric, "1890976.09"),
+				token.New(1, 50, 49, 4, token.LiteralNumeric, ".977"),
 				token.New(1, 54, 53, 0, token.EOF, ""),
 			},
 		},
@@ -191,23 +191,23 @@ func TestRuleBasedScanner(t *testing.T) {
 			"11.672E19 11.672E+19 11.657EE19 0xCAFEBABE 2.5E-1 1.2.3.4.5.6.7 5.hello something.4 ",
 			ruleset.Default,
 			[]token.Token{
-				token.New(1, 1, 0, 9, token.Literal, "11.672E19"),
-				token.New(1, 11, 10, 10, token.Literal, "11.672E+19"),
+				token.New(1, 1, 0, 9, token.LiteralNumeric, "11.672E19"),
+				token.New(1, 11, 10, 10, token.LiteralNumeric, "11.672E+19"),
 				token.New(1, 22, 21, 2, token.Literal, "11"),
-				token.New(1, 24, 23, 1, token.Error, "unexpected token: '.' at offset 23"),
+				token.New(1, 24, 23, 1, token.Literal, "."),
 				token.New(1, 25, 24, 7, token.Literal, "657EE19"),
-				token.New(1, 33, 32, 10, token.Literal, "0xCAFEBABE"),
-				token.New(1, 44, 43, 6, token.Literal, "2.5E-1"),
-				token.New(1, 51, 50, 3, token.Literal, "1.2"),
-				token.New(1, 54, 53, 2, token.Literal, ".3"),
-				token.New(1, 56, 55, 2, token.Literal, ".4"),
-				token.New(1, 58, 57, 2, token.Literal, ".5"),
-				token.New(1, 60, 59, 2, token.Literal, ".6"),
-				token.New(1, 62, 61, 2, token.Literal, ".7"),
-				token.New(1, 65, 64, 2, token.Literal, "5."),
+				token.New(1, 33, 32, 10, token.LiteralNumeric, "0xCAFEBABE"),
+				token.New(1, 44, 43, 6, token.LiteralNumeric, "2.5E-1"),
+				token.New(1, 51, 50, 3, token.LiteralNumeric, "1.2"),
+				token.New(1, 54, 53, 2, token.LiteralNumeric, ".3"),
+				token.New(1, 56, 55, 2, token.LiteralNumeric, ".4"),
+				token.New(1, 58, 57, 2, token.LiteralNumeric, ".5"),
+				token.New(1, 60, 59, 2, token.LiteralNumeric, ".6"),
+				token.New(1, 62, 61, 2, token.LiteralNumeric, ".7"),
+				token.New(1, 65, 64, 2, token.LiteralNumeric, "5."),
 				token.New(1, 67, 66, 5, token.Literal, "hello"),
 				token.New(1, 73, 72, 9, token.Literal, "something"),
-				token.New(1, 82, 81, 2, token.Literal, ".4"),
+				token.New(1, 82, 81, 2, token.LiteralNumeric, ".4"),
 				token.New(1, 85, 84, 0, token.EOF, ""),
 			},
 		},
@@ -278,7 +278,6 @@ func _TestRuleBasedScannerWithRuleset(input string, ruleset ruleset.Ruleset, wan
 		if len(got) < limit {
 			limit = len(got)
 		}
-
 		for i := 0; i < limit; i++ {
 			assert.Equal(want[i].Line(), got[i].Line(), "Line doesn't match")
 			assert.Equal(want[i].Col(), got[i].Col(), "Col doesn't match")