modified type registration, added set registration

Author: gopherus

kind.go

@@ -80,12 +80,30 @@ func (k Kind) IsDropTable() bool {
 func ParseKind(SQL string) Kind {
 	SQL = removeSQLComments(SQL)
 	normalizedSQL := strings.TrimSpace(SQL)
+	if len(normalizedSQL) < 2 {
+		return KindUnknown
+	}
 	firstToken := strings.ToLower(normalizedSQL[0:2])
 	secondToken := ""
+	secondPart := ""
+
 	if index := strings.Index(normalizedSQL, " "); index != -1 {
 		for i := index; i < len(normalizedSQL); i++ {
 			if unicode.IsLetter(rune(normalizedSQL[i])) {
 				secondToken = strings.ToLower(normalizedSQL[i : i+1])
+				if i+1 < len(normalizedSQL) {
+					secondPart = normalizedSQL[i+1:]
+				}
+				break
+			}
+		}
+	}
+
+	thirdToken := ""
+	if index := strings.Index(secondPart, " "); index != -1 {
+		for i := index; i < len(secondPart); i++ {
+			if unicode.IsLetter(rune(secondPart[i])) {
+				thirdToken = strings.ToLower(secondPart[i : i+1])
 				break
 			}
 		}
@@ -108,19 +126,38 @@ func ParseKind(SQL string) Kind {
 		case 'e': //delete
 			return KindDelete
 		case 'r': //drop
+			if len(secondToken) == 0 {
+				return KindUnknown
+			}
 			switch secondToken[0] {
 			case 't': //drop table
 				return KindDropTable
 			}
 		}
 	case 'r': //register
+		if len(secondToken) == 0 {
+			return KindUnknown
+		}
 		switch secondToken[0] {
-		case 't', 'g': //register type, global type
+		case 't': //register type
 			return KindRegisterType
 		case 's': //register set
 			return KindRegisterSet
+		case 'g': //g global
+			if len(thirdToken) == 0 {
+				return KindUnknown
+			}
+			switch thirdToken[0] {
+			case 't': //register type (global type)
+				return KindRegisterType
+			case 's': //register set (global set)
+				return KindRegisterSet
+			}
 		}
 	case 'c': //create
+		if len(secondToken) == 0 {
+			return KindUnknown
+		}
 		switch secondToken[0] {
 		case 't': //create table
 			return KindCreateTable

lex.go

@@ -66,9 +66,10 @@ const (
 	deleteCode
 	withKeyword
 	unionKeyword
-	registerTypeKeyword
 	globalKeyword
-	registerSetKeyword
+	registerKeyword
+	typeKeyword
+	ttlKeyword
 )
 
 var whitespaceMatcher = parsly.NewToken(whitespaceCode, "whitespace", matcher.NewWhiteSpace())
@@ -168,13 +169,13 @@ var ifExistsMatcher = parsly.NewToken(ifExistsToken, "IF EXISTS", matcher.NewSpa
 var createTableMatcher = parsly.NewToken(createTableToken, "CREATE TABLE", matcher.NewSpacedSet([]string{
 	"create table"}, &option.Case{}))
 
-var registerType = parsly.NewToken(registerTypeKeyword, "REGISTER TYPE", matcher.NewSpacedSet([]string{
-	"register type"}, &option.Case{}))
-
-var registerSet = parsly.NewToken(registerSetKeyword, "REGISTER SET", matcher.NewSpacedSet([]string{
-	"register set"}, &option.Case{}))
-
 var defaultMatcher = parsly.NewToken(defaultToken, "DEFAULT", matcher.NewKeyword("default", &option.Case{}))
 
 var dropTableMatcher = parsly.NewToken(dropTableToken, "DROP TABLE", matcher.NewSpacedSet([]string{
 	"drop table"}, &option.Case{}))
+
+var registerKeywordMatcher = parsly.NewToken(registerKeyword, "REGISTER", matcher.NewKeyword("register", &option.Case{}))
+
+var typeKeywordMatcher = parsly.NewToken(typeKeyword, "TYPE", matcher.NewKeyword("type", &option.Case{}))
+
+var ttlKeywordMatcher = parsly.NewToken(ttlKeyword, "With TTL", matcher.NewFragment("with ttl", &option.Case{Sensitive: false}))

schema.go

@@ -1,6 +1,7 @@
 package sqlparser
 
 import (
+	"fmt"
 	"github.com/viant/parsly"
 	"github.com/viant/sqlparser/schema"
 	"strings"
@@ -16,13 +17,18 @@ func ParseRegisterType(SQL string) (*schema.Register, error) {
 }
 
 func parseRegisterType(cursor *parsly.Cursor, destination *schema.Register) error {
-	match := cursor.MatchAfterOptional(whitespaceMatcher, registerType)
-	if match.Code != registerTypeKeyword {
-		return cursor.NewError(registerType)
+	match := cursor.MatchAfterOptional(whitespaceMatcher, registerKeywordMatcher)
+	if match.Code != registerKeyword {
+		return cursor.NewError(registerKeywordMatcher)
 	}
 	if match = cursor.MatchAfterOptional(whitespaceMatcher, globalMatcher); match.Code == globalKeyword {
 		destination.Global = true
 	}
+
+	match = cursor.MatchAfterOptional(whitespaceMatcher, typeKeywordMatcher)
+	if match.Code != typeKeyword {
+		return cursor.NewError(typeKeywordMatcher)
+	}
 	match = cursor.MatchAfterOptional(whitespaceMatcher, selectorMatcher)
 	if match.Code != selectorTokenCode {
 		return cursor.NewError(selectorMatcher)
@@ -37,23 +43,41 @@ func parseRegisterType(cursor *parsly.Cursor, destination *schema.Register) erro
 }
 
 // ParseRegisterSet parses register set
-func ParseRegisterSet(SQL string) (*schema.Register, error) {
-	result := &schema.Register{}
+func ParseRegisterSet(SQL string) (*schema.RegisterSet, error) {
+	result := &schema.RegisterSet{}
 	SQL = removeSQLComments(SQL)
 	cursor := parsly.NewCursor("", []byte(SQL), 0)
 	err := parseRegisterSet(cursor, result)
 	return result, err
 }
 
-// TODO create parse register object
-func parseRegisterSet(cursor *parsly.Cursor, destination *schema.Register) error {
-	match := cursor.MatchAfterOptional(whitespaceMatcher, registerSet)
-	if match.Code != registerSetKeyword {
-		return cursor.NewError(registerSet)
+func parseRegisterSet(cursor *parsly.Cursor, destination *schema.RegisterSet) error {
+	match := cursor.MatchAfterOptional(whitespaceMatcher, registerKeywordMatcher)
+	if match.Code != registerKeyword {
+		return cursor.NewError(registerKeywordMatcher)
 	}
 	if match = cursor.MatchAfterOptional(whitespaceMatcher, globalMatcher); match.Code == globalKeyword {
 		destination.Global = true
 	}
+	match = cursor.MatchAfterOptional(whitespaceMatcher, setKeywordMatcher)
+	if match.Code != setKeyword {
+		return cursor.NewError(setKeywordMatcher)
+	}
+
+	match = cursor.MatchAfterOptional(whitespaceMatcher, ttlKeywordMatcher)
+	if match.Code == ttlKeyword {
+		match = cursor.MatchAfterOptional(whitespaceMatcher, intLiteralMatcher)
+		if match.Code != intLiteralMatcher.Code {
+			return cursor.NewError(setKeywordMatcher)
+		}
+
+		ttl64, err := match.Int(cursor)
+		if err != nil {
+			return fmt.Errorf("parseregisterset unable to get int value due to: %w", err)
+		}
+		destination.TTL = int(ttl64)
+	}
+
 	match = cursor.MatchAfterOptional(whitespaceMatcher, selectorMatcher)
 	if match.Code != selectorTokenCode {
 		return cursor.NewError(selectorMatcher)

schema/register.go

@@ -6,3 +6,8 @@ type Register struct {
 	Global bool
 	Spec   string
 }
+
+type RegisterSet struct {
+	Register
+	TTL int
+}