prepare space feature

client/main.go

@@ -95,6 +95,12 @@ func main() {
 	// for rows.Next() {  }
 	// fmt.Printf("[create] %v\n", time.Since(t))
 
+	// t = time.Now()
+	// rows, err = client.Query([]byte(`PREPARE TABLE testtable ROWS 1000000;`))
+	// exitIfErr(errors.Wrap(err, "query failed"))
+	// for rows.Next() {  }
+	// fmt.Printf("[prepare] %v\n", time.Since(t))
+
 	// t = time.Now()
 	// var insertId int
 	// setInterval(time.Second, func() {
@@ -224,7 +230,7 @@ func main() {
 	rows, err = client.Query([]byte(`
 		SELECT id, firstname, lastname
 		FROM testtable
-		WHERE_INDEX id id >= 1 AND id <= 1000000;
+		WHERE_INDEX id id >= 450000 AND id <= 460000;
 	`))
 	exitIfErr(errors.Wrap(err, "query failed"))
 	var (

pkg/index/index.go

@@ -53,8 +53,8 @@ func (i *Index) Options() bptree.Options {
 	return i.tree.Options()
 }
 
-func (i *Index) PrepareSpace(size uint32) {
-	i.tree.PrepareSpace(size)
+func (i *Index) PrepareSpace(rows int) {
+	i.tree.PrepareSpace(uint32(rows * int(i.tree.HeapSize() / i.tree.Count())))
 }
 
 func (i *Index) Close() error {

pkg/table/table.go

@@ -83,10 +83,10 @@ func (t* Table) Column(name string) *column.Column {
 	return t.meta.ColumnsMap[name]
 }
 
-func (t* Table) PrepareSpace(size uint32) {
-	t.df.PrepareSpace(size)
+func (t* Table) PrepareSpace(rows int) {
+	t.df.PrepareSpace(uint32(rows * int(t.df.HeapSize() / t.df.Count())))
 	for _, i := range t.indexes {
-		i.PrepareSpace(size)
+		i.PrepareSpace(rows)
 	}
 }
 

services/executor/dml_prepare.go

@@ -0,0 +1,39 @@
+package executor
+
+import (
+	"fmt"
+	"io"
+
+	"go-dbms/services/parser/query/dml"
+
+	"github.com/pkg/errors"
+)
+
+func (es *ExecutorServiceT) dmlPrepareValidate(q *dml.QueryPrepare) error {
+	_, ok := es.tables[q.Table]
+	if !ok {
+		return fmt.Errorf("table not found: '%s'", q.Table)
+	}
+
+	if q.Rows < 0 {
+		return fmt.Errorf("rows must be positive integer")
+	}
+
+	return nil
+}
+
+func (es *ExecutorServiceT) dmlPrepare(q *dml.QueryPrepare) (io.WriterTo, error) {
+	if err := es.dmlPrepareValidate(q); err != nil {
+		return nil, errors.Wrapf(err, "validation error")
+	}
+
+	p := newPipe(EOS)
+	go func() {
+		es.tables[q.Table].PrepareSpace(q.Rows)
+		if _, err := p.Write(EOS); err != nil {
+			panic(err)
+		}
+	}()
+
+	return p, nil
+}

services/executor/executor.go

@@ -48,12 +48,13 @@ func New(dataPath string) (*ExecutorServiceT, error) {
 
 func (es *ExecutorServiceT) Exec(q query.Querier) (io.WriterTo, error) {
 	switch q.GetType() {
-		case query.CREATE: return es.ddlCreate(q.(create.Creater))
-		case query.DELETE: return es.dmlDelete(q.(*dml.QueryDelete))
-		case query.INSERT: return es.dmlInsert(q.(*dml.QueryInsert))
-		case query.SELECT: return es.dmlSelect(q.(*dml.QuerySelect))
-		case query.UPDATE: return es.dmlUpdate(q.(*dml.QueryUpdate))
-		default:           panic(fmt.Errorf("invalid query type: '%s'", q.GetType()))
+		case query.CREATE:  return es.ddlCreate(q.(create.Creater))
+		case query.DELETE:  return es.dmlDelete(q.(*dml.QueryDelete))
+		case query.INSERT:  return es.dmlInsert(q.(*dml.QueryInsert))
+		case query.SELECT:  return es.dmlSelect(q.(*dml.QuerySelect))
+		case query.UPDATE:  return es.dmlUpdate(q.(*dml.QueryUpdate))
+		case query.PREPARE: return es.dmlPrepare(q.(*dml.QueryPrepare))
+		default:            panic(fmt.Errorf("invalid query type: '%s'", q.GetType()))
 	}
 }
 

services/parser/kwords/kwords.go

@@ -17,6 +17,10 @@ var KeyWords = map[string]struct{}{
 
 	"UPDATE": {},
 	"SET":    {},
+
+	"PREPARE": {},
+	"TABLE":   {},
+	"ROWS":    {},
 }
 
 var IndexOperators = map[string]struct{}{

services/parser/parser.go

@@ -31,7 +31,7 @@ func (ps *ParserServiceT) ParseQuery(data []byte) (query.Querier, error) {
 		switch qt {
 			case query.CREATE, query.DROP:
 				return ddl.Parse(s, qt)
-			case query.DELETE, query.INSERT, query.SELECT, query.UPDATE:
+			case query.DELETE, query.INSERT, query.SELECT, query.UPDATE, query.PREPARE:
 				return dml.Parse(s, qt)
 		}
 	}

services/parser/query/dml/dml.go

@@ -15,11 +15,12 @@ func Parse(s *scanner.Scanner, queryType query.QueryType) (query.Querier, error)
 	var q query.Querier
 
 	switch queryType {
-		case query.DELETE: q = &QueryDelete{}
-		case query.INSERT: q = &QueryInsert{}
-		case query.SELECT: q = &QuerySelect{}
-		case query.UPDATE: q = &QueryUpdate{}
-		default:           return nil, errors.New(fmt.Sprintf("unsupported query type: '%s'", queryType))
+		case query.DELETE:  q = &QueryDelete{}
+		case query.INSERT:  q = &QueryInsert{}
+		case query.SELECT:  q = &QuerySelect{}
+		case query.UPDATE:  q = &QueryUpdate{}
+		case query.PREPARE: q = &QueryPrepare{}
+		default:            return nil, errors.New(fmt.Sprintf("unsupported query type: '%s'", queryType))
 	}
 
 	return q, q.Parse(s)

services/parser/query/dml/prepare.go

@@ -0,0 +1,70 @@
+package dml
+
+import (
+	"strconv"
+	"text/scanner"
+
+	"go-dbms/services/parser/errors"
+	"go-dbms/services/parser/kwords"
+	"go-dbms/services/parser/query"
+)
+
+type QueryPrepare struct {
+	query.Query
+	DB    string
+	Table string
+	Rows  int
+}
+
+
+func (qp *QueryPrepare) Parse(s *scanner.Scanner) (err error) {
+	defer func ()  {
+		if r := recover(); r != nil {
+			var ok bool
+			err, ok = r.(error)
+			if !ok {
+				panic(r)
+			}
+		}
+	}()
+
+	qp.Type = query.PREPARE
+
+	qp.parseTable(s)
+	qp.parseRows(s)
+
+	return nil
+}
+
+func (qp *QueryPrepare) parseTable(s *scanner.Scanner) {
+	s.Scan()
+	if s.TokenText() != "TABLE" {
+		panic(errors.ErrSyntax)
+	}
+
+	s.Scan()
+	qp.Table = s.TokenText()
+	if _, isKW := kwords.KeyWords[qp.Table]; isKW {
+		panic(errors.ErrSyntax)
+	}
+}
+
+func (qp *QueryPrepare) parseRows(s *scanner.Scanner) {
+	s.Scan()
+	if s.TokenText() != "ROWS" {
+		panic(errors.ErrSyntax)
+	}
+
+	s.Scan()
+	rows, err := strconv.Atoi(s.TokenText())
+	if err != nil {
+		panic(err)
+	}
+
+	qp.Rows = rows
+
+	s.Scan()
+	if s.TokenText() != ";" {
+		panic(errors.ErrSyntax)
+	}
+}

services/parser/query/query.go

@@ -14,6 +14,7 @@ const (
 	DROP     QueryType = "DROP"
 	TRUNCATE QueryType = "TRUNCATE"
 	RENAME   QueryType = "RENAME"
+	PREPARE  QueryType = "PREPARE"
 )
 
 type Querier interface {