Hier fassen wir die Methode zum Definieren einer Tabelle mit SQLAlchemy zusammen. ** Im Folgenden ist Dialekt (DB-Typ) MySQL. ** **.
Es kann durch mysql_charset von __table_args__ angegeben werden.
Zum Beispiel, wenn Sie einen Zeichensatz als utf8mb4 angeben möchten
class User(Base):
__table_args__=({"mysql_charset": "utf8mb4"})
Und es ist ausreichend. Wenn Sie utf8 angeben, wird die Warnung übrigens wie folgt ausgegeben.
Warning: (3719, "'utf8' is currently an alias for the character set UTF8MB3, but will be an alias for UTF8MB4 in a future release. Please consider using UTF8MB4 in order to be unambiguous.")
ROW_FORMAT=DYNAMIC Die maximale Schlüssellänge des Index beträgt 3072 Byte. Wenn die MySQL-Version jedoch 5.6 oder früher ist, beträgt der Standardwert 767 Byte. Wenn Sie 5.6 oder früher verwenden und wie folgt schreiben, tritt daher ein Fehler auf.
class User(Base):
__table_args__=({"mysql_charset": "utf8mb4"})
a=Column(String(255), unique=True)
Dies liegt daran, dass utf8mb4 angegeben ist, also 255 * 4 = 1020 (Byte), was 767 Bytes überschreitet. (Übrigens ist im Fall von utf8mb3 255 * 3 = 765 (Byte) in Ordnung) Durch Setzen von "ROW_FORMAT = DYNAMIC" beträgt die maximale Schlüssellänge des Index 3072 Byte. Sie können wie folgt schreiben.
class User(Base):
__table_args__=({"mysql_charset": "utf8mb4", "mysql_row_format": "DYNAMIC"})
a=Column(String(255), unique=True)
In 5.7 und höher ist standardmäßig "ROW_FORMAT = DYNAMIC".
Es kann durch mysql_engine von __table_args__ angegeben werden.
Wenn Sie beispielsweise die DB-Engine für InnoDB angeben möchten,
class User(Base):
__table_args__=({"mysql_engine": "InnoDB"})
Und es ist ausreichend.
Data Types
Als generische Typen von SQLAlchemy können Sie es importieren und mit from sqlalchemy.types import hogehoge verwenden.
Zum Beispiel gibt es Folgendes.
from sqlalchemy.types import Float
from sqlalchemy.types import Integer
from sqlalchemy.types import String
from sqlalchemy.types import DateTime
Für diese generischen Typen wählt SQL Alchemy die entsprechenden Datentypen entsprechend dem DB-Typ aus, der bei "CREATE TABLE" verwendet werden soll. Offizielle Dokumente (generische Typen)
Beispielsweise sind vorzeichenlose int, tiny int und timestamp type in Generic Types nicht enthalten. Verwenden Sie in einem solchen Fall "from sqlalchemy.dialects.mysql import fugafuga".
from sqlalchemy.dialects.mysql import INTEGER as Integer
from sqlalchemy.dialects.mysql import TINYINT as Tinyint
from sqlalchemy.dialects.mysql import TIMESTAMP as Timestamp
class User(Base):
a=Column(Integer(unsigned=True)) #a ist int ohne Vorzeichen int
b=Column(Tinyint(1)) #b ist winzig int(1)
c=Column(Timestamp) #c ist der Zeitstempel
(Offizielle Dokumentation (MySQL-Datentypen))
Primary Key
Sie können primary_key = True in der Spalte setzen.
class User(Base):
id=Column(Integer, primary_key=True) #ID ist Primärschlüssel
Wenn Sie einen zusammengesetzten Primärschlüssel erstellen möchten, setzen Sie für beide primary_key = True.
class User(Base):
# id_1 und id_2 ist ein zusammengesetzter Primärschlüssel
id_1=Column(Integer, primary_key=True)
id_2=Column(Integer, primary_key=True)
Auto Increment
Setzen Sie in der Spalte autoincrement = True.
class User(Base):
id=Column(Integer, autoincrement=True) #ID ist Auto Increment
Setzen Sie "server_default = hogehoge" in die Spalte. Beachten Sie, dass Sie string oder text () an server_default übergeben müssen.
from sqlalchemy.dialects.mysql import TINYINT as Tinyint
class User(Base):
bool=Column(Tinyint(1), server_default="1") #String übergeben
Wenn die übergebene Zeichenfolge eine Zeichenfolge ist, ändert sie sich in einfache Anführungszeichen, und wenn es sich um text () handelt, ändert sie sich ohne Anführungszeichen.
x=Column(String, server_default="val")
x STRING DEFAULT 'val' #Wechseln Sie zu einfachen Anführungszeichen
y=Column(DateTime, server_default=text("NOW()")
y DATETIME DEFAULT NOW() #kein Zitat
Offizielle Dokumentation (server_default)
Wenn der Standardwert current_timestamp sein soll, setzen Sie from sqlalchemy.sql.functions import current_timestamp und server_default = current_timestamp ().
from sqlalchemy.dialects.mysql import TIMESTAMP as Timestamp
from sqlalchemy.sql.functions import current_timestamp
class User(Base):
created_at=Column(Timestamp, server_default=current_timestamp())
Offizielle Dokumentation (aktueller Zeitstempel) )
Es wird nicht wiedergegeben, selbst wenn "server_onupdate = hogehoge" in der Spalte festgelegt ist. Wenn Sie daher "DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP" festlegen möchten, verwenden Sie "server_default".
from sqlalchemy.dialects.mysql import TIMESTAMP as Timestamp
from sqlalchemy.sql.expression import text
class User(Base):
created_at=Column(Timestamp, server_default=text('CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP'))
Und es ist ausreichend. How to set DEFAULT ON UPDATE CURRENT_TIMESTAMP in mysql with sqlalchemy?
Sie können in der Spalte "nullable = False" setzen.
class User(Base):
a=Column(Integer, nullable=False) #a ist int und nicht null
Wenn Sie einer einzelnen Spalte eine eindeutige Einschränkung hinzufügen möchten, können Sie in der Spalte "unique = True" festlegen.
class User(Base):
a=Column(Integer, unique=True) #a ist int und einzigartig
Wenn Sie eine eindeutige Einschränkung für mehrere Spalten festlegen möchten, müssen Sie "sqlalchemy.schema.UniqueConstraint" in "table_args" schreiben.
from sqlalchemy.schema import UniqueConstraint
class User(Base):
#(a, b)In einzigartiger
__table_args__=(UniqueConstraint("a", "b", name="uq_user_00"))
a=Column(Integer)
b=Column(Integer)
Natürlich können Sie "sqlalchemy.schema.UniqueConstraint" auch dann verwenden, wenn Sie eine eindeutige Einschränkung für eine einzelne Spalte festlegen möchten.
Setzen Sie in der Spalte "sqlalchemy.schema.ForeignKey".
Grundsätzlich sqlalchemy.schema.ForeignKey (" {tabellenname}. {Spaltenname} ", name =" {fremder_schlüssel_beschränkungsname} ")
from sqlalchemy.schema import ForeignKey
class User(Base):
__tablename__="users"
id=Column(Integer, nullable=False, autoincrement=True, primary_key=True)
name=Column(String(255), nullable=False)
class TestResult(Base):
__tablename__="test_results"
id=Column(Integer, nullable=False, autoincrement=True, primary_key=True)
value=Column(Integer, nullable=False)
user_id=Column(Integer, ForeignKey("users.id", name="fk_test_results_00", nullable=False)) #Die ID der Benutzertabelle lautet ForeignKey
Wenn Sie OnUpdate oder OnDelete festlegen möchten, fügen Sie "onupdate =" CASCADE "oder" ondelete = "CASCADE" "in" sqlalchemy.schema.ForeignKey () "hinzu. Offizielles Dokument (ForeignKey.params.column) Als Einschränkung müssen unter den Optionen, die in Column geschrieben werden sollen, DataType und ForeignKey vorher und die mit "=" übergebenen Optionen danach geschrieben werden. relation Durch Erstellen einer Beziehung können Sie dem Fremdschlüssel folgen, ohne explizit beizutreten. Die Beziehung kann wie in der Spaltendefinition auf "hoge = sqlalchemy.orm.relationship (" {Klassenname} ", uselist = {True or False})" gesetzt werden. Uselist wird auf True gesetzt, wenn mehrere Daten verknüpft sind, und auf False, wenn nur eine vorhanden ist. Im Folgenden Benutzer: TestResult = eins: viele.
from sqlalchemy.schema import ForeignKey
from sqlalchemy.orm import relationship
class User(Base):
__tablename__="users"
id=Column(Integer, nullable=False, autoincrement=True, primary_key=True)
name=Column(String(255), nullable=False)
test_result=relationship("TestResult", uselist=True) #Erstellen Sie eine Beziehung zwischen Benutzer und TestResult,Mehrere zu verknüpfende Daten
class TestResult(Base):
__tablename__="test_results"
id=Column(Integer, nullable=False, autoincrement=True, primary_key=True)
value=Column(Integer, nullable=False)
user_id=Column(Integer, ForeignKey("users.id", name="fk_test_results_00", nullable=False)) #Die ID der Benutzertabelle lautet ForeignKey
user=relationship("User") #Erstellen Sie eine Beziehung von TestResult zu User,Ein Datenelement zum Verbinden
Durch Festlegen einer solchen Beziehung können Sie eine Instanz jeder Klasse wie folgt aufrufen.
test_result_1=session.query(TestResult).filter(TestResult.id==1).one() # test_Rufen Sie in der Ergebnistabelle die mit der ID 1 ab.
user_of_test_result_1=test_result_1.user #test_result_1 Benutzer_Sie können eine Instanz der Benutzerklasse abrufen, deren ID mit der ID übereinstimmt.
# user_of_test_result_1=User
user_1=session.query(User).filter(User.id==1).one() #Rufen Sie in der Benutzertabelle die mit der ID 1 ab.
test_results_of_user_1=user_1.test_result # user_Benutzer-Matching-ID von 1_Sie können eine Liste der Instanzen der TestResult-Klasse mit der ID abrufen
# test_results_of_user_1=[TestResult, TestResult, ...]
Eine der Optionen ist faul, und mit diesem Parameter können Sie den Zeitpunkt festlegen, zu dem die Tabelle gelesen wird, auf die die Beziehung festgelegt ist. Standardmäßig wird es geladen, wenn es aufgerufen wird.
Entspricht der Standardeinstellung. Es wird gelesen, wenn das Beziehungsziel aufgerufen wird.
test_result_1=session.query(TestResult).filter(TestResult.id==1).one() #Benutzer ist hier noch nicht geladen.
user_of_test_result_1=test_result_1.user #Benutzer wird hier geladen
lazy="immediate" Wenn die Beziehungsquelle aufgerufen wird, wird auch das Beziehungsziel aufgerufen. Die Abfrage wird separat ausgegeben, um die Beziehungsquelle und das Beziehungsziel aufzurufen.
test_result_1=session.query(TestResult).filter(TestResult.id==1).one() #Benutzer wird auch hier geladen
Wenn die Beziehungsquelle aufgerufen wird, wird auch das Beziehungsziel aufgerufen. Der Unterschied zu faul = "sofort" besteht darin, wie oft die Abfrage ausgegeben wird. Da es durch Beitritt aufgerufen wird, kann die Abfrage nur einmal ausgegeben werden. Offizielles Dokument (Beziehung)
Dieser Artikel wurde unter Bezugnahme auf die folgenden Informationen verfasst. ・ Offizielles Dokument
Recommended Posts