【LangChain】langchain_community.chat_message_histories.SQLChatMessageHistory 类：将聊天消息历史存储到 SQL 数据库的工具类

最新推荐文章于 2025-05-17 16:00:52 发布
最新推荐文章于 2025-05-17 16:00:52 发布
阅读量652 收藏 16
点赞数
分类专栏： LangChain 文章标签： langchain community chat_message SQLChatMessage SQL 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013172930/article/details/147850966
版权

langchain_community.chat_message_histories.SQLChatMessageHistory 类是 LangChain 社区库中用于将聊天消息历史存储到 SQL 数据库的工具类，适合持久化管理和多轮对话的上下文跟踪。

本文基于 LangChain 0.3.x ，详细介绍 SQLChatMessageHistory 的定义、参数、方法和典型场景，并提供一个独立示例，展示如何使用 SQLChatMessageHistory 结合 ChatOpenAI 和 SQLite 数据库实现人工智能主题的多轮对话，示例突出消息历史的持久化存储和上下文保留。

langchain_community.chat_message_histories.SQLChatMessageHistory 简介

SQLChatMessageHistory 是 LangChain 社区库中的消息历史存储类，通过 SQL 数据库（支持 SQLite、PostgreSQL 等）持久化存储对话消息（HumanMessage、AIMessage 等）。它适合需要长期保存对话历史或多用户会话管理的场景，相比内存存储的 ChatMessageHistory，它提供数据持久化和跨会话访问能力。

核心功能：

  • 将对话消息存储到 SQL 数据库，支持持久化。
  • 按会话 ID（session_id）组织消息，支持多用户或多会话。
  • 支持添加、获取、清除消息。
  • 集成到对话链，实现上下文感知的多轮对话。

适用场景：

  • 构建生产级聊天机器人，需持久化对话历史。
  • 多用户应用，跟踪每个用户的会话。
  • 需要跨设备或会话恢复对话的场景。
  • 与 LLM 链结合，提供长期上下文支持。

与其他消息历史类对比：

  • ChatMessageHistory：内存存储，临时使用，非持久化。
  • RedisChatMessageHistory：基于 Redis，适合高并发但需额外部署。
  • SQLChatMessageHistory：基于 SQL 数据库，持久化且易于集成。

类定义和初始化

以下是 SQLChatMessageHistory 的定义，基于 LangChain 社区库源码（langchain_community/chat_message_histories/sql.py）和官方文档（SQLChatMessageHistory)。

类签名
class SQLChatMessageHistory(BaseChatMessageHistory):
    def __init__(
        self,
        session_id: str,
        connection_string: str,
        table_name: str = "message_store",
        session_id_field_name: str = "session_id",
        created_at_field_name: str = "created_at",
        custom_message_to_dict: Optional[Callable[[BaseMessage], Dict[str, Any]]] = None,
        custom_dict_to_message: Optional[Callable[[Dict[str, Any]], BaseMessage]] = None
    ) -> None
  • 参数：
    • session_id（str）：会话标识符，区分不同对话。
    • connection_string（str）：SQL 数据库连接字符串（如 "sqlite:///chat_history.db"）。
    • table_name（str，默认 "message_store"）：存储消息的表名。
    • session_id_field_name（str，默认 "session_id"）：会话 ID 列名。
    • created_at_field_name（str，默认 "created_at"）：创建时间列名。
    • custom_message_to_dict（Optional[Callable]，默认 None）：自定义消息转字典函数。
    • custom_dict_to_message（Optional[Callable]，默认 None）：自定义字典转消息函数。
  • 功能：
    • 自动创建数据库表（包含 session_id、message 等列）。
    • 按 session_id 存储和查询消息。
    • 支持 SQLite、PostgreSQL 等数据库。
初始化示例
from langchain_community.chat_message_histories import SQLChatMessageHistory
history = SQLChatMessageHistory(
    session_id="ai_chat_001",
    connection_string="sqlite:///chat_history.db",
    table_name="message_store"
)

数据库表结构

SQLChatMessageHistory 自动创建以下表结构（以 table_name="message_store" 为例）：

CREATE TABLE message_store (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    session_id TEXT NOT NULL,
    message TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
  • 字段：
    • id：消息唯一标识，自增。
    • session_id：会话 ID，区分对话。
    • message：消息内容（序列化为 JSON，包含类型和内容）。
    • created_at：消息创建时间。

常用方法

SQLChatMessageHistory 继承自 langchain_core.chat_history.BaseChatMessageHistory，提供以下核心方法。

1. add_message
def add_message(self, message: BaseMessage) -> None
  • 功能：添加单条消息到数据库。
  • 输入：message（BaseMessage），如 HumanMessage 或 AIMessage。
  • 示例：
    from langchain_core.messages import HumanMessage, AIMessage
history.add_message(HumanMessage(content="什么是人工智能？"))
history.add_message(AIMessage(content="人工智能是计算机科学的一个分支。"))
2. add_user_message
def add_user_message(self, message: str) -> None
  • 功能：添加用户消息（HumanMessage）。
  • 输入：message（str），用户输入文本。
  • 示例：
    history.add_user_message("AI 有哪些应用？")
3. add_ai_message
def add_ai_message(self, message: str) -> None
  • 功能：添加 AI 消息（AIMessage）。
  • 输入：message（str），模型响应文本。
  • 示例：
    history.add_ai_message("AI 应用于医疗、自动驾驶等领域。")
4. clear
def clear(self) -> None
  • 功能：删除当前 session_id 的所有消息。
  • 示例：
    history.clear()
print(len(history.messages))  # 0
5. messages 属性
  • 功能：从数据库查询当前 session_id 的消息列表。
  • 输出：List[BaseMessage]，所有消息。
  • 示例：
    for msg in history.messages:
    print(f"{msg.__class__.__name__}: {msg.content}")
6. 异步方法
  • 功能：异步版本方法（如 aclear、aadd_message）。
  • 使用场景：高并发场景。
  • 示例：
    import asyncio
await history.aclear()

使用方式

以下是使用 SQLChatMessageHistory 的步骤。

1. 安装依赖
pip install --upgrade langchain langchain-openai langchain-community sqlalchemy
2. 设置 OpenAI API 密钥
export OPENAI_API_KEY="your-api-key"

或在代码中：

import os
os.environ["OPENAI_API_KEY"] = "your-api-key"
3. 初始化 SQLChatMessageHistory
from langchain_community.chat_message_histories import SQLChatMessageHistory
history = SQLChatMessageHistory(
    session_id="ai_chat_001",
    connection_string="sqlite:///chat_history.db"
)
4. 构建对话链
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
llm = ChatOpenAI(model="gpt-3.5-turbo")
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个人工智能专家，回答用户问题。"),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])
chain = prompt | llm
5. 调用链并存储历史
from langchain_core.runnables.history import RunnableWithMessageHistory
chain_with_history = RunnableWithMessageHistory(
    runnable=chain,
    get_session_history=lambda session_id: SQLChatMessageHistory(
        session_id=session_id,
        connection_string="sqlite:///chat_history.db"
    ),
    input_messages_key="input",
    history_messages_key="history"
)
response = chain_with_history.invoke(
    {"input": "什么是人工智能？"},
    config={"configurable": {"session_id": "ai_chat_001"}}
)

使用 SQLChatMessageHistory 的示例

以下是一个独立示例，展示如何使用 SQLChatMessageHistory 结合 ChatOpenAI 和 SQLite 数据库实现人工智能主题的多轮对话，持久化存储消息历史并保留上下文。示例使用 RunnableWithMessageHistory 简化对话管理。

准备环境：

  • 获取 OpenAI API 密钥：OpenAI Platform。
  • 设置环境变量：
    export OPENAI_API_KEY="your-api-key"
  • 安装依赖：
    pip install --upgrade langchain langchain-openai langchain-community sqlalchemy

代码：

from langchain_community.chat_message_histories import SQLChatMessageHistory
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables.history import RunnableWithMessageHistory

# 初始化 ChatOpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)

# 定义提示模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个人工智能专家，回答用户问题。"),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])

# 定义输出解析器
parser = StrOutputParser()

# 创建对话链
chain = prompt | llm | parser

# 包装链以支持消息历史
chain_with_history = RunnableWithMessageHistory(
    runnable=chain,
    get_session_history=lambda session_id: SQLChatMessageHistory(
        session_id=session_id,
        connection_string="sqlite:///chat_history.db"
    ),
    input_messages_key="input",
    history_messages_key="history"
)

# 测试 SQLChatMessageHistory 和对话链
print("测试 SQLChatMessageHistory 和对话链：")
try:
    session_id = "ai_chat_001"
    
    # 第一轮对话
    question1 = "什么是人工智能？"
    result1 = chain_with_history.invoke(
        {"input": question1},
        config={"configurable": {"session_id": session_id}}
    )
    print(f"问题 1: {question1}")
    print(f"回答 1: {result1}")
    
    # 第二轮对话（依赖上下文）
    question2 = "它有哪些应用？"
    result2 = chain_with_history.invoke(
        {"input": question2},
        config={"configurable": {"session_id": session_id}}
    )
    print(f"\n问题 2: {question2}")
    print(f"回答 2: {result2}")
    
    # 显示消息历史
    history = SQLChatMessageHistory(session_id=session_id, connection_string="sqlite:///chat_history.db")
    print("\n消息历史：")
    for i, msg in enumerate(history.messages):
        print(f"消息 {i+1} ({msg.__class__.__name__}): {msg.content}")
except Exception as e:
    print(f"错误: {e}")

输出示例（实际输出取决于模型和 API 响应）：

测试 SQLChatMessageHistory 和对话链：
问题 1: 什么是人工智能？
回答 1: 人工智能（AI）是计算机科学的一个分支，旨在模拟人类智能，如学习、推理和问题解决。

问题 2: 它有哪些应用？
回答 2: 人工智能的应用包括医疗诊断、自动驾驶、语音识别、推荐系统和金融分析等领域。

消息历史：
消息 1 (HumanMessage): 什么是人工智能？
消息 2 (AIMessage): 人工智能（AI）是计算机科学的一个分支，旨在模拟人类智能，如学习、推理和问题解决。
消息 3 (HumanMessage): 它有哪些应用？
消息 4 (AIMessage): 人工智能的应用包括医疗诊断、自动驾驶、语音识别、推荐系统和金融分析等领域。
代码说明
  1. SQLChatMessageHistory：
    • 使用 SQLite 数据库（sqlite:///chat_history.db）存储消息。
    • 设置 session_id="ai_chat_001" 区分会话。
  2. LLM 初始化：
    • 使用 ChatOpenAI 调用 gpt-3.5-turbo，设置 temperature=0.7。
  3. 提示模板：
    • ChatPromptTemplate 包含系统消息、历史占位符和用户输入。
    • MessagesPlaceholder 注入历史消息。
  4. 对话链：
    • 使用 LCEL 组合 prompt、llm 和 parser。
    • RunnableWithMessageHistory 包装链，动态加载 SQLChatMessageHistory。
  5. 测试：
    • 进行两轮对话：定义 AI 和询问应用。
    • 使用 session_id 确保上下文一致。
    • 显示数据库中的消息历史。
  6. 错误处理：
    • 使用 try-except 捕获 API 或数据库错误。

运行要求：

  • 有效的 OpenAI API 密钥：
    export OPENAI_API_KEY="your-api-key"
  • 安装依赖：
    pip install --upgrade langchain langchain-openai langchain-community sqlalchemy
  • SQLite 无需额外安装（Python 内置支持）。
  • 网络连接：访问 https://api.openai.com.

注意事项

  1. API 密钥：
    • 确保 OPENAI_API_KEY 已设置：
      echo $OPENAI_API_KEY
    • 或在代码中设置：
      llm = ChatOpenAI(api_key="your-api-key")
  2. 数据库配置：
    • SQLite：简单，无需服务器：
      connection_string="sqlite:///chat_history.db"
    • PostgreSQL：生产环境：
      connection_string="postgresql://user:password@localhost:5432/dbname"
    • 确保数据库可写：
      touch chat_history.db
chmod 666 chat_history.db
  3. 会话 ID：
    • 唯一 session_id 区分对话：
      session_id="ai_chat_001"
    • 重复使用 session_id 加载历史：
      history = SQLChatMessageHistory(session_id="ai_chat_001", connection_string="sqlite:///chat_history.db")
  4. 性能优化：
    • 限制历史长度：避免上下文过长：
      max_messages = 10
history.messages = history.messages[-max_messages:]
    • 异步调用：使用 ainvoke：
      result = await chain_with_history.ainvoke(input, config)
    • 数据库索引：为 session_id 添加索引：
      CREATE INDEX idx_session_id ON message_store (session_id);
  5. 错误调试：
    • 数据库错误：
      • 检查连接：
        import sqlalchemy
engine = sqlalchemy.create_engine("sqlite:///chat_history.db")
engine.connect()
      • 验证表结构：
        sqlite3 chat_history.db "SELECT * FROM message_store LIMIT 1"
    • API 错误：
      • 检查密钥：
        print(os.environ.get("OPENAI_API_KEY"))
      • 增加超时：
        llm = ChatOpenAI(timeout=30)
    • 消息丢失：
      • 检查历史：
        print(history.messages)
      • 验证 session_id：
        print(session_id)

常见问题

Q1：如何使用 PostgreSQL 替代 SQLite？
A：修改 connection_string：

history = SQLChatMessageHistory(
    session_id="ai_chat_001",
    connection_string="postgresql://user:password@localhost:5432/chat_db"
)

安装 PostgreSQL 驱动：

pip install psycopg2

Q2：如何清理特定会话历史？
A：调用 clear：

history.clear()

或直接删除数据库记录：

DELETE FROM message_store WHERE session_id = 'ai_chat_001';

Q3：如何与 RAG 结合？
A：添加检索上下文：

from langchain.vectorstores import FAISS
vectorstore = FAISS.from_documents(docs, OpenAIEmbeddings())
retriever = vectorstore.as_retriever()
prompt = ChatPromptTemplate.from_messages([
    ("system", "根据上下文和历史回答：\n{context}"),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])
chain = {"context": retriever, "history": lambda x: history.messages, "input": lambda x: x["input"]} | prompt | llm

Q4：如何支持开源模型？
A：使用 ChatOllama：

from langchain_ollama import ChatOllama
llm = ChatOllama(model="llama3")
chain = prompt | llm | parser
chain_with_history = RunnableWithMessageHistory(
    runnable=chain,
    get_session_history=lambda session_id: SQLChatMessageHistory(
        session_id=session_id,
        connection_string="sqlite:///chat_history.db"
    ),
    input_messages_key="input",
    history_messages_key="history"
)

总结

langchain_community.chat_message_histories.SQLChatMessageHistory 是 LangChain 中持久化对话历史的核心工具，核心功能包括：

  • 定义：通过 SQL 数据库存储消息历史。
  • 初始化：配置 session_id 和 connection_string。
  • 常用方法：add_message、add_user_message、add_ai_message、clear。
  • 适用场景：多轮对话、持久化存储、生产级应用。
洞悉LangChain：LangChain工程化设计，从API到智能Agent的全面探索
丨汀、的博客
07-12 909
洞悉LangChain：LangChain工程化设计，从API到智能Agent的全面探索
使用LangChain构建基于RAG技术的智能问答系统：深入解析与实战指南
m0_57781768的博客
09-07 457
RAG是一种通过外部数据增强LLM知识的方法。虽然LLM可以在广泛的主题上进行推理，但它们的知识通常局限于训练期间所接触到的公开数据，且无法涵盖模型训练后产生的新信息。为了构建可以处理私人数据或应对模型知识截止日期之后数据的AI应用，必须增强模型对这些新数据的认知。而这种将相关信息检索并插入模型提示的过程，便是检索增强生成（RAG）。LangChain为构建问答系统及RAG应用提供了多种组件，尤其是在处理非结构化数据时具有优势。
【LangChain】langchain_community.chat_message_histories.ChatMessageHistory 类：在内存中存储和管理对话消息历史
彬彬侠的博客
05-10 817
ChatMessageHistory 是 LangChain 社区库中的内存消息历史存储类，用于在内存中存储和管理对话消息（HumanMessage、AIMessage 等）。它是一个轻量级的消息历史实现，适合临时对话管理，常用于测试或简单应用。相比其他历史存储（如 RedisChatMessageHistory），它无需外部数据库，但数据不持久化。初始化：简单创建，无需配置。常用方法：add_message、add_user_message、add_ai_message、clear。适用场景：多轮对话、上
【LangChain】langchain_community.chat_message_histories.RedisChatMessageHistory 类：将聊天消息历史存储到 Redis 数据库
彬彬侠的博客
05-10 779
RedisChatMessageHistory 是 LangChain 社区库中的消息历史存储类，通过 Redis 数据库（一个高性能的键值存储）持久化存储对话消息（HumanMessage、AIMessage 等）。它适合需要高并发访问、快速读写和持久化对话历史的场景，特别适用于生产级聊天机器人或多用户应用。相比内存存储的 ChatMessageHistory 或 SQLChatMessageHistory，Redis 提供更高的吞吐量和分布式支持。初始化：配置 session_id 和 redis_ur
【LangChain】langchain_community.chat_message_histories 模块：存储和管理对话中的消息历史的工具集
彬彬侠的博客
05-10 728
langchain_community.chat_message_histories 模块是 LangChain 社区库的一部分，提供一系列消息历史管理类，用于存储和管理对话中的消息（HumanMessage、AIMessage 等）。包含以下关键类：ChatMessageHistory：内存存储，适合测试。SQLChatMessageHistory：SQL 数据库，适合单机持久化。RedisChatMessageHistory：Redis 存储，适合高并发。MongoDBChatMessageHistor
【LangChain】langchain_core.runnables.history.RunnableWithMessageHistory 类：将消息历史集成到可运行对象（Runnable）的工具类
彬彬侠的博客
05-10 778
RunnableWithMessageHistory 是 LangChain 核心库中的 Runnable 包装器类，用于将消息历史管理（通过 BaseChatMessageHistory）集成到现有的 Runnable 工作流中。它通过动态加载和保存对话历史，确保链（Chain）或模型能够根据历史上下文生成响应，特别适合构建多轮对话系统。初始化：配置 runnable 和 get_session_history。常用方法：invoke（同步）、ainvoke（异步）、stream（流式）。适用场景：多轮对
【LangChain】Chain：传统 Chain（langchain.chains 模块） 和 LCEL 链（langchain_core.runnables 模块）
彬彬侠的博客
05-03 676
在 LangChain 中，Chain 是指通过组合多个组件（如提示模板、语言模型、解析器、检索器等）构建的工作流，用于处理输入并生成输出。Chain 是 LangChain 的核心概念，尤其在早期版本（如 0.1.x）中广泛使用。随着 LangChain 0.2.x 和 0.3.x 的发展，传统的 Chain（如 LLMChain、ConversationalRetrievalChain）逐渐被 LangChain Expression Language（LCEL） 取代，LCEL 提供了更灵活、统一的链
从API到Agent：洞悉LangChain工程化设计
简放视野的专栏
04-17 1087
本文作者试着从工程角度去理解LangChain的设计和使用。大家可以将此文档作为LangChain的“10分钟快速上手”手册，希望帮助需要的同学实现AI工程的Bootstrap。
从API到Agent：万字长文洞悉LangChain工程化设计
Z4400840的博客
07-17 915
正式开始前，还是有必要从定义（What）开始。LangChain是2022年10月底，由哈佛大学的Harrison Chase发起的基于开源大语言模型的AI工程开发框架。当然也可以问一下AI：我：LangChain是什么？GPT-4：LangChain 是一个开源的语言模型工具链框架，旨在使研究人员和开发人员能够更轻松地构建、实验和部署以自然语言处理（NLP）为中心的应用程序。
高效管理数据库中的对话历史：使用SQLAlchemy和LangChain
tt_jishu的博客
11-20 481
本文介绍了如何通过SQLAlchemy和LangChain管理数据库中的对话历史。通过这些工具，不仅可以轻松存储，还能够在复杂的对话处理中保持高效。SQLAlchemy官方文档LangChain GitHub仓库。
使用PostgreSQL存储聊天消息历史：从基础到实践
cgsayuclv的博客
11-02 161
本文介绍了使用PostgreSQL存储聊天消息历史的基础知识和实践操作。PostgreSQL官方文档PostgreSQL教程Langchain社区文档。
使用 SQLAlchemy 和 LangChain 存储与处理聊天历史
fvasd1aw4的博客
12-28 352
SQL（Structured Query Language）是一个专用于管理关系型数据库系统中的数据的编程语言。SQLAlchemy 则是个开源的 SQL 工具包和对象关系映射（ORM）套件，它提供了一个简洁的接口来连接 Python 和数据库。这里，我们将使用 LangChain 提供的类来将聊天历史存储到数据库中。这个功能目前支持多种数据库，但如果你要使用 SQLite 之外的其他数据库，记得安装对应的数据库驱动哦。使用。
通过SQLAlchemy存储聊天历史：使用Python轻松管理对话数据
afTFODguAKBF的博客
09-15 660
通过本文，你应该了解如何使用SQLAlchemy和LangChain来存储和管理聊天历史。你可以探索更多SQLAlchemy的功能，或结合机器学习模型，提升你的应用功能。SQLAlchemy 官方文档LangChain GitHub 仓库。
【大模型从入门到精通19】开源库框架LangChain LangChain文档加载器1
kaggle expert，全球排名前1000，清华计算机研究生，兴趣算法工程
08-13 1712
在数据驱动的应用领域，特别是涉及对话界面和大型语言模型（LLM）的应用中，从各种来源高效加载、处理并与数据进行交互的能力至关重要。这些加载器擅长处理来自公共源的数据，如 YouTube、Twitter 和 Hacker News，同时也适用于来自专有源的数据，如 Figma 和 Notion。保存清洗后的文本：可选地，脚本可以将清洗和分词后的文档文本保存到文件中。这个扩展的代码提供了一个更全面的示例，展示如何从加载和清洗文本到基本分析和处理特殊情况，对 PDF 文档进行程序化的处理。
【Redis】RedLock实现原理
weixin_42430947的博客
05-13 784
若成功获得超过半数节点（如5个中的3个）的锁，且总耗时未超ttl，则锁获取成功。
MySQL读写分离
2501_91344113的博客
05-15 935
在slave1和2上查询不到，在master上才能查看到这条语句内容，说明写操作在master服务器上，由此验证，已经实现了mysql读写分离，目前所有的操作都全部在master主服务器上，用来避免数据的不同步，所有的读操作都分摊给了slave从服务器，用来分担数据库的压力。简单来说，读写分离就是只在主服务器上写，只在从服务器上读。不过，无论是哪种存储方式，在最终用户看，MyCAT里都是一个传统的数据库表，支持标准的 SQL,语句进行数据的操作，这样，对前端业务系统来说可以大幅降低开发难度，提升开发速度。
使用Spring Boot和Spring Security构建安全的RESTful API
最新发布
intwei的博客
05-17 367
本文详细介绍了如何使用Spring Boot和Spring Security构建安全的RESTful API，并结合JWT实现身份验证与授权。通过实际代码示例，帮助开发者快速上手。完整的项目代码可以在GitHub上找到。
pg_basbackup备份与恢复
HighGO
05-15 867
r, --max-rate=RATE 传输数据目录的最大传输速率（以 kB/s 为单位，或使用后缀“k”或“M”）-F, --format=p|t 输出格式（plain,直接拷贝数据文件，tar 配合 -z -Z 进行打包压缩）-X, --wal-method=none|fetch|stream 包含指定方法所需的 WAL 文件。-s, --status-interval=状态包发送到服务器的间隔时间（以秒为单位）-Z, --compress=0-9 使用给定的压缩级别压缩 tar 输出。
数据库MySQL学习——day11(高级连接与数据库规范化)
blackA_的博客
05-15 958
消除数据冗余（重复）避免插入、删除、更新异常提高数据一致性和存储效率连接类型说明SELF JOIN表自己连接自己CROSS JOIN两表所有组合（笛卡尔积）范式原则1NF每列值必须是原子值（不能有逗号分隔）2NF消除部分依赖（非主属性依赖主键全部）3NF消除传递依赖（非主属性不依赖其他非主属性）
From gitee.com:wei-luxin/mock * branch feature@1.0.1-gitStudy -> FETCH_HEAD fatal: refusing to merge unrelated histories
07-27
这段引用内容是一个关于使用shell脚本实现文件清理的示例代码\[1\]。它通过双层for循环遍历指定目录下的所有文件，并根据白名单文件中的内容判断是否删除文件。如果文件不在白名单中，则使用rm命令删除该文件。 另外，引用\[2\]是关于使用unalias命令删除别名的示例。通过执行unalias命令，可以删除指定的命令别名。 引用\[3\]是关于使用find命令进行文件查找的示例。通过find命令可以根据不同的条件进行文件查找，比如根据文件的拥有者、文件大小、文件名等。 至于您提到的问题，"fatal: refusing to merge unrelated histories"是Git在合并分支时出现的错误信息。这个错误通常是由于两个分支的历史记录没有共同的祖先导致的。您可以尝试使用--allow-unrelated-histories选项来允许合并没有共同祖先的分支。例如，可以使用以下命令来解决该问题： git merge --allow-unrelated-histories <branch-name> 请注意，这个选项可能会导致合并后的历史记录变得混乱，所以在使用之前请确保您知道自己在做什么。 #### 引用[.reference_title] - *1* [自动化工具-在保留白名单文件的前提下，删除剩余文件](https://blog.csdn.net/monarch91/article/details/129282167)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [Linux常用命令](https://blog.csdn.net/weixin_44175418/article/details/123637284)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

彬彬侠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值