Python操作Cassandra：cassandra-driver使用教程

目前golang学习网上已经有很多关于文章的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《Python操作Cassandra教程：cassandra-driver使用详解》，也希望能帮助到大家，如果阅读完后真的对你学习文章有帮助，欢迎动动手指，评论留言并分享~

使用cassandra-driver连接Cassandra集群的最佳实践包括：1. 使用DCAwareRoundRobinPolicy进行数据中心感知的负载均衡，指定本地数据中心以降低延迟；2. 根据业务需求配置重试策略，如DowngradingConsistencyRetryPolicy以提升可用性；3. 启用认证和SSL/TLS确保安全性，通过PlainTextAuthProvider和ssl_options配置访问控制和加密通信；4. 合理设置连接超时参数，如connect_timeout和socket_options以适应网络环境。这些配置共同保障了高效、稳定、安全的Cassandra连接。

Python操作Cassandra，我通常会毫不犹豫地选择cassandra-driver这个官方库。它就像是为Python量身定制的Cassandra翻译官，能让你用最Pythonic的方式与这个分布式数据库进行高效的对话，无论是连接、执行CQL查询，还是处理复杂的数据类型映射，它都做得非常出色，省去了很多底层细节的烦恼。

解决方案

要开始用Python和Cassandra打交道，第一步自然是安装cassandra-driver。

pip install cassandra-driver

安装完成后，核心流程通常是这样的：

1. 建立连接： 使用Cluster对象来定义你的Cassandra集群节点。
2. 创建会话： 通过cluster.connect()获取一个会话（Session），这是你与数据库交互的门户。
3. 执行查询： 使用session.execute()方法来发送CQL（Cassandra Query Language）语句。
4. 处理结果： execute()方法返回的结果集可以像列表一样迭代处理。

一个简单的例子，我们来创建一个键空间（Keyspace）和一张表，然后插入一些数据并查询出来：

from cassandra.cluster import Cluster
from cassandra.auth import PlainTextAuthProvider # 如果需要认证

# 假设你的Cassandra运行在本地，或者你知道集群的IP地址
# 如果有认证，需要配置AuthProvider
# auth_provider = PlainTextAuthProvider(username='your_user', password='your_password')
# cluster = Cluster(['127.0.0.1'], auth_provider=auth_provider)
cluster = Cluster(['127.0.0.1']) # 简单起见，不带认证

session = None
try:
    session = cluster.connect()

    # 创建一个键空间，如果不存在的话
    session.execute("""
        CREATE KEYSPACE IF NOT EXISTS my_keyspace
        WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}
    """)
    session.set_keyspace('my_keyspace') # 切换到这个键空间

    # 创建一张表
    session.execute("""
        CREATE TABLE IF NOT EXISTS users (
            user_id UUID PRIMARY KEY,
            name text,
            email text
        )
    """)

    # 插入数据
    from cassandra.util import uuid_from_time
    user_id_1 = uuid_from_time()
    session.execute(
        "INSERT INTO users (user_id, name, email) VALUES (?, ?, ?)",
        (user_id_1, "张三", "zhangsan@example.com")
    )
    print(f"插入用户：{user_id_1}")

    user_id_2 = uuid_from_time()
    session.execute(
        "INSERT INTO users (user_id, name, email) VALUES (?, ?, ?)",
        (user_id_2, "李四", "lisi@example.com")
    )
    print(f"插入用户：{user_id_2}")

    # 查询数据
    rows = session.execute("SELECT user_id, name, email FROM users")
    print("\n所有用户：")
    for row in rows:
        print(f"ID: {row.user_id}, 姓名: {row.name}, 邮箱: {row.email}")

    # 根据ID查询特定用户
    specific_user_id = user_id_1
    row = session.execute("SELECT name, email FROM users WHERE user_id = ?", (specific_user_id,)).one()
    if row:
        print(f"\n查询到特定用户 ({specific_user_id}): 姓名: {row.name}, 邮箱: {row.email}")
    else:
        print(f"\n未查询到用户 ({specific_user_id})")

    # 更新数据
    session.execute(
        "UPDATE users SET email = ? WHERE user_id = ?",
        ("zhangsan_new@example.com", user_id_1)
    )
    print(f"\n更新用户 {user_id_1} 的邮箱")

    # 再次查询确认更新
    row = session.execute("SELECT email FROM users WHERE user_id = ?", (user_id_1,)).one()
    if row:
        print(f"更新后邮箱: {row.email}")

    # 删除数据
    session.execute("DELETE FROM users WHERE user_id = ?", (user_id_2,))
    print(f"\n删除用户 {user_id_2}")

    # 再次查询确认删除
    rows = session.execute("SELECT user_id FROM users")
    print("\n剩余用户：")
    for row in rows:
        print(f"ID: {row.user_id}")
    if not list(rows): # 迭代器已经耗尽，需要重新执行查询
        rows_after_delete = session.execute("SELECT user_id FROM users")
        if not list(rows_after_delete):
            print("所有用户已删除。")

except Exception as e:
    print(f"操作过程中发生错误: {e}")
finally:
    if session:
        session.shutdown()
    if cluster:
        cluster.shutdown()

这段代码展示了从连接到CRUD操作的全过程。值得注意的是，cassandra-driver会自动处理连接池和负载均衡，这在背后默默地提升了效率。

cassandra-driver连接Cassandra集群的最佳实践是什么？

说实话，连接Cassandra集群远不止写上IP地址那么简单，尤其是在生产环境中。我个人觉得，理解并配置好Cluster对象的参数，是构建稳定、高性能应用的关键。

首先，连接池和负载均衡是cassandra-driver的内置优势，你几乎不需要手动管理。它默认会维护到集群中多个节点的连接，并采用智能的负载均衡策略（比如DCAwareRoundRobinPolicy，数据中心感知轮询策略），这能确保你的请求均匀分布，并且优先访问距离最近、性能最好的节点。如果你有多个数据中心，强烈建议使用DCAwareRoundRobinPolicy并指定本地数据中心名称，这样可以避免不必要的跨数据中心流量，显著降低延迟。

from cassandra.cluster import Cluster, DCAwareRoundRobinPolicy

# 假设你的本地数据中心名称是 'datacenter1'
cluster = Cluster(
    ['node1_ip', 'node2_ip'],
    load_balancing_policy=DCAwareRoundRobinPolicy(local_dc='datacenter1')
)

其次，重试策略（Retry Policy）也非常重要。Cassandra是一个分布式系统，网络瞬时抖动、节点故障、或读写超时都是可能发生的。cassandra-driver提供了默认的重试策略，但你也可以自定义。例如，DowngradingConsistencyRetryPolicy在某些情况下会尝试降低一致性级别来完成操作，这在对可用性要求极高的场景下非常有用，但你需要权衡数据一致性。我通常会根据业务对数据一致性和可用性的具体要求来调整这个策略。

from cassandra.policies import DowngradingConsistencyRetryPolicy

cluster = Cluster(
    ['127.0.0.1'],
    retry_policy=DowngradingConsistencyRetryPolicy()
)

再者，安全性不容忽视。如果你的Cassandra集群启用了认证（用户名/密码）或SSL/TLS加密，那么在Python驱动中也必须配置。PlainTextAuthProvider用于简单的用户名密码认证，而SSL选项则需要提供证书路径等信息。这就像给你的数据通道加了一把锁，防止未授权访问和数据窃听。

from cassandra.auth import PlainTextAuthProvider
from ssl import CERT_REQUIRED

auth_provider = PlainTextAuthProvider(username='my_user', password='my_password')
cluster = Cluster(
    ['127.0.0.1'],
    auth_provider=auth_provider,
    ssl_options={
        'ca_certs': '/path/to/ca.crt',
        'certfile': '/path/to/client.crt',
        'keyfile': '/path/to/client.key',
        'ssl_version': 'TLSv1_2',
        'require_validation': True # CERT_REQUIRED
    }
)

最后，连接超时设置也值得关注。默认的超时时间可能不适合所有场景。如果你的网络环境较差或者Cassandra集群响应较慢，可以适当调高connect_timeout和socket_options中的read_timeout，避免不必要的连接中断。但也要注意，过高的超时时间可能会导致请求长时间阻塞。

cluster = Cluster(
    ['127.0.0.1'],
    connect_timeout=10, # 连接建立超时，秒
    socket_options=[(1, 10, 5)] # (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 5秒心跳)
)

总之，连接Cassandra不仅仅是把IP填进去，它是一个需要细致配置的过程，每个参数都可能影响应用的性能和稳定性。

如何使用cassandra-driver进行高效的数据读写？

高效的数据读写，在我看来，是与Cassandra打交道的核心艺术。仅仅能读写是不够的，你得让它快，让它稳。

首先，预处理语句（Prepared Statements）是提升性能和安全性的利器，几乎是生产环境的标配。它的原理是，你先将带有参数占位符的CQL语句发送给Cassandra集群进行解析和编译，集群会返回一个句柄。之后每次执行这条语句，你只需要发送句柄和参数值，省去了重复解析的开销。这对于频繁执行的查询（比如插入、更新、通过主键查询）效果尤为显著。

# 假设表已存在
insert_user_stmt = session.prepare("INSERT INTO users (user_id, name, email) VALUES (?, ?, ?)")
select_user_stmt = session.prepare("SELECT name, email FROM users WHERE user_id = ?")

# 执行预处理语句
session.execute(insert_user_stmt, (uuid_from_time(), "王五", "wangwu@example.com"))
row = session.execute(select_user_stmt, (user_id_1,)).one()

其次，批量操作（Batching）在某些特定场景下能带来性能提升。cassandra-driver支持LoggedBatch和UnloggedBatch。LoggedBatch会保证批处理中的所有操作要么全部成功，要么全部失败（原子性），但会有额外的写入开销。UnloggedBatch则不保证原子性，但性能更高，适用于大量不要求严格原子性的写入，比如日志记录。需要注意的是，批处理并非万能药，如果批次过大，反而可能导致性能下降甚至超时。我通常只在需要原子性或少量相关操作时才考虑LoggedBatch，对于大量独立写入，单条异步执行可能更好。

from cassandra.query import BatchStatement, BatchType

batch = BatchStatement(batch_type=BatchType.UNLOGGED) # 或 BatchType.LOGGED
batch.add(insert_user_stmt, (uuid_from_time(), "赵六", "zhaoliu@example.com"))
batch.add(insert_user_stmt, (uuid_from_time(), "孙七", "sunqi@example.com"))
session.execute(batch)

再者，一致性级别（Consistency Level）的选择直接影响读写性能和数据强一致性保证。ONE最快但可能读到旧数据，QUORUM兼顾性能和一致性，ALL最强一致性但性能最慢且可用性最低。根据业务对数据新鲜度和可用性的要求来选择。例如，对于用户登录这种强一致性要求高的操作，我可能会选择QUORUM；而对于不那么敏感的日志记录，ONE就足够了。

from cassandra.query import ConsistencyLevel

# 写入时使用LOCAL_QUORUM，确保本地数据中心内大多数节点确认
session.execute(insert_user_stmt, (uuid_from_time(), "周八", "zhouba@example.com"), consistency_level=ConsistencyLevel.LOCAL_QUORUM)

# 读取时使用ONE，快速获取数据，即使可能不是最新
rows = session.execute("SELECT * FROM users", consistency_level=ConsistencyLevel.ONE)

最后，对于大量数据的读取，分页（Paging）是必不可少的。Cassandra不建议执行SELECT * FROM large_table这样的全表扫描，因为它会将所有数据加载到内存，可能导致OOM或超时。cassandra-driver会自动处理分页，但你可以通过fetch_size参数控制每次从Cassandra获取的行数，这有助于控制内存使用和网络负载。

# 默认情况下驱动会自动分页，但你可以设置fetch_size来控制每次取回的行数
rows = session.execute("SELECT * FROM users", fetch_size=100)
for row in rows:
    print(row)

异步操作也是提升吞吐量的有效手段，session.execute_async()允许你并行发送多个查询，而不用等待前一个查询完成。这在处理大量独立请求时非常有用。

cassandra-driver中常见的问题与调试技巧有哪些？

在使用cassandra-driver的过程中，我遇到过不少头疼的问题，但大部分都有规律可循，并且有相应的调试方法。

最常见的问题之一就是连接失败或超时。这通常表现为NoHostAvailable错误。首先，检查Cassandra集群是否健康运行，节点IP地址是否正确，端口（默认9042）是否开放。网络防火墙、安全组配置不当是常见原因。其次，如果集群在运行，但连接仍然超时，可能是connect_timeout设置过低，或者网络延迟过高。我通常会尝试用cqlsh在Python应用运行的机器上直接连接Cassandra，如果cqlsh也连不上，那问题肯定出在网络或Cassandra本身。

# 检查Cassandra日志，通常在/var/log/cassandra/system.log或/var/log/cassandra/debug.log
# 检查网络连通性：
# ping <cassandra_node_ip>
# telnet <cassandra_node_ip> 9042

一致性级别相关的错误，比如WriteTimeout或ReadTimeout，意味着在指定的一致性级别下，Cassandra集群未能在规定时间内响应足够多的副本。这可能是集群负载过高、节点故障、网络拥堵或数据模型设计不合理（例如，热点分区）导致的。调试时，我会检查Cassandra集群的监控指标（如CPU、内存、磁盘I/O、网络流量），以及Cassandra的日志中是否有相关错误或警告。同时，审视查询的consistency_level设置是否合理，有时降低一致性级别可以缓解问题。

数据类型不匹配也是一个隐蔽的坑。Python的数据类型和Cassandra的CQL数据类型之间有映射关系，但并非所有都直接对应。例如，Cassandra的decimal类型在Python中是Decimal对象，uuid是UUID对象。如果你尝试插入一个错误的Python类型，驱动会抛出InvalidRequest或TypeError。我的经验是，仔细查阅cassandra-driver的官方文档，了解类型映射规则，并在代码中进行必要的类型转换。

from decimal import Decimal
from uuid import uuid4

# 假设Cassandra表字段为decimal_col decimal, uuid_col uuid
# 确保Python数据类型匹配
session.execute("INSERT INTO my_table (decimal_col, uuid_col) VALUES (?, ?)", (Decimal('123.45'), uuid4()))

预处理语句的缓存问题偶尔也会出现。当集群拓扑发生变化（如节点上线下线），或者某个预处理语句在某个节点上失效时，可能会导致问题。cassandra-driver有内置的缓存机制，但有时你可能需要手动清除或刷新缓存，或者在捕获到相关错误时重新准备语句。

开启驱动日志是排查问题最直接有效的方法。cassandra-driver使用了Python标准的logging模块。在你的应用启动时配置好日志，可以输出详细的连接状态、查询执行、错误信息等，这对于理解驱动的内部行为和定位问题非常有帮助。

import logging

log = logging.getLogger()
log.setLevel(logging.DEBUG) # 设置为DEBUG可以看到更详细的信息
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter("%(levelname)s:%(name)s:%(threadName)s:%(message)s"))
log.addHandler(handler)

# 这样你就能在控制台看到驱动的详细日志了

最后，利用Cassandra本身的Tracing功能。在cqlsh中执行TRACING ON，然后执行你的CQL查询，Cassandra会记录该查询在集群中每个阶段的详细信息，包括网络延迟、节点处理时间等，这能帮助你深入分析查询性能瓶颈。在cassandra-driver中，你也可以通过session.execute(query, trace=True)来开启跟踪，然后通过query.response_future.get_query_trace()获取跟踪信息。这是一个强大的工具，能让你看到查询在分布式系统中的“旅程”。

调试Cassandra和cassandra-driver的问题，往往是一个系统性的过程，需要结合网络、Cassandra集群状态、驱动配置和代码逻辑多方面进行排查。

本篇关于《Python操作Cassandra：cassandra-driver使用教程》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！