duckdb 插件机制研究

已于 2024-05-29 17:55:35 修改
阅读量1.2k 收藏 14
点赞数 9
分类专栏： OceanBase 数据库技术 文章标签： oceanbase
于 2024-05-27 21:16:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maray/article/details/139247407
版权

本文研究 duckdb 内置的 extensions 工作机制。

插件架构

在 duckdb 源码内，内置了一组原生插件，位于顶层 extension 目录下：

extensions
除此之外，还支持 Out-of-Tree Extension，简单说就是独立的插件，不是集成在源码树中。独立编译好后，可以 运行时载入到 duckdb 中。
这里有一个细节：为了安全，任何 Out-of-Tree Extension，必须通过 duckdb 官方签名后，才能被正确载入。这个可以一定程度上防范载入有安全风险的第三方插件。

插件原理

为了明白原理，先简单看几个插件的核心注册逻辑。以 dbgen、httpfs、parquet 三个插件为例。

  • dbgen
// https://github.com/duckdb/duckdb/blob/main/extension/tpch/tpch_extension.cpp
namespace duckdb {

static void LoadInternal(DuckDB &db) {
	auto &db_instance = *db.instance;

	TableFunction dbgen_func("dbgen", {}, DbgenFunction, DbgenBind);
	dbgen_func.named_parameters["sf"] = LogicalType::DOUBLE;
	dbgen_func.named_parameters["overwrite"] = LogicalType::BOOLEAN;
	dbgen_func.named_parameters["catalog"] = LogicalType::VARCHAR;
	dbgen_func.named_parameters["schema"] = LogicalType::VARCHAR;
	dbgen_func.named_parameters["suffix"] = LogicalType::VARCHAR;
	dbgen_func.named_parameters["children"] = LogicalType::UINTEGER;
	dbgen_func.named_parameters["step"] = LogicalType::UINTEGER;
	ExtensionUtil::RegisterFunction(db_instance, dbgen_func);

	// create the TPCH pragma that allows us to run the query
	auto tpch_func = PragmaFunction::PragmaCall("tpch", PragmaTpchQuery, {LogicalType::BIGINT});
	ExtensionUtil::RegisterFunction(db_instance, tpch_func);

	// create the TPCH_QUERIES function that returns the query
	TableFunction tpch_query_func("tpch_queries", {}, TPCHQueryFunction, TPCHQueryBind, TPCHInit);
	ExtensionUtil::RegisterFunction(db_instance, tpch_query_func);

	// create the TPCH_ANSWERS that returns the query result
	TableFunction tpch_query_answer_func("tpch_answers", {}, TPCHQueryAnswerFunction, TPCHQueryAnswerBind, TPCHInit);
	ExtensionUtil::RegisterFunction(db_instance, tpch_query_answer_func);
}

void TpchExtension::Load(DuckDB &db) {
	LoadInternal(db);
}

std::string TpchExtension::GetQuery(int query) {
	return tpch::DBGenWrapper::GetQuery(query);
}

std::string TpchExtension::GetAnswer(double sf, int query) {
	return tpch::DBGenWrapper::GetAnswer(sf, query);
}

std::string TpchExtension::Name() {
	return "tpch";
}

std::string TpchExtension::Version() const {
#ifdef EXT_VERSION_TPCH
	return EXT_VERSION_TPCH;
#else
	return "";
#endif
}

} // namespace duckdb

extern "C" {

DUCKDB_EXTENSION_API void tpch_init(duckdb::DatabaseInstance &db) {
	duckdb::DuckDB db_wrapper(db);
	duckdb::LoadInternal(db_wrapper);
}

DUCKDB_EXTENSION_API const char *tpch_version() {
	return duckdb::DuckDB::LibraryVersion();
}
}
  • httpfs

namespace duckdb {

static void LoadInternal(DatabaseInstance &instance) {
	S3FileSystem::Verify(); // run some tests to see if all the hashes work out
	auto &fs = instance.GetFileSystem();

	fs.RegisterSubSystem(make_uniq<HTTPFileSystem>());
	fs.RegisterSubSystem(make_uniq<HuggingFaceFileSystem>());
	fs.RegisterSubSystem(make_uniq<S3FileSystem>(BufferManager::GetBufferManager(instance)));

	auto &config = DBConfig::GetConfig(instance);

	// Global HTTP config
	// Single timeout value is used for all 4 types of timeouts, we could split it into 4 if users need that
	config.AddExtensionOption("http_timeout", "HTTP timeout read/write/connection/retry", LogicalType::UBIGINT,
	                          Value(30000));
	config.AddExtensionOption("http_retries", "HTTP retries on I/O error", LogicalType::UBIGINT, Value(3));
	config.AddExtensionOption("http_retry_wait_ms", "Time between retries", LogicalType::UBIGINT, Value(100));
	config.AddExtensionOption("force_download", "Forces upfront download of file", LogicalType::BOOLEAN, Value(false));
	// Reduces the number of requests made while waiting, for example retry_wait_ms of 50 and backoff factor of 2 will
	// result in wait times of  0 50 100 200 400...etc.
	config.AddExtensionOption("http_retry_backoff", "Backoff factor for exponentially increasing retry wait time",
	                          LogicalType::FLOAT, Value(4));
	config.AddExtensionOption(
	    "http_keep_alive",
	    "Keep alive connections. Setting this to false can help when running into connection failures",
	    LogicalType::BOOLEAN, Value(true));
	config.AddExtensionOption("enable_server_cert_verification", "Enable server side certificate verification.",
	                          LogicalType::BOOLEAN, Value(false));
	config.AddExtensionOption("ca_cert_file", "Path to a custom certificate file for self-signed certificates.",
	                          LogicalType::VARCHAR, Value(""));
	// Global S3 config
	config.AddExtensionOption("s3_region", "S3 Region", LogicalType::VARCHAR, Value("us-east-1"));
	config.AddExtensionOption("s3_access_key_id", "S3 Access Key ID", LogicalType::VARCHAR);
	config.AddExtensionOption("s3_secret_access_key", "S3 Access Key", LogicalType::VARCHAR);
	config.AddExtensionOption("s3_session_token", "S3 Session Token", LogicalType::VARCHAR);
	config.AddExtensionOption("s3_endpoint", "S3 Endpoint", LogicalType::VARCHAR);
	config.AddExtensionOption("s3_url_style", "S3 URL style", LogicalType::VARCHAR, Value("vhost"));
	config.AddExtensionOption("s3_use_ssl", "S3 use SSL", LogicalType::BOOLEAN, Value(true));
	config.AddExtensionOption("s3_url_compatibility_mode", "Disable Globs and Query Parameters on S3 URLs",
	                          LogicalType::BOOLEAN, Value(false));

	// S3 Uploader config
	config.AddExtensionOption("s3_uploader_max_filesize", "S3 Uploader max filesize (between 50GB and 5TB)",
	                          LogicalType::VARCHAR, "800GB");
	config.AddExtensionOption("s3_uploader_max_parts_per_file", "S3 Uploader max parts per file (between 1 and 10000)",
	                          LogicalType::UBIGINT, Value(10000));
	config.AddExtensionOption("s3_uploader_thread_limit", "S3 Uploader global thread limit", LogicalType::UBIGINT,
	                          Value(50));

	// HuggingFace options
	config.AddExtensionOption("hf_max_per_page", "Debug option to limit number of items returned in list requests",
	                          LogicalType::UBIGINT, Value::UBIGINT(0));

	auto provider = make_uniq<AWSEnvironmentCredentialsProvider>(config);
	provider->SetAll();

	CreateS3SecretFunctions::Register(instance);
	CreateBearerTokenFunctions::Register(instance);
}

void HttpfsExtension::Load(DuckDB &db) {
	LoadInternal(*db.instance);
}
std::string HttpfsExtension::Name() {
	return "httpfs";
}

std::string HttpfsExtension::Version() const {
#ifdef EXT_VERSION_HTTPFS
	return EXT_VERSION_HTTPFS;
#else
	return "";
#endif
}

} // namespace duckdb

extern "C" {

DUCKDB_EXTENSION_API void httpfs_init(duckdb::DatabaseInstance &db) {
	LoadInternal(db);
}

DUCKDB_EXTENSION_API const char *httpfs_version() {
	return duckdb::DuckDB::LibraryVersion();
}
}
  • parquet
void ParquetExtension::Load(DuckDB &db) {
	auto &db_instance = *db.instance;
	auto &fs = db.GetFileSystem();
	fs.RegisterSubSystem(FileCompressionType::ZSTD, make_uniq<ZStdFileSystem>());

	auto scan_fun = ParquetScanFunction::GetFunctionSet();
	scan_fun.name = "read_parquet";
	ExtensionUtil::RegisterFunction(db_instance, scan_fun);
	scan_fun.name = "parquet_scan";
	ExtensionUtil::RegisterFunction(db_instance, scan_fun);

	// parquet_metadata
	ParquetMetaDataFunction meta_fun;
	ExtensionUtil::RegisterFunction(db_instance, MultiFileReader::CreateFunctionSet(meta_fun));

	// parquet_schema
	ParquetSchemaFunction schema_fun;
	ExtensionUtil::RegisterFunction(db_instance, MultiFileReader::CreateFunctionSet(schema_fun));

	// parquet_key_value_metadata
	ParquetKeyValueMetadataFunction kv_meta_fun;
	ExtensionUtil::RegisterFunction(db_instance, MultiFileReader::CreateFunctionSet(kv_meta_fun));

	// parquet_file_metadata
	ParquetFileMetadataFunction file_meta_fun;
	ExtensionUtil::RegisterFunction(db_instance, MultiFileReader::CreateFunctionSet(file_meta_fun));

	CopyFunction function("parquet");
	function.copy_to_bind = ParquetWriteBind;
	function.copy_to_initialize_global = ParquetWriteInitializeGlobal;
	function.copy_to_initialize_local = ParquetWriteInitializeLocal;
	function.copy_to_sink = ParquetWriteSink;
	function.copy_to_combine = ParquetWriteCombine;
	function.copy_to_finalize = ParquetWriteFinalize;
	function.execution_mode = ParquetWriteExecutionMode;
	function.copy_from_bind = ParquetScanFunction::ParquetReadBind;
	function.copy_from_function = scan_fun.functions[0];
	function.prepare_batch = ParquetWritePrepareBatch;
	function.flush_batch = ParquetWriteFlushBatch;
	function.desired_batch_size = ParquetWriteDesiredBatchSize;
	function.file_size_bytes = ParquetWriteFileSize;
	function.serialize = ParquetCopySerialize;
	function.deserialize = ParquetCopyDeserialize;
	function.supports_type = ParquetWriter::TypeIsSupported;

	function.extension = "parquet";
	ExtensionUtil::RegisterFunction(db_instance, function);

	// parquet_key
	auto parquet_key_fun = PragmaFunction::PragmaCall("add_parquet_key", ParquetCrypto::AddKey,
	                                                  {LogicalType::VARCHAR, LogicalType::VARCHAR});
	ExtensionUtil::RegisterFunction(db_instance, parquet_key_fun);

	auto &config = DBConfig::GetConfig(*db.instance);
	config.replacement_scans.emplace_back(ParquetScanReplacement);
	config.AddExtensionOption("binary_as_string", "In Parquet files, interpret binary data as a string.",
	                          LogicalType::BOOLEAN);
}

std::string ParquetExtension::Name() {
	return "parquet";
}

std::string ParquetExtension::Version() const {
#ifdef EXT_VERSION_PARQUET
	return EXT_VERSION_PARQUET;
#else
	return "";
#endif
}

} // namespace duckdb

#ifdef DUCKDB_BUILD_LOADABLE_EXTENSION
extern "C" {

DUCKDB_EXTENSION_API void parquet_init(duckdb::DatabaseInstance &db) { // NOLINT
	duckdb::DuckDB db_wrapper(db);
	db_wrapper.LoadExtension<duckdb::ParquetExtension>();
}

DUCKDB_EXTENSION_API const char *parquet_version() { // NOLINT
	return duckdb::DuckDB::LibraryVersion();
}
}
#endif

上面三个插件里，分别出现了如下注册字眼：

// tpch
	TableFunction tpch_query_answer_func("tpch_answers", {}, TPCHQueryAnswerFunction, TPCHQueryAnswerBind, TPCHInit);
	ExtensionUtil::RegisterFunction(db_instance, tpch_query_answer_func);
	
// parquet
	auto &db_instance = *db.instance;
	auto &fs = db.GetFileSystem();
	fs.RegisterSubSystem(FileCompressionType::ZSTD, make_uniq<ZStdFileSystem>());
	ExtensionUtil::RegisterFunction(db_instance, MultiFileReader::CreateFunctionSet(meta_fun));

// httpfs
	auto &fs = instance.GetFileSystem();
	fs.RegisterSubSystem(make_uniq<HTTPFileSystem>());
	fs.RegisterSubSystem(make_uniq<HuggingFaceFileSystem>());
	fs.RegisterSubSystem(make_uniq<S3FileSystem>(BufferManager::GetBufferManager(instance)));
	ExtensionUtil::RegisterSecretType(instance, secret_type);

可以看到，ExtensionUtil 在这里面扮演了很重要的角色。ExtensionUtil 支持注册普通函数、聚合函数、Table 函数、PragmaFunction、Collation、Secret 等。对于 Duckdb 的框架，了解到这一层已经差不多了，至于 ExtensionUtil 的实现，大家可以根据自己系统的特性灵活处理，本质上无非就是针对每一个类型的扩展，设计一套可扩展、可查找、高性能的功能集合接口。

class ExtensionUtil {
public:
	//! Register a new scalar function - throw an exception if the function already exists
	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunction function);
	//! Register a new scalar function set - throw an exception if the function already exists
	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunctionSet function);
	//! Register a new aggregate function - throw an exception if the function already exists
	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, AggregateFunction function);
	//! Register a new aggregate function set - throw an exception if the function already exists
	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, AggregateFunctionSet function);
	//! Register a new table function - throw an exception if the function already exists
	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, TableFunction function);
	//! Register a new table function set - throw an exception if the function already exists
	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, TableFunctionSet function);
	//! Register a new pragma function - throw an exception if the function already exists
	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, PragmaFunction function);
	//! Register a new pragma function set - throw an exception if the function already exists
	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, PragmaFunctionSet function);

	//! Register a CreateSecretFunction
	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateSecretFunction function);

	//! Register a new copy function - throw an exception if the function already exists
	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CopyFunction function);
	//! Register a new macro function - throw an exception if the function already exists
	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateMacroInfo &info);

	//! Register a new collation
	DUCKDB_API static void RegisterCollation(DatabaseInstance &db, CreateCollationInfo &info);

	//! Returns a reference to the function in the catalog - throws an exception if it does not exist
	DUCKDB_API static ScalarFunctionCatalogEntry &GetFunction(DatabaseInstance &db, const string &name);
	DUCKDB_API static TableFunctionCatalogEntry &GetTableFunction(DatabaseInstance &db, const string &name);

	//! Add a function overload
	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, ScalarFunction function);
	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, ScalarFunctionSet function);
	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, TableFunctionSet function);

	//! Registers a new type
	DUCKDB_API static void RegisterType(DatabaseInstance &db, string type_name, LogicalType type,
	                                    bind_type_modifiers_function_t bind_type_modifiers = nullptr);

	//! Registers a new secret type
	DUCKDB_API static void RegisterSecretType(DatabaseInstance &db, SecretType secret_type);

	//! Registers a cast between two types
	DUCKDB_API static void RegisterCastFunction(DatabaseInstance &db, const LogicalType &source,
	                                            const LogicalType &target, BoundCastInfo function,
	                                            int64_t implicit_cast_cost = -1);
};

} // namespace duckdb

另外，还用到了 RegisterSubSystem，这说明对于文件系统，Duckdb 也做了抽象，方便插件化。

instance.GetFileSystem().RegisterSubSystem(make_uniq<HTTPFileSystem>());

总结

插件机制是个好东西。为了你的系统能够获得这个好东西，最好是系统在第一天设计的时候就做好抽象，把每一类系统功能都抽象成集合，每一类功能都支持“运行时可寻址”。

在 OceanBase 中，最容易插件化的是系统函数，因为它数量众多，客观上从第一天起就逼迫 OceanBase 把它做成易扩展、易寻址的样子。

至于 filesystem 支持、文件格式支持，OceanBase 没有做好抽象，他们的插件化，也需要做大量改造才可能。

maray
关注
专栏目录
2023-03-24 duckdb-线程池与并行任务处理
悟世之路
03-24 1121
duckdb对于物理计划的执行采用了并行处理, 对pipeline的处理很值得学习.本文以聚合为例进行分析。
2023-03-29 duckdb-物理计划执行-Pipeline和TaskScheduler
悟世之路
03-29 891
duckdb的物理计划的执行的架构设计很出色, 每个物理计划的算子可以多线程并行的处理.处于核心地位的便是Pipeline和TaskSchedule, 可以将其理解为多线程模型中的生产者与消费者模式, 但是和物理计划执行组合起来, 就能体会到这样设计的简洁和优雅.
轻量级高性能数据库duckdb
mopmgerg54mo的博客
08-28 1131
类型：DuckDB是一个轻量级、高性能的嵌入式数据库，不需要单独的服务器进程，可以直接在应用程序中嵌入。设计目标：提供高效的SQL查询能力，支持数据分析和处理。特点：支持多种数据格式（如CSV、Parquet等），可以与Pandas、NumPy等数据科学工具无缝集成。
duckdb：DuckDB是一个进程内SQL OLAP数据库管理系统
01-30
安装 如果您只想安装和使用DuckDB，请访问以获取安装和使用说明。 发展历程 为了进行开发，DuckDB需要 ，Python3和符合C++11编译器。 在根目录中运行make来编译源代码。 为了进行开发，请使用make debug来构建未优化的调试版本。 您应该运行make unit和make allunit以在进行更改后验证您的版本是否正常运行。 要测试性能，可以通过执行./build/release/benchmark/benchmark_runner从根目录运行多个标准基准测试。 另请参阅我们的。
性能为王：DuckDB架构与优化技巧全解析 | LeetTalk Daily
LinkTime_Cloud的博客
09-29 844
“LeetTalk Daily”，每日科技前沿，由LeetTools AI精心筛选，为您带来最新鲜、最具洞察力的科技新闻。本报告旨在深入探讨DuckDB的架构及其性能分析。DuckDB是一种高效的内存SQL OLAP数据库管理系统，因其在数据分析中的卓越表现而受到广泛关注。本文将重点介绍DuckDB的核心特性，包括其对大数据集的高效处理能力、对远程文件的支持以及在地理空间数据处理中的潜力。此外，报...
DuckDB
jixiaoyu0209的博客
06-16 2004
内嵌数据库：不需要单独的服务器进程，直接在应用程序中嵌入。高性能：针对分析工作负载进行了优化。灵活的数据格式支持：支持CSV、Parquet等格式的数据读取和写入。与数据科学工具集成：可以与Pandas、NumPy等库无缝结合使用。DuckDB是一个功能强大且灵活的内嵌数据库，适合数据分析和处理。通过本文介绍的基础功能、进阶功能和高级教程，开发者可以轻松上手并熟练运用DuckDB进行各种数据操作。更多详细信息和示例请参考官方文档。
DuckDB学习-初识tpcds
seedcup的专栏
11-15 2593
了解下duckdb如何执行tpcds的查询语句
duckdb学习笔记
weixin_45500438的博客
11-14 282
【代码】duckdb学习笔记。
DuckDB 是一个嵌入式矢量化内存数据库管理系统
qq_34068440的博客
06-12 835
DuckDB是一个嵌入式矢量化内存数据库管理系统（DBMS），旨在提供高性能分析查询处理。DuckDB 是为数据科学家、研究人员和开发人员设计的，为他们提供了执行复杂分析任务的能力，而无需设置或维护传统的数据库服务器。DuckDB 是一个具有高性能和低复杂性的嵌入式数据库解决方案，特别适用于数据分析任务。其轻量级的设计和矢量化执行引擎使其在数据分析领域具有显著的优势。随着技术的进步和社区的发展，DuckDB 在未来有望成为数据分析领域的重要工具。
duckdb-odbc
11-01
【duckdb-odbc】是一个基于ODBC（Open Database Connectivity）的应用程序，它允许用户通过标准的ODBC接口与DuckDB数据库进行交互。DuckDB是一款开源的关系型数据库管理系统，设计目标是提供高性能的数据处理能力，...
duckdb_fdw:DuckDB PostgreSQL外部数据包装器
05-25
DuckDB PostgreSQL外部数据包装器 这个PostgreSQL扩展是的Foreign Data Wrapper。 当前版本可与PostgreSQL 9.6、10、11、12和13一起使用。 安装 1.安装DuckDB库 您可以并构建DuckDB。 git clone ...
Parallel-Grouped-Aggregation-in-DuckDB-DuckDB.pdf
04-21
本文将深入探讨DuckDB中的并行分组聚合机制。 **分组聚合（GROUP BY）** `GROUP BY`语句用于将数据按照指定列的值进行分组，返回的结果集中每组只有一行数据，包含每个分组的汇总信息。例如，以下SQL查询： ```...
嵌入式分析型数据库（DuckDB）
最新发布
weixin_43156294的博客
10-01 1582
DuckDB是一款集轻量级、高性能于一体的嵌入式分析型数据库。在单机内存不断增大以及 SSD 存储逐渐普及的背景下，大部分数据处理工作可以在单机上完成，且很多 OLAP（在线分析处理）场景也能在单机上进行。DuckDB 就是为了满足这种在单机环境下进行高效数据分析的需求而诞生的。它是荷兰 CWI 数据库组的一个项目，学术气息浓厚，架构清晰，适合学习和研究。
DuckDB - 一款嵌入式关系型 OLAP 数据库管理系统
Tony.Dong的专栏
07-07 5222
DuckDB 是一款嵌入式数据库，主要用于嵌入其他程序执行快速的 SQL 分析查询，官方称其为“分析型数据库中的 SQLite”。
推荐：DuckDB - 高性能的分析型数据库系统
gitblog_00016的博客
05-10 637
推荐：DuckDB - 高性能的分析型数据库系统 duckdbDuckDB is an in-process SQL OLAP Database Management System项目地址:https://gitcode.com/gh_mirrors/du/duckdb 1、项目介绍 DuckDB 是一个专为高效数据分析设计的嵌入式数据库管理系统。它以其出色的速度、可靠性、便携性和易用性而著称。...
DuckDB - 小记
AI + 工程
04-20 2330
关于 DuckDB 特点 使用场景 DuckDB与SQLite对比 SQL 示例 LangChain + DuckDB
使用duckdb
xunmeng2002的专栏
08-12 741
在读取该字段时其不能直接使用 duckdb_decimal 类型进行读取，因为其数据块中存储的字段的实际类型是int16,int32,int64或hugeint，具体使用那种类型的整型与定义的decimal的宽度有关，需要使用对应的整型类型来读取，然后通过对 duckdb_decimal 类型构造复制来获得对于的demical类型，要转为double类型，还需要调用 duckdb_decimal_to_double 函数进行转换。最近研究了一下duckdb的使用，也是踩了一些坑，这里记录一下。
DuckDB 是个值得学习的系统
余璜的技术博客
05-27 375
我认为，作为一个软件，引入”插件“是商业成功的必要条件。
duckdb创建数据库
09-10
DuckDB是一个嵌入式关系型数据库管理系统，它支持SQL查询语言，并且主要用于数据科学和分析任务。创建数据库是使用DuckDB时的基础操作之一，可以通过DuckDB提供的命令行工具或者API来进行。以下是创建数据库的基本步骤： 1. 通过命令行创建数据库：如果你是通过命令行与DuckDB交互，可以使用SQL语句`CREATE DATABASE`来创建一个新的数据库。例如： ```sql CREATE DATABASE my_database; ``` 这条命令会在当前的文件系统路径下创建一个名为`my_database`的新数据库文件。 2. 使用API创建数据库：如果你是在应用程序中使用DuckDB，那么你可能会通过编程语言提供的API来创建数据库。以Python为例，可以使用`duckdb.connect()`方法连接到一个尚未存在的数据库文件，从而创建新的数据库： ```python import duckdb conn = duckdb.connect('my_database.db') ``` 这段代码会创建一个名为`my_database.db`的数据库文件，并返回一个连接对象。 创建数据库后，你就可以在这个数据库中创建表、执行查询和进行其他数据库操作了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值