Use io.StringWriter instead of io.Writer for efficiency

Author: stephenafamo

.golangci.yml

@@ -31,6 +31,7 @@ linters:
     errcheck:
       exclude-functions:
         - (io.Writer).Write
+        - (io.StringWriter).WriteString
         - (*text/template.Template).Parse
         - (github.com/jackc/pgx/v5.Tx).Rollback
     revive:

cached.go

@@ -28,7 +28,7 @@ func CacheN(ctx context.Context, exec Executor, q Query, start int) (BaseQuery[*
 	cached := BaseQuery[*cached]{
 		QueryType: q.Type(),
 		Expression: &cached{
-			query: []byte(query),
+			query: query,
 			args:  args,
 			start: start,
 		},
@@ -55,19 +55,19 @@ func (e WrongStartError) Error() string {
 }
 
 type cached struct {
-	query []byte
+	query string
 	args  []any
 	start int
 	Load
 }
 
 // WriteSQL implements Expression.
-func (c *cached) WriteSQL(ctx context.Context, w io.Writer, d Dialect, start int) ([]any, error) {
+func (c *cached) WriteSQL(ctx context.Context, w io.StringWriter, d Dialect, start int) ([]any, error) {
 	if start != c.start {
 		return nil, WrongStartError{Expected: c.start, Got: start}
 	}
 
-	if _, err := w.Write(c.query); err != nil {
+	if _, err := w.WriteString(c.query); err != nil {
 		return nil, err
 	}
 

clause/combine.go

@@ -34,27 +34,27 @@ func (s *Combine) SetCombine(c Combine) {
 	*s = c
 }
 
-func (s Combine) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
+func (s Combine) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
 	if s.Strategy == "" {
 		return nil, ErrNoCombinationStrategy
 	}
 
-	w.Write([]byte(s.Strategy))
+	w.WriteString(s.Strategy)
 
 	if s.All {
-		w.Write([]byte(" ALL "))
+		w.WriteString(" ALL ")
 	} else {
-		w.Write([]byte(" "))
+		w.WriteString(" ")
 	}
 
-	w.Write([]byte("("))
+	w.WriteString("(")
 
 	args, err := s.Query.WriteQuery(ctx, w, start)
 	if err != nil {
 		return nil, err
 	}
 
-	w.Write([]byte(")"))
+	w.WriteString(")")
 
 	return args, nil
 }

clause/conflict.go

@@ -22,16 +22,16 @@ type ConflictClause struct {
 	Where
 }
 
-func (c ConflictClause) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
-	w.Write([]byte("ON CONFLICT"))
+func (c ConflictClause) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
+	w.WriteString("ON CONFLICT")
 
 	args, err := bob.ExpressIf(ctx, w, d, start, c.Target, true, "", "")
 	if err != nil {
 		return nil, err
 	}
 
-	w.Write([]byte(" DO "))
-	w.Write([]byte(c.Do))
+	w.WriteString(" DO ")
+	w.WriteString(c.Do)
 
 	setArgs, err := bob.ExpressIf(ctx, w, d, start+len(args), c.Set, len(c.Set.Set) > 0, " SET\n", "")
 	if err != nil {
@@ -55,7 +55,7 @@ type ConflictTarget struct {
 	Where      []any
 }
 
-func (c ConflictTarget) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
+func (c ConflictTarget) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
 	if c.Constraint != "" {
 		return bob.ExpressIf(ctx, w, d, start, c.Constraint, true, " ON CONSTRAINT ", "")
 	}

clause/cte.go

@@ -17,31 +17,31 @@ type CTE struct {
 	Cycle        CTECycle
 }
 
-func (c CTE) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
-	w.Write([]byte(c.Name))
+func (c CTE) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
+	w.WriteString(c.Name)
 	_, err := bob.ExpressSlice(ctx, w, d, start, c.Columns, "(", ", ", ")")
 	if err != nil {
 		return nil, err
 	}
 
-	w.Write([]byte(" AS "))
+	w.WriteString(" AS ")
 
 	switch {
 	case c.Materialized == nil:
 		// do nothing
 		break
 	case *c.Materialized:
-		w.Write([]byte("MATERIALIZED "))
+		w.WriteString("MATERIALIZED ")
 	case !*c.Materialized:
-		w.Write([]byte("NOT MATERIALIZED "))
+		w.WriteString("NOT MATERIALIZED ")
 	}
 
-	w.Write([]byte("("))
+	w.WriteString("(")
 	args, err := c.Query.WriteQuery(ctx, w, start)
 	if err != nil {
 		return nil, err
 	}
-	w.Write([]byte(")"))
+	w.WriteString(")")
 
 	searchArgs, err := bob.ExpressIf(ctx, w, d, start+len(args), c.Search,
 		len(c.Search.Columns) > 0, "\n", "")
@@ -71,16 +71,16 @@ type CTESearch struct {
 	Set     string
 }
 
-func (c CTESearch) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
+func (c CTESearch) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
 	// [ SEARCH { BREADTH | DEPTH } FIRST BY column_name [, ...] SET search_seq_col_name ]
-	fmt.Fprintf(w, "SEARCH %s FIRST BY ", c.Order)
+	w.WriteString(fmt.Sprintf("SEARCH %s FIRST BY ", c.Order))
 
 	args, err := bob.ExpressSlice(ctx, w, d, start, c.Columns, "", ", ", "")
 	if err != nil {
 		return nil, err
 	}
 
-	fmt.Fprintf(w, " SET %s", c.Set)
+	w.WriteString(fmt.Sprintf(" SET %s", c.Set))
 
 	return args, nil
 }
@@ -93,16 +93,16 @@ type CTECycle struct {
 	DefaultVal any
 }
 
-func (c CTECycle) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
+func (c CTECycle) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
 	//[ CYCLE column_name [, ...] SET cycle_mark_col_name [ TO cycle_mark_value DEFAULT cycle_mark_default ] USING cycle_path_col_name ]
-	w.Write([]byte("CYCLE "))
+	w.WriteString("CYCLE ")
 
 	args, err := bob.ExpressSlice(ctx, w, d, start, c.Columns, "", ", ", "")
 	if err != nil {
 		return nil, err
 	}
 
-	fmt.Fprintf(w, " SET %s", c.Set)
+	w.WriteString(fmt.Sprintf(" SET %s", c.Set))
 
 	markArgs, err := bob.ExpressIf(ctx, w, d, start+len(args), c.SetVal,
 		c.SetVal != nil, " TO ", "")
@@ -118,7 +118,7 @@ func (c CTECycle) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, star
 	}
 	args = append(args, defaultArgs...)
 
-	fmt.Fprintf(w, " USING %s", c.Using)
+	w.WriteString(fmt.Sprintf(" USING %s", c.Using))
 
 	return args, nil
 }

clause/fetch.go

@@ -16,7 +16,7 @@ func (f *Fetch) SetFetch(fetch Fetch) {
 	*f = fetch
 }
 
-func (f Fetch) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
+func (f Fetch) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
 	if f.Count == nil {
 		return nil, nil
 	}

clause/frame.go

@@ -35,7 +35,7 @@ func (f *Frame) SetExclusion(excl string) {
 	f.Exclusion = excl
 }
 
-func (f Frame) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
+func (f Frame) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
 	if f.Mode == "" {
 		f.Mode = "RANGE"
 	}
@@ -46,11 +46,11 @@ func (f Frame) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start i
 
 	var args []any
 
-	w.Write([]byte(f.Mode))
-	w.Write([]byte(" "))
+	w.WriteString(f.Mode)
+	w.WriteString(" ")
 
 	if f.End != nil {
-		w.Write([]byte("BETWEEN "))
+		w.WriteString("BETWEEN ")
 	}
 
 	startArgs, err := bob.Express(ctx, w, d, start, f.Start)

clause/from.go

@@ -94,13 +94,13 @@ func (f TableRef) As(alias string, columns ...string) TableRef {
 	return f
 }
 
-func (f TableRef) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
+func (f TableRef) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
 	if f.Only {
-		w.Write([]byte("ONLY "))
+		w.WriteString("ONLY ")
 	}
 
 	if f.Lateral {
-		w.Write([]byte("LATERAL "))
+		w.WriteString("LATERAL ")
 	}
 
 	args, err := bob.Express(ctx, w, d, start, f.Expression)
@@ -109,7 +109,7 @@ func (f TableRef) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, star
 	}
 
 	if f.WithOrdinality {
-		w.Write([]byte(" WITH ORDINALITY"))
+		w.WriteString(" WITH ORDINALITY")
 	}
 
 	_, err = bob.ExpressSlice(ctx, w, d, start, f.Partitions, " PARTITION (", ", ", ")")
@@ -118,20 +118,20 @@ func (f TableRef) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, star
 	}
 
 	if f.Alias != "" {
-		w.Write([]byte(" AS "))
+		w.WriteString(" AS ")
 		d.WriteQuoted(w, f.Alias)
 	}
 
 	if len(f.Columns) > 0 {
-		w.Write([]byte("("))
+		w.WriteString("(")
 		for k, cAlias := range f.Columns {
 			if k != 0 {
-				w.Write([]byte(", "))
+				w.WriteString(", ")
 			}
 
 			d.WriteQuoted(w, cAlias)
 		}
-		w.Write([]byte(")"))
+		w.WriteString(")")
 	}
 
 	// No args for index hints
@@ -144,9 +144,9 @@ func (f TableRef) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, star
 	case f.IndexedBy == nil:
 		break
 	case *f.IndexedBy == "":
-		w.Write([]byte(" NOT INDEXED"))
+		w.WriteString(" NOT INDEXED")
 	default:
-		fmt.Fprintf(w, " INDEXED BY %q", *f.IndexedBy)
+		w.WriteString(fmt.Sprintf(" INDEXED BY %q", *f.IndexedBy))
 	}
 
 	joinArgs, err := bob.ExpressSlice(ctx, w, d, start+len(args), f.Joins, "\n", "\n", "")
@@ -164,24 +164,24 @@ type IndexHint struct {
 	For     string // JOIN, ORDER BY or GROUP BY
 }
 
-func (f IndexHint) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
+func (f IndexHint) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
 	if f.Type == "" {
 		return nil, nil
 	}
-	fmt.Fprintf(w, "%s INDEX ", f.Type)
+	w.WriteString(fmt.Sprintf("%s INDEX ", f.Type))
 
 	_, err := bob.ExpressIf(ctx, w, d, start, f.For, f.For != "", " FOR ", "")
 	if err != nil {
 		return nil, err
 	}
 
 	// Always include the brackets
-	fmt.Fprint(w, " (")
+	w.WriteString(" (")
 	_, err = bob.ExpressSlice(ctx, w, d, start, f.Indexes, "", ", ", "")
 	if err != nil {
 		return nil, err
 	}
-	fmt.Fprint(w, ")")
+	w.WriteString(")")
 
 	return nil, nil
 }

clause/group_by.go

@@ -29,17 +29,17 @@ func (g *GroupBy) SetGroupByDistinct(distinct bool) {
 	g.Distinct = distinct
 }
 
-func (g GroupBy) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
+func (g GroupBy) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
 	var args []any
 
 	// don't write anything if there are no groups
 	if len(g.Groups) == 0 {
 		return args, nil
 	}
 
-	w.Write([]byte("GROUP BY "))
+	w.WriteString("GROUP BY ")
 	if g.Distinct {
-		w.Write([]byte("DISTINCT "))
+		w.WriteString("DISTINCT ")
 	}
 
 	args, err := bob.ExpressSlice(ctx, w, d, start, g.Groups, "", ", ", "")
@@ -48,8 +48,8 @@ func (g GroupBy) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start
 	}
 
 	if g.With != "" {
-		w.Write([]byte(" WITH "))
-		w.Write([]byte(g.With))
+		w.WriteString(" WITH ")
+		w.WriteString(g.With)
 	}
 
 	return args, nil
@@ -60,8 +60,8 @@ type GroupingSet struct {
 	Type   string // GROUPING SET | CUBE | ROLLUP
 }
 
-func (g GroupingSet) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
-	w.Write([]byte(g.Type))
+func (g GroupingSet) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
+	w.WriteString(g.Type)
 	args, err := bob.ExpressSlice(ctx, w, d, start, g.Groups, " (", ", ", ")")
 	if err != nil {
 		return nil, err

clause/having.go

@@ -15,7 +15,7 @@ func (h *Having) AppendHaving(e ...any) {
 	h.Conditions = append(h.Conditions, e...)
 }
 
-func (h Having) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
+func (h Having) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
 	args, err := bob.ExpressSlice(ctx, w, d, start, h.Conditions, "HAVING ", " AND ", "")
 	if err != nil {
 		return nil, err