Merge pull request #13 from team-gonyo/feature/chapter13

Feature/chapter13

Author: uchijo

parse/lexer.go

@@ -83,7 +83,7 @@ func (l *Lexer) EatDelim(d rune) error {
 
 func (l *Lexer) EatIntConstant() (int32, error) {
 	if ok := l.MatchIntConstant(); !ok {
-		return 0, fmt.Errorf("tried to eat int token(%v), but got other token type(%v)", tokenInt, l.currentTokenType)
+		return 0, fmt.Errorf("tried to eat int token(%v), but got other token type(%v) with input '%v'", tokenInt, l.currentTokenType, l.input)
 	}
 	retval, err := strconv.Atoi(l.currentToken)
 	if err != nil {
@@ -100,7 +100,7 @@ func (l *Lexer) EatIntConstant() (int32, error) {
 
 func (l *Lexer) EatStringConstant() (string, error) {
 	if ok := l.MatchStringConstant(); !ok {
-		return "", fmt.Errorf("tried to eat string token(%v), but got other token type(%v)", tokenString, l.currentTokenType)
+		return "", fmt.Errorf("tried to eat string token(%v), but got other token type(%v) with input '%v'", tokenString, l.currentTokenType, l.input)
 	}
 	retval := l.currentToken
 	err := l.extractToken()
@@ -116,7 +116,7 @@ func (l *Lexer) EatStringConstant() (string, error) {
 func (l *Lexer) EatKeyword(keyword string) error {
 	keyword = strings.ToLower(keyword)
 	if ok := l.MatchKeyword(keyword); !ok {
-		return fmt.Errorf("tried to eat string token(%v), but got other token type(%v)", tokenKeyword, l.currentTokenType)
+		return fmt.Errorf("tried to eat string token(%v), but got other token type(%v) with input '%v'", tokenKeyword, l.currentTokenType, l.input)
 	}
 	if keyword != strings.ToLower(l.currentToken) {
 		return fmt.Errorf("expected keyword is %v, but got %v", keyword, l.currentToken)
@@ -132,7 +132,7 @@ func (l *Lexer) EatKeyword(keyword string) error {
 
 func (l *Lexer) EatId() (string, error) {
 	if ok := l.MatchId(); !ok {
-		return "", fmt.Errorf("tried to eat string token(%v), but got other token type(%v)", tokenIdentifier, l.currentTokenType)
+		return "", fmt.Errorf("tried to eat string token(%v), but got other token type(%v) with input '%v'", tokenIdentifier, l.currentTokenType, l.input)
 	}
 	retval := l.currentToken
 	err := l.extractToken()
@@ -291,7 +291,7 @@ func isAllowedSymbol(ch rune) bool {
 func isIdentChar(ch rune) bool {
 	isDigit := isDigitChar(ch)
 	isChar := isChar(ch)
-	return isDigit || isChar
+	return isDigit || isChar || ch == '_'
 }
 
 func isIdentStart(ch rune) bool {

parse/lexer_test.go

@@ -36,6 +36,16 @@ func TestLexerToken(t *testing.T) {
 				},
 			},
 		},
+		{
+			desc:  "parse hoge_fuga",
+			input: "hoge_fuga",
+			expected: []expects{
+				{
+					"hoge_fuga",
+					tokenIdentifier,
+				},
+			},
+		},
 		{
 			desc:  "parse 123",
 			input: "123",

parse/parser_test.go

@@ -46,6 +46,20 @@ func TestQueryParser(t *testing.T) {
 				)),
 			},
 		},
+		{
+			desc:  "parse SELECT hoge, piyo FROM fuga WHERE hoge = 1",
+			input: "SELECT hoge, piyo FROM fuga WHERE hoge = 1",
+			expected: &QueryData{
+				fields: []string{"hoge", "piyo"},
+				tables: map[string]interface{}{"fuga": struct{}{}},
+				pred: query.NewPredicateWithTerm(query.NewTerm(
+					query.NewFieldNameExpression("hoge"),
+					query.NewConstantExpression(
+						scan.NewIntConstant(1),
+					),
+				)),
+			},
+		},
 		{
 			desc:  "case insensitive",
 			input: "SELECT hoge, fuga FROM piyo WHERE hoge = 1",

plan/group_by_plan.go

@@ -0,0 +1,72 @@
+package plan
+
+import (
+	"github.com/team-gonyo/gonyo-db/query"
+	"github.com/team-gonyo/gonyo-db/record"
+	"github.com/team-gonyo/gonyo-db/scan"
+	"github.com/team-gonyo/gonyo-db/tx"
+)
+
+type GroupByPlan struct {
+	plan            Plan
+	groupFields     []string
+	aggregationFunc []query.AggregationFn
+	schema          *record.Schema
+}
+
+var _ Plan = (*GroupByPlan)(nil)
+
+func NewGroupByPlan(
+	tx *tx.Transaction,
+	plan Plan,
+	groupFields []string,
+	aggregationFuncs []query.AggregationFn,
+) *GroupByPlan {
+	schema := record.NewSchema()
+	for _, fieldName := range groupFields {
+		schema.Add(fieldName, plan.Schema())
+	}
+	for _, fn := range aggregationFuncs {
+		schema.AddIntField(fn.FieldName())
+	}
+
+	return &GroupByPlan{
+		plan: NewSortPlan(plan, groupFields, tx),
+		groupFields: groupFields,
+		aggregationFunc: aggregationFuncs,
+		schema: schema,
+	}
+}
+
+func (g *GroupByPlan) Open() (scan.Scan, error) {
+	s, err := g.plan.Open()
+	if err != nil {
+		return nil, err
+	}
+
+	return query.NewGroupByScan(s, g.groupFields, g.aggregationFunc), nil
+}
+
+func (g *GroupByPlan) BlocksAccessed() (int, error) {
+	return g.plan.BlocksAccessed()
+}
+
+func (g *GroupByPlan) RecordsOutput() int {
+	groups := 1
+	for _, fieldName := range g.groupFields {
+		groups *= g.plan.DistinctValues(fieldName)
+	}
+	return groups
+}
+
+func (g *GroupByPlan) DistinctValues(fldName string) int {
+	if g.plan.Schema().HasField(fldName) {
+		return g.plan.DistinctValues(fldName)
+	}
+
+	return g.RecordsOutput()
+}
+
+func (g *GroupByPlan) Schema() *record.Schema {
+	return g.schema
+}

plan/group_by_plan_test.go

@@ -0,0 +1,61 @@
+package plan
+
+import (
+	"testing"
+
+	"github.com/team-gonyo/gonyo-db/query"
+)
+
+func TestGroupBy(t *testing.T) {
+	db, _, _ := createTester(t)
+	tx, err := db.NewTx()
+	if err != nil {
+		t.Fatalf("Failed to create transaction: %v", err)
+	}
+	defer tx.Commit()
+
+	todoDetailPlan, err := NewTablePlan(tx, "todo_detail", db.MetadataManager())
+	if err != nil {
+		t.Fatalf("Failed to create todo_detail plan: %v", err)
+	}
+	groupByPlan := NewGroupByPlan(tx, todoDetailPlan, []string{"todo_id"}, []query.AggregationFn{NewMaxFunc("some_score")})
+	groupBySchema := groupByPlan.Schema()
+	for _, field := range groupBySchema.Fields() {
+		t.Logf("Field: %s", field)
+	}
+
+	// スキャンを開く
+	groupByScan, err := groupByPlan.Open()
+	if err != nil {
+		t.Fatalf("Failed to open group by scan: %v", err)
+	}
+	defer groupByScan.Close()
+
+	// スキャンを実行して、結果を確認
+	count := 0
+	for {
+		hasNext, err := groupByScan.Next()
+		if err != nil {
+			t.Fatalf("Failed to get next record: %v", err)
+		}
+		if !hasNext {
+			break
+		}
+
+		todoId, err := groupByScan.GetInt("todo_id")
+		if err != nil {
+			t.Fatalf("Failed to get todo_id: %v", err)
+		}
+		someScore, err := groupByScan.GetInt("maxofsome_score")
+		if err != nil {
+			t.Fatalf("Failed to get some_score: %v", err)
+		}
+
+		t.Logf("todo_id: %d, some_score: %d", todoId, someScore)
+
+		count++
+	}
+	if count != 2 {
+		t.Fatalf("Expected 2 records, got %d", count)
+	}
+}

plan/index_join_plan.go

@@ -51,8 +51,12 @@ func (ijp *IndexJoinPlan) Open() (*query.IndexJoinScan, error) {
 	return query.NewIndexJoinScan(scan1, idx, ijp.joinField, ts)
 }
 
-func (ijp *IndexJoinPlan) BlocksAccessed() int {
-	return ijp.plan1.BlocksAccessed() + (ijp.plan1.RecordsOutput() * ijp.ii.BlocksAccessed()) + ijp.RecordsOutput()
+func (ijp *IndexJoinPlan) BlocksAccessed() (int, error) {
+	plan1BlockAccesses, err := ijp.plan1.BlocksAccessed()
+	if err != nil {
+		return 0, err
+	}
+	return plan1BlockAccesses + (ijp.plan1.RecordsOutput() * ijp.ii.BlocksAccessed()) + ijp.RecordsOutput(), nil
 }
 
 func (ijp *IndexJoinPlan) RecordsOutput() int {

plan/materialize_plan.go

@@ -0,0 +1,103 @@
+package plan
+
+import (
+	"math"
+
+	"github.com/team-gonyo/gonyo-db/query"
+	"github.com/team-gonyo/gonyo-db/record"
+	"github.com/team-gonyo/gonyo-db/scan"
+	"github.com/team-gonyo/gonyo-db/tx"
+)
+
+var _ Plan = (*MaterializePlan)(nil)
+
+type MaterializePlan struct {
+	srcPlan Plan
+	tx      *tx.Transaction
+}
+
+func NewMaterializePlan(tx *tx.Transaction, srcPlan Plan) *MaterializePlan {
+	return &MaterializePlan{
+		srcPlan: srcPlan,
+		tx:      tx,
+	}
+}
+
+// これを呼ぶと仮想テーブルが作成される
+func (m *MaterializePlan) Open() (scan.Scan, error) {
+	schema := m.srcPlan.Schema()
+	tempTable, err := query.NewTempTable(m.tx, schema)
+	if err != nil {
+		return nil, err
+	}
+
+	src, err := m.srcPlan.Open()
+	if err != nil {
+		return nil, err
+	}
+	defer src.Close()
+
+	dest, err := tempTable.Open()
+	if err != nil {
+		return nil, err
+	}
+
+	// srcを進めるループ
+	for {
+		ok, err := src.Next()
+		if !ok {
+			break
+		}
+		if err != nil {
+			return nil, err
+		}
+
+		// destを空きスロットまで移動
+		err = dest.Insert()
+		if err != nil {
+			return nil, err
+		}
+		// schemaの各フィールドを舐めるループ
+		for _, fieldName := range schema.Fields() {
+			val, err := src.GetVal(fieldName)
+			if err != nil {
+				return nil, err
+			}
+
+			err = dest.SetVal(fieldName, val)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	dest.BeforeFirst()
+	return dest, nil
+}
+
+func (m *MaterializePlan) BlocksAccessed() (int, error) {
+	// create a dummy layout object to calculate slot size
+	// FIXME: エラー握りつぶし！！
+	// Plan#BlocksAccessed()のシグネチャを変えないとエラーをエスカレーションできない
+	// だが、12章のIndexPlanもPlanを実装していて、そっちがマージされてからじゃないとコンフリクトしそう
+	// 溜まったPRが落ち着いて、直せるようになった時点で対処すること
+	layout, err := record.NewLayoutFromSchema(m.Schema())
+	if err != nil {
+		return 0, err
+	}
+
+	recordPerBlock := (float64(m.tx.BlockSize())) / float64(layout.SlotSize())
+	return int(math.Ceil(float64(m.srcPlan.RecordsOutput()) / recordPerBlock)), nil
+}
+
+func (m *MaterializePlan) RecordsOutput() int {
+	return m.srcPlan.RecordsOutput()
+}
+
+func (m *MaterializePlan) DistinctValues(fldName string) int {
+	return m.srcPlan.DistinctValues(fldName)
+}
+
+func (m *MaterializePlan) Schema() *record.Schema {
+	return m.srcPlan.Schema()
+}