A Tool to Visualize Definition of Tables in RDB

maru44 — Sat, 05 Mar 2022 00:09:52 +0000

Link:
https://github.com/maru44/scheman

Scheman is a tool to visualize definition of tables in RDB.

Main purpose of this is accelerating working collaboration between engineers and non-engineers.

You can generate drawing of tables schema and ERD with one command and just a few settings by using this.

You can choose output destination from Notion, File or both of them.

Usage

I will show you usage.

Installation

install

go install github.com/maru44/scheman@v1.3.0

If you want not to install you can use by

go run github.com/maru44/scheman@v1.3.0 ...

I will proceed on the premise of scheman installed.

Setup config

Create scheman.toml(.yaml) and write database settings.

[psql]
  dbname  = "scheman"
  host    = "localhost"
  port    = 5432
  user    = "root"
  pass    = "password"
  sslmode = "disable"
  schema  = "public"

Command

I will show some examples.

Notion

First I will show you the command to write tables schema and ERD in notion.

go install github.com/volatiletech/sqlboiler/v4/drivers/sqlboiler-psql@v4.8.6 \
  && scheman psql --services notion --erd-outputs notion \
    --notion-token ${NOTION_TOKEN} --notion-page-id ${PSQL_NOTION_PAGE_ID}

Flag services indicates the output destinations of schema-definition.
Flag erd-outputs indicates the output destinations of ERD.

The value of table-index is output like the following picture if the command succeeded.
If you want to overwrite schema definition and ERD in notion from next time, please set notion-page-index the value outputted in command line.

The Free Entry attribute is the attribute you can write freely. This value is inherited even if you execute scheman command next time.

The outputs will be like these pictures.
I'm sorry for these pictures are very rough.

schema-definition
https://user-images.githubusercontent.com/46714011/155822065-f0f9f785-b2b1-4abd-b98b-052496dff169.png

ERD
https://user-images.githubusercontent.com/46714011/155862202-77e81b99-681a-44fb-bf1c-669dae7f1f5a.png

File

go install github.com/volatiletech/sqlboiler/v4/drivers/sqlboiler-psql@v4.8.6 \
  && scheman psql --def-file ./def.csv --erd-file ./erd.md

Flag def-file indicates the output destination file of schema-definition.
Flag erd-file indicates the output destination file of ERD.

The outputs will be like these.

schema-definition
https://github.com/maru44/scheman/blob/master/testdata/postgres/def.csv

ERD
https://github.com/maru44/scheman/blob/master/testdata/postgres/erd.md

Options

config
- the file written configurations
- default is scheman
- you can use sqlboiler.toml if you set this sqlboiler.toml
services
- indicates the output destinations of schema-definition
- default is [ ]
- option is only notion yet
erd-outputs
- indicates the output destinations of ERD
- default is [ ]
- option is only notion yet
disable-views
- if true, scheman ignore views
- default is false
attr-ignore
- which attributes ignore
- default is [ ]
- options are Data Type, PK, Auto Generate, Unique, Null, Default, Comment, Free Entry, Enum

Thanks

Using sqlboiler to parse connected database.
https://github.com/volatiletech/sqlboiler

Using go-notion as notion client.
https://github.com/dstotijn/go-notion

Minimum Library to Handle Error for Go

maru44 — Sun, 24 Oct 2021 10:49:22 +0000

Introduction

I made an error library named perr.

Perr gives error persona and enrich error.
You can handle error properly, safely and easily with perr.

Link:
https://github.com/maru44/perr

image ref:
https://pixabay.com/ja/?utm_source=link-attribution&utm_medium=referral&utm_campaign=image&utm_content=2661641

Purpose

Why I made this.

main purpose

I think errors must possess their persona.
- For client(which means client side and user using your service)
- For developer

For example, dial tcp 127.0.0.1:3306: connect: connection refused must not be shown for client. At the same time, Internal Server Error is not enough for developer.

sub purpose

Map() and Json() method make it easy to store and analyze error for you.
Is() and Level() method make it easy to handle error.
You can trace error with Traces() method.

Sample

wrapping error

You can wrap an error has existed already.
You can wrap an error as many times as you like.

package main

import (
    "fmt"
    "strconv"

    "github.com/maru44/perr"
)

func main() {
    _, err := strconv.Atoi("a")

    p := perr.Wrap(err, perr.BadRequest)
    p2 := perr.Wrap(p, perr.BadRequest)
    p3 := perr.Wrap(p2, perr.InternalServerError)

    fmt.Println("developer:", p3)
    fmt.Println("client:", p3.Output())

    fmt.Println("\n", p3.Traces())
}

/* output */
// developer: strconv.Atoi: parsing "a": invalid syntax
// client: Bad Request

// /tmp/sandbox2199832404/prog.go:13 ===> main
//  /tmp/sandbox2199832404/prog.go:14 ===> main
//      /tmp/sandbox2199832404/prog.go:15 ===> main

new error

package main

import (
    "fmt"

    "github.com/maru44/perr"
)

func main() {
    p:= perr.New("Someone pour coffee", perr.IAmATeaPot)

    fmt.Println("developer: ", p)
    fmt.Println("client: ", p.Output())

    p2 := perr.New("", perr.IAmATeaPot)
    fmt.Println("\ndeveloper: ", p2)
    fmt.Println("client: ", p2.Output())
}

/* output */
// developer:  Someone pour coffee
// client:  I'm a teapot

// developer:  I'm a teapot
// client:  I'm a teapot

DEV Community: maru44