gdulai/simpleorm
Public Access
1
0
Fork 0
Code Issues 5 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

WIP: Refactor parse

Browse Source
This commit is contained in:
gdulai
2026-06-05 15:54:47 +02:00
parent d20184a6f0
commit 146f07fa02
10 changed files with 255 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files
schema/constraint.go
+17 -8
View File
@@ -3,14 +3,16 @@ package schema
import (
"errors"
"strings"
"git.gdulai.com/gdulai/simpleorm/util"
)
type Constraint struct {
Name string
Type string
Columns []Column
RefTable *Table
RefColumns []Column
Name string
Type string
Columns []Column
RefTypeName string
RefColumns []Column
}
func (c *Constraint) GetDDL() (string, error) {
@@ -26,7 +28,9 @@ func (c *Constraint) GetDDL() (string, error) {
func (c *Constraint) getPkDDL() string {
var ddl strings.Builder
ddl.WriteString("CONSTRAINT " + c.Name + " PRIMARY KEY(")
ddl.WriteString("CONSTRAINT ")
ddl.WriteString(c.Name)
ddl.WriteString(" PRIMARY KEY(")
for i, col := range c.Columns {
if i != 0 {
ddl.WriteString(", ")
@@ -39,7 +43,9 @@ func (c *Constraint) getPkDDL() string {
func (c *Constraint) getFkDDL() string {
var ddl strings.Builder
ddl.WriteString("CONSTRAINT " + c.Name + " FOREIGN KEY(")
ddl.WriteString("CONSTRAINT ")
ddl.WriteString(c.Name)
ddl.WriteString(" FOREIGN KEY(")
for i, col := range c.Columns {
if i != 0 {
@@ -47,7 +53,10 @@ func (c *Constraint) getFkDDL() string {
}
ddl.WriteString(col.Name)
}
ddl.WriteString(") REFERENCES " + c.RefTable.Name + "(")
ddl.WriteString(") REFERENCES ")
ddl.WriteString(util.CamelToSnake(c.RefTypeName))
ddl.WriteString("(")
for i, col := range c.RefColumns {
if i != 0 {
schema/parser.go
+103
View File
@@ -0,0 +1,103 @@
package schema
import (
"reflect"
"strings"
"git.gdulai.com/gdulai/simpleorm/util"
log "gitlab.com/gdulai/simpleloglvl"
)
type Parser struct {
typ reflect.Type
columns []Column
constraints []Constraint
}
func NewParser[T any](obj T) *Parser {
objType := reflect.TypeOf(obj)
return &Parser{typ: objType}
}
// Step 1 of the parsing, it creates the table instance and
func (p *Parser) ParseColumns() {
var columns []Column
for field := range p.typ.Fields() {
field := field
col := NewColumn(util.CamelToSnake((field.Name)), field.Name, determineType(field.Type), field.Tag)
columns = append(columns, col)
}
p.columns = columns
}
// Step 2 of the parsing, it creates the constrains with the table references
func (p *Parser) ParseConstraints(tableParsers map[string]*Parser) {
pkConstraint := Constraint{Name: "pk_" + strings.ToLower(util.CamelToSnake((p.typ.Name()))), Type: "pk"}
fkConstraints := make(map[string]Constraint)
for _, col := range p.columns {
_, ok := col.Modifiers["pk"]
if ok {
pkConstraint.Columns = append(pkConstraint.Columns, col)
continue
}
fkMod, ok := col.Modifiers["fk"]
if !ok {
continue
}
fkModParts := strings.Split(fkMod, ".")
refTypeName := fkModParts[0]
refTableName := util.CamelToSnake(refTypeName)
parser, ok := tableParsers[refTypeName]
if !ok {
log.LogError("[ORM] Reference table not found", refTypeName)
}
fkId, ok := col.Modifiers["fk_id"]
if fkId == "" {
fkId = "fk_" + strings.ToLower(refTableName)
}
fkConstraint, ok := fkConstraints[fkId]
if !ok {
fkConstraint = Constraint{Name: fkId, Type: "fk", RefTypeName: refTypeName}
}
fkConstraint.Columns = append(fkConstraint.Columns, col)
refField := fkModParts[1]
for _, refC := range parser.columns {
if refC.FieldName == refField {
fkConstraint.RefColumns = append(fkConstraint.RefColumns, refC)
}
}
fkConstraints[fkId] = fkConstraint
}
p.constraints = append(p.constraints, pkConstraint)
for _, fkConstraint := range fkConstraints {
p.constraints = append(p.constraints, fkConstraint)
}
}
// Step 3 of the paring, create the schema.Table instance
// Returns the schema.Table pointer
func (p Parser) ParseTable() *Table {
return &Table{name: util.CamelToSnake(p.typ.Name()), typ: p.typ, columns: p.columns, constraints: p.constraints}
}
func determineType(typ reflect.Type) string {
typStr := typ.String()
switch typStr {
case "string":
return "TEXT"
case "int", "bool":
return "INTEGER"
case "time.Time", "int64":
return "BIGINT"
}
return "VARCHAR(255)"
}
schema/table.go
+61 -25
View File
@@ -7,17 +7,40 @@ import (
"git.gdulai.com/gdulai/simpleorm/util"
)
type OrderBy struct {
Field string
Direction string
}
type Table struct {
Name string
Type reflect.Type
Columns []Column
Constraints []Constraint
name string
typ reflect.Type
columns []Column
constraints []Constraint
}
func (t Table) Name() string {
return t.name
}
func (t Table) Type() reflect.Type {
return t.typ
}
func (t Table) Columns() []Column {
return t.columns
}
func (t Table) Constraints() []Constraint {
return t.constraints
}
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 {
ddl.WriteString("CREATE TABLE IF NOT EXISTS ")
ddl.WriteString(t.name)
ddl.WriteString(" (")
for i, col := range t.columns {
if i != 0 {
ddl.WriteString(", ")
}
@@ -27,12 +50,13 @@ func (t Table) GetDDL() (string, error) {
}
ddl.WriteString(colDdl)
}
for _, constr := range t.Constraints {
for _, constr := range t.constraints {
constrDdl, err := constr.GetDDL()
if err != nil {
return "", err
}
ddl.WriteString(", " + constrDdl)
ddl.WriteString(", ")
ddl.WriteString(constrDdl)
}
ddl.WriteString(");")
@@ -43,7 +67,7 @@ func (t Table) GetSelectDML() (string, error) {
var dml strings.Builder
dml.WriteString("SELECT ")
for i, col := range t.Columns {
for i, col := range t.columns {
if i != 0 {
dml.WriteString(", ")
}
@@ -54,21 +78,24 @@ func (t Table) GetSelectDML() (string, error) {
dml.WriteString(colDml)
}
dml.WriteString(" FROM " + t.Name)
dml.WriteString(" FROM ")
dml.WriteString(t.name)
return dml.String(), nil
}
func (t Table) GetCountDML() string {
return "SELECT COUNT(*) FROM " + t.Name
return "SELECT COUNT(*) FROM " + t.name
}
func (t Table) GetInsertDML(count int) (string, error) {
var dml strings.Builder
dml.WriteString("INSERT INTO " + util.CamelToSnake(t.Type.Name()) + " (")
dml.WriteString("INSERT INTO ")
dml.WriteString(util.CamelToSnake(t.typ.Name()))
dml.WriteString(" (")
columnsLen := len(t.Columns)
columnsLen := len(t.columns)
effectiveColumnsLen := 0
for i, col := range t.Columns {
for i, col := range t.columns {
_, ok := col.Modifiers["pk"]
if ok && t.IsPkAuto() {
continue
@@ -111,12 +138,14 @@ func (t Table) GetInsertDML(count int) (string, error) {
func (t Table) GetUpdateDML() (string, error) {
var dml strings.Builder
dml.WriteString("UPDATE " + util.CamelToSnake(t.Type.Name()) + " SET ")
dml.WriteString("UPDATE ")
dml.WriteString(util.CamelToSnake(t.typ.Name()))
dml.WriteString(" SET ")
colLen := len(t.Columns)
colLen := len(t.columns)
var pkColumns []string
// Colum names
for i, col := range t.Columns {
for i, col := range t.columns {
modifiers := col.Modifiers
_, ok := modifiers["pk"]
@@ -133,9 +162,11 @@ func (t Table) GetUpdateDML() (string, error) {
}
if i != colLen-1 {
dml.WriteString(colDml + ", ")
dml.WriteString(colDml)
dml.WriteString(", ")
} else {
dml.WriteString(colDml + " ")
dml.WriteString(colDml)
dml.WriteString(" ")
}
}
@@ -145,7 +176,8 @@ func (t Table) GetUpdateDML() (string, error) {
if i != 0 {
dml.WriteString(" AND ")
}
dml.WriteString(pkCol + " = ?")
dml.WriteString(pkCol)
dml.WriteString(" = ?")
}
return dml.String(), nil
@@ -153,17 +185,21 @@ func (t Table) GetUpdateDML() (string, error) {
func (t Table) GetDeleteDML(count int) (string, error) {
var dml strings.Builder
dml.WriteString("DELETE FROM " + t.Name + " WHERE ")
dml.WriteString("DELETE FROM ")
dml.WriteString(t.name)
dml.WriteString(" WHERE ")
for _, col := range t.Columns {
for _, col := range t.columns {
modifiers := col.Modifiers
_, ok := modifiers["pk"]
if ok {
if count > 1 {
dml.WriteString(col.Name + " IN (")
dml.WriteString(col.Name)
dml.WriteString(" IN (")
} else {
dml.WriteString(col.Name + " = ")
dml.WriteString(col.Name)
dml.WriteString(" = ")
}
}
}
@@ -183,7 +219,7 @@ func (t Table) GetDeleteDML(count int) (string, error) {
}
func (t Table) IsPkAuto() bool {
for _, constr := range t.Constraints {
for _, constr := range t.constraints {
if constr.Type != "pk" {
continue
}