sql/parse: parse USING and config key-value in CREATE INDEX

Signed-off-by: Miguel Molina <miguel@erizocosmi.co>

Author: erizocosmico

sql/analyzer/validation_rules_test.go

@@ -276,6 +276,7 @@ func TestValidateIndexCreation(t *testing.T) {
 					expression.NewGetFieldWithTable(0, sql.Int64, "bar", "b", false),
 				)},
 				"",
+				make(map[string]string),
 			),
 			false,
 		},
@@ -288,6 +289,7 @@ func TestValidateIndexCreation(t *testing.T) {
 					expression.NewGetFieldWithTable(0, sql.Int64, "foo", "c", false),
 				)},
 				"",
+				make(map[string]string),
 			),
 			false,
 		},
@@ -300,6 +302,7 @@ func TestValidateIndexCreation(t *testing.T) {
 					expression.NewGetFieldWithTable(0, sql.Int64, "foo", "b", false),
 				)},
 				"",
+				make(map[string]string),
 			),
 			true,
 		},

sql/index.go

@@ -109,7 +109,7 @@ type IndexDriver interface {
 	// Create a new index. If exprs is more than one expression, it means the
 	// index has multiple columns indexed. If it's just one, it means it may
 	// be an expression or a column.
-	Create(path, table, db, id string, exprs []Expression) (Index, error)
+	Create(path, table, db, id string, exprs []Expression, config map[string]string) (Index, error)
 	// Load the index at the given path.
 	Load(path string) (Index, error)
 	// Save the given index at the given path.

sql/parse/create_index.go

@@ -24,8 +24,9 @@ type parseFunc func(*bufio.Reader) error
 func parseCreateIndex(s string) (sql.Node, error) {
 	r := bufio.NewReader(strings.NewReader(s))
 
-	var name, table string
+	var name, table, driver string
 	var exprs []string
+	var config = make(map[string]string)
 	steps := []parseFunc{
 		expect("create"),
 		skipSpaces,
@@ -37,8 +38,20 @@ func parseCreateIndex(s string) (sql.Node, error) {
 		skipSpaces,
 		readIdent(&table),
 		skipSpaces,
+		optional(
+			expect("using"),
+			skipSpaces,
+			readIdent(&driver),
+			skipSpaces,
+		),
 		readExprs(&exprs),
 		skipSpaces,
+		optional(
+			expect("with"),
+			skipSpaces,
+			readKeyValue(config),
+			skipSpaces,
+		),
 	}
 
 	for _, step := range steps {
@@ -47,9 +60,6 @@ func parseCreateIndex(s string) (sql.Node, error) {
 		}
 	}
 
-	// TODO: parse using
-	// TODO: parse config
-
 	var indexExprs = make([]sql.Expression, len(exprs))
 	for i, e := range exprs {
 		var err error
@@ -63,10 +73,128 @@ func parseCreateIndex(s string) (sql.Node, error) {
 		name,
 		plan.NewUnresolvedTable(table),
 		indexExprs,
-		"",
+		driver,
+		config,
 	), nil
 }
 
+func optional(steps ...parseFunc) parseFunc {
+	return func(rd *bufio.Reader) error {
+		for _, step := range steps {
+			err := step(rd)
+			if err == io.EOF || errUnexpectedSyntax.Is(err) {
+				return nil
+			}
+
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	}
+}
+
+func readKeyValue(kv map[string]string) parseFunc {
+	return func(rd *bufio.Reader) error {
+		r, _, err := rd.ReadRune()
+		if err != nil {
+			return err
+		}
+
+		if r != '(' {
+			return errUnexpectedSyntax.New("(", string(r))
+		}
+
+		for {
+			var key, value string
+			steps := []parseFunc{
+				skipSpaces,
+				readIdent(&key),
+				skipSpaces,
+				expectRune('='),
+				skipSpaces,
+				readValue(&value),
+				skipSpaces,
+			}
+
+			for _, step := range steps {
+				if err := step(rd); err != nil {
+					return err
+				}
+			}
+
+			r, _, err := rd.ReadRune()
+			if err != nil {
+				return err
+			}
+
+			switch r {
+			case ')':
+				kv[key] = value
+				return nil
+			case ',':
+				kv[key] = value
+				continue
+			default:
+				return errUnexpectedSyntax.New(", or )", string(r))
+			}
+		}
+	}
+}
+
+func readValue(val *string) parseFunc {
+	return func(rd *bufio.Reader) error {
+		var buf bytes.Buffer
+		var singleQuote, doubleQuote, ignoreNext bool
+		var first = true
+		for {
+			r, _, err := rd.ReadRune()
+			if err == io.EOF {
+				break
+			}
+
+			if err != nil {
+				return err
+			}
+
+			if singleQuote || doubleQuote {
+				switch true {
+				case ignoreNext:
+					ignoreNext = false
+				case r == '\\':
+					ignoreNext = true
+					continue
+				case r == '\'' && singleQuote:
+					singleQuote = false
+					continue
+				case r == '"' && doubleQuote:
+					doubleQuote = false
+					continue
+				}
+			} else if first && (r == '\'' || r == '"') {
+				if r == '\'' {
+					singleQuote = true
+				} else {
+					doubleQuote = true
+				}
+				first = false
+				continue
+			} else if !unicode.IsLetter(r) && !unicode.IsNumber(r) && r != '_' {
+				if err := rd.UnreadRune(); err != nil {
+					return err
+				}
+				break
+			}
+
+			buf.WriteRune(r)
+		}
+
+		*val = strings.ToLower(buf.String())
+		return nil
+	}
+}
+
 func parseIndexExpr(str string) (sql.Expression, error) {
 	stmt, err := sqlparser.Parse("SELECT " + str)
 	if err != nil {
@@ -123,22 +251,38 @@ func readExprs(exprs *[]string) parseFunc {
 		var buf bytes.Buffer
 		r, _, err := rd.ReadRune()
 		if err != nil {
+			if err == io.EOF {
+				return errUnexpectedSyntax.New("(", "EOF")
+			}
 			return err
 		}
 
 		if r != '(' {
-			return errUnexpectedSyntax.New("(", r)
+			return errUnexpectedSyntax.New("(", string(r))
 		}
 
 		var level int
 		var hasNonIdentChars bool
+		var singleQuote, doubleQuote bool
+		var ignoreNext bool
 		for {
 			r, _, err := rd.ReadRune()
 			if err != nil {
 				return err
 			}
 
 			switch true {
+			case singleQuote || doubleQuote:
+				switch true {
+				case ignoreNext:
+					ignoreNext = false
+				case r == '\\':
+					ignoreNext = true
+				case r == '"' && doubleQuote:
+					doubleQuote = false
+				case r == '\'' && singleQuote:
+					singleQuote = false
+				}
 			case unicode.IsLetter(r) || r == '_':
 			case r == '(':
 				level++
@@ -154,6 +298,12 @@ func readExprs(exprs *[]string) parseFunc {
 					buf.Reset()
 					return nil
 				}
+			case r == '"':
+				hasNonIdentChars = true
+				doubleQuote = true
+			case r == '\'':
+				hasNonIdentChars = true
+				singleQuote = true
 			case r == ',' && level == 0:
 				if hasNonIdentChars {
 					return errUnexpectedSyntax.New(",", ")")
@@ -171,9 +321,25 @@ func readExprs(exprs *[]string) parseFunc {
 	}
 }
 
+func expectRune(expected rune) parseFunc {
+	return func(rd *bufio.Reader) error {
+		r, _, err := rd.ReadRune()
+		if err != nil {
+			return err
+		}
+
+		if r != expected {
+			return errUnexpectedSyntax.New(expected, string(r))
+		}
+
+		return nil
+	}
+}
+
 func expect(expected string) parseFunc {
 	return func(r *bufio.Reader) error {
 		var ident string
+
 		if err := readIdent(&ident)(r); err != nil {
 			return err
 		}
@@ -198,10 +364,7 @@ func skipSpaces(r *bufio.Reader) error {
 		}
 
 		if !unicode.IsSpace(ru) {
-			if err := r.UnreadRune(); err != nil {
-				return err
-			}
-			return nil
+			return r.UnreadRune()
 		}
 	}
 }