node.go

package zinc

import (
	"bytes"
	"reflect"
	"unicode"
)

type Node interface {
	ToSql(p SqlPrinter, opts *Options)
}

type SqlPrinter interface {
	Raw(s string) SqlPrinter
	Str(s string) SqlPrinter
	Value(v any, opts *SqlValueOptions) SqlPrinter
}

type SqlValueOptions struct {
	Separator string
	Left      string
	Right     string
	ItemLeft  string
	ItemRight string
	*Options
}

func ToSql(q any, opts *Options) (string, error) {
	opts = ensureOptions(opts)
	if opts.Dialect == nil {
		panic(ErrInvalidDriver)
	}
	return toSql(q, opts)
}

func MustSql(q any, opts *Options) string {
	qs, err := ToSql(q, opts)
	if err != nil {
		panic(err)
	}
	return qs
}

func toSql(q any, opts *Options) (string, error) {
	if q == nil {
		return "", nil
	} else if q0, ok := q.(string); ok {
		return q0, nil
	} else if sqlable0, ok := q.(Node); ok && sqlable0 != nil {
		printer := sqlPrinter{}
		sqlable0.ToSql(&printer, opts)
		return printer.buff.String(), nil
	} else {
		return "", ErrInvalidQuery
	}
}

type sqlPrinter struct {
	buff bytes.Buffer
}

var _ SqlPrinter = (*sqlPrinter)(nil)

func (p *sqlPrinter) Raw(s string) SqlPrinter {
	if s != "" {
		p.buff.WriteString(s)
	}
	return p
}

func (p *sqlPrinter) Str(s string) SqlPrinter {
	if s != "" {
		p.appendLeadingSpace()
		p.buff.WriteString(s)
	}
	return p
}

func (p *sqlPrinter) Quote(s string, opts *Options) SqlPrinter {
	if s != "" {
		p.Str(opts.Dialect.QuoteString(s))
	}
	return p
}

func (p *sqlPrinter) Naming(s string, opts *Options) SqlPrinter {
	if s != "" {
		p.Str(opts.Dialect.NamingString(s))
	}
	return p
}

func (p *sqlPrinter) Value(v any, opts *SqlValueOptions) SqlPrinter {
	switch v1 := v.(type) {
	case nil:
	case string:
		p.Str(v1)
	case Node:
		if v1 != nil {
			v1.ToSql(p, opts.Options)
		}
	case []string:
		p.appendList(opts, func(i int) (any, bool) {
			if i < len(v1) {
				return v1[i], true
			}
			return nil, false
		})
	case []Node:
		p.appendList(opts, func(i int) (any, bool) {
			if i < len(v1) {
				return v1[i], true
			}
			return nil, false
		})
	case []any:
		p.appendList(opts, func(i int) (any, bool) {
			if i < len(v1) {
				return v1[i], true
			}
			return nil, false
		})
	default:
		v2 := valueOf(v)
		if v2.Kind() == reflect.Slice || v2.Kind() == reflect.Array {
			p.appendList(opts, func(i int) (any, bool) {
				if i < v2.Len() {
					return v2.Index(i).Interface(), true
				}
				return nil, false
			})
		}
	}
	return p
}

func (p *sqlPrinter) appendList(opts *SqlValueOptions, iterator func(int) (any, bool)) {
	p.Str(opts.Left)
	i := 0
	for {
		v, ok := iterator(i)
		if !ok {
			break
		}
		if i > 0 {
			p.Raw(opts.Separator)
		}
		p.Raw(opts.ItemLeft)
		p.Value(v, opts)
		p.Raw(opts.ItemRight)
		i += 1
	}
	p.Raw(opts.Right)

}

func (p *sqlPrinter) appendLeadingSpace() {
	buff := p.buff
	n := buff.Len()
	if n <= 0 {
		return
	}
	latestChar := rune(buff.Bytes()[n-1])
	if !unicode.IsSpace(latestChar) && latestChar != '(' {
		p.buff.WriteByte(' ')
	}
}