My mysql database table name does not use plural form. Now the generated files always need me to manually add annotations, which seems too inconvenient. I have solved this problem, but I am not sure whether it is the most good implementation like this

await...

When I generate the fields for a MySQL table with DECIMAL columns (DECIMAL(19, 6) in this case), I'm getting fields like this:

field.Float64("cost")

However, this leads to a compilation error, because the method name is actually Float, not Float64. Right now I have to change it by hand to:

field.Float("cost")

Attempting to import from a postgres 13 database with this command:

go run ariga.io/entimport/cmd/entimport -dialect postgres -dsn "host=localhost port=5432 user=postgres dbname=testdb password=tesdbPass sslmode=disable" -tables "services"

It crashes with the error: entimport: schema import failed - postgres: querying schema tables: pq: argument of AND must be type boolean, not type information_schema.sql_identifier

If I do not include the -tables param, it crashes with: schema import failed - entimport: invalid primary key - single part key must be present

So I tried generating my ent schema using entimport and everything seemed to work just fine until I noticed that my Join table wasn't in the folder. I ran this command trying to generate the table:

go run ariga.io/entimport/cmd/entimport -tables friendship  -dsn "<mydsn>"

but I still got an error telling me that schema import failed:

entimport: schema import failed - entimport: join tables must be inspected with ref tables - append 
`tables` flag

I've tried the append flag but I can't seem to find it in docs

What does the above error mean? The table I try to import has a primary key, not partioned.

create table artikel
(
    `Artikel-Id` int auto_increment primary key,
    requires_internal_protocol varchar(255) null
)
    collate = latin1_german2_ci;

Storage engine InnoDB with MySQL 5.7

ent generates an error trying to parse the generated schema from the ddl below. The provided error is: "mismatch field type between edge field "username" and id of type "User" (string != int32)"

CREATE TABLE `users` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `token` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `username` (`username`),
  UNIQUE KEY `token` (`token`)
) ENGINE=InnoDB AUTO_INCREMENT=23 DEFAULT CHARSET=utf8;

CREATE TABLE `programme_uploads` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `upload_time` datetime NOT NULL,
  PRIMARY KEY (`id`),
  KEY `username` (`username`),
  KEY `upload_time_index` (`upload_time`),
  CONSTRAINT `programme_uploads_ibfk_1` FOREIGN KEY (`username`) REFERENCES `users` (`username`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=23 DEFAULT CHARSET=utf8;

I think it might be missing the foreign key reference in the generation?

In my DB I have a few schemas and when I run:

go run ariga.io/entimport/cmd/entimport -dsn "postgres://user:password@localhost:5432/db_name?sslmode=disable"

it generates Ent schemas only for the public schema. I know that I can specify search_path=<schema_name> in the DSN query. But again, I have tables with the same names but inside different schemas. How did it suppose to work?

Both mysql and mariadb can accept a precision for current_timestamp

mysql: https://dev.mysql.com/doc/refman/8.0/en/timestamp-initialization.html mariadb: https://mariadb.com/kb/en/current_timestamp/

So the line case "default_generated on update current_timestamp", "on update current_timestamp": in extraAttr() function may need to be adjusted.

Schema:

create table test
(
    id            bigint unsigned auto_increment
        primary key,
    expires_at    timestamp default current_timestamp() not null on update current_timestamp()
)
    collate = utf8mb4_unicode_ci;

I would send a PR but I cannot find the code in https://github.com/ariga/atlas

Did this get a blog post in the Ent web site ?

the reason I raise this is because when I discuss ent with long time devs they hate that ent is not database first in terms of the source of the schema.

This PR is using a mux inspired by Atlas which is now in charge of the connection to DB. The SchemaImporter now only implements dialect specific converters. Updated the readme and CLI to use mux.

see documents on ent site sql.DB Integration we can set db options in the DB() in normal code.but in the generated code, we could not access the DB object. so if it is possible to add some functional option to set SetMaxIdleConns SetMaxOpenConns SetConnMaxLifetime

When I use entimport to generate ent code, if the table name in the database ends with s, it will be trimmed. In order to make the generated code consistent with the database, it is recommended not to call this method.

for example, my table name is profit_and_loss, and the generated file name is profit_and_los.go

// old version
func typeName(tableName string) string {
	return inflect.Camelize(inflect.Singularize(tableName))
}

// new version
func typeName(tableName string) string {
	return inflect.Camelize(tableName)
}

I'm having an issue generating the schema from my existing postgres database. Ive been followign this post - https://entgo.io/blog/2021/10/11/generating-ent-schemas-from-existing-sql-databases/

When i execgo generate ./ent i get the following error:

entc/load: load schema dir: /home/kay/powerlevel/backend/ent/schema/authentication.go:19:276: not enough arguments in call to field.UUID have (string) want (string, driver.Valuer) exit status 1 ent/generate.go:3: running "go": exit status 1

database

-- CreateTable
CREATE TABLE "users" (
    "id" UUID NOT NULL DEFAULT gen_random_uuid(),
    "email" TEXT NOT NULL,
    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
    "updated_at" TIMESTAMP(3),
    "deleted_at" TIMESTAMP(3),

    CONSTRAINT "users_pkey" PRIMARY KEY ("id")
);

-- CreateTable
CREATE TABLE "authentication" (
    "id" UUID NOT NULL DEFAULT gen_random_uuid(),
    "type" TEXT NOT NULL,
    "service_id" TEXT NOT NULL,
    "session_id" TEXT NOT NULL,
    "password" TEXT NOT NULL,
    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
    "updated_at" TIMESTAMP(3),
    "deleted_at" TIMESTAMP(3),
    "user_id" UUID NOT NULL,

    CONSTRAINT "authentication_pkey" PRIMARY KEY ("id")
);

-- AddForeignKey
ALTER TABLE "authentication" ADD CONSTRAINT "authentication_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON DELETE RESTRICT ON UPDATE CASCADE;

I exec the following to get the code generated - go run ariga.io/entimport/cmd/entimport -dsn "postgres://root:password@localhost:5432/powerlevel?sslmode=disable"

ent/schema/authentication.go

// Code generated by entimport, DO NOT EDIT.

package schema

import (
	"entgo.io/ent"
	"entgo.io/ent/dialect/entsql"
	"entgo.io/ent/schema"
	"entgo.io/ent/schema/edge"
	"entgo.io/ent/schema/field"
	"github.com/google/uuid"
)

type Authentication struct {
	ent.Schema
}

func (Authentication) Fields() []ent.Field {
	return []ent.Field{field.UUID("id", uuid.UUID{}), field.String("type"), field.String("service_id"), field.String("session_id"), field.String("password"), field.Time("created_at"), field.Time("updated_at").Optional(), field.Time("deleted_at").Optional(), field.UUID("user_id").Optional(uuid.UUID{})}
}
func (Authentication) Edges() []ent.Edge {
	return []ent.Edge{edge.From("user", User.Type).Ref("authentications").Unique().Field("user_id")}
}
func (Authentication) Annotations() []schema.Annotation {
	return []schema.Annotation{entsql.Annotation{Table: "authentication"}}
}

ent/schema/user.go

// Code generated by entimport, DO NOT EDIT.

package schema

import (
	"entgo.io/ent"
	"entgo.io/ent/schema"
	"entgo.io/ent/schema/edge"
	"entgo.io/ent/schema/field"
	"github.com/google/uuid"
)

type User struct {
	ent.Schema
}

func (User) Fields() []ent.Field {
	return []ent.Field{field.UUID("id", uuid.UUID{}), field.String("email"), field.Time("created_at"), field.Time("updated_at").Optional(), field.Time("deleted_at").Optional()}
}
func (User) Edges() []ent.Edge {
	return []ent.Edge{edge.To("authentications", Authentication.Type)}
}
func (User) Annotations() []schema.Annotation {
	return nil
}

This is my first time using entgo, am i doing something wrong?

go version go1.18.4 linux/amd64
ariga.io/entimport v0.0.0-20220722070026-e5b57d96ab7c // indirect
entgo.io/ent v0.11.1 // indirect

Just playing around with it, it seems like in ent/schema/authentication.go this field.UUID("user_id").Optional(uuid.UUID{}) should have been field.UUID("user_id", uuid.UUID{}).Optional()? After editing that change and then attempting to generate, it does generate without errors. But it seems like i should not be editing these generated files. Although i dont think this manual change has worked properly to setup the edges. as the following statement brings back no authentication data despite it being the db. users, err := services.EntClient.User.Query().WithAuthentications().All(services.EntContext)

I believe entimport does not currently match the field.UUID API which accepts a second argument.

I just got a field generated as: field.UUID("fooer_id").Optional(uuid.UUID{})

where I believe the appropriate syntax is field.UUID("fooer_id", uuid.UUID{}).Optional()

go run ariga.io/entimport/cmd/entimport -dsn "mysql://root:pass@tcp(192.168.10.153:3306)/zzz" -tables "xxx"^C

Same command do generate schema.go file properly in linux

Actual A DB has a clients table that collides with ent.Client and a subsequent change to the ent.Schema is necessary to fix the error.

Suggestion When importing an existing database with entimport, there should be a prefix (or suffix) for the generated methods. In the configuration for entimport there should be an option to specify the prefix.

Example prefix: legacy table: clients Result: LegacyClient