filter.go

// Copyright 2018 Eryx <evorui аt gmail dοt com>, All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package pgsqlgo

import (
	"fmt"
	"strings"

	"github.com/lynkdb/lynkapi/go/lynktable"
)

const (
	filterExprSep = "."
)

var filterOperators = map[string]string{
	"eq":   "= ?",
	"ne":   "<> ?",
	"gt":   "> ?",
	"ge":   ">= ?",
	"lt":   "< ?",
	"le":   "<= ?",
	"like": "LIKE ?",
	"in":   "IN (?)",
}

type filterItem struct {
	exprs []string
	args  []interface{}
	isOr  bool
}

type Filter struct {
	params []filterItem
}

func NewFilter() lynktable.Filter {
	return &Filter{}
}

func (fr *Filter) Reset() lynktable.Filter {
	fr.params = []filterItem{}
	return fr
}

func (fr *Filter) And(expr string, args ...interface{}) lynktable.Filter {

	if expr == "" || len(args) == 0 {
		return nil
	}

	fr.params = append(fr.params, filterItem{
		exprs: strings.Split(expr, filterExprSep),
		args:  args,
	})

	return fr
}

func (fr *Filter) Or(expr string, args ...interface{}) lynktable.Filter {

	if expr == "" || len(args) == 0 {
		return nil
	}

	fr.params = append(fr.params, filterItem{
		exprs: strings.Split(expr, filterExprSep),
		args:  args,
		isOr:  true,
	})

	return fr
}

func (fr *Filter) Parse() (where string, params []interface{}) {

	if fr == nil || len(fr.params) == 0 {
		return
	}

	for i, p := range fr.params {

		if i > 0 {
			if p.isOr {
				where += "OR "
			} else {
				where += "AND "
			}
		}

		operator := ""

		if len(p.exprs) == 1 {
			p.exprs = append(p.exprs, "eq")
		}

		if v, ok := filterOperators[p.exprs[1]]; ok {
			operator = v
		}

		if operator == "" {
			operator = "= ?"
		}

		if len(p.exprs) > 1 && p.exprs[1] == "in" && len(p.args) > 1 {

			res := []string{}
			for i := 0; i < len(p.args); i++ {
				res = append(res, "?")
			}

			where += fmt.Sprintf("%s IN (%s) ", dialectQuoteStr(p.exprs[0]), strings.Join(res, ","))
			params = append(params, p.args...)

		} else {

			where += fmt.Sprintf("%s %s ", dialectQuoteStr(p.exprs[0]), operator)
			params = append(params, p.args[0])
		}
	}

	return
}