常連

ER図を書くツールは何をつかっていますか？

私がつかったことがあるのは、次のものです。

設計時
  - [ERMaster](http://ermaster.sourceforge.net/index_ja.html)
  - Excel でちまちまと書いていく..
  
リバース・エンジニアリング時
  -  [erd](http://qiita.com/kanpou_/items/74eca1846101e6db3387)

その他：(研究中)
  - eclips の Sirius は ER 図作成につかえるものなのでしょか？

追加 (2015-11-13)
* そもそも、DBを使う場合, 設計時に ER 図を書きますか？
  (複数人で作業する場合を想定しています。)

ER図を書くツールは何をつかっていますか？

下記のように、prismaのschema.prismaにはDATABASE_URLの環境変数を読み込む設定がありますが、このDATABASE_URLの値を別のenvファイルから参照するようにしたい場合はどうしたらいいでしょうか？

デフォルトは、プロジェクト直下の.envを参照するようになっています。

環境はnest.jsを使用しています。
dot-envを使用して、prisma generateを行なってからnest.jsを起動しても、下記のエラーがでてしまいます。

■prisma/schema.prisma
```
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}
```

■.env
```
DATABASE_URL=${DRIVER}://$......
```

■error
```
Error: error: Error validating datasource `db`: the URL must start with the protocol `mysql://`.
```

prismaのdatabaseのurlの環境変数の参照を別のenvファイルにしたい

### 前提

GoでAPIを構築する際、ORMを使用せず生のSQLを書くとそれをStructにマッピングする必要があります。
sqlx (https://github.com/launchbadge/sqlx) のようなライブラリを使うことで、マッピングを簡易的に行うことも可能ですが、
One-to-ManyやMany-to-Manyとなると対応しておらず、クエリを複数回叩くか、取得したデータをループで回して手動でStructに入れていかなければなりません。

はじめはそんなわけがないと思い、いろいろ解決策を探したのですが例えばここ（https://stackoverflow.com/questions/54601529/efficiently-mapping-one-to-many-many-to-many-database-to-struct-in-golang） 
でも言及されてるように、泥臭い解決方しかないようです。


### 聞きたいこと

そこでお聞きしたいのは、どうやって解決するか？ということではなく、
本当にこんなことをみんなやってるのか？という素朴な疑問です。

ORMの話になったとき、巷ではよく「ORMを使うのはよくない」とか「本来ORMは必要ない」というような情報を目にします。
中でもGoは言語思想的にもしくは言語の特徴的にORMを使わない方が良いという風潮が強いように感じます。

でもORMを使わないことがこんなに面倒ならあまりに割に合ってない気がしてしまいます。

リンク先の例は非常にシンプルなものですが、実際の現場ではもっと複数のテーブルを組み合わせる必要があったり、もっと深くネストすることもありますよね、そう考えるととてもORM無しでやれるとは思えません。

世の中のバックエンドエンジニア方々、ORMなんて無くていいんだという強者な人たちは本当にこんなことをしているのでしょうか？
それとも私が知らないだけでもっと優れた解決法があるのでしょうか？

個人ではフルスタックで開発していますが、ORMを使用した経験(Node.js + prisma等)しかありません。
会社で働く際はフロントエンド中心でバックエンドを触る機会はあまりなく、あったとしてもORMを使用したプロジェクトにしか関わったことがないのでこちらで質問させていただきました。

先輩方のお話を聞かせていただけると幸いです。

GoでのORMを使用しないAPI開発。SQLの結果をstructにmapすることについて。

### 質問
現在、バックエンドエンジニアへの転職活動中でポートフォリオを作成しております！
先日現場のエンジニアの方から「SQL文を使えないのはダメだ」と言われてしまったのですが、PFレベルのアプリケーション開発ではO/Rマッパーを使用すればSQL文を深くは理解しないままそれなりのDB操作が出来てしまうためあまりピンときませんでした。(一応生成されるSQL文は理解できます！)

そこで現場でORMを使用している方に質問なのですが、どのような場面でSQL文を理解、使用できないと困るのが教えていただきたく質問させていただきました。
私の予想では
・FW内ではなく直接DBを触る機会が頻繁に発生するため
・実際のアプリケーションではORMの簡単なメソッド では絞り込むことができない複雑なDB処理がしばしば発生するため
なのかな、と考えております。
宜しくお願いいたします。

現場ではORMだけではなくSQL文を頻繁に利用するのでしょうか？

Pythonを使ってRedshiftのデータを加工、分析、表示するコードを書いています。
DBから取得したデータをpandasのDataFrameに入れていろいろと触る方針です。
PythonからRedshiftに接続する方法を調べていて、psycopg2を使って接続、SQLを実行する方法は確立したのですが、SQLAlchemyをかませてcreate_engineしてから接続する方法を紹介しているところが非常に多く、混乱しています。
psycopg2を使って直接接続すれば
```python
import pandas as pd
import psycopg2 as pg2

con= pg2.connect(host=server,database=db,port=dbport,user=username,password=userpass) as con:
df=pd.read_sql(query,con)
con.close()
```
のようなコードで済むところを、
```python
from sqlalchemy create_engine
import pandas as pd
import numpy as np
import psycopg2 as pg2

db_conf='postgresql+psycopg2://{user}:{passwd}@{host}:{port}/{dbname}'.format(
    user=username,passwd=userpass,host=server,port=dbport,dbname=db)
engine=create_engine(db_conf)
con=engine.connect()
data=pd.read_sql(q,engine)
con.close()
engine.dispose()
```
上記のように一度SQLAlchemyでエンジンを作ってデータを取る方法を紹介しているのですが、変数も増えるしコードも長くなるしいいことがないように思えてなりません。

わざわざコードを冗長にしているからには相応の理由があると思うのですが、pythonスクリプトからSQLAlchemyを一度はさんでSQLに接続するメリット、使わなかった場合のデメリットとはなんでしょうか？

SQLAlchemyなどのORMエンジンを使う意味

現在Java（SpringBoot）でJPA（Hibernate）を利用してDBサーバーと通信するWEBシステムを作成しております。
JPAで取得したデータはEntityクラスを用意し、そこにマッピングして受け取るようにしています。

そこで問題があるのですが、データ量が少なければ問題ないのですがマッピングする量が増えた時、レスポンスが著しく遅くなることが分かりました。
調べたところwebサーバーとDBサーバーの通信時間、DBサーバーのレスポンス時間は問題ありません。

JavaでEntityクラスにマッピングする際時間がかかることが分かりました。
今までNodeなどでは発生しなかった問題なので、解決策が見つからず途方にくれています。
とりあえず現在はデータ量に制限を設けることで、問題を先送りしています。
具体的には検索時に、レスポンスの件数が100件以上であればエラーして絞込の条件を増やすように促すなどです。

entityクラスのフィールドを制限し、マッピングする項目制限をするなどもあるのでしょうが、現状使わない項目でも随時利用していくことになるでしょうし（本当に使わない項目であればそもそもDBのテーブル構成から検討する必要がありますが）、出来ればマッピングクラスはDBの全項目をフォローしたいところです。

サーバースペックの問題も勿論あると思いますが、多少良いサーバーを用意して実験してもさほど結果は変わりませんでした。
具体的には1000件の項目の多いテーブルデータを取得してブラウザに表示するまでに15秒かかりました。
Javaでクラスにマッピングするとなると、こんなものなのでしょうか。

何か良い解決方法があれば、ご教授願います。

[Java]JPAのマッピングに時間がかかりすぎる件について

### 実現したいこと
SQLiteに全角英数字を含むカラム名があるとき、エラーを出さずにデータを追加したい
（カラム名には「明細ＩＤ」や「詳細１」のように全角英数字が含まれている）

元のカラム名を変更せずに対処する方法を教えてください。
SQLAlchemyで問題解決できなければ、他のORMライブラリでも構いません。

### 発生している問題・分からないこと
TypeError: '明細ID' is an invalid keyword argument for mydata
のエラーが出ます。
全角英数字で指定しているカラム名が半角英数字に変換されてしまっているもよう（変換されないようにするためにはどうすればよいか）


### エラーメッセージ
```error
Traceback (most recent call last):
...
  File "/opt/homebrew/Caskroom/miniconda/base/envs/3_10_6/lib/python3.10/site-packages/sqlalchemy/orm/state.py", line 481, in _initialize_instance
    with util.safe_reraise():
  File "/opt/homebrew/Caskroom/miniconda/base/envs/3_10_6/lib/python3.10/site-packages/sqlalchemy/util/langhelpers.py", line 70, in __exit__
    compat.raise_(
  File "/opt/homebrew/Caskroom/miniconda/base/envs/3_10_6/lib/python3.10/site-packages/sqlalchemy/util/compat.py", line 208, in raise_
    raise exception
  File "/opt/homebrew/Caskroom/miniconda/base/envs/3_10_6/lib/python3.10/site-packages/sqlalchemy/orm/state.py", line 479, in _initialize_instance
    return manager.original_init(*mixed[1:], **kwargs)
  File "/opt/homebrew/Caskroom/miniconda/base/envs/3_10_6/lib/python3.10/site-packages/sqlalchemy/orm/decl_base.py", line 1163, in _declarative_constructor
    raise TypeError(
TypeError: '明細ID' is an invalid keyword argument for mydata
```

### 該当のソースコード

```Python
DATABASE = os.path.expanduser('mydata.sqlite')
Base = automap_base()
engine = sqlalchemy.create_engine(f'sqlite:///{DATABASE}', echo=False)
Base.prepare(engine, reflect=True)
Mydata = Base.classes.mydata
session = Session(bind = engine)
records = []
for record in csv_dict:
    records.append(Mydata(
        明細ＩＤ = record['明細ＩＤ'], #<- 全角英字のカラム名、ここでエラーになる
        金額 = record['金額'],
        詳細１ = record['詳細１'], #<- 全角数字のカラム名、ここでエラーになる
        詳細２ = record['詳細２'])), #<- 全角数字のカラム名、ここでエラーになる
session.add_all(records)
session.commit()

# csv_dictは次のようなdictのlistです
# {'明細ＩＤ': '20001205002', '金額': 165, '詳細１': '手数料', '詳細２': ''}

```

### 試したこと・調べたこと
- [x] teratailやGoogle等で検索した
- [x] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [ ] その他

##### 上記の詳細・結果
「python sqlalchemy カラム名に全角英数字」で検索しても同様の問題が見つかりません
「明細ＩＤ」をシングルクウォート、ダブルクウォート、バッククウォートで囲ってみたり、全角英数字の前にバックスラッシュ（エスケープ）を入れたりしたけど、だめでした。


### 補足
python 3.10.6
SQLAlchemy 1.4.39


SQLAlchemy のカラム名に全角英数字がある場合のTypeError

### 前提・実現したいこと

バッチを複数並列に実行することを想定しています。
その場合、DBへの書き込みは、`session.commit()`すればいいだけなのでしょうか？
マルチスレッドでも問題なく動作し、適切な場所で`commit`or`rollback`されるのでしょうか？
サンプルコードを作成して試してみて、実現できているように後述する疑問が残ってしましました。

### 試したこと
下記のように`setting.py`にsessonを定義し
db関連をまとめたパッケージの`__init__.py`で`import`しています

```python 
# setting.py
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, scoped_session

# DB設定
USERNAME = "test"
PASSWORD = "test"
HOST = "127.0.0.1"
DBNAME = "TEST"
CHARSET = "utf8"
ENCODING = "utf-8"
DB_ECHO = True

# mysql
DATABASE = f"mysql://{USERNAME}:{PASSWORD}@{HOST}/{DBNAME}?charset={CHARSET}"

ENGINE = create_engine(
    DATABASE,
    encoding=ENCODING,
    echo=DB_ECHO
)

# session作成
session = scoped_session(
    sessionmaker(
        autocommit=False,
        autoflush=False,
        bind=ENGINE
    )
)

DbBase = declarative_base()
```

マルチスレッドで2テーブルにinsertするテストコードを実行してみました
```python
# main
from db import DbBase, session, ENGINE
from db.job1 import Job1
from db.job2 import Job2

import threading
import time

DbBase.metadata.drop_all(bind=ENGINE, tables=[Job1.__table__, Job2.__table__])
DbBase.metadata.create_all(bind=ENGINE, tables=[Job1.__table__, Job2.__table__])

def create_sample1():

    for i in range(1,1000):
        job = Job1()
        job.name = f"TEST{i}"
        job.note = i
        session.add(job)
        time.sleep(0.01)

    session.rollback()


def create_sample2():

    for i in range(1, 1000):
        job = Job2()
        job.name = f"TEST{i}"
        session.add(job)
        time.sleep(0.02)

    session.commit()


thread1 = threading.Thread(target=create_sample1)
thread2 = threading.Thread(target=create_sample2)


thread1.start()
thread2.start()

```

### 試した上での疑問
job1のほうはrollbackされ、job2はcommitされており実現はされているような気はします。
ただ、上記ソースではトランザクションが始まるタイミングがわからず、本当に大丈夫なのか？という不安も解消されていません。

`session`はグローバルで定義されており、共通に利用しています。
それなのに、なぜ片方のみrollbackができるのでしょうか？どこからトランザクションが開始されるのでしょうか？

※ トランザクション開始を明示するならと
`session.begin()`と書くと`autocommit=False`の時は、トランザクションがすでに貼られていますと言われ
`session.begin_nested()`と書くと、おそらくmysqlには対応していないのかinsertが反映されてませんでした。



もやもやっとした疑問のため、わかりづらい箇所があるかと思いますが
よろしくお願いします。