Data model generator for postgres database.

generator/metadata/column_info.go

@@ -0,0 +1,116 @@
+package metadata
+
+import (
+	"database/sql"
+	"github.com/serenize/snaker"
+)
+
+type ColumnInfo struct {
+	Name       string
+	IsNullable bool
+	DataType   string
+	TableInfo  *TableInfo
+}
+
+func (c ColumnInfo) IsUnique() bool {
+	for _, uniqueColumn := range c.TableInfo.PrimaryKeys {
+		if uniqueColumn == c.Name {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (c ColumnInfo) ToGoVarName() string {
+	return snaker.SnakeToCamelLower(c.TableInfo.Name) + snaker.SnakeToCamel(c.Name) + "Column"
+}
+
+func (c ColumnInfo) ToGoType() string {
+	typeStr := c.GoBaseType()
+	if c.IsNullable {
+		return "*" + typeStr
+	}
+
+	return typeStr
+}
+
+func (c ColumnInfo) GoBaseType() string {
+	if forignKeyTable, ok := c.TableInfo.ForeignTableMap[c.Name]; ok {
+		return snaker.SnakeToCamel(forignKeyTable)
+	} else {
+		switch c.DataType {
+		case "boolean":
+			return "bool"
+		case "smallint":
+			return "int16"
+		case "integer":
+			return "int"
+		case "bigint":
+			return "int64"
+		//case "date" : return "time.Time"
+		case "bytea":
+			return "[]byte"
+		case "text":
+			return "string"
+		default:
+			return "string"
+		}
+	}
+}
+
+func (c ColumnInfo) ToGoDMFieldName() string {
+	if forignKeyTable, ok := c.TableInfo.ForeignTableMap[c.Name]; ok {
+		return snaker.SnakeToCamel(forignKeyTable)
+	} else {
+		return snaker.SnakeToCamel(c.Name)
+	}
+}
+
+func (c ColumnInfo) ToGoFieldName() string {
+	return snaker.SnakeToCamel(c.Name)
+}
+
+func fetchColumnInfos(db *sql.DB, tableInfo *TableInfo) ([]ColumnInfo, error) {
+
+	query := `
+SELECT column_name, is_nullable, data_type 
+FROM information_schema.columns
+where table_schema = $1 and table_name = $2
+order by ordinal_position;`
+
+	//fmt.Println(query)
+
+	rows, err := db.Query(query, tableInfo.DatabaseInfo.SchemaName, &tableInfo.Name)
+
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	ret := []ColumnInfo{}
+
+	for rows.Next() {
+		columnInfo := ColumnInfo{}
+		var isNullable string
+		err := rows.Scan(&columnInfo.Name, &isNullable, &columnInfo.DataType)
+
+		columnInfo.IsNullable = isNullable == "YES"
+
+		if err != nil {
+			return nil, err
+		}
+
+		columnInfo.TableInfo = tableInfo
+
+		ret = append(ret, columnInfo)
+	}
+
+	err = rows.Err()
+
+	if err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}

generator/metadata/database_info.go

@@ -0,0 +1,29 @@
+package metadata
+
+import (
+	"database/sql"
+)
+
+type DatabaseInfo struct {
+	DatabaseName string
+	SchemaName   string
+	TableInfos   []TableInfo
+}
+
+func GetDatabaseInfo(db *sql.DB, databaseName, schemaName string) (*DatabaseInfo, error) {
+
+	databaseInfo := &DatabaseInfo{
+		databaseName,
+		schemaName,
+		[]TableInfo{},
+	}
+
+	var err error
+	databaseInfo.TableInfos, err = fetchTableInfos(db, databaseInfo)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return databaseInfo, nil
+}

generator/metadata/table_info.go

@@ -0,0 +1,172 @@
+package metadata
+
+import (
+	"database/sql"
+	"fmt"
+	"github.com/serenize/snaker"
+	"strings"
+)
+
+type TableInfo struct {
+	Name            string
+	PrimaryKeys     []string
+	ForeignTableMap map[string]string
+	Columns         []ColumnInfo
+	DatabaseInfo    *DatabaseInfo
+}
+
+func (t TableInfo) IsForeignKey(columnName string) bool {
+	_, exist := t.ForeignTableMap[columnName]
+
+	return exist
+}
+
+func (t TableInfo) ToGoModelStructName() string {
+	return snaker.SnakeToCamel(t.Name)
+}
+
+func (t TableInfo) ToGoVarName() string {
+	return snaker.SnakeToCamel(t.Name)
+}
+
+func (t TableInfo) ToGoStructName() string {
+	return snaker.SnakeToCamel(t.Name) + "Table"
+}
+
+func (t TableInfo) ToGoColumnFieldList(sep string) string {
+	columnNames := []string{}
+	for _, columnInfo := range t.Columns {
+		columnNames = append(columnNames, columnInfo.ToGoVarName())
+	}
+	return strings.Join(columnNames, sep)
+}
+
+func fetchTableInfos(db *sql.DB, databaseInfo *DatabaseInfo) ([]TableInfo, error) {
+	query := `
+SELECT table_name 
+FROM information_schema.tables
+where table_schema = $1 and table_type = 'BASE TABLE';`
+
+	//fmt.Println(query, schemaName)
+
+	rows, err := db.Query(query, &databaseInfo.SchemaName)
+
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	tableInfos := []TableInfo{}
+	for rows.Next() {
+		var tableName string
+		err = rows.Scan(&tableName)
+		if err != nil {
+			return nil, err
+		}
+
+		tableInfo := &TableInfo{}
+		tableInfo.Name = tableName
+		tableInfo.PrimaryKeys, err = getPrimaryKeys(db, databaseInfo.SchemaName, tableName)
+		if err != nil {
+			return nil, err
+		}
+		tableInfo.DatabaseInfo = databaseInfo
+		tableInfo.Columns, err = fetchColumnInfos(db, tableInfo)
+
+		if err != nil {
+			return nil, err
+		}
+
+		tableInfo.ForeignTableMap, err = getForignKeyMap(db, databaseInfo.SchemaName, tableName)
+
+		if err != nil {
+			return nil, err
+		}
+
+		tableInfos = append(tableInfos, *tableInfo)
+	}
+
+	fmt.Println("FOUND", len(tableInfos), "tables")
+
+	err = rows.Err()
+
+	if err != nil {
+		return nil, err
+	}
+
+	return tableInfos, nil
+}
+
+func getPrimaryKeys(db *sql.DB, schemaName, tableName string) ([]string, error) {
+	query := `
+SELECT c.column_name
+FROM information_schema.key_column_usage AS c
+LEFT JOIN information_schema.table_constraints AS t
+ON t.constraint_name = c.constraint_name
+WHERE t.table_schema = $1 AND t.table_name = $2 AND t.constraint_type = 'PRIMARY KEY';
+`
+	rows, err := db.Query(query, schemaName, tableName)
+
+	if err != nil {
+		return nil, err
+	}
+
+	primaryKeys := []string{}
+
+	for rows.Next() {
+		primaryKey := ""
+		err := rows.Scan(&primaryKey)
+
+		if err != nil {
+			return nil, err
+		}
+
+		primaryKeys = append(primaryKeys, primaryKey)
+	}
+
+	return primaryKeys, nil
+}
+
+func getForignKeyMap(db *sql.DB, schemaName, tableName string) (map[string]string, error) {
+	query := `
+SELECT 
+    kcu.column_name,
+    ccu.table_name AS foreign_table_name,
+    ccu.column_name AS foreign_column_name 
+FROM 
+    information_schema.table_constraints AS tc 
+    JOIN information_schema.key_column_usage AS kcu
+      ON tc.constraint_name = kcu.constraint_name
+      AND tc.table_schema = kcu.table_schema
+    JOIN information_schema.constraint_column_usage AS ccu
+      ON ccu.constraint_name = tc.constraint_name
+      AND ccu.table_schema = tc.table_schema
+WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = $1 AND tc.table_name=$2;
+`
+	rows, err := db.Query(query, schemaName, tableName)
+
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	ret := map[string]string{}
+	for rows.Next() {
+		var columnName, foreignTableName, foreignColumnName string
+		err := rows.Scan(&columnName, &foreignTableName, &foreignColumnName)
+
+		if err != nil {
+			return nil, err
+		}
+
+		ret[columnName] = foreignTableName
+	}
+
+	err = rows.Err()
+
+	if err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}