SQLAlchemy使用MetaData对象与模型类操作数据库表

`MetaData` 对象和模型类在使用 SQLAlchemy 与 数据库进行交互时，有一些不同之处。

使用 `MetaData` 对象，可直接操作数据库表结构。它允许您定义表名、列名、数据类型等。然后，使用 `create_all` 方法创建这些表。这种方法更适合在需要完全控制数据库表结构的情况下，例如在创建数据库时进行初始设置。

MetaData 对象是 SQLAlchemy 中的一个核心组件，它用于表示数据库表结构。使用 MetaData 对象，您可以直接操作数据库表结构，而不需要定义模型类。这种方法更适合在需要完全控制数据库表结构的情况下，例如在创建数据库时进行初始设置。

MetaData 对象的主要特点和应用场景：

• 定义表名、列名、数据类型等。
• 使用 Table 类创建表，并将其与 MetaData 对象关联。
• 使用 create_all 方法创建表，将 MetaData 对象和引擎对象作为参数传递。
• 在没有使用 ORM 的情况下，使用 MetaData 对象进行数据库操作。

  from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, DateTime
  from sqlalchemy.sql import select
  import datetime
  
  metadata = MetaData()
  
  table_users = Table('users', metadata,
      Column('id', Integer, primary_key=True),  # 添加主键属性
      Column('name', String),
      Column('age', Integer),
      Column('created_at', DateTime)
  )
  
  engine = create_engine('sqlite:///MetaDatausers.db')
  
  
  metadata.create_all(engine)
  
  # 插入数据
  insert_stmt = table_users.insert().values(
      name='Alice', age=30, created_at=datetime.datetime.now()
  )
  with engine.connect() as connection:
      connection.execute(insert_stmt)
  insert_stmt = table_users.insert().values(
      name='Bob', age=25, created_at=datetime.datetime.now()
  )
  
  with engine.connect() as connection:
      connection.execute(insert_stmt)
      connection.commit()
  
  insert_stmt = table_users.insert().values(
      name='Charlie', age=35, created_at=datetime.datetime.now()
  )
  
  with engine.connect() as connection:
      connection.execute(insert_stmt)
      connection.commit()
  
  insert_stmt = table_users.insert().values(
      name='David', age=40, created_at=datetime.datetime.now()
  )
  
  with engine.connect() as connection:
      connection.execute(insert_stmt)
      connection.commit()
  
  insert_stmt = table_users.insert().values(
      name='Eve', age=45, created_at=datetime.datetime.now()
  )
  
  with engine.connect() as connection:
      connection.execute(insert_stmt)
      connection.commit()
  
  # 查询数据
  select_stmt = table_users.select()
  
  
  with engine.connect() as connection:
      result = connection.execute(select_stmt)
      for row in result.fetchall():
          print(row)
  

使用模型类，可以定义类来表示数据库表的结构。

模型类是 SQLAlchemy 中的另一个核心组件，它用于表示数据库表的结构。模型类与数据库表一一对应，每个模型类对应一个表。模型类更适合在需要对数据库表进行复杂查询和操作时，例如在使用 ORM 进行数据操作时。

模型类的主要特点和应用场景：

• 定义类来表示数据库表的结构，每个模型类对应一个表。
• 使用 declarative_base() 函数创建基类，然后继承该基类创建模型类。
• 在模型类中使用 Column 装饰器定义列名、数据类型等。
• 使用 ORM 进行数据操作，例如插入、查询、更新和删除数据。

from sqlalchemy import create_engine, Column, Integer, String, DateTime
from sqlalchemy.orm import declarative_base,sessionmaker

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    name = Column(String)
    age = Column(Integer)
    created_at = Column(DateTime)

engine = create_engine('mssql+pymssql://username:password@server/database?driver=SQL+Server+Native+Client+11.0')
Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)
session = Session()

# 插入数据
new_user = User(name='Alice', age=30, created_at=datetime.now())
session.add(new_user)
session.commit()

# 删除数据
session.query(User).filter(User.id == 1).delete()
session.commit()

# 更新数据
user_to_update = session.query(User).filter(User.id == 1).one()
user_to_update.name = 'Bob'
session.commit()

# 查询数据
users = session.query(User).filter(User.id == 1).all()
for user in users:
    print(user)

session.close()

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import declarative_base,sessionmaker

# 设置数据库连接字符串
conn_str = 'sqlite:///examplesqlalchemy.db'

# 创建数据库引擎
engine = create_engine(conn_str)

# 创建基类
Base = declarative_base()


# 定义用户表
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    username = Column(String(50), unique=True, nullable=False)
    email = Column(String(100), nullable=False)

# 创建数据库表
Base.metadata.create_all(engine)

# 创建会话
Session = sessionmaker(bind=engine)
session = Session()

# 插入数据
new_user = User(username='john_doe8', email='john@example.com')
session.add(new_user)
session.commit()

# 插入数据
new_user2 = User(username='john_doe9', email='john2@example.com')
session.add(new_user2)
session.commit()


# 查询数据
users = session.query(User).all()
for user in users:
    print(user.username, user.email)

# 更新数据
user = session.query(User).filter_by(username='john_doe8').first()
user.email = 'john_updated@example.com'
session.commit()

# 删除数据
user = session.query(User).filter_by(username='john_doe6').first()
session.delete(user)
session.commit()

# 关闭会话
session.close()

总之，`MetaData` 对象和模型类在使用 SQLAlchemy 与 数据库进行交互时，有一些不同之处。`MetaData` 对象更适合在需要完全控制数据库表结构的情况下，而模型类更适合在需要对数据库表进行复杂查询和操作时。在实际应用中，您可以根据需要选择使用 `MetaData` 对象或模型类。

请注意，在运行此示例程序之前，需要确保已安装 SQLAlchemy 和 Pyodbc /create_engine('mssql+pymssql，并且已配置正确的数据库连接信息。
 

SQLAlchemy 1.4 库中的主要类及其重要方法：

Engine：

• **create_engine()：**创建一个指向数据库的引擎对象。
• **execute()：**执行一个 SQL 查询或命令。
• **connect()：**返回一个连接对象，用于执行查询和命令。

Session：

• **sessionmaker()：**创建一个会话工厂，用于生成会话对象。
• init(bind)：使用给定的引擎或连接对象初始化一个会话。
• **add()：**向会话添加一个新对象。
• **query()：**返回一个查询对象，用于检索数据库中的对象。
• **commit()：**将会话中的所有更改提交到数据库。
• **rollback()：**回滚会话中的所有更改。
• **close()：**关闭会话，释放所有资源。

Table：

• Table(name, metadata, *columns)：创建一个表对象，代表数据库中的一个表。
• **insert()：**返回一个插入语句对象，可用于向表中插入新行。
• **update()：**返回一个更新语句对象，可用于更新表中的行。
• **delete()：**返回一个删除语句对象，可用于从表中删除行。

MetaData：

• **MetaData()：**创建一个元数据对象，用于存储表定义和其他元数据。

Column：

• **Column(name, type, *args, kwargs)：创建列对象，代表表中的列。

查询对象：

• **filter()：**添加一个过滤条件到查询。
• **order_by()：**添加一个排序条件到查询。
• **offset()：**设置结果偏移量。
• **limit()：**设置结果限制。
• **all()：**检索所有匹配查询的结果。
• **one()：**检索与查询匹配的第一个结果。
• **count()：**返回与查询匹配的结果数。

其他类：

• **orm.mapper()：**将类映射到表，以便对象可以与数据库行进行交互。
• **orm.relationship()：**定义对象之间关系。
• **event.listen()：**注册一个事件监听器，以便在特定事件（例如对象创建或更新）发生时执行某个操作。

通过了解这些类及其方法，您可以使用 SQLAlchemy 1.4 有效地执行数据库操作。