example.pb.sqlx.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: example/example.proto

package example

import (
	"database/sql/driver"
	"encoding/json"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	_ "github.com/gogo/protobuf/types"
	"github.com/jmoiron/sqlx"
	_ "github.com/mwitkow/go-proto-validators"
	log "github.com/sirupsen/logrus"
	"github.com/weiwolves/protoc-gen-sqlx/lib"
	"github.com/weiwolves/protoc-gen-sqlx/pb/sql"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = fmt.Errorf
var _ = math.Inf

////////////////////////// GLOBAL vars :))))))

type QueryExampleItem struct {
	Verbose     int
	DB          *sqlx.DB
	driver      string
	debug       bool
	created     bool
	table       string
	field       string
	fields      []string
	defFields   map[string]interface{}
	query       string
	filter      string
	filterValue []interface{}
	sort        string
	order       string
	limit       int64
	offset      int64
	current     int64
	total       int64
}

// NewQueryExampleItem - initialize QueryExampleItem
func NewQueryExampleItem(verbose int) *QueryExampleItem {
	p := QueryExampleItem{
		Verbose:   verbose,
		fields:    ExampleItemFields(),
		defFields: ExampleItemFieldsMap(),
		limit:     1000,
		offset:    0,
		sort:      "id",
		order:     "ASC",
	}
	p.table = ExampleItemTableName()
	p.field = ExampleItemFieldsString()
	return &p
}

// SetDB setting database
func (p *QueryExampleItem) SetDB(db *sqlx.DB) {
	p.DB = db
}

// Close closes the database, releasing any open resources.
func (p *QueryExampleItem) Close() error {
	return p.DB.Close()
}

// TableName overrides the default tablename generated by QueryExampleItem
func ExampleItemTableName() string {
	return "example_items"
}

func ExampleItemFieldsString() string {
	return "id, created_at, updated_at, deleted_at, name, move_id"
}

func ExampleItemFields() []string {
	return []string{"id", "created_at", "updated_at", "deleted_at", "name", "move_id"}
}

func ExampleItemFieldsMap() map[string]interface{} {
	set := make(map[string]interface{})
	set["id"] = "id"
	set["created_at"] = "created_at"
	set["updated_at"] = "updated_at"
	set["deleted_at"] = "deleted_at"
	set["name"] = "name"
	set["move_id"] = "move_id"
	return set
}

func ExampleItemFieldsContain(item string) bool {
	flds := ExampleItemFieldsMap()
	_, ok := flds[item]
	return ok
}

func (p *QueryExampleItem) Scan(val interface{}) error {
	return json.Unmarshal(val.([]byte), p)
}
func (p *QueryExampleItem) Value() (driver.Value, error) {
	return json.Marshal(p)
}

// BuildOneQuery - return one row
func (p *QueryExampleItem) BuildOneQuery(in *sql.SqlQuery, field string) (string, []interface{}) {
	return p.BuildQuery(in, field, false, true)
}

// BuildMultiQuery - return rows
func (p *QueryExampleItem) BuildMultiQuery(in *sql.SqlQuery, field string) (string, []interface{}) {
	return p.BuildQuery(in, field, false, false)
}

func (p *QueryExampleItem) Count(in *sql.SqlQuery) int64 {
	var result lib.Result
	wh := ""
	filter, args := p.applyFilters(in.Filter)
	if len(filter) > 0 {
		wh = fmt.Sprintf(" WHERE%s", filter)
	}
	str := fmt.Sprintf("SELECT COUNT(*) AS total FROM %s%s LIMIT 1", p.table, wh)
	if p.Verbose > 3 {
		log.Println("[Count] QUERY:", str, "params:", args)
	}
	err := p.DB.QueryRowx(str, args...).StructScan(&result)
	if err != nil {
		log.Errorln("[Count]", err)
	}
	return result.Total
}

func (p *QueryExampleItem) BuildQuery(in *sql.SqlQuery, f string, reserved bool, one bool) (string, []interface{}) {
	wh := ""
	filter, filterValue := p.applyFilters(in.Filter)
	field := p.field

	if len(f) > 0 {
		field = f
	} else if len(in.Field) > 0 {
		field = p.applyField()
	}
	if len(filter) > 0 {
		wh = fmt.Sprintf(" WHERE%s", filter)
	}

	limit := p.limit
	log.Warningln("LIMIT", in.GetLimit())

	order := p.order
	offset := p.offset
	if in.GetPage() > 0 {
		log.Warningln("TODO pagination BuildQuery")
	} else if in.GetFirst() > 0 {
		offset = 0
		order = "ASC"
		limit = in.GetFirst()
	} else if in.GetLast() > 0 {
		offset = 0
		order = "DESC"
		limit = in.GetLast()
	}

	str := fmt.Sprintf("SELECT %s FROM %s%s", field, p.table, wh)
	if one {
		return fmt.Sprintf("%s ORDER BY %s %s LIMIT 1", str, p.sort, order), filterValue
	}
	return fmt.Sprintf("%s ORDER BY %s %s LIMIT %d OFFSET %d", str, p.sort, order, limit, offset), filterValue
}

func (p *QueryExampleItem) applyField() string {
	field := ""
	fields := ExampleItemFields()
	for _, v := range fields {
		if len(field) == 0 {
			field = v
		} else {
			field = fmt.Sprintf("%s, %s", field, v)
		}
	}
	return field
}

func (p *QueryExampleItem) applyFilters(filters []*sql.SqlFilter) (string, []interface{}) {
	filter := ""
	var filterValue []interface{}
	for key, val := range filters {
		if len(filter) > 0 {
			filter = fmt.Sprintf("%s AND %s%s", filter, val.Name, lib.FilteringMode(val.Mode.String(), key+1))
		} else {
			filter = fmt.Sprintf(" %s%s", val.Name, lib.FilteringMode(val.Mode.String(), key+1))
		}
		if val.Mode.String() != "IS_NULL" && val.Mode.String() != "NOT_NULL" {
			filterValue = append(filterValue, val.Value)
		}
	}
	return filter, filterValue
}

type QueryExample struct {
	Verbose     int
	DB          *sqlx.DB
	driver      string
	debug       bool
	created     bool
	table       string
	field       string
	fields      []string
	defFields   map[string]interface{}
	query       string
	filter      string
	filterValue []interface{}
	sort        string
	order       string
	limit       int64
	offset      int64
	current     int64
	total       int64
}

// NewQueryExample - initialize QueryExample
func NewQueryExample(verbose int) *QueryExample {
	p := QueryExample{
		Verbose:   verbose,
		fields:    ExampleFields(),
		defFields: ExampleFieldsMap(),
		limit:     1000,
		offset:    0,
		sort:      "id",
		order:     "ASC",
	}
	p.table = ExampleTableName()
	p.field = ExampleFieldsString()
	return &p
}

// SetDB setting database
func (p *QueryExample) SetDB(db *sqlx.DB) {
	p.DB = db
}

// Close closes the database, releasing any open resources.
func (p *QueryExample) Close() error {
	return p.DB.Close()
}

// TableName overrides the default tablename generated by QueryExample
func ExampleTableName() string {
	return "examples"
}

func ExampleFieldsString() string {
	return "id, created_at, updated_at, deleted_at, name, product, organization_id AS organization, state, items"
}

func ExampleFields() []string {
	return []string{"id", "created_at", "updated_at", "deleted_at", "name", "product", "organization_id AS organization", "state", "items"}
}

func ExampleFieldsMap() map[string]interface{} {
	set := make(map[string]interface{})
	set["id"] = "id"
	set["created_at"] = "created_at"
	set["updated_at"] = "updated_at"
	set["deleted_at"] = "deleted_at"
	set["name"] = "name"
	set["product"] = "product"
	set["organization_id"] = "organization_id AS organization"
	set["state"] = "state"
	set["items"] = "items"
	return set
}

func ExampleFieldsContain(item string) bool {
	flds := ExampleFieldsMap()
	_, ok := flds[item]
	return ok
}

func (p *QueryExample) Scan(val interface{}) error {
	return json.Unmarshal(val.([]byte), p)
}
func (p *QueryExample) Value() (driver.Value, error) {
	return json.Marshal(p)
}

// BuildOneQuery - return one row
func (p *QueryExample) BuildOneQuery(in *sql.SqlQuery, field string) (string, []interface{}) {
	return p.BuildQuery(in, field, false, true)
}

// BuildMultiQuery - return rows
func (p *QueryExample) BuildMultiQuery(in *sql.SqlQuery, field string) (string, []interface{}) {
	return p.BuildQuery(in, field, false, false)
}

func (p *QueryExample) Count(in *sql.SqlQuery) int64 {
	var result lib.Result
	wh := ""
	filter, args := p.applyFilters(in.Filter)
	if len(filter) > 0 {
		wh = fmt.Sprintf(" WHERE%s", filter)
	}
	str := fmt.Sprintf("SELECT COUNT(*) AS total FROM %s%s LIMIT 1", p.table, wh)
	if p.Verbose > 3 {
		log.Println("[Count] QUERY:", str, "params:", args)
	}
	err := p.DB.QueryRowx(str, args...).StructScan(&result)
	if err != nil {
		log.Errorln("[Count]", err)
	}
	return result.Total
}

func (p *QueryExample) BuildQuery(in *sql.SqlQuery, f string, reserved bool, one bool) (string, []interface{}) {
	wh := ""
	filter, filterValue := p.applyFilters(in.Filter)
	field := p.field

	if len(f) > 0 {
		field = f
	} else if len(in.Field) > 0 {
		field = p.applyField()
	}
	if len(filter) > 0 {
		wh = fmt.Sprintf(" WHERE%s", filter)
	}

	limit := p.limit
	log.Warningln("LIMIT", in.GetLimit())

	order := p.order
	offset := p.offset
	if in.GetPage() > 0 {
		log.Warningln("TODO pagination BuildQuery")
	} else if in.GetFirst() > 0 {
		offset = 0
		order = "ASC"
		limit = in.GetFirst()
	} else if in.GetLast() > 0 {
		offset = 0
		order = "DESC"
		limit = in.GetLast()
	}

	str := fmt.Sprintf("SELECT %s FROM %s%s", field, p.table, wh)
	if one {
		return fmt.Sprintf("%s ORDER BY %s %s LIMIT 1", str, p.sort, order), filterValue
	}
	return fmt.Sprintf("%s ORDER BY %s %s LIMIT %d OFFSET %d", str, p.sort, order, limit, offset), filterValue
}

func (p *QueryExample) applyField() string {
	field := ""
	fields := ExampleFields()
	for _, v := range fields {
		if len(field) == 0 {
			field = v
		} else {
			field = fmt.Sprintf("%s, %s", field, v)
		}
	}
	return field
}

func (p *QueryExample) applyFilters(filters []*sql.SqlFilter) (string, []interface{}) {
	filter := ""
	var filterValue []interface{}
	for key, val := range filters {
		if len(filter) > 0 {
			filter = fmt.Sprintf("%s AND %s%s", filter, val.Name, lib.FilteringMode(val.Mode.String(), key+1))
		} else {
			filter = fmt.Sprintf(" %s%s", val.Name, lib.FilteringMode(val.Mode.String(), key+1))
		}
		if val.Mode.String() != "IS_NULL" && val.Mode.String() != "NOT_NULL" {
			filterValue = append(filterValue, val.Value)
		}
	}
	return filter, filterValue
}