code: func (p *Parser) Parse(src []byte) (model.Stmts, error) {
  	cctx, cancel := context.WithCancel(context.TODO())
  	defer cancel()
  
  	ctx := newParseCtx(cctx)
  	ctx.input = src
  	ctx.lexsrc = lex(cctx, src)
  
  	var stmts model.Stmts
  LOOP:
  	for {
  		ctx.skipWhiteSpaces()
  		switch t := ctx.peek(); t.Type {
  		case CREATE:
  			stmt, err := p.parseCreate(ctx)
  			if err != nil {
  				if errors.IsIgnorable(err) {
  					// this is ignorable.
  					continue
  				}
  				if pe, ok := err.(ParseError); ok {
  					return nil, pe
  				}
  				return nil, errors.Wrap(err, `failed to parse create`)
  			}
  			stmts = append(stmts, stmt)
  		case COMMENT_IDENT:
  			ctx.advance()
  		case DROP, SET, USE:
  			// We don't do anything about these
  		S1:
  			for {
  				switch t := ctx.peek(); t.Type {
  				case SEMICOLON:
  					ctx.advance()
  					fallthrough
  				case EOF:
  					break S1
  				default:
  					ctx.advance()
  				}
  			}
  		case SEMICOLON:
  			// you could have statements where it's just empty, followed by a
  			// semicolon. These are just empty lines, so we just skip and go
  			// process the next statement
  			ctx.advance()
  			continue
  		case EOF:
  			ctx.advance()
  			break LOOP
  		default:
  			return nil, newParseError(ctx, t, "expected CREATE, COMMENT_IDENT, SEMICOLON or EOF")
  		}
  	}
  
  	return stmts, nil
  }
docs: // Parse parses the given set of SQL statements and creates a
  // model.Stmts structure.
  // If it encounters errors while parsing, the returned error will be a
  // ParseError type.