helpers.go

package clickhouse

import (
	"bytes"
	"database/sql/driver"
	"fmt"
	"reflect"
	"regexp"
	"strings"
	"time"

	"github.com/kshvakov/clickhouse/lib/types"
)

var typeByteSlice = reflect.TypeOf([]byte{})

func numInput(query string) int {

	var (
		count          int
		args           = make(map[string]struct{})
		reader         = bytes.NewReader([]byte(query))
		quote, keyword bool
		limit          = newMatcher("limit")
	)
	for {
		if char, _, err := reader.ReadRune(); err == nil {
			switch char {
			case '\'', '`':
				quote = !quote
			}
			if quote {
				continue
			}
			switch {
			case char == '?' && keyword:
				count++
			case char == '@':
				if param := paramParser(reader); len(param) != 0 {
					if _, found := args[param]; !found {
						args[param] = struct{}{}
						count++
					}
				}
			case
				char == '=',
				char == '<',
				char == '>',
				char == '(',
				char == ',',
				char == '%',
				char == '[':
				keyword = true
			default:
				if limit.matchRune(char) {
					keyword = true
				} else {
					keyword = keyword && (char == ' ' || char == '\t' || char == '\n')
				}
			}
		} else {
			break
		}
	}
	return count
}

func paramParser(reader *bytes.Reader) string {
	var name bytes.Buffer
	for {
		if char, _, err := reader.ReadRune(); err == nil {
			if char == '_' || char >= '0' && char <= '9' || 'a' <= char && char <= 'z' || 'A' <= char && char <= 'Z' {
				name.WriteRune(char)
			} else {
				reader.UnreadRune()
				break
			}
		} else {
			break
		}
	}
	return name.String()
}

var selectRe = regexp.MustCompile(`\s+SELECT\s+`)

func isInsert(query string) bool {
	if f := strings.Fields(query); len(f) > 2 {
		return strings.EqualFold("INSERT", f[0]) && strings.EqualFold("INTO", f[1]) && !selectRe.MatchString(strings.ToUpper(query))
	}
	return false
}

func quote(v driver.Value) string {
	switch value := v.(type) {
	case *types.Array:
		v = value.Values()
	}
	switch v := reflect.ValueOf(v); v.Kind() {
	case reflect.Slice:
		switch v := reflect.ValueOf(v); v.Kind() {
		case reflect.Array, reflect.Slice:
			if t := v.Type(); t != (typeByteSlice) {
				values := make([]string, 0, v.Len())
				for i := 0; i < v.Len(); i++ {
					values = append(values, quote(v.Index(i).Interface()))
				}
				return strings.Join(values, ", ")
			}
		}
	}
	switch v := v.(type) {
	case []byte:
		// TODO: Performance
		return "'" + strings.NewReplacer(`\`, `\\`, `'`, `\'`).Replace(string(v)) + "'"
	case string:
		return "'" + strings.NewReplacer(`\`, `\\`, `'`, `\'`).Replace(v) + "'"
	case time.Time:
		return formatTime(v)
	}
	return fmt.Sprint(v)
}

func formatTime(value time.Time) string {
	if (value.Hour() + value.Minute() + value.Second() + value.Nanosecond()) == 0 {
		return fmt.Sprintf("toDate(%d)", int(int16(value.Unix()/24/3600)))
	}
	return fmt.Sprintf("toDateTime(%d)", int(uint32(value.Unix())))
}