0Pricing
Pandas & NumPy Academy · 课时

将 DataFrames 写入数据库表

使用 DataFrame.to_sql() 将清洗后的 DataFrame 持久化到新表或现有表中，并控制 if_exists 和 chunksize

将 DataFrames 写入数据库表 是 CoddyKit 上的免费 Pandas & NumPy Academy 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Pandas & NumPy Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Pandas & NumPy Academy 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Why Write DataFrames to Databases?

After cleaning and transforming data in Pandas, you often need to persist the results back to a database: to make them available to other applications, dashboards, or team members; to store incremental analysis results; or to build a data mart from a raw data lake. DataFrame.to_sql() is the standard Pandas method for writing data to any SQLAlchemy-supported database in a single call.

Basic to_sql() Usage

df.to_sql('table_name', con=engine, if_exists='replace', index=False) writes the DataFrame to a database table. The if_exists parameter controls what happens if the table already exists: 'fail' raises an error, 'replace' drops and recreates the table, and 'append' adds new rows without touching existing ones. Always set index=False unless you explicitly want to store the DataFrame index as a column in the database.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///results.db')

df = pd.DataFrame({
    'date': pd.date_range('2024-01-01', periods=5),
    'revenue': [1200.0, 980.5, 1450.0, 760.3, 1100.0],
    'region': ['North', 'South', 'East', 'West', 'North']
})

df.to_sql('daily_revenue', con=engine,
          if_exists='replace', index=False)
print('Table written successfully')

The if_exists Parameter Explained

The three values of if_exists serve different use cases. 'replace' is for development: drop the old table and create a fresh one — schema changes are automatic but all old data is lost. 'append' is for incremental loads: add new rows to the existing table without changing its structure — useful for daily batch jobs. 'fail' is a safety guard: use it to protect important tables from being accidentally overwritten by a pipeline with a bug.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///results.db')

new_batch = pd.DataFrame({
    'date': ['2024-06-01', '2024-06-02'],
    'revenue': [1500.0, 1300.0],
    'region': ['North', 'East']
})

# Append new rows without losing existing data
new_batch.to_sql('daily_revenue', con=engine,
                 if_exists='append', index=False)
print('Appended new rows')

Controlling Column Data Types

By default, to_sql() maps Pandas dtypes to SQLAlchemy types automatically. Sometimes the defaults are wrong — for example, a datetime64 column might be stored as TEXT in SQLite. Use the dtype parameter to specify exact SQL types using SQLAlchemy type objects. This ensures correct storage, proper indexing, and accurate type handling when the data is read back. Always verify the schema after writing with a quick PRAGMA table_info() or inspector.get_columns().

import pandas as pd
import sqlalchemy as sa
from sqlalchemy import types

engine = sa.create_engine('sqlite:///results.db')

df = pd.DataFrame({
    'id': [1, 2, 3],
    'name': ['Alice', 'Bob', 'Carol'],
    'score': [0.95, 0.87, 0.91],
    'created_at': pd.to_datetime(['2024-01-01', '2024-01-02', '2024-01-03'])
})

df.to_sql('users', con=engine, if_exists='replace', index=False,
          dtype={'id': types.Integer(),
                 'score': types.Float(),
                 'created_at': types.DateTime()})

Writing in Chunks with chunksize

For large DataFrames, to_sql() without a chunksize tries to insert all rows in a single statement, which can fail with a database timeout or memory error. Specify chunksize=N to insert N rows per transaction. This gives the database a chance to commit incrementally and reduces peak memory usage. A chunksize of 10,000–50,000 rows typically balances insert speed and memory, but the optimal value depends on your database and network latency.

import pandas as pd
import sqlalchemy as sa
import numpy as np

engine = sa.create_engine('sqlite:///results.db')

# Large DataFrame
df = pd.DataFrame({
    'id': range(500000),
    'value': np.random.randn(500000)
})

# Insert in chunks of 10,000 rows at a time
df.to_sql('large_table', con=engine,
          if_exists='replace',
          index=False,
          chunksize=10000)
print('Written 500,000 rows')

Upsert: Insert or Update

Pandas' to_sql() does not natively support upsert (insert if new, update if exists). To implement upsert, use SQLAlchemy's Core with an INSERT OR REPLACE (SQLite) or ON CONFLICT DO UPDATE (PostgreSQL) statement. The common workaround in Pandas is: write to a temporary staging table with if_exists='replace', then run raw SQL to merge the staging table into the production table, then drop the staging table.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///results.db')

new_data = pd.DataFrame({
    'id': [1, 2, 5],
    'value': [99.9, 88.8, 77.7]
})

# Write to staging table
new_data.to_sql('staging', con=engine,
                if_exists='replace', index=False)

# Merge into production (SQLite syntax)
with engine.connect() as conn:
    conn.execute(sa.text(
        'INSERT OR REPLACE INTO production SELECT * FROM staging'
    ))
    conn.commit()
print('Upsert complete')

Verifying the Write

After writing, always verify the result by reading back a summary count and row count. Compare them against the source DataFrame. This catches silent failures caused by dtype mismatches (e.g., NaN in an integer column causing partial inserts) or database constraints (e.g., unique key violations silently skipping rows in some configurations). A quick SELECT COUNT(*) FROM table after every to_sql call adds minimal overhead and prevents silent data loss.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///results.db')

df = pd.DataFrame({'id': range(1000), 'value': range(1000)})
df.to_sql('my_table', con=engine, if_exists='replace', index=False)

# Verify
with engine.connect() as conn:
    count = conn.execute(sa.text('SELECT COUNT(*) FROM my_table')).scalar()
print(f'Source rows: {len(df)}, DB rows: {count}')
assert count == len(df), 'Row count mismatch!'

Adding a Primary Key After Writing

to_sql() writes data but does not add primary keys or database constraints — it creates a plain table. For a production table, add the primary key constraint separately using raw SQL executed through SQLAlchemy. SQLite requires recreating the table to add constraints after creation, but PostgreSQL supports ALTER TABLE ADD PRIMARY KEY. Alternatively, define the full schema upfront and use if_exists='append' to insert data into an existing properly-defined table.

import pandas as pd
import sqlalchemy as sa
from sqlalchemy import Table, Column, Integer, Float, MetaData

engine = sa.create_engine('sqlite:///results.db')
meta = MetaData()

# Define table with primary key
my_table = Table('defined_table', meta,
    Column('id', Integer, primary_key=True),
    Column('value', Float)
)
meta.create_all(engine)  # Create table with constraints

# Then insert data using append
df = pd.DataFrame({'id': range(5), 'value': [1.1, 2.2, 3.3, 4.4, 5.5]})
df.to_sql('defined_table', con=engine,
          if_exists='append', index=False)

Transactional Writes

For data consistency, wrap to_sql() in an explicit transaction. If any step in a multi-table write fails, you can roll back all changes. Without a transaction, partial writes can leave the database in an inconsistent state. SQLAlchemy's connection context manager with conn.begin() enables manual transaction control. Alternatively, use engine.begin() for an auto-commit block that rolls back on exception.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///results.db')

df_orders = pd.DataFrame({'id': [1, 2], 'amount': [100.0, 200.0]})
df_summary = pd.DataFrame({'total': [300.0], 'count': [2]})

try:
    with engine.begin() as conn:  # Auto-rollback on exception
        df_orders.to_sql('orders_v2', con=conn,
                         if_exists='replace', index=False)
        df_summary.to_sql('summary_v2', con=conn,
                          if_exists='replace', index=False)
    print('Both tables written atomically')
except Exception as e:
    print(f'Write failed, rolled back: {e}')

Performance: Bulk Insert Methods

The default to_sql() inserts one row per SQL statement, which is very slow for large DataFrames. Pass method='multi' to use a single INSERT with multiple value tuples — typically 10-100x faster. For PostgreSQL, pass a custom method function that uses the COPY protocol (via psycopg2's copy_expert) for the absolute fastest bulk load. The optimal method depends on your database version and network setup.

import pandas as pd
import sqlalchemy as sa
import numpy as np
import time

engine = sa.create_engine('sqlite:///perf.db')
df = pd.DataFrame({'a': range(100000), 'b': np.random.randn(100000)})

# Default (one row per INSERT) — slow
start = time.time()
df.to_sql('test_default', con=engine, if_exists='replace', index=False)
print(f'Default: {time.time()-start:.2f}s')

# multi-row INSERT — faster
start = time.time()
df.to_sql('test_multi', con=engine, if_exists='replace',
          index=False, method='multi', chunksize=1000)
print(f'Multi: {time.time()-start:.2f}s')

Logging and Auditing Writes

In production pipelines, track what was written and when by maintaining an audit log table. After each successful to_sql(), insert a row into the audit log with the table name, row count, timestamp, and pipeline run ID. This makes it easy to detect missing runs, double-writes, or schema changes over time. The audit log itself is a Pandas DataFrame written via to_sql — the same technique applied recursively for operational monitoring.

import pandas as pd
import sqlalchemy as sa
from datetime import datetime

engine = sa.create_engine('sqlite:///results.db')

def write_with_audit(df, table_name, engine, run_id):
    df.to_sql(table_name, con=engine, if_exists='append', index=False)
    audit = pd.DataFrame([{
        'run_id': run_id,
        'table_name': table_name,
        'rows_written': len(df),
        'written_at': datetime.utcnow().isoformat()
    }])
    audit.to_sql('audit_log', con=engine, if_exists='append', index=False)
    print(f'Wrote {len(df)} rows to {table_name}')

df = pd.DataFrame({'id': [1, 2], 'val': [10, 20]})
write_with_audit(df, 'my_table', engine, run_id='run_001')

Quick Check

Test your understanding of Data Analysis concepts from this lesson.

Lesson Recap

In this lesson you learned: df.to_sql() writes a DataFrame to any SQLAlchemy-connected database table with the if_exists parameter controlling create/append/replace behaviour, chunksize and method='multi' improve performance for large DataFrames, and transactional writes with engine.begin() ensure atomic multi-table updates that roll back on failure. Next up we compare Pandas and SQL to understand when each tool is the better choice.

常见问题解答

「将 DataFrames 写入数据库表」课时是免费的吗？

是的 — 「将 DataFrames 写入数据库表」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Pandas & NumPy Academy 课程的其余内容，请升级到 CoddyKit PRO。 Pandas & NumPy Academy 课程共包含 4 节课。

「将 DataFrames 写入数据库表」这节课中我会学到什么？

使用 DataFrame.to_sql() 将清洗后的 DataFrame 持久化到新表或现有表中，并控制 if_exists 和 chunksize 你通过在浏览器中直接运行的动手代码来练习 Pandas & NumPy Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Pandas & NumPy Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Pandas & NumPy Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。

「将 DataFrames 写入数据库表」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Pandas & NumPy Academy 课中编写并运行代码吗？

能。每节 Pandas & NumPy Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 使用 SQLAlchemy 连接数据库
  2. 从 Pandas 运行 SQL 查询
  3. 将 DataFrames 写入数据库表
  4. Pandas 与 SQL：选择合适的工具
← 返回 Pandas & NumPy Academy