simpleorm/schema/table.go

package schema

import (
	"errors"
	"reflect"
	"strings"

	"git.gdulai.com/gdulai/simpleorm/util"
)

type Table struct {
	Name        string
	Type        reflect.Type
	Columns     []Column
	Constraints []Constraint
}

func (t Table) GetDDL() (string, error) {
	var ddl strings.Builder
	ddl.WriteString("CREATE TABLE IF NOT EXISTS " + t.Name + " (")
	for i, col := range t.Columns {
		if i != 0 {
			ddl.WriteString(", ")
		}
		colDdl, err := col.GetDDL()
		if err != nil {
			return "", err
		}
		ddl.WriteString(colDdl)
	}
	for _, constr := range t.Constraints {
		constrDdl, err := constr.GetDDL()
		if err != nil {
			return "", err
		}
		ddl.WriteString(", " + constrDdl)
	}

	ddl.WriteString(");")
	return ddl.String(), nil
}

func (t Table) GetSelectDML() (string, error) {
	var dml strings.Builder
	dml.WriteString("SELECT ")

	for i, col := range t.Columns {
		if i != 0 {
			dml.WriteString(", ")
		}
		colDml, err := col.GetSelectDML()
		if err != nil {
			return "", err
		}
		dml.WriteString(colDml)
	}

	dml.WriteString(" FROM " + t.Name)
	return dml.String(), nil
}

func (t Table) GetInsertDML(count int) (string, error) {
	var dml strings.Builder
	dml.WriteString("INSERT INTO " + util.CamelToSnake(t.Type.Name()) + " (")

	columnsLen := len(t.Columns)
	effectiveColumnsLen := 0
	for i, col := range t.Columns {
		_, ok := col.Modifiers["pk"]
		if ok && t.IsPkAuto() {
			continue
		}

		colDml, err := col.GetInsertDML()
		if err != nil {
			return "", err
		}

		dml.WriteString(colDml)
		if i != columnsLen-1 {
			dml.WriteString(", ")
		}
		effectiveColumnsLen++
	}

	dml.WriteString(") VALUES")

	for i := range count {
		if i != 0 {
			dml.WriteString(", ")
		}
		for j := range effectiveColumnsLen {
			if j == 0 {
				dml.WriteString("(")
			}
			if j != effectiveColumnsLen-1 {
				dml.WriteString("?, ")
			} else {
				dml.WriteString("?)")
			}
		}
	}

	return dml.String(), nil
}

func (t Table) GetUpdateDML() (string, error) {
	var dml strings.Builder
	dml.WriteString("UPDATE  " + util.CamelToSnake(t.Type.Name()) + " SET ")

	colLen := len(t.Columns)
	var pkColumns []string
	// Colum names
	for i, col := range t.Columns {
		modifiers := col.Modifiers

		_, ok := modifiers["pk"]
		if ok {
			pkColumns = append(pkColumns, col.Name)
			if t.IsPkAuto() {
				continue
			}
		}

		colDml, err := col.GetUpdateDML()
		if err != nil {
			return "", err
		}

		if i != colLen-1 {
			dml.WriteString(colDml + ", ")
		} else {
			dml.WriteString(colDml + " ")
		}
	}

	dml.WriteString("WHERE ")

	for i, pkCol := range pkColumns {
		if i != 0 {
			dml.WriteString(" AND ")
		}
		dml.WriteString(pkCol + " = ?")
	}

	return dml.String(), nil
}

func (t Table) GetDeleteDML(count int) (string, error) {
	var dml strings.Builder
	dml.WriteString("DELETE FROM " + t.Name + " WHERE ")

	for _, col := range t.Columns {
		modifiers := col.Modifiers

		_, ok := modifiers["pk"]
		if ok {
			if count > 1 {
				dml.WriteString(col.Name + " IN (")
			} else {
				dml.WriteString(col.Name + " = ")
			}
		}
	}

	for i := range count {
		if i != 0 {
			dml.WriteString(", ")
		}
		dml.WriteString("?")
	}

	if count > 1 {
		dml.WriteString(")")
	}

	return dml.String(), nil
}

func (t Table) IsPkAuto() bool {
	for _, constr := range t.Constraints {
		if constr.Type != "pk" {
			continue
		}

		return len(constr.Columns) == 1
	}
	return true
}

func (t Table) GetPkColumns() ([]Column, error) {
	var values []Column
	for _, constraint := range t.Constraints {
		if constraint.Type == "pk" {
			for _, col := range constraint.Columns {
				_, ok := t.Type.FieldByName(col.FieldName)
				if !ok {
					continue
				}
				values = append(values, col)
			}
		}
	}
	if len(values) == 0 {
		return nil, errors.New("Could not determine pk column!")
	}

	return values, nil
}