缘起

最近复习设计模式
拜读谭勇德的<<设计模式就该这样学>>
本系列笔记拟采用golang练习之

解释器模式

  1. 解释器模式（Interpreter Pattern）指给定一门语言，
  2. 定义它的文法的一种表示，
  3. 并定义一个解释器
  4. ，该解释器使用该表示来解释语言中的句子。
  5. 解释器模式是一种按照规定的文法（语法）进行解析的模式，
  6. 属于行为型设计模式。
  8. (摘自 谭勇德 <<设计模式就该这样学>>)

场景

  • 某业务系统, 随数据量增加, 数据库访问压力日渐增大
  • 业务team希望平台team提供透明的缓存解决方案以缓解数据库压力
  • 平台team经反复讨论研究, 决定采用解释器模式, 直接拦截/解析/执行SQL(子集)语句, 提供透明化缓存服务

SQL(子集)文法

  1. SQL:
  2.   select + FIELD_LIST + from TABLE_NAME + (where BOOL_EXPRESSION)?
  4. FIELD_LIST:
  5.     *
  6.   | COLUMN_LIST
  8. COLUMN_LIST:
  9.     COLUMN_NAME + (,COLUMN_NAME)*
  11. COLUMN_NAME:
  12.     IDENTIFIER
  14. IDENTIFIER:
  15.     [_a-zA-Z] + [_a-zA-Z0-9]*
  17. TABLE_NAME: 
  18.   IDENTIFIER
  20. BOOL_EXPRESSION:
  21.     STRING_FIELD = STRING_LITERAL
  22.   | STRING_FIELD <> STRING_LITERAL
  23.   | STRING_FIELD like STRING_LITERAL
  24.   | STRING_FIELD not like STRING_LITERAL
  25.   | INT_FIELD = INT_LITERAL
  26.   | INT_FIELD <> INT_LITERAL
  27.   | INT_FIELD > INT_LITERAL
  28.   | INT_FIELD >= INT_LITERAL
  29.   | INT_FIELD < INT_LITERAL
  30.   | INT_FIELD <= INT_LITERAL
  31.   | ( + BOOL_EXPRESSION + )
  32.   | BOOL_EXPRESSION and BOOL_EXPRESSION
  33.   | BOOL_EXPRESSION or BOOL_EXPRESSION
  35. STRING_FIELD:
  36.     IDENTIFIER
  38. INT_FIELD:
  39.     IDENTIFIER
  41. STRING_LITERAL:
  42.     \" + [^"]* + \"
  44. INT_LIETRAL:
  45.     [1-9] + [0-9]*

设计

  • IDatabase: 数据库接口
  • IDataTable: 数据表接口
  • IDataRow: 数据行接口
  • IDataField: 数据字段接口
  • IRowFilter: 数据行过滤器接口
  • tEmptyRowFilter: 静态为true/false的行过滤器
  • tExpressionRowFilter: 基于布尔表达式的行过滤器
  • Tokens: SQL(子集)记号枚举
  • Nodes: SQL(子集)语法树节点枚举
  • Chars: 词法分析辅助类
  • ISQLParser: SQL(子集)词法分析器接口
  • Lexer: 词法分析实现
  • Parser: 语法分析实现, SQL(子集)解释器的核心
  • tTokenQueue: 词法节点队列
  • tArrayStack: 基于数组实现的LIFO堆栈
  • IBoolExpression: 布尔表达式接口
  • tFieldExpression: 基于字段计算的布尔表达式
  • tLogicExpression: 基于关系(AND/OR)计算的布尔表达式
  • SaleOrder: 销售订单实体类
  • ISaleOrderService: 销售订单服务接口, 继承自IDataTable接口
  • tMockDatabase: 虚拟的数据库服务, 实现IDatabase接口
  • tMockSaleOrderService: 虚拟的销售订单服务, 实现ISaleOrderService接口

单元测试

interpreter_pattern_test.go, 模拟销售订单的保存与SQL查询

  1. package behavioral_patterns
  3. import (
  4.     "learning/gooop/behavioral_patterns/interpreter"
  5.     "testing"
  6. )
  8. func Test_Interpreter(t *testing.T) {
  9.     service := interpreter.MockSaleOrderService
  10.     service.Save(interpreter.NewSaleOrder(1, "张三", "广州", "电视", 10))
  11.     service.Save(interpreter.NewSaleOrder(11, "张三三", "广州", "电视", 11))
  12.     service.Save(interpreter.NewSaleOrder(2, "李四", "深圳", "冰箱", 20))
  13.     service.Save(interpreter.NewSaleOrder(22, "李四四", "深圳", "冰箱", 21))
  14.     service.Save(interpreter.NewSaleOrder(3, "王五", "东莞", "空调", 30))
  15.     service.Save(interpreter.NewSaleOrder(33, "王五五", "东莞", "空调", 31))
  18.     db := interpreter.MockDatabase
  19.     e,rows := db.Query("select * from sale_order where (city='广州' or city='深圳') and quantity>10")
  20.     if e != nil {
  21.         t.Error(e)
  22.     } else {
  23.         for _,it := range rows {
  24.             t.Logf("%s", it)
  25.         }
  26.     }
  27. }

测试输出

  1. $ go test -v interpreter_pattern_test.go 
  2. === RUN   Test_Interpreter
  3.     interpreter_pattern_test.go:24: id=2, customer=李四, city=深圳, product=冰箱, quantity=20
  4.     interpreter_pattern_test.go:24: id=22, customer=李四四, city=深圳, product=冰箱, quantity=21
  5.     interpreter_pattern_test.go:24: id=11, customer=张三三, city=广州, product=电视, quantity=11
  6. --- PASS: Test_Interpreter (0.00s)
  7. PASS
  8. ok      command-line-arguments  0.002s

IDatabase.go

数据库接口

  1. package interpreter
  3. type IDatabase interface {
  4.     Register(table IDataTable)
  5.     Query(sql string) (error, []IDataRow)
  6. }

IDataTable.go

数据表接口

  1. package interpreter
  3. type IDataTable interface {
  4.     Name() string
  5.     Filter(filter IRowFilter) []IDataRow
  6. }

IDataRow.go

数据行接口

  1. package interpreter
  3. type IDataRow interface {
  4.     GetField(field string) (error,IDataField)
  5. }

IDataField.go

数据字段接口

  1. package interpreter
  3. import (
  4.     "errors"
  5. )
  7. type IDataField interface {
  8.     Name() string
  9.     DataType() DataTypes
  10.     GetString() (error,string)
  11.     GetInt() (error, int)
  12. }
  15. type DataTypes int
  16. const StringDataType DataTypes = 1
  17. const IntDataType DataTypes = 2
  20. type tIntField struct {
  21.     name string
  22.     value int
  23. }
  25. func newIntField(name string, value int) *tIntField {
  26.     return &tIntField{
  27.         name,value,
  28.     }
  29. }
  31. func (me *tIntField) Name() string {
  32.     return me.name
  33. }
  35. func (me *tIntField) DataType() DataTypes {
  36.     return IntDataType
  37. }
  39. func (me *tIntField) GetString() (error,string) {
  40.     return errors.New("not implemented"), ""
  41. }
  43. func (me *tIntField) GetInt() (error,int) {
  44.     return nil, me.value
  45. }
  48. type tStringField struct {
  49.     name string
  50.     value string
  51. }
  53. func newStringField(name string, value string) *tStringField {
  54.     return &tStringField{
  55.         name,value,
  56.     }
  57. }
  59. func (me *tStringField) Name() string {
  60.     return me.name
  61. }
  63. func (me *tStringField) DataType() DataTypes {
  64.     return StringDataType
  65. }
  67. func (me *tStringField) GetString() (error,string) {
  68.     return nil, me.value
  69. }
  71. func (me *tStringField) GetInt() (error,int) {
  72.     return errors.New("not implemented"), 0
  73. }

IRowFilter.go

数据行过滤器接口

  1. package interpreter
  3. type IRowFilter interface {
  4.     Filter(row IDataRow) bool
  5. }

tEmptyRowFilter.go

静态为true/false的行过滤器

  1. package interpreter
  3. type tEmptyRowFilter struct {
  4.     accept bool
  5. }
  7. func newEmptyRowFilter(accept bool) IRowFilter {
  8.     return &tEmptyRowFilter{
  9.         accept: accept,
  10.     }
  11. }
  13. func (me *tEmptyRowFilter) Filter(row IDataRow) bool {
  14.     return me.accept
  15. }

tExpressionRowFilter.go

基于布尔表达式的行过滤器

  1. package interpreter
  4. type tExpressionRowFilter struct {
  5.     expression IBoolExpression
  6. }
  8. func newExpressionRowFilter(e IBoolExpression) IRowFilter {
  9.     return &tExpressionRowFilter{
  10.         expression: e,
  11.     }
  12. }
  14. func (me *tExpressionRowFilter) Filter(row IDataRow) bool {
  15.     return me.expression.Eval(row)
  16. }

Tokens.go

SQL记号枚举

  1. package tokens
  3. type Tokens string
  5. const Select Tokens = "select"
  6. const Star Tokens = "*"
  7. const Comma Tokens = ","
  8. const From Tokens = "from"
  9. const Where Tokens = "where"
  10. const Identifier Tokens = "identifier"
  11. const LB Tokens = "("
  12. const RB Tokens = ")"
  13. const And Tokens = "and"
  14. const OR Tokens = "or"
  15. const Equal Tokens = "="
  16. const NotEqual Tokens = "<>"
  17. const Greater Tokens = ">"
  18. const GreaterEqual Tokens = ">="
  19. const Less Tokens = "<"
  20. const LessEqual Tokens = "<="
  21. const Like Tokens = "like"
  22. const NotLike Tokens = "not like"
  23. const StringLiteral Tokens = "string_literal"
  24. const IntLiteral Tokens = "int_literal"

Nodes.go

SQL语法树节点枚举

  1. package nodes
  3. type Nodes int
  4. const TokenNode Nodes = 1
  5. const ExpressionNode Nodes = 2

Chars.go

词法分析辅助类

  1. package interpreter
  4. type tChars struct {
  6. }
  9. func newCharsLib() *tChars {
  10.     return &tChars{}
  11. }
  13. func (me *tChars) IsSpace(it rune) bool {
  14.     switch it {
  15.     case ' ':
  16.         return true
  17.     case '\t':
  18.         return true
  19.     case '\r':
  20.         return true
  21.     case '\n':
  22.         return true
  23.     }
  25.     return false
  26. }
  29. func (me *tChars) Is09(it rune) bool {
  30.     return it >= '0' && it <= '9'
  31. }
  33. func (me *tChars) Is19(it rune) bool {
  34.     return it >= '1' && it <= '9'
  35. }
  37. func (me *tChars) IsLetter(it rune) bool {
  38.     return (it >= 'a' && it <= 'z') || (it >= 'A' && it <= 'Z')
  39. }
  41. func (me *tChars) IsUnderscore(it rune) bool {
  42.     return it == '_'
  43. }
  45. func (me *tChars) IsLB(it rune) bool {
  46.     return it == '('
  47. }
  49. func (me *tChars) IsRB(it rune) bool {
  50.     return it == ')'
  51. }
  53. func (me *tChars) IsChar(it rune, args... rune) bool {
  54.     for _,v := range args {
  55.         if v == it {
  56.             return true
  57.         }
  58.     }
  59.     return false
  60. }
  62. var chars = newCharsLib()

ISQLParser.go

SQL词法分析器接口

  1. package interpreter
  4. type ISQLParser interface {
  5.     Parse(sql string) (error,*ParseResult)
  6. }
  9. type ParseResult struct {
  10.     Fields []string
  11.     Table string
  12.     RowFilter IRowFilter
  13. }
  15. func newParseResult() *ParseResult {
  16.     return &ParseResult{
  17.         make([]string, 0),
  18.         "",
  19.         nil,
  20.     }
  21. }

Lexer.go

SQL(子集)词法分析实现

  1. package interpreter
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "learning/gooop/behavioral_patterns/interpreter/tokens"
  7. )
  10. type tLexer struct {
  11.     chars []rune
  12.     count int
  13.     pos int
  14.     tokens []*tTokenNode
  15. }
  17. func newLexer(sql string) *tLexer {
  18.     chars := []rune(sql)
  19.     return &tLexer{
  20.         chars: chars,
  21.         count: len(chars),
  22.         pos: 0,
  23.         tokens: make([]*tTokenNode, 0),
  24.     }
  25. }
  28. func (me *tLexer) push(it *tTokenNode) {
  29.     me.tokens = append(me.tokens, it)
  30. }
  32. func (me *tLexer) Parse() (error, []*tTokenNode) {
  33.     fnMatchingWord := func(t tokens.Tokens) bool {
  34.         pattern := string(t)
  35.         from := me.pos
  36.         if me.MatchingConst(pattern) && me.MatchingSpace() {
  37.             me.push(newTokenNode(t, string(t), from, me.pos - 1))
  38.             return true
  39.         }
  41.         return false
  42.     }
  44.     fnMatchingOP := func(t tokens.Tokens) bool {
  45.         pattern := string(t)
  46.         from := me.pos
  47.         if me.MatchingConst(pattern) {
  48.             me.push(newTokenNode(t, string(t), from, me.pos - 1))
  49.             return true
  50.         }
  52.         return false
  53.     }
  55.     for {
  56.         // eof
  57.         if me.IsEof() {
  58.             return nil, me.tokens
  59.         }
  61.         me.SkipSpace()
  62.         from := me.pos
  64.         // select, from, where
  65.         if fnMatchingWord(tokens.Select) || fnMatchingWord(tokens.From) || fnMatchingWord(tokens.Where) {
  66.             continue
  67.         }
  69.         // start,comma
  70.         if fnMatchingWord(tokens.Star) || fnMatchingWord(tokens.Comma) {
  71.             continue
  72.         }
  74.         // and, or
  75.         if fnMatchingWord(tokens.And) {
  76.             continue
  77.         } else if fnMatchingWord(tokens.OR) {
  78.             continue
  79.         }
  81.         // like, not like
  82.         if fnMatchingWord(tokens.Like) {
  83.             continue
  84.         } else if fnMatchingWord(tokens.NotLike) {
  85.             continue
  86.         }
  88.         // (, )
  89.         if fnMatchingOP(tokens.LB) {
  90.             continue
  91.         } else if fnMatchingOP(tokens.RB) {
  92.             continue
  93.         }
  95.         // =,<>,>,>=,<,<=
  96.         if fnMatchingOP(tokens.Equal) {
  97.             continue
  98.         } else if fnMatchingOP(tokens.NotEqual) {
  99.             continue
  100.         } else if fnMatchingOP(tokens.GreaterEqual) {
  101.             continue
  102.         } else if fnMatchingOP(tokens.Greater) {
  103.             continue
  104.         } else if fnMatchingOP(tokens.LessEqual) {
  105.             continue
  106.         } else if fnMatchingOP(tokens.Less) {
  107.             continue
  108.         }
  110.         // identifier
  111.         b,v := me.MatchingIdentifier()
  112.         if b {
  113.             me.push(newTokenNode(tokens.Identifier, v, from, from + len(v)))
  114.             continue
  115.         }
  117.         // string literal
  118.         b,v = me.MatchingString()
  119.         if b {
  120.             me.push(newTokenNode(tokens.StringLiteral, v, from, from + len(v)))
  121.             continue
  122.         }
  124.         // int literal
  125.         b,v = me.MatchingInt()
  126.         if b {
  127.             me.push(newTokenNode(tokens.IntLiteral, v, from, from + len(v)))
  128.             continue
  129.         }
  131.         // unknown
  132.         return errors.New(fmt.Sprintf("unknown token at %v", from)), nil
  133.     }
  134. }
  137. func (me *tLexer) IsEof() bool {
  138.     return me.pos >= me.count
  139. }
  141. func (me *tLexer) SkipSpace() {
  142.     for {
  143.         if me.pos >= me.count {
  144.             break
  145.         }
  147.         if chars.IsSpace(me.Char()) {
  148.             me.pos++
  149.         } else {
  150.             break
  151.         }
  152.     }
  153. }
  155. func (me *tLexer) MatchingConst(s string) bool {
  156.     pattern := []rune(s)
  157.     for i,it := range pattern {
  158.         n := me.pos + i
  159.         if n >= me.count {
  160.             return false
  161.         }
  162.         if me.chars[n] != it {
  163.             return false
  164.         }
  165.     }
  167.     me.pos += len(pattern)
  168.     return true
  169. }
  171. func (me *tLexer) Char() rune {
  172.     if me.pos >= me.count {
  173.         return 0
  174.     }
  176.     return me.chars[me.pos]
  177. }
  179. func (me *tLexer) MatchingSpace() bool {
  180.     if chars.IsSpace(me.Char()) {
  181.         me.pos++
  182.         return true
  183.     }
  184.     return false
  185. }
  187. func (me *tLexer) MatchingString() (bool,string) {
  188.     mark := me.pos
  190.     if me.Char() != '\'' {
  191.         return false, ""
  192.     }
  194.     i := mark
  195.     for {
  196.         i++
  198.         switch me.chars[i] {
  199.         case '\'':
  200.             me.pos = i + 1
  201.             return true, string(me.chars[mark:me.pos])
  203.         default:
  204.             if i >= me.count {
  205.                 return false, ""
  206.             }
  207.         }
  208.     }
  209. }
  212. func (me *tLexer) MatchingIdentifier() (bool, string) {
  213.     mark := me.pos
  215.     c := me.Char()
  216.     if !(chars.IsUnderscore(c) || chars.IsLetter(c)) {
  217.         return false, ""
  218.     }
  220.     i := mark
  221.     for {
  222.         i++
  223.         if i > mark + 30 {
  224.             return false,""
  225.         }
  227.         it := me.chars[i]
  228.         if chars.IsLetter(it) || chars.Is09(it) || chars.IsUnderscore(it) {
  229.             continue
  231.         } else {
  232.             me.pos = i
  233.             return true, string(me.chars[mark:i])
  234.         }
  235.     }
  236. }
  239. func (me *tLexer) MatchingInt() (bool, string) {
  240.     if me.Char() == '0' {
  241.         me.pos++
  242.         return true, "0"
  243.     }
  245.     mark := me.pos
  247.     if !chars.Is19(me.Char()) {
  248.         return false, ""
  249.     }
  251.     i := mark
  252.     for {
  253.         i++
  254.         if i >= me.count {
  255.             me.pos = me.count
  256.             return true, string(me.chars[mark:])
  257.         }
  259.         if i > mark + 10 {
  260.             return false, ""
  261.         }
  263.         it := me.chars[i]
  264.         if chars.Is09(it) {
  265.             continue
  266.         }
  268.         if chars.IsSpace(it) {
  269.             me.pos = i - 1
  270.             return true, string(me.chars[mark:i])
  272.         } else {
  273.             return false, ""
  274.         }
  275.     }
  276. }

Parser.go

语法分析实现

  1. package interpreter
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "learning/gooop/behavioral_patterns/interpreter/tokens"
  7.     "strconv"
  8. )
  10. type tSQLParser struct {
  11.     result *ParseResult
  12. }
  15. func newSQLParser() ISQLParser {
  16.     return &tSQLParser{
  17.         newParseResult(),
  18.     }
  19. }
  21. func (me *tSQLParser) Parse(sql string) (error,*ParseResult) {
  22.     lexer := newLexer(sql)
  23.     e, tks := lexer.Parse()
  24.     if e != nil {
  25.         return e, nil
  26.     }
  28.     queue := newTokenQueue(tks)
  30.     // select (* | field-list)
  31.     e = me.ParseSelectPart(queue)
  32.     if e != nil {
  33.         return e, nil
  34.     }
  36.     // from
  37.     e = me.ParseFromPart(queue)
  38.     if e != nil {
  39.         return e, nil
  40.     }
  42.     // where + bool_expression
  43.     e = me.ParseWherePart(queue)
  44.     if e != nil {
  45.         return e, nil
  46.     }
  48.     // eof
  49.     if !queue.IsEmpty() {
  50.         _,t := queue.Poll()
  51.         return errors.New(fmt.Sprintf("expecting EOF at %v", t.from)), nil
  52.     }
  54.     return nil, me.result
  55. }
  57. func (me *tSQLParser) ParseSelectPart(queue *tTokenQueue) error {
  58.     b,v := queue.Poll()
  59.     if !b {
  60.         return errors.New("expecting SELECT keyword")
  61.     }
  63.     if v.token != tokens.Select {
  64.         return errors.New(fmt.Sprintf("expecting SELECT keyword but found '%s'", v.value))
  65.     }
  67.     fields := make([]string, 0)
  69.     b,v = queue.Peek()
  70.     if !b {
  71.         return errors.New("unexpected EOF")
  72.     }
  74.     switch v.token {
  75.     case tokens.Star:
  76.         queue.Poll()
  77.         fields = append(fields, v.value)
  78.         break
  80.     case tokens.Identifier:
  81.         queue.Poll()
  82.         fields = append(fields, v.value)
  83.         break
  85.     default:
  86.         return errors.New(fmt.Sprintf("expecting column name but found '%s'", v.value))
  87.     }
  89.     for {
  90.         b,v := queue.Peek()
  91.         if !b {
  92.             break
  93.         }
  95.         if v.token != tokens.Comma {
  96.             break
  97.         }
  98.         queue.Poll()
  100.         b,v = queue.Peek()
  101.         if !b || v.token != tokens.Identifier {
  102.             return errors.New(fmt.Sprintf("expecting column name but found '%s'", v.value))
  103.         }
  104.         queue.Poll()
  105.         fields = append(fields, v.value)
  106.     }
  108.     if len(fields) > 0 {
  109.         me.result.Fields = fields
  110.         return nil
  111.     }
  113.     return errors.New("expecting column names")
  114. }
  117. func (me *tSQLParser) ParseFromPart(queue *tTokenQueue) error {
  118.     b,v1 := queue.Poll()
  119.     if !b {
  120.         return errors.New("expecting 'from', but eof")
  121.     }
  123.     if v1.token != tokens.From {
  124.         return errors.New(fmt.Sprintf("expecting 'from' at %v", v1.from))
  125.     }
  127.     b,v2 := queue.Poll()
  128.     if !b {
  129.         return errors.New("expecting table name, but eof")
  130.     }
  131.     if v2.token == tokens.Identifier {
  132.         me.result.Table = v2.value
  133.         return nil
  134.     }
  136.     return errors.New(fmt.Sprintf("expecting table name at %v", v2.from))
  137. }
  140. func (me *tSQLParser) ParseWherePart(queue *tTokenQueue) error {
  141.     if queue.IsEmpty() {
  142.         // no where clause
  143.         me.result.RowFilter = newEmptyRowFilter(true)
  144.         return nil
  145.     }
  147.     _,v1 := queue.Poll()
  148.     if v1.token != tokens.Where {
  149.         return errors.New(fmt.Sprintf("expecting 'where' keyword at %v", v1.from))
  150.     }
  152.     stack := newArrayStack()
  153.     e, expression := me.ParseWhereExpression(queue, stack)
  154.     if e != nil {
  155.         return e
  156.     }
  158.     me.result.RowFilter = newExpressionRowFilter(expression)
  159.     return nil
  160. }
  163. func (me *tSQLParser) ParseWhereExpression(queue *tTokenQueue, stack *tArrayStack) (error, IBoolExpression) {
  164.     for {
  165.         if queue.IsEmpty() {
  166.             break
  167.         }
  169.         _,t := queue.Poll()
  170.         switch t.token {
  171.         case tokens.LB:
  172.             stack.Push(t)
  173.             break
  175.         case tokens.Identifier:
  176.             stack.Push(t)
  177.             break
  179.         case tokens.Equal:
  180.             stack.Push(t)
  181.             break
  183.         case tokens.NotEqual:
  184.             stack.Push(t)
  185.             break
  187.         case tokens.Like:
  188.             stack.Push(t)
  189.             break
  191.         case tokens.NotLike:
  192.             stack.Push(t)
  193.             break
  195.         case tokens.Greater:
  196.             stack.Push(t)
  197.             break
  199.         case tokens.GreaterEqual:
  200.             stack.Push(t)
  201.             break
  203.         case tokens.Less:
  204.             stack.Push(t)
  205.             break
  207.         case tokens.LessEqual:
  208.             stack.Push(t)
  209.             break
  211.         case tokens.And:
  212.             stack.Push(t)
  213.             break
  215.         case tokens.OR:
  216.             stack.Push(t)
  217.             break
  219.         case tokens.StringLiteral:
  220.             // field op string
  221.             b, v := stack.Pop()
  222.             if !b || !v.IsToken() {
  223.                 return errors.New(fmt.Sprintf("expecting operator before %s", t.value)), nil
  224.             }
  226.             op := v.(*tTokenNode)
  227.             if !me.TokenIn(op.token, tokens.Equal, tokens.NotEqual, tokens.Like, tokens.NotLike) {
  228.                 return errors.New(fmt.Sprintf("expecting string operator before %s", t.value)), nil
  229.             }
  231.             b,v = stack.Pop()
  232.             if !b || !v.IsToken() {
  233.                 return errors.New(fmt.Sprintf("expecting column name before %s", op.from)), nil
  234.             }
  235.             field := v.(*tTokenNode)
  236.             if field.token != tokens.Identifier {
  237.                 return errors.New(fmt.Sprintf("expecting column name at %v", field.from)), nil
  238.             }
  240.             exp := newStringFieldExpression(op.token, field.value, t.value)
  241.             e := me.PushExpression(exp, stack)
  242.             if e != nil {
  243.                 return e, nil
  244.             }
  245.             break
  248.         case tokens.IntLiteral:
  249.             // field op int
  250.             b, v := stack.Pop()
  251.             if !b || !v.IsToken() {
  252.                 return errors.New(fmt.Sprintf("expecting operator before %s", t.value)), nil
  253.             }
  255.             op := v.(*tTokenNode)
  256.             if !me.TokenIn(op.token, tokens.Equal, tokens.NotEqual, tokens.Greater, tokens.GreaterEqual, tokens.Less, tokens.LessEqual) {
  257.                 return errors.New(fmt.Sprintf("expecting int operator before %s", t.value)), nil
  258.             }
  260.             b,v = stack.Pop()
  261.             if !b || !v.IsToken() {
  262.                 return errors.New(fmt.Sprintf("expecting column name before %v", op.from)), nil
  263.             }
  264.             field := v.(*tTokenNode)
  265.             if field.token != tokens.Identifier {
  266.                 return errors.New(fmt.Sprintf("expecting column name at %v", field.from)), nil
  267.             }
  269.             i,_ := strconv.Atoi(t.value)
  270.             exp := newIntFieldExpression(op.token, field.value, i)
  271.             e := me.PushExpression(exp, stack)
  272.             if e != nil {
  273.                 return e, nil
  274.             }
  275.             break
  278.         case tokens.RB:
  279.             // )
  280.             b,v := stack.Pop()
  281.             if !b || !v.IsExpression() {
  282.                 return errors.New(fmt.Sprintf("expecting expression before %v", t.from)), nil
  283.             }
  284.             expression := v.(*tExpressionNode).Expression
  286.             b,v = stack.Pop()
  287.             if !b || !v.IsToken() {
  288.                 return errors.New(fmt.Sprintf("expected ( not found at %v", t.from)), nil
  289.             }
  290.             lb := v.(*tTokenNode)
  291.             if lb.token != tokens.LB {
  292.                 return errors.New(fmt.Sprintf("expected ( not found at %v", t.from)), nil
  293.             }
  295.             e := me.PushExpression(expression, stack)
  296.             if e != nil {
  297.                 return e, nil
  298.             }
  299.             break
  300.         }
  301.     }
  304.     if stack.Size() != 1{
  305.         return errors.New("invalid expression"), nil
  306.     }
  307.     ok, node := stack.Peek()
  308.     if !ok || !node.IsExpression() {
  309.         return errors.New("invalid expression"), nil
  310.     }
  312.     return nil,node.(*tExpressionNode).Expression
  313. }
  316. func (me *tSQLParser) TokenIn(t tokens.Tokens, args... tokens.Tokens) bool {
  317.     for _,it := range args {
  318.         if it == t {
  319.             return true
  320.         }
  321.     }
  322.     return false
  323. }
  326. func (me *tSQLParser) PushExpression(exp IBoolExpression, stack *tArrayStack) error {
  327.     b,n := stack.Peek()
  328.     if !b {
  329.         stack.Push(newExpressionNode(exp))
  330.         return nil
  331.     }
  333.     if !n.IsToken() {
  334.         return errors.New("expecting and/or/(")
  335.     }
  337.     t := n.(*tTokenNode)
  338.     if !me.TokenIn(t.token, tokens.And, tokens.OR, tokens.LB) {
  339.         return errors.New("expecting and/or/(")
  340.     }
  342.     if me.TokenIn(t.token, tokens.And, tokens.OR) {
  343.         stack.Pop()
  344.         b,n = stack.Pop()
  345.         if !b || !n.IsExpression(){
  346.             return errors.New("expecting bool expression")
  347.         }
  348.         e := n.(*tExpressionNode)
  349.         return me.PushExpression(newLogicNode(t.token, e.Expression, exp), stack)
  351.     } else {
  352.         stack.Push(newExpressionNode(exp))
  353.         return nil
  354.     }
  355. }

tTokenQueue.go

词法节点队列

  1. package interpreter
  3. type tTokenQueue struct {
  4.     items []*tTokenNode
  5.     size int
  6.     next int
  7. }
  10. func newTokenQueue(nodes []*tTokenNode) *tTokenQueue {
  11.     return &tTokenQueue{
  12.         nodes,
  13.         len(nodes),
  14.         0,
  15.     }
  16. }
  18. func (me *tTokenQueue) Poll() (bool,*tTokenNode) {
  19.     b,v := me.Peek()
  20.     if b {
  21.         me.next++
  22.     }
  23.     return b,v
  24. }
  27. func (me *tTokenQueue) Peek() (bool, *tTokenNode) {
  28.     if me.next >= me.size {
  29.         return false, nil
  30.     }
  32.     it := me.items[me.next]
  33.     return true, it
  34. }
  36. func (me *tTokenQueue) IsEmpty() bool {
  37.     return me.next >= me.size
  38. }

tArrayStack.go

基于数组实现的LIFO堆栈

  1. package interpreter
  3. import "learning/gooop/behavioral_patterns/interpreter/tokens"
  5. type tArrayStack struct {
  6.     items []iStackNode
  7. }
  10. type iStackNode interface {
  11.     IsToken() bool
  12.     IsExpression() bool
  13. }
  16. func newArrayStack() *tArrayStack {
  17.     return &tArrayStack{
  18.         make([]iStackNode, 0),
  19.     }
  20. }
  22. func (me *tArrayStack) Push(node iStackNode) {
  23.     me.items = append(me.items, node)
  24. }
  26. func (me *tArrayStack) Size() int {
  27.     return len(me.items)
  28. }
  30. func (me *tArrayStack) Peek() (bool,iStackNode) {
  31.     if me.Size() <= 0 {
  32.         return false, nil
  33.     }
  34.     return true, me.items[me.Size() - 1]
  35. }
  37. func (me *tArrayStack) Pop() (bool, iStackNode) {
  38.     if me.Size() <= 0 {
  39.         return false, nil
  40.     }
  42.     it := me.items[me.Size() - 1]
  43.     me.items = me.items[:me.Size() - 1]
  44.     return true, it
  45. }
  47. type tTokenNode struct {
  48.     token tokens.Tokens
  49.     value string
  50.     from int
  51.     to int
  52. }
  54. func newTokenNode(t tokens.Tokens, v string, from int, to int) *tTokenNode {
  55.     return &tTokenNode{
  56.         t,v, from, to,
  57.     }
  58. }
  61. func (me *tTokenNode) IsToken() bool {
  62.     return true
  63. }
  65. func (me *tTokenNode) IsExpression() bool {
  66.     return false
  67. }
  70. type tExpressionNode struct {
  71.     Expression IBoolExpression
  72. }
  75. func newExpressionNode(e IBoolExpression) *tExpressionNode {
  76.     return &tExpressionNode{
  77.         e,
  78.     }
  79. }
  82. func (me *tExpressionNode) IsToken() bool {
  83.     return false
  84. }
  86. func (me *tExpressionNode) IsExpression() bool {
  87.     return true
  88. }

IBoolExpression.go

布尔表达式接口

  1. package interpreter
  3. type IBoolExpression interface {
  4.     Eval(row IDataRow) bool
  5. }

tFieldExpression.go

基于字段计算的布尔表达式

  1. package interpreter
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "learning/gooop/behavioral_patterns/interpreter/tokens"
  7.     "strings"
  8. )
  10. type tFieldExpression struct {
  11.     op tokens.Tokens
  12.     field string
  13.     stringLiteral string
  14.     intLiteral int
  15. }
  18. func newStringFieldExpression(op tokens.Tokens, field string, s string) *tFieldExpression {
  19.     return &tFieldExpression{
  20.         op, field, strings.Trim(s, "'"), 0,
  21.     }
  22. }
  24. func newIntFieldExpression(op tokens.Tokens, field string, value int) *tFieldExpression {
  25.     return &tFieldExpression{
  26.         op, field, "", value,
  27.     }
  28. }
  30. func (me *tFieldExpression) Eval(row IDataRow) bool {
  31.     e, fld := row.GetField(me.field)
  32.     if e != nil {
  33.         panic(e)
  34.     }
  36.     switch fld.DataType() {
  37.     case StringDataType:
  38.         e,v := fld.GetString()
  39.         if e != nil {
  40.             panic(e)
  41.         }
  42.         return me.EvalString(v)
  44.     case IntDataType:
  45.         e,v := fld.GetInt()
  46.         if e != nil {
  47.             panic(e)
  48.         }
  49.         return me.EvalInt(v)
  51.     default:
  52.         panic(errors.New("unknown data type"))
  53.     }
  54. }
  56. func (me *tFieldExpression) EvalString(value string) bool {
  57.     switch me.op {
  58.     case tokens.Equal:
  59.         return value == me.stringLiteral
  61.     case tokens.NotEqual:
  62.         return value != me.stringLiteral
  64.     case tokens.Like:
  65.         fallthrough
  66.     case tokens.NotLike:
  67.         like := false
  68.         p := strings.HasPrefix(value, "%")
  69.         s := strings.HasPrefix(value, "%")
  71.         if p && s {
  72.             like = strings.Contains(value, me.stringLiteral)
  73.         } else if p {
  74.             like = strings.HasSuffix(value, me.stringLiteral)
  75.         } else if s {
  76.             like = strings.HasPrefix(value, me.stringLiteral)
  77.         } else {
  78.             like = value == me.stringLiteral
  79.         }
  81.         if me.op == tokens.Like {
  82.             return like
  83.         } else {
  84.             return !like
  85.         }
  86.         break
  88.     default:
  89.         panic(errors.New(fmt.Sprintf("unsupported string operation: %s", me.op)))
  90.     }
  92.     return false
  93. }
  96. func (me *tFieldExpression) EvalInt(value int) bool {
  97.     switch me.op {
  98.     case tokens.Equal:
  99.         return value == me.intLiteral
  101.     case tokens.NotEqual:
  102.         return value != me.intLiteral
  104.     case tokens.Greater:
  105.         return value > me.intLiteral
  107.     case tokens.GreaterEqual:
  108.         return value >= me.intLiteral
  110.     case tokens.Less:
  111.         return value < me.intLiteral
  113.     case tokens.LessEqual:
  114.         return value <= me.intLiteral
  116.     default:
  117.         panic(errors.New(fmt.Sprintf("unsupported int operation: %s", me.op)))
  118.     }
  119. }

tLogicExpression.go

基于关系(AND/OR)计算的布尔表达式

  1. package interpreter
  3. import (
  4.     "fmt"
  5.     "learning/gooop/behavioral_patterns/interpreter/tokens"
  6. )
  8. type tLogicExpression struct {
  9.     op tokens.Tokens
  10.     left IBoolExpression
  11.     right IBoolExpression
  12. }
  15. func newLogicNode(op tokens.Tokens, left IBoolExpression, right IBoolExpression) *tLogicExpression {
  16.     return &tLogicExpression{
  17.         op, left, right,
  18.     }
  19. }
  22. func (me *tLogicExpression) Eval(row IDataRow) bool {
  23.     switch me.op {
  24.     case tokens.And:
  25.         return me.left.Eval(row) && me.right.Eval(row)
  27.     case tokens.OR:
  28.         return me.left.Eval(row) || me.right.Eval(row)
  30.     default:
  31.         panic(fmt.Sprintf("unsupported bool operation: %s", me.op))
  32.     }
  33. }

SaleOrder.go

销售订单实体类

  1. package interpreter
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "strings"
  7. )
  9. type SaleOrder struct {
  10.     id *tIntField
  11.     customer *tStringField
  12.     city *tStringField
  13.     product *tStringField
  14.     quantity *tIntField
  15. }
  17. func NewSaleOrder(id int, customer string, city string, product string, quantity int) *SaleOrder {
  18.     return &SaleOrder{
  19.         id: newIntField("id", id),
  20.         customer: newStringField("customer", customer),
  21.         city: newStringField("city", city),
  22.         product: newStringField("product", product),
  23.         quantity: newIntField("quantity", quantity),
  24.     }
  25. }
  28. func (me *SaleOrder) ID() int {
  29.     return me.id.value
  30. }
  32. func (me *SaleOrder) Customer() string {
  33.     return me.customer.value
  34. }
  36. func (me *SaleOrder) City() string {
  37.     return me.city.value
  38. }
  40. func (me *SaleOrder) Product() string {
  41.     return me.product.value
  42. }
  44. func (me *SaleOrder) Quantity() int {
  45.     return me.quantity.value
  46. }
  48. func (me *SaleOrder) GetField(field string) (error,IDataField) {
  49.     if strings.EqualFold(field, "ID") {
  50.         return nil, me.id
  51.     }
  53.     if strings.EqualFold(field, "Customer") {
  54.         return nil, me.customer
  55.     }
  57.     if strings.EqualFold(field, "City") {
  58.         return nil, me.city
  59.     }
  61.     if strings.EqualFold(field, "Product") {
  62.         return nil, me.product
  63.     }
  65.     if strings.EqualFold(field, "Quantity") {
  66.         return nil, me.quantity
  67.     }
  69.     return errors.New("no such field"), nil
  70. }
  72. func (me *SaleOrder) String() string {
  73.     return fmt.Sprintf("id=%v, customer=%v, city=%v, product=%v, quantity=%v", me.ID(), me.Customer(), me.City(), me.Product(), me.Quantity())
  74. }

ISaleOrderService.go

销售订单服务接口, 继承自IDataTable接口

  1. package interpreter
  3. type ISaleOrderService interface {
  4.     IDataTable
  5.     Save(order *SaleOrder)
  6. }

tMockDatabase.go

虚拟的数据库服务, 实现IDatabase接口

  1. package interpreter
  3. import "errors"
  5. type tMockDatabase struct {
  6.     tables map[string]IDataTable
  7. }
  9. func newMockDatabase() IDatabase {
  10.     return &tMockDatabase{
  11.         tables: make(map[string]IDataTable, 0),
  12.     }
  13. }
  15. func (me *tMockDatabase) Register(table IDataTable) {
  16.     me.tables[table.Name()] = table
  17. }
  19. func (me *tMockDatabase) Query(sql string) (error, []IDataRow) {
  20.     parser := newSQLParser()
  21.     e, result := parser.Parse(sql)
  22.     if e != nil {
  23.         return e, nil
  24.     }
  26.     table, ok := me.tables[result.Table]
  27.     if !ok {
  28.         return errors.New("table not found"), nil
  29.     }
  31.     return nil, table.Filter(result.RowFilter)
  32. }
  34. var MockDatabase = newMockDatabase()

tMockSaleOrderService.go

虚拟的销售订单服务, 实现ISaleOrderService接口

  1. package interpreter
  3. type tMockSaleOrderService struct {
  4.     items map[int]*SaleOrder
  5. }
  7. func (me *tMockSaleOrderService) Save(it *SaleOrder) {
  8.     me.items[it.ID()] = it
  9. }
  12. func (me *tMockSaleOrderService) Name() string {
  13.     return "sale_order"
  14. }
  16. func (me *tMockSaleOrderService) Filter(filter IRowFilter) []IDataRow {
  17.     rows := make([]IDataRow, 0)
  18.     for _,it := range me.items {
  19.         if filter.Filter(it) {
  20.             rows = append(rows, it)
  21.         }
  22.     }
  23.     return rows
  24. }
  26. func newMockSaleOrderService() ISaleOrderService {
  27.     it := &tMockSaleOrderService{
  28.         items: make(map[int]*SaleOrder, 0),
  29.     }
  30.     MockDatabase.Register(it)
  31.     return it
  32. }
  34. var MockSaleOrderService = newMockSaleOrderService()

解释器模式小结

  1. 解释器模式的优点
  2. （1）在解释器模式中，由于语法是由很多类表示的，当语法规则更改时，
  3.     只需修改相应的非终结符表达式即可；
  4.     当扩展语法时，只需添加相应的非终结符类即可。
  5. （2）增加了新的解释表达式的方式。
  6. （3）解释器模式对应的文法应当是比较简单且易于实现的，过于复杂的语法并不适合使用解释器模式。
  8. 解释器模式的缺点
  9. （1）解释器模式的每个语法都要产生一个非终结符表达式，当语法规则比较复杂时，
  10.     就会产生大量解释类，引起类膨胀，增加系统维护的难度。
  11. （2）解释器模式采用递归调用方法，
  12.     每个非终结符表达式都只关心与自己有关的表达式，
  13.     每个表达式都需要知道最终的结果，
  14.     因此完整表达式的最终结果是通过从后往前递归调用的方式获取的。
  15.     当完整表达式层级较深时，解释效率下降，
  16.     且出错时调试困难，因为递归迭代的层级太深。
  18. (摘自 谭勇德 <<设计模式就该这样学>>)

(end)