Implement table name resolution across compiler, CG and bytecode

Author: RohitAwate

compiler/codegen/generator.go

@@ -19,24 +19,27 @@ import (
 	"github.com/RohitAwate/commaql/compiler/ast"
 	"github.com/RohitAwate/commaql/compiler/common"
 	"github.com/RohitAwate/commaql/compiler/parser/tokenizer"
+	"github.com/RohitAwate/commaql/table"
 	"github.com/RohitAwate/commaql/vm"
 	"github.com/RohitAwate/commaql/vm/values"
 )
 
 type CodeGenerator struct {
-	statements []ast.Stmt
-	Code       vm.Bytecode
-	Errors     []common.Error
+	statements   []ast.Stmt
+	Code         vm.Bytecode
+	Errors       []common.Error
+	tableContext map[string]*table.Table
 }
 
-func NewCodeGenerator(statements []ast.Stmt) (*CodeGenerator, error) {
+func NewCodeGenerator(statements []ast.Stmt, tableContext map[string]*table.Table) (*CodeGenerator, error) {
 	if statements == nil {
 		return nil, fmt.Errorf("root of AST cannot be nil")
 	}
 
 	return &CodeGenerator{
-		statements: statements,
-		Code:       vm.NewBytecode(),
+		statements:   statements,
+		Code:         vm.NewBytecode(),
+		tableContext: tableContext,
 	}, nil
 }
 
@@ -53,11 +56,15 @@ func (cg *CodeGenerator) Run() common.PhaseStatus {
 
 func (cg *CodeGenerator) visitSelectStmt(ss *ast.SelectStmt) {
 	for _, tableNode := range ss.Tables {
-		val := values.String{Meta: tableNode.TableToken.Lexeme}
-		loc := cg.Code.AddConstant(val)
-
-		cg.Code.EmitWithArg(vm.OpLoadConst, loc)
-		cg.Code.Emit(vm.OpLoadTable)
+		if resolvedTable, ok := cg.tableContext[tableNode.TableToken.Lexeme]; !ok {
+			cg.emitError(fmt.Sprintf("unknown table: %s", tableNode.TableToken.Lexeme), tableNode.TableToken)
+			return
+		} else {
+			loc := cg.Code.AddTableContext(resolvedTable)
+			var tableRegisterIndex uint = 1 // TODO: make this dynamic for a pair of tables at a time
+			cg.Code.EmitWithArgs(vm.OpLoadTable, loc, tableRegisterIndex)
+			cg.Code.Emit(vm.OpLoadTable)
+		}
 	}
 
 	cg.Code.Emit(vm.OpSetExecCtx)
@@ -98,17 +105,17 @@ func (cg *CodeGenerator) visitLiteral(lit *ast.Literal) {
 		// TODO: Write a helper for this, lots of duplication between these cases
 		val := values.NewNumber(lit.Meta.Lexeme)
 		loc := cg.Code.AddConstant(val)
-		cg.Code.EmitWithArg(vm.OpLoadConst, loc)
+		cg.Code.EmitWithArgs(vm.OpLoadConst, loc)
 	case tokenizer.TRUE:
 		fallthrough
 	case tokenizer.FALSE:
 		val := values.NewBoolean(lit.Meta.Type)
 		loc := cg.Code.AddConstant(val)
-		cg.Code.EmitWithArg(vm.OpLoadConst, loc)
+		cg.Code.EmitWithArgs(vm.OpLoadConst, loc)
 	case tokenizer.STRING:
 		val := values.NewString(lit.Meta.Lexeme)
 		loc := cg.Code.AddConstant(val)
-		cg.Code.EmitWithArg(vm.OpLoadConst, loc)
+		cg.Code.EmitWithArgs(vm.OpLoadConst, loc)
 	default:
 		// FIXME
 	}
@@ -148,3 +155,7 @@ func (cg *CodeGenerator) visitBinaryExpr(be *ast.BinaryExpr) {
 func (cg *CodeGenerator) visitGroupedExpr(ge *ast.GroupedExpr) {
 	cg.visitExpr(&ge.InnerExpr)
 }
+
+func (cg *CodeGenerator) emitError(msg string, token common.Token) {
+	cg.Errors = append(cg.Errors, common.Error{Message: msg, Location: token.Location})
+}

compiler/compiler.go

@@ -25,7 +25,7 @@ import (
 )
 
 type Compiler struct {
-	Tables []table.Table
+	tableContext map[string]*table.Table
 }
 
 func NewCompiler(filepath string) (*Compiler, error) {
@@ -34,12 +34,16 @@ func NewCompiler(filepath string) (*Compiler, error) {
 		return nil, fmt.Errorf("file not found: %s", filepath)
 	}
 
-	csvTable, err := table.NewCSVTable(reader)
+	var csvTable table.Table
+	csvTable, err = table.NewCSVTable(reader)
 	if err != nil {
 		return nil, fmt.Errorf("could not read from file: %s", filepath)
 	}
 
-	return &Compiler{Tables: []table.Table{csvTable}}, nil
+	tableContext := map[string]*table.Table{
+		"superhero": &csvTable, // TODO: Remove hardcoded value
+	}
+	return &Compiler{tableContext: tableContext}, nil
 }
 
 func (c *Compiler) Compile(query string) {
@@ -49,8 +53,14 @@ func (c *Compiler) Compile(query string) {
 	p := parser.Parser{Tokens: tokens}
 	statements, _ := p.Run()
 
-	cg, _ := codegen.NewCodeGenerator(statements)
+	cg, _ := codegen.NewCodeGenerator(statements, c.tableContext)
 	cg.Run()
 
+	if len(cg.Errors) > 0 {
+		for _, err := range cg.Errors {
+			fmt.Println(err.Message)
+		}
+	}
+
 	disassembler.Disassemble(&cg.Code)
 }

main.go

@@ -24,7 +24,7 @@ func main() {
 				amount,
 				payment_date
 			FROM
-				customer
+				superhero
 			WHERE amount = 100 - 2
 			ORDER BY payment_date, amount;`
 

vm/bytecode.go

@@ -14,7 +14,10 @@
 
 package vm
 
-import "github.com/RohitAwate/commaql/vm/values"
+import (
+	"github.com/RohitAwate/commaql/table"
+	"github.com/RohitAwate/commaql/vm/values"
+)
 
 type OpCode uint
 
@@ -72,6 +75,7 @@ func GetOpCodeInfo(opCode OpCode) OpCodeInfo {
 type Bytecode struct {
 	Blob          []OpCode
 	ConstantsPool []values.Value
+	TableContext  []*table.Table
 }
 
 func NewBytecode() Bytecode {
@@ -86,12 +90,24 @@ func (b *Bytecode) AddConstant(v values.Value) uint {
 	return uint(len(b.ConstantsPool) - 1)
 }
 
+func (b *Bytecode) AddTableContext(t *table.Table) uint {
+	b.TableContext = append(b.TableContext, t)
+	return uint(len(b.TableContext) - 1)
+}
+
 func (b *Bytecode) Emit(oc OpCode) uint {
 	b.Blob = append(b.Blob, oc)
 	return uint(len(b.Blob))
 }
 
-func (b *Bytecode) EmitWithArg(oc OpCode, arg uint) uint {
-	b.Blob = append(b.Blob, oc, OpCode(arg))
-	return uint(len(b.Blob) - 2)
+func (b *Bytecode) EmitWithArgs(oc OpCode, args ...uint) uint {
+	convertedArgs := make([]OpCode, len(args)+1)
+
+	convertedArgs[0] = oc
+	for i, arg := range args {
+		convertedArgs[i+1] = OpCode(arg)
+	}
+
+	b.Blob = append(b.Blob, convertedArgs...)
+	return uint(len(b.Blob) - len(convertedArgs))
 }