Awesome

sg

sg: A simple standard SQL generator written in Go.

Overview

• Builders
  • Insert
  • Delete
  • Update
  • Select
• Generators
  • Create view
  • Create index
  • Create unique index
  • Index definition
  • Column definition
  • Primary key
  • Default
  • Delete
  • Delete from
  • Drop table
  • Drop view
  • Drop event
  • Drop procedure
  • Insert
  • Values
  • Alias
  • Arg
  • From
  • Left join
  • Right join
  • Inner join
  • On
  • Select
  • Order by
  • Asc
  • Desc
  • Asc group
  • Desc group
  • Group by
  • Having
  • Update
  • Set
  • Set eq
  • Where
  • And
  • Or
  • Not
  • And group
  • Or group
  • Eq
  • Not eq
  • Gt
  • Gt eq
  • Lt
  • Lt eq
  • Like
  • Left like
  • Right like
  • Instr
  • In
  • Between and

Builders

Insert Builder

package main

import (
  "fmt"
  . "github.com/go-the-way/sg"
)

func main() {
  builder := InsertBuilder().
    Table(T("table_person")).
    Column(C("col1"), C("col2")).
    Value(Arg(100), Arg(200))
  fmt.Println(builder.Build())
  // Output:
  // INSERT INTO table_person (col1, col2) VALUES (?, ?) [100 200]
}

Delete Builder

package main

import (
	"fmt"
	. "github.com/go-the-way/sg"
)

func main() {
	builder := DeleteBuilder().
		Delete(T("t1.*")).
		From(As(C("table1"), "t1"), As(C("table2"), "t2")).
		Where(AndGroup(Gt("t1.col1", 100), Gt("t2.col2", 200)))
	fmt.Println(builder.Build())
	// Output:
	// DELETE t1.* FROM table1 AS t1, table2 AS t2 WHERE ((t1.col1 > ?) AND (t2.col2 > ?)) [100 200]
}

Update Builder

package main

import (
	"fmt"
	. "github.com/go-the-way/sg"
)

func main() {
	builder := UpdateBuilder().
		Update(As(T("table_person"), "t")).
		Join(LeftJoin(As(T("table_a"), "ta"), On(C("t.col1 = ta.col1")))).
		Set(SetEq("col1", 100), SetEq("col2", 200)).
		Where(AndGroup(Eq("a", 100), Eq("b", 200)))
	fmt.Println(builder.Build())
	// Output:
	// UPDATE table_person AS t LEFT JOIN table_a AS ta ON (t.col1 = ta.col1) SET col1 = ?, col2 = ? WHERE ((a = ?) AND (b = ?)) [100 200 100 200]
}

Select Builder

package main

import (
	"fmt"
	. "github.com/go-the-way/sg"
)

func main() {
	builder := SelectBuilder().
		Select(C("a"), C("b")).
		From(T("table_person")).
		Join(LeftJoin(As(T("table_a"), "ta"), On(C("ta.col1 = tb.col1")))).
		Where(AndGroup(Eq("a", 100), Eq("b", 200))).
		OrderBy(DescGroup(C("a"), C("b")))
	fmt.Println(builder.Build())
	// Output:
	// SELECT a, b FROM table_person LEFT JOIN table_a AS ta ON (ta.col1 = tb.col1) WHERE ((a = ?) AND (b = ?)) ORDER BY a DESC, b DESC [100 200]
}

Generators

Create view

CreateView(P("vm_nowTime"), P(`select NOW() AS t`)

Create index

CreateIndex(false, P("idx_name"), T("table"), C("name"))

Create unique index

CreateUniqueIndex(P("idx_name"), T("table"), C("name"))

Index definition

IndexDefinition(false, P("idx_name"), C("name"))

Column definition

ColumnDefinition(P("id"), P("int"), false, true, false, "", "ID")

Primary key

PrimaryKey(C("id"))

Default

Default(C("1"))

Delete

Delete([]Ge{}, T("table_a"))

Delete from

DeleteFrom(T("table_a"))

Drop table

DropTable(T("table"))

Drop view

DropView(T("view"))

Drop event

DropEvent(T("event"))

Drop procedure

DropProcedure(T("procedure"))

Insert

Insert(C("table"), C("aa"))

Values

Values(Arg(100))

Alias

Alias(C("hello"), "hello_lo")

Arg

Arg(100)

From

From(T("table_a"), T("table_b"))

Left join

LeftJoin(As(T("table_a"), "ta"), On(C("ta.col1 = tb.col1"))

Right join

RightJoin(As(T("table_a"), "ta"), On(C("ta.col1 = tb.col1"))

Inner join

InnerJoin(As(T("table_a"), "ta"), On(C("ta.col1 = tb.col1"))

On

On(C("ta.col1 = tb.col1"))

Select

Select(C("t.col_a"))

Order by

OrderBy(AscGroup(C("t.abc"), C("t.xxx")))

Asc

Asc(C("t.abc"))

Desc

Desc(C("t.abc"))

Asc group

AscGroup(C("t.abc"), C("t.xxx"))

Desc group

DescGroup(C("t.abc"), C("t.xxx"))

Group by

GroupBy(C("t.abc"), C("t.xyz"))

Having

Having(AndGroup(Eq("a", 1)))

Update

Update(T("table_a"))

Set

Set(C("t.a = t.b"))

Set eq

SetEq("col1", 100)

Where

Where(AndGroup(Eq("a", 1)))

And

And(Eq("c", 100))

Or

Or(Eq("c", 100))

Not

Not(Eq("c", 100))

And group

AndGroup(Gt("t1.col1", 100), Gt("t2.col2", 200))

Or group

OrGroup(Eq("a", 1), Eq("b", 100))

Eq

Eq("a", 1))

Not eq

NotEq("a", 1))

Gt

Gt("a", 1))

Gt eq

Lt("a", 1))

Lt

Lt("a", 1))

Lt eq

LtEq("a", 1))

Like

Like("a", 1)

Left like

LeftLike("a", 1)

Right like

RightLike("a", 1)

Instr

Instr("a", 1)

In

In("a", 1)

Between and

BetweenAnd(c, rune(100), rune(100))