我正在为我们的应用程序开发一个新的RESTful Web服务。
当对某些实体执行GET时，客户端可以请求实体的内容。如果他们想添加一些参数（例如排序列表），可以在查询字符串中添加这些参数。
或者，我希望人们能够在请求主体中指定这些参数。HTTP/1.1似乎并没有明确禁止这一点。这将允许他们指定更多信息，可能会更容易指定复杂的XML请求。
我的问题：
这完全是个好主意吗？HTTP客户端在GET请求中使用请求体时会遇到问题吗？
https://www.rfc-editor.org/rfc/rfc2616
在include指令中使用尖括号和引号有什么区别？
#包括＜文件名＞#包括“文件名”
如何设置、清除和切换一点？
优化SQLite很棘手。C应用程序的大容量插入性能可以从每秒85个插入到每秒96000多个插入不等！
背景：我们正在使用SQLite作为桌面应用程序的一部分。我们有大量的配置数据存储在XML文件中，这些文件被解析并加载到SQLite数据库中，以便在应用程序初始化时进行进一步处理。SQLite非常适合这种情况，因为它速度快，不需要专门的配置，并且数据库作为单个文件存储在磁盘上。
理由：最初我对我看到的表现感到失望。事实证明，SQLite的性能可能会有很大的差异（对于批量插入和选择），这取决于数据库的配置方式和API的使用方式。弄清楚所有选项和技术都是什么并不是一件小事，所以我认为创建这个社区wiki条目以与Stack Overflow读者共享结果是明智的，这样可以避免其他人进行同样的调查。
实验：与其简单地谈论一般意义上的性能提示（即“使用事务！”），我认为最好编写一些C代码，并实际衡量各种选项的影响。我们将从一些简单的数据开始：
一个28 MB TAB分隔的文本文件（约865000条记录），其中包含多伦多市的完整运输时间表我的测试机器是运行Windows XP的3.60 GHz P4。该代码使用Visual C++2005编译为“发布版”，其中包含“完全优化”（/Ox）和“支持快速代码”（/Ot）。我正在使用SQLite“合并”，它直接编译到我的测试应用程序中。我的SQLite版本有点旧（3.6.7），但我怀疑这些结果将与最新版本相当（如果您不这么认为，请留下评论）。
让我们写一些代码！
代码：一个简单的C程序，逐行读取文本文件，将字符串拆分为值，然后将数据插入SQLite数据库。在这个“基线”版本的代码中，创建了数据库，但我们实际上不会插入数据：
/*************************************************************
Baseline code to experiment with SQLite performance.
Input data is a 28 MB TAB-delimited text file of the
complete Toronto Transit System schedule/route info
from http://www.toronto.ca/open/datasets/ttc-routes/
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "sqlite3.h"
#define INPUTDATA "C:\\TTC_schedule_scheduleitem_10-27-2009.txt"
#define DATABASE "c:\\TTC_schedule_scheduleitem_10-27-2009.sqlite"
#define TABLE "CREATE TABLE IF NOT EXISTS TTC (id INTEGER PRIMARY KEY, Route_ID TEXT, Branch_Code TEXT, Version INTEGER, Stop INTEGER, Vehicle_Index INTEGER, Day Integer, Time TEXT)"
#define BUFFER_SIZE 256
int main(int argc, char **argv) {
sqlite3 * db;
sqlite3_stmt * stmt;
char * sErrMsg = 0;
char * tail = 0;
int nRetCode;
int n = 0;
clock_t cStartClock;
FILE * pFile;
char sInputBuf [BUFFER_SIZE] = "\0";
char * sRT = 0; /* Route */
char * sBR = 0; /* Branch */
char * sVR = 0; /* Version */
char * sST = 0; /* Stop Number */
char * sVI = 0; /* Vehicle */
char * sDT = 0; /* Date */
char * sTM = 0; /* Time */
char sSQL [BUFFER_SIZE] = "\0";
/*********************************************/
/* Open the Database and create the Schema */
sqlite3_open(DATABASE, &db);
sqlite3_exec(db, TABLE, NULL, NULL, &sErrMsg);
/*********************************************/
/* Open input file and import into Database*/
cStartClock = clock();
pFile = fopen (INPUTDATA,"r");
while (!feof(pFile)) {
fgets (sInputBuf, BUFFER_SIZE, pFile);
sRT = strtok (sInputBuf, "\t"); /* Get Route */
sBR = strtok (NULL, "\t"); /* Get Branch */
sVR = strtok (NULL, "\t"); /* Get Version */
sST = strtok (NULL, "\t"); /* Get Stop Number */
sVI = strtok (NULL, "\t"); /* Get Vehicle */
sDT = strtok (NULL, "\t"); /* Get Date */
sTM = strtok (NULL, "\t"); /* Get Time */
/* ACTUAL INSERT WILL GO HERE */
n++;
}
fclose (pFile);
printf("Imported %d records in %4.2f seconds\n", n, (clock() - cStartClock) / (double)CLOCKS_PER_SEC);
sqlite3_close(db);
return 0;
}
“控制”
按原样运行代码实际上不会执行任何数据库操作，但它会让我们了解原始C文件I/O和字符串处理操作的速度。
0.94中导入864913条记录秒
太棒了我们可以每秒执行920000次插入，但前提是我们实际上不执行任何插入：-）
“最坏情况”
我们将使用从文件中读取的值生成SQL字符串，并使用sqlite3_exec调用该SQL操作：
sprintf(sSQL, "INSERT INTO TTC VALUES (NULL, '%s', '%s', '%s', '%s', '%s', '%s', '%s')", sRT, sBR, sVR, sST, sVI, sDT, sTM);
sqlite3_exec(db, sSQL, NULL, NULL, &sErrMsg);
这会很慢，因为每次插入都会将SQL编译成VDBE代码，并且每次插入都将发生在自己的事务中。有多慢？
9933.61中导入864913条记录秒
诶呀2小时45分钟！这只是每秒85次插入。
使用事务
默认情况下，SQLite将计算唯一事务中的每个INSERT/UPDATE语句。如果执行大量插入，建议将操作包装在事务中：
sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, &sErrMsg);
pFile = fopen (INPUTDATA,"r");
while (!feof(pFile)) {
...
}
fclose (pFile);
sqlite3_exec(db, "END TRANSACTION", NULL, NULL, &sErrMsg);
38.03年导入864913条记录秒
那更好。只需在一个事务中包装所有插入，我们的性能就提高到每秒23000个插入。
使用准备好的语句
使用事务是一个巨大的改进，但是如果我们反复使用相同的SQL，那么为每个插入重新编译SQL语句就没有意义了。让我们使用sqlite3_prepare_v2编译一次SQL语句，然后使用sqlite_3_bind_text将参数绑定到该语句：
/* Open input file and import into the database */
cStartClock = clock();
sprintf(sSQL, "INSERT INTO TTC VALUES (NULL, @RT, @BR, @VR, @ST, @VI, @DT, @TM)");
sqlite3_prepare_v2(db, sSQL, BUFFER_SIZE, &stmt, &tail);
sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, &sErrMsg);
pFile = fopen (INPUTDATA,"r");
while (!feof(pFile)) {
fgets (sInputBuf, BUFFER_SIZE, pFile);
sRT = strtok (sInputBuf, "\t"); /* Get Route */
sBR = strtok (NULL, "\t"); /* Get Branch */
sVR = strtok (NULL, "\t"); /* Get Version */
sST = strtok (NULL, "\t"); /* Get Stop Number */
sVI = strtok (NULL, "\t"); /* Get Vehicle */
sDT = strtok (NULL, "\t"); /* Get Date */
sTM = strtok (NULL, "\t"); /* Get Time */
sqlite3_bind_text(stmt, 1, sRT, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 2, sBR, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 3, sVR, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 4, sST, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 5, sVI, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 6, sDT, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 7, sTM, -1, SQLITE_TRANSIENT);
sqlite3_step(stmt);
sqlite3_clear_bindings(stmt);
sqlite3_reset(stmt);
n++;
}
fclose (pFile);
sqlite3_exec(db, "END TRANSACTION", NULL, NULL, &sErrMsg);
printf("Imported %d records in %4.2f seconds\n", n, (clock() - cStartClock) / (double)CLOCKS_PER_SEC);
sqlite3_finalize(stmt);
sqlite3_close(db);
return 0;
16.27年导入864913条记录秒
美好的还有一点代码（别忘了调用sqlite3_clear_bindings和sqlite3_reset），但我们的性能提高了一倍多，达到每秒53000次插入。
PRAGMA同步=关闭
默认情况下，SQLite将在发出OS级写入命令后暂停。这保证了数据被写入磁盘。通过设置synchronous=OFF，我们指示SQLite将数据简单地交给OS进行写入，然后继续。如果计算机在数据写入磁盘之前发生灾难性崩溃（或电源故障），则数据库文件可能会损坏：
/* Open the database and create the schema */
sqlite3_open(DATABASE, &db);
sqlite3_exec(db, TABLE, NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA synchronous = OFF", NULL, NULL, &sErrMsg);
12.41年导入864913条记录秒
这些改进现在更小了，但我们的插入速度达到了每秒69600次。
PRAGMA journal_mode=内存
考虑通过计算PRAGMA journal_mode=memory将回滚日志存储在内存中。您的交易会更快，但如果在交易过程中断电或程序崩溃，数据库可能会处于损坏状态，交易部分完成：
/* Open the database and create the schema */
sqlite3_open(DATABASE, &db);
sqlite3_exec(db, TABLE, NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA journal_mode = MEMORY", NULL, NULL, &sErrMsg);
13.50年导入864913条记录秒
比之前的优化速度稍慢，每秒64000次插入。
PRAGMA synchronous=关闭，PRAGMA journal_mode=MEMORY
让我们结合前面两个优化。这有点风险（万一发生崩溃），但我们只是导入数据（而不是运行银行）：
/* Open the database and create the schema */
sqlite3_open(DATABASE, &db);
sqlite3_exec(db, TABLE, NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA synchronous = OFF", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA journal_mode = MEMORY", NULL, NULL, &sErrMsg);
12.00年导入864913条记录秒
好极了我们每秒可以进行72000次插入。
使用内存数据库
为了好玩，让我们在前面所有优化的基础上，重新定义数据库文件名，以便完全在RAM中工作：
#define DATABASE ":memory:"
10.94年导入864913条记录秒
将数据库存储在RAM中并不太实用，但令人印象深刻的是，我们每秒可以执行79000次插入。
重构C代码
虽然不是SQLite的具体改进，但我不喜欢while循环中额外的char*赋值操作。让我们快速重构该代码，将strtok（）的输出直接传递到sqlite3_bind_text（）中，让编译器尝试加快速度：
pFile = fopen (INPUTDATA,"r");
while (!feof(pFile)) {
fgets (sInputBuf, BUFFER_SIZE, pFile);
sqlite3_bind_text(stmt, 1, strtok (sInputBuf, "\t"), -1, SQLITE_TRANSIENT); /* Get Route */
sqlite3_bind_text(stmt, 2, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Branch */
sqlite3_bind_text(stmt, 3, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Version */
sqlite3_bind_text(stmt, 4, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Stop Number */
sqlite3_bind_text(stmt, 5, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Vehicle */
sqlite3_bind_text(stmt, 6, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Date */
sqlite3_bind_text(stmt, 7, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Time */
sqlite3_step(stmt); /* Execute the SQL Statement */
sqlite3_clear_bindings(stmt); /* Clear bindings */
sqlite3_reset(stmt); /* Reset VDBE */
n++;
}
fclose (pFile);
注意：我们又回到了使用真实的数据库文件。内存数据库很快，但不一定实用
8.94中导入864913条记录秒
对参数绑定中使用的字符串处理代码进行了轻微的重构，使我们能够每秒执行96700次插入。我认为可以肯定地说，这是非常快的。当我们开始调整其他变量（例如页面大小、索引创建等）时，这将是我们的基准。
摘要（迄今为止）
我希望你还在我身边！我们开始走这条路的原因是，SQLite的大容量插入性能差异很大，而且需要进行哪些更改来加快操作并不总是显而易见的。使用相同的编译器（和编译器选项）、相同版本的SQLite和相同的数据，我们优化了我们的代码和SQLite的使用，从最坏的情况下每秒85次插入到每秒96000次插入！
CREATE INDEX然后INSERT vs.INSERT然后CREATE INDEX
在开始测量SELECT性能之前，我们知道我们将创建索引。下面的一个答案建议，在进行批量插入时，在插入数据之后创建索引会更快（而不是先创建索引然后再插入数据）。让我们试试：
创建索引，然后插入数据
sqlite3_exec(db, "CREATE INDEX 'TTC_Stop_Index' ON 'TTC' ('Stop')", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, &sErrMsg);
...
18.13年导入864913条记录秒
插入数据，然后创建索引
...
sqlite3_exec(db, "END TRANSACTION", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "CREATE INDEX 'TTC_Stop_Index' ON 'TTC' ('Stop')", NULL, NULL, &sErrMsg);
13.66年导入864913条记录秒
正如预期的那样，如果对一列进行索引，则大容量插入速度较慢，但如果在插入数据之后创建索引，则会有所不同。我们的无索引基线是每秒96000个插入。首先创建索引，然后插入数据，每秒可以插入47700个数据，而首先插入数据，然后创建索引，每秒可以进行63300个插入。
我很乐意接受其他场景的建议。。。并且将很快为SELECT查询编译类似的数据。
我更新了最新的操作系统，和/或重新启动了我的计算机（每次重大更新都会发生这种情况，但这次我所做的只是在2022-09-13年重新启动我的计算机）
今天早上，我在MacBook pro的命令行中导航到我的工作代码库，在存储库中键入“gitstatus”，收到一个错误：
（2022年9月，这个错误大不相同，但我没有捕捉到它）
xcrun:错误：无效的活动开发人员路径（/Library/developer/CommandLineTools），在以下位置缺少xcrun:/Librari/developer/CommandLineTools/usr/bin/xcrun
git不起作用！
如何修复git和命令行工具？
RESTful编程到底是什么？
主持人注意: 这个问题不适合我们的问题和答案格式,目前适用于 Stack Overflow 的具体性规则. 我们通常使用“历史锁”用于内容仍然有价值的问题. 但是,这个问题的答案是积极维护的,历史锁不允许编辑答案。
基于表格的网站验证
我們認為 Stack Overflow 不僅應該是非常具体的技術問題的資源,而且應該是如何解決常見問題的變化的一般指南。
它应该包括主题如:
如何登录 如何登录 如何保持登录 如何管理Cookie(包括推荐设置) SSL/HTTPS加密 如何存储密码 使用秘密问题 已忘记用户名/密码功能 使用虚假信息 防止跨网站请求漏洞(CSRF) OpenID “记住我” 检查框 浏览器自动完成用户名和密码 秘密 URL(由 digest 保护的公共 URL) C
角色和授权 HTTP 基本验证
请帮助我们:
提示子主题 提交关于这个主题的好文章 编辑官方答案
在阅读了C++/STL的C++/STL的隐藏特征和暗角(comp.lang.c++.modated)之后,我感到非常惊讶的是,以下的片段在2008年视觉工作室和G++4.4编辑和工作。
代码如下:
#include <stdio.h>
int main()
{
int x = 10;
while (x --> 0) // x goes to 0
{
printf("%d ", x);
}
}
产出:
9 8 7 6 5 4 3 2 1 0
我想这是C,因为它在海合会也是工作。标准中的定义在哪里,它来自何处?
阅读后C++/STL 的隐藏特征和暗角上 年 月comp.lang.c++.moderated我感到非常惊讶的是, 以下的片段在2008年视觉工作室和G++4.
代码如下:
#include <stdio.h>
int main()
{
int x = 10;
while (x --> 0) // x goes to 0
{
printf("%d ", x);
}
}
产出:
9 8 7 6 5 4 3 2 1 0
我想这是C,因为它在海合会也是工作。标准中的定义在哪里,它来自何处?