Finished version 1.0.0

Author: mentix02

engine/store/store.go

@@ -1,4 +1,4 @@
-// package store provides APIs for low level
+// Package store provides APIs for low level
 // interaction with the key-value data store.
 package store
 
@@ -31,16 +31,16 @@ func Init() *Store {
 // Del performs a thread safe delete over keys provided and
 // returns a slice of Booleans (BaseType implement) signifying
 // successful deletion if key was found.
-func (s *Store) Del(keys []string) []types.Boolean {
+func (s *Store) Del(keys []string) []types.BaseType {
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
-	var statuses []types.Boolean
+	var statuses []types.BaseType
 	for _, key := range keys {
 		if _, ok := s.pairs[key]; ok {
 			delete(s.pairs, key)
-			statuses = append(statuses, *types.NewBoolean(true))
+			statuses = append(statuses, types.NewBoolean(true))
 		} else {
-			statuses = append(statuses, *types.NewBoolean(false))
+			statuses = append(statuses, types.NewBoolean(false))
 		}
 	}
 	return statuses

engine/types/types.go

@@ -7,147 +7,114 @@ import (
 	"unsafe"
 )
 
+// BaseType makes up the most basic building blocks of all
+// primitive data types for HellDB. There is no differentiation
+// between composite or self sufficient types.
+//
+// The Name function is a meta function that returns the string
+// identifier for a type - in case we need a strongly typed interpreter
+// that supports operations for reducing or mapping over keys.
+//
+// SizeOf returns an unsigned integer for the number of bytes taken
+// up by a data member - it's statically defined for some types (ex. Boolean),
+// grows with size for some (ex. String, Collection) and is platform dependent
+// for others (ex. Int).
+//
+// String is another meta function returns a native string
+// representation for a type useful for taking snapshots (currently
+// unsupported) before shutdown or at random intervals.
+//
+// Native returns a native Go type representation for a BaseType. Compound
+// data types can also be represented such as heterogeneous arrays (Collection)
+// since they all implement the BaseType interface and required methods.
 type BaseType interface {
 	Name() string
 	SizeOf() uint
 	String() string
 	Native() interface{}
 }
 
+// Int is a struct that implements BaseType for signed 64
+// bit integers.
 type Int struct {
-	data int64
+	Data int64 `json:"int"`
 }
 
-type String struct {
-	data string
-}
-
-type Boolean struct {
-	data bool
-}
-
-type Collection struct {
-	data []BaseType
-}
-
-/* -----------------int------------------ */
-
-func (i *Int) Name() string {
-	return "integer"
-}
-
-func (i *Int) SizeOf() uint {
-	return uint(unsafe.Sizeof(i.data))
-}
-
-func (i *Int) String() string {
-	return strconv.FormatInt(i.data, 10)
-}
-
-func (i *Int) Native() interface{} {
-	return i.data
-}
+func (i *Int) Native() interface{} { return i.Data }
+func (i *Int) Name() string        { return "integer" }
+func NewInt(data int64) *Int       { return &Int{Data: data} }
+func (i *Int) SizeOf() uint        { return uint(unsafe.Sizeof(i.Data)) }
+func (i *Int) String() string      { return strconv.FormatInt(i.Data, 10) }
 
-func NewInt(data int64) *Int {
-	return &Int{data: data}
+type String struct {
+	Data string `json:"string"`
 }
 
-/* -----------------str----------------- */
-
-func (s *String) Name() string {
-	return "str"
-}
+func (s *String) Name() string        { return "str" }
+func (s *String) String() string      { return s.Data }
+func (s *String) Native() interface{} { return s.Data }
+func (s *String) SizeOf() uint        { return uint(len(s.Data)) }
+func NewString(data string) *String   { return &String{Data: data} }
 
-func (s *String) SizeOf() uint {
-	return uint(len(s.data))
+type Boolean struct {
+	Data bool `json:"bool"`
 }
 
-func (s *String) String() string {
-	return s.data
-}
+func (b *Boolean) SizeOf() uint        { return 1 }
+func (b *Boolean) Native() interface{} { return b.Data }
+func (b *Boolean) Name() string        { return "boolean" }
+func NewBoolean(data bool) *Boolean    { return &Boolean{Data: data} }
 
-func (s *String) Native() interface{} {
-	return s.data
+func (b *Boolean) String() string {
+	if b.Data {
+		return "true"
+	} else {
+		return "false"
+	}
 }
 
-func NewString(data string) *String {
-	return &String{data: data}
+type Collection struct {
+	Data []BaseType `json:"collection"`
 }
 
-/* ----------------collection---------------- */
+func (c *Collection) Name() string              { return "collection" }
+func (c *Collection) Native() interface{}       { return serializeCollection(c) }
+func NewCollection(data []BaseType) *Collection { return &Collection{Data: data} }
 
-func (c *Collection) Name() string {
-	return "collection"
+func serializeCollection(collection *Collection) []interface{} {
+	var list []interface{}
+	for _, val := range collection.Data {
+		if c, ok := val.(*Collection); ok {
+			list = append(list, serializeCollection(c))
+		} else {
+			list = append(list, val.Native())
+		}
+	}
+	return list
 }
 
 func (c *Collection) SizeOf() uint {
-	if l := uint(len(c.data)); l == 0 {
+	if l := uint(len(c.Data)); l == 0 {
 		return 0
 	} else {
 		var total uint = 0
-		for _, item := range c.data {
+		for _, item := range c.Data {
 			total += item.SizeOf()
 		}
 		return total
 	}
 }
 
 func (c *Collection) String() string {
-	if len(c.data) == 0 {
+	if len(c.Data) == 0 {
 		return "[]"
 	} else {
 		var b strings.Builder
 		b.WriteString("[ ")
-		for i := 0; i < len(c.data)-1; i++ {
-			_, _ = fmt.Fprintf(&b, "%s, ", c.data[i].String())
+		for i := 0; i < len(c.Data)-1; i++ {
+			_, _ = fmt.Fprintf(&b, "%s, ", c.Data[i].String())
 		}
-		_, _ = fmt.Fprintf(&b, "%s ]", c.data[len(c.data)-1].String())
+		_, _ = fmt.Fprintf(&b, "%s ]", c.Data[len(c.Data)-1].String())
 		return b.String()
 	}
 }
-
-func serializeCollection(collection *Collection) []interface{} {
-	var list []interface{}
-	for _, val := range collection.data {
-		if c, ok := val.(*Collection); ok {
-			list = append(list, serializeCollection(c))
-		} else {
-			list = append(list, val.Native())
-		}
-	}
-	return list
-}
-
-func (c *Collection) Native() interface{} {
-	return serializeCollection(c)
-}
-
-func NewCollection(data []BaseType) *Collection {
-	return &Collection{data: data}
-}
-
-/* ----------------boolean---------------- */
-
-func (b *Boolean) Name() string {
-	return "boolean"
-}
-
-func (b *Boolean) SizeOf() uint {
-	return 1
-}
-
-func (b *Boolean) String() string {
-	if b.data {
-		return "true"
-	} else {
-		return "false"
-	}
-}
-
-func (b *Boolean) Native() interface{} {
-	return b.data
-}
-
-func NewBoolean(data bool) *Boolean {
-	return &Boolean{data: data}
-}

main.go

@@ -11,23 +11,35 @@ import (
 
 func main() {
 
-	clientFlag := flag.NewFlagSet("client", flag.ExitOnError)
-	serverFlag := flag.NewFlagSet("server", flag.ExitOnError)
+	const (
+		version   = "1.0.0"
+		debugStr  = "debug"
+		serverStr = "server"
+	)
+
+	debugFlag := flag.NewFlagSet(debugStr, flag.ExitOnError)
+	serverFlag := flag.NewFlagSet(serverStr, flag.ExitOnError)
+	versionPtr := flag.Bool("v", false, "displays current database version")
 
 	serverPortPtr := serverFlag.Uint("port", 8080, "port to run helldb on")
-	clientPromptPtr := clientFlag.String("prompt", ">>> ", "prompt to use for client")
+	debugPromptPtr := debugFlag.String("prompt", ">>> ", "prompt to use for client")
 
 	flag.Parse()
 
+	if *versionPtr {
+		println(version)
+		os.Exit(0)
+	}
+
 	if len(os.Args) <= 1 {
 		server.Serve(strconv.Itoa(int(*serverPortPtr)))
 	}
 
 	switch os.Args[1] {
-	case "server":
+	case debugStr:
+		evaluator.REPL(*debugPromptPtr)
+	case serverStr:
 		server.Serve(strconv.Itoa(int(*serverPortPtr)))
-	case "client":
-		evaluator.REPL(*clientPromptPtr)
 	}
 
 }

portal/evaluator/evaluator.go

@@ -3,6 +3,7 @@ package evaluator
 import (
 	"bufio"
 	"fmt"
+	"helldb/engine/types"
 	"os"
 
 	s "helldb/engine/store"
@@ -19,7 +20,7 @@ func REPL(prompt string) {
 	fmt.Print(prompt)
 	for scanner.Scan() {
 		input := scanner.Text()
-		if input == "json" {
+		if input == "dumb" {
 			fmt.Println(store.JSON())
 			fmt.Print(prompt)
 			continue
@@ -39,32 +40,25 @@ func Eval(input string) Response {
 	p := parser.New(l)
 	query := p.ParseQuery()
 	if len(p.Errors()) == 0 {
-		for _, statement := range query.Statements {
+		results := make([][]types.BaseType, len(query.Statements))
+		for i, statement := range query.Statements {
 			if valid, isGet := isGetOrDelStatement(statement); valid {
 				var keys []string
 				if isGet {
 					keys = keysFromGetStatement(statement)
+					results[i] = store.Get(keys)
 				} else {
 					keys = keysFromDelStatement(statement)
+					results[i] = store.Del(keys)
 				}
-				return Response{Errors: nil, Results: store.Get(keys)}
 			} else {
 				putStatement := statement.(*ast.PutStatement)
-				key := putStatement.Key.String()
-				element := putStatement.Value
-				switch element.(type) {
-				case *ast.IntegerLiteral:
-					store.Put(key, element.(*ast.IntegerLiteral).ToBaseType())
-				case *ast.StringLiteral:
-					store.Put(key, element.(*ast.StringLiteral).ToBaseType())
-				case *ast.BooleanLiteral:
-					store.Put(key, element.(*ast.BooleanLiteral).ToBaseType())
-				case *ast.CollectionLiteral:
-					store.Put(key, element.(*ast.CollectionLiteral).ToBaseType())
-				}
-				return Response{Errors: nil, Results: nil}
+				key, value := putStatement.Key.String(), putStatement.Value
+				store.Put(key, ast.ExtractToBaseType(value))
+				results[i] = nil
 			}
 		}
+		return Response{Errors: p.Errors(), Results: results}
 	}
 	return Response{Errors: p.Errors(), Results: nil}
 }

portal/evaluator/responses.go

@@ -1,8 +1,17 @@
 package evaluator
 
-import "helldb/engine/types"
+import (
+	"encoding/json"
+
+	"helldb/engine/types"
+)
+
+func toJson(data interface{}) string {
+	b, _ := json.Marshal(data)
+	return string(b)
+}
 
 type Response struct {
-	Errors  []string         `json:"errors"`
-	Results []types.BaseType `json:"results"`
+	Errors  []string           `json:"errors"`
+	Results [][]types.BaseType `json:"results"`
 }

portal/evaluator/utils.go

@@ -3,21 +3,24 @@ package evaluator
 import (
 	"encoding/json"
 	"fmt"
+
 	"helldb/engine/types"
 	"helldb/query/ast"
 	"helldb/query/token"
 )
 
-func showResults(results []types.BaseType) {
+func showResults(results [][]types.BaseType) {
 	for _, result := range results {
-		var res interface{}
-		if result != nil {
-			res = result.Native()
-		} else {
-			res = nil
+		for _, retValue := range result {
+			var res interface{}
+			if retValue != nil {
+				res = retValue.Native()
+			} else {
+				res = nil
+			}
+			str, _ := json.MarshalIndent(res, "", "  ")
+			fmt.Println(string(str))
 		}
-		str, _ := json.MarshalIndent(res, "", "  ")
-		fmt.Println(string(str))
 	}
 }