Use database command

lexical/lexemes.go

@@ -18,3 +18,4 @@ const L_COUNT = "count"
 const L_SHOW = "show"
 const L_TABLES = "tables"
 const L_DATABASES = "databases"
+const L_USE = "use"

lexical/lexical.go

@@ -113,7 +113,7 @@ func Token() (uint8, *TokenError) {
 			}
 			break
 		case S_ID:
-			for unicode.IsLetter(char) || unicode.IsNumber(char) || string(char) == "_" {
+			for unicode.IsLetter(char) || unicode.IsNumber(char) || string(char) == "_" || string(char) == "-" {
 				lexeme = lexeme + string(char)
 				char = nextChar()
 			}
@@ -240,6 +240,8 @@ func lexemeToToken(lexeme string) uint8 {
 		return T_TABLES
 	case L_DATABASES:
 		return T_DATABASES
+	case L_USE:
+		return T_USE
 	}
 	return T_ID
 }

lexical/tokens.go

@@ -34,6 +34,7 @@ const T_FUCK = 66
 const T_SHOW = 31
 const T_TABLES = 32
 const T_DATABASES = 33
+const T_USE = 34
 
 var tokenNameMap map[uint8]string
 
@@ -70,6 +71,7 @@ func allocMapTokenNames() {
 			T_SHOW:             "T_SHOW",
 			T_TABLES:           "T_TABLES",
 			T_DATABASES:        "T_DATABASES",
+			T_USE:              "T_USE",
 		}
 	}
 }

main.go

@@ -50,9 +50,9 @@ func main() {
 				Hidden: true,
 			},
 			&cli.BoolFlag{
-				Name:   "show-tables",
+				Name:    "show-tables",
 				Aliases: []string{"s"},
-				Hidden: true,
+				Hidden:  true,
 			},
 		},
 		Commands: []*cli.Command{
@@ -171,6 +171,9 @@ func runQuery(query, folder, typeFormat string) error {
 	case lexical.T_SHOW:
 		err = runtime.RunShow(ast)
 		break
+	case lexical.T_USE:
+		err = runtime.RunUse(ast)
+		break
 	}
 
 	return err

parser/ast.go

@@ -37,6 +37,10 @@ type NodeShow struct {
 	Databases bool
 }
 
+type NodeUse struct {
+	Branch string
+}
+
 type NodeExpr interface {
 	Assertion(lvalue, rvalue string) bool
 	Operator() uint8
@@ -137,6 +141,10 @@ func (s *NodeShow) Run() {
 	return
 }
 
+func (u *NodeUse) Run() {
+	return
+}
+
 func (e *NodeEmpty) Run() {
 	return
 }

parser/parser.go

@@ -66,6 +66,9 @@ func gProgram() (NodeMain, error) {
 	case lexical.T_SHOW:
 		node, err = gShow()
 		break
+	case lexical.T_USE:
+		node, err = gUse()
+		break
 	default:
 		err = fmt.Errorf("Error: invalid command")
 	}
@@ -162,6 +165,23 @@ func gShow() (*NodeShow, error) {
 	return node, nil
 }
 
+func gUse() (*NodeUse, error) {
+	var err *lexical.TokenError
+	look_ahead, err = lexical.Token()
+	if err != nil {
+		return nil, err
+	}
+
+	node := new(NodeUse)
+	if look_ahead != lexical.T_ID {
+		return nil, throwSyntaxError(lexical.T_ID, look_ahead)
+	}
+
+	node.Branch = lexical.CurrentLexeme
+	look_ahead, _ = lexical.Token()
+	return node, nil
+}
+
 func gTableNames() ([]string, error) {
 	if look_ahead != lexical.T_FROM {
 		return nil, throwSyntaxError(lexical.T_FROM, look_ahead)

parser/parser_test.go

@@ -710,3 +710,38 @@ func TestInvalidShow(t *testing.T) {
 		t.Fail()
 	}
 }
+
+func TestUse(t *testing.T) {
+	New("use master")
+	ast, err := AST()
+	node := ast.Child.(*NodeUse)
+
+	if err != nil {
+		t.Errorf("Error parsing 'use master': %v", err)
+	}
+
+	if node.Branch != "master" {
+		t.Errorf("NodeUse.Branch should be 'master', is '%s'", node.Branch)
+	}
+}
+
+func TestInvalidUse(t *testing.T) {
+	cases := []string{
+		"use",
+		"use master extra-param",
+	}
+
+	fail := false
+	for _, c := range cases {
+		New(c)
+		_, err := AST()
+		if err == nil {
+			t.Logf("Input '%v' should fail", c)
+			fail = true
+		}
+	}
+
+	if fail {
+		t.Fail()
+	}
+}

runtime/runtime.go

@@ -11,6 +11,7 @@ import (
 	"github.com/cloudson/gitql/parser"
 	"github.com/cloudson/gitql/semantical"
 	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/config"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/object"
 	"github.com/olekukonko/tablewriter"
@@ -143,6 +144,55 @@ func RunShow(node *parser.NodeProgram) error {
 	return nil
 }
 
+func RunUse(node *parser.NodeProgram) error {
+	builder = GetGitBuilder(node.Path)
+	u := node.Child.(*parser.NodeUse)
+
+	w, err := repo.Worktree()
+	if err != nil {
+		return err
+	}
+
+	s, err := w.Status()
+	if err != nil {
+		return err
+	}
+
+	if !s.IsClean() {
+		return fmt.Errorf("worktree is not clean")
+	}
+
+	refName := plumbing.ReferenceName(fmt.Sprintf("refs/heads/%s", u.Branch))
+	cOp := &git.CheckoutOptions{
+		Branch: refName,
+		Create: false,
+	}
+	err = w.Checkout(cOp)
+	if err != nil {
+		// Try fetching branch from origin and then switching to it.
+		// If it doesn't work, return the original error.
+		remote, remoteErr := repo.Remote("origin")
+		if remoteErr != nil {
+			return err
+		}
+		remoteErr = remote.Fetch(&git.FetchOptions{
+			RefSpecs: []config.RefSpec{
+				config.RefSpec(fmt.Sprintf("%s:%s", refName, refName)),
+			},
+		})
+		if remoteErr != nil {
+			return err
+		}
+		err = w.Checkout(cOp)
+	}
+
+	if err == nil {
+		fmt.Println("switched to database", u.Branch)
+	}
+
+	return err
+}
+
 func findWalkType(n *parser.NodeProgram) uint8 {
 	s := n.Child.(*parser.NodeSelect)
 	switch s.Tables[0] {