SQL Server 数据太多优化的方法

CREATE TABLE Orders (
    OrderID INT PRIMARY KEY,         -- 主键索引，自动创建聚集索引
    CustomerID INT,                  -- 客户ID
    OrderDate DATETIME,              -- 订单日期
    ProductID INT,                   -- 产品ID
    TotalAmount DECIMAL(18, 2),      -- 订单总金额
    Status VARCHAR(20)               -- 订单状态
);

-- OrderID 是主键，默认会创建聚集索引
-- 所以在这种情况下不需要额外创建聚集索引

CREATE NONCLUSTERED INDEX idx_Customer_OrderDate
ON Orders (CustomerID, OrderDate);

CREATE NONCLUSTERED INDEX idx_ProductID
ON Orders (ProductID);

-- 删除冗余的单列索引
DROP INDEX idx_ProductID ON Orders;

-- 使用 idx_Customer_OrderDate 索引
SELECT OrderID, ProductID, TotalAmount
FROM Orders
WHERE CustomerID = 1001 AND OrderDate BETWEEN '2024-01-01' AND '2024-12-31';

-- 使用 idx_ProductID 索引
SELECT OrderID, CustomerID, TotalAmount
FROM Orders
WHERE ProductID = 500;

-- 按 OrderID 查询，使用默认的聚集索引
SELECT CustomerID, ProductID, TotalAmount, Status
FROM Orders
WHERE OrderID = 123456;

SELECT OrderID, ProductID, TotalAmount, Status
FROM Orders
WHERE CustomerID = 1001
  AND OrderDate BETWEEN '2024-01-01' AND '2024-12-31';

CREATE NONCLUSTERED INDEX idx_Customer_OrderDate
ON Orders (CustomerID, OrderDate);

SELECT OrderID, CustomerID, TotalAmount, Status
FROM Orders
WHERE ProductID = 500;

CREATE NONCLUSTERED INDEX idx_ProductID
ON Orders (ProductID);

SELECT CustomerID, ProductID, TotalAmount, Status
FROM Orders
WHERE OrderID = 123456;

-- 聚集索引已自动创建，无需额外创建

SELECT OrderID, CustomerID, ProductID, TotalAmount, Status
FROM Orders
WHERE CustomerID IN (1001, 1002, 1003);

CREATE NONCLUSTERED INDEX idx_CustomerID
ON Orders (CustomerID);

SELECT * FROM Orders;

SELECT OrderID, CustomerID, TotalAmount FROM Orders;

SELECT o.OrderID, o.TotalAmount, p.ProductName
FROM Orders o
JOIN Products p ON o.ProductID = p.ProductID
WHERE o.CustomerID = 1001
  AND o.OrderDate BETWEEN '2024-01-01' AND '2024-12-31';

CREATE NONCLUSTERED INDEX idx_Orders_Customer_OrderDate_Product
ON Orders (CustomerID, OrderDate, ProductID);
CREATE NONCLUSTERED INDEX idx_Products_ProductID
ON Products (ProductID);

SELECT OrderID, CustomerID, TotalAmount, Status
FROM Orders
WHERE OrderDate BETWEEN '2024-01-01' AND '2024-12-31'
ORDER BY OrderDate
OFFSET 0 ROWS FETCH NEXT 20 ROWS ONLY;

CREATE NONCLUSTERED INDEX idx_OrderDate
ON Orders (OrderDate);

SELECT CustomerID, 
       (SELECT SUM(TotalAmount) FROM Orders WHERE CustomerID = 1001 AND OrderDate BETWEEN '2024-01-01' AND '2024-12-31') AS TotalSpent
FROM Customers
WHERE CustomerID = 1001;

SELECT o.CustomerID, SUM(o.TotalAmount) AS TotalSpent
FROM Orders o
WHERE o.CustomerID = 1001
  AND o.OrderDate BETWEEN '2024-01-01' AND '2024-12-31'
GROUP BY o.CustomerID;

-- 创建分区函数：按年度分区
CREATE PARTITION FUNCTION OrderDatePartitionFunc (DATE)
AS RANGE RIGHT FOR VALUES ('2023-01-01', '2024-01-01', '2025-01-01');

-- 创建分区方案：将分区函数应用到物理文件组
CREATE PARTITION SCHEME OrderDatePartitionScheme
AS PARTITION OrderDatePartitionFunc
TO ([PRIMARY], [FG_2023], [FG_2024], [FG_2025]);

-- 创建分区表：应用分区方案
CREATE TABLE Orders
(
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    OrderDate DATE,
    ProductID INT,
    TotalAmount DECIMAL(10, 2),
    Status VARCHAR(20)
)
ON OrderDatePartitionScheme (OrderDate);

-- 查询 2024 年的订单，查询仅会访问相应的分区，提高查询效率
SELECT OrderID, CustomerID, ProductID, TotalAmount
FROM Orders
WHERE OrderDate BETWEEN '2024-01-01' AND '2024-12-31';

-- 创建 Orders_1 分表
CREATE TABLE Orders_1
(
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    OrderDate DATE,
    ProductID INT,
    TotalAmount DECIMAL(10, 2),
    Status VARCHAR(20)
);
-- 创建 Orders_2 分表
CREATE TABLE Orders_2
(
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    OrderDate DATE,
    ProductID INT,
    TotalAmount DECIMAL(10, 2),
    Status VARCHAR(20)
);
-- 创建 Orders_3 分表
CREATE TABLE Orders_3
(
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    OrderDate DATE,
    ProductID INT,
    TotalAmount DECIMAL(10, 2),
    Status VARCHAR(20)
);
-- 创建 Orders_4 分表
CREATE TABLE Orders_4
(
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    OrderDate DATE,
    ProductID INT,
    TotalAmount DECIMAL(10, 2),
    Status VARCHAR(20)
);

-- 示例：根据 CustomerID 哈希值选择分表
DECLARE @CustomerID INT = 1001;
DECLARE @TableSuffix INT;
-- 使用哈希算法来决定表
SET @TableSuffix = @CustomerID % 4;
-- 插入数据
IF @TableSuffix = 0
BEGIN
    INSERT INTO Orders_1 (OrderID, CustomerID, OrderDate, ProductID, TotalAmount, Status)
    VALUES (123456, 1001, '2024-01-01', 101, 150.00, 'Paid');
END
ELSE IF @TableSuffix = 1
BEGIN
    INSERT INTO Orders_2 (OrderID, CustomerID, OrderDate, ProductID, TotalAmount, Status)
    VALUES (123457, 1002, '2024-01-02', 102, 250.00, 'Pending');
END
ELSE IF @TableSuffix = 2
BEGIN
    INSERT INTO Orders_3 (OrderID, CustomerID, OrderDate, ProductID, TotalAmount, Status)
    VALUES (123458, 1003, '2024-01-03', 103, 350.00, 'Shipped');
END
ELSE
BEGIN
    INSERT INTO Orders_4 (OrderID, CustomerID, OrderDate, ProductID, TotalAmount, Status)
    VALUES (123459, 1004, '2024-01-04', 104, 450.00, 'Delivered');
END

-- 查询某个客户的订单
DECLARE @CustomerID INT = 1001;
DECLARE @TableSuffix INT;
SET @TableSuffix = @CustomerID % 4;
-- 查询数据
IF @TableSuffix = 0
BEGIN
    SELECT * FROM Orders_1 WHERE CustomerID = @CustomerID;
END
ELSE IF @TableSuffix = 1
BEGIN
    SELECT * FROM Orders_2 WHERE CustomerID = @CustomerID;
END
ELSE IF @TableSuffix = 2
BEGIN
    SELECT * FROM Orders_3 WHERE CustomerID = @CustomerID;
END
ELSE
BEGIN
    SELECT * FROM Orders_4 WHERE CustomerID = @CustomerID;
END

-- 创建主订单表 Orders
CREATE TABLE Orders
(
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    OrderDate DATE,
    ProductID INT,
    TotalAmount DECIMAL(10, 2),
    Status VARCHAR(20)
);
-- 创建归档表 ArchivedOrders
CREATE TABLE ArchivedOrders
(
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    OrderDate DATE,
    ProductID INT,
    TotalAmount DECIMAL(10, 2),
    Status VARCHAR(20)
);

-- 将超过 1 年的订单数据从 Orders 表移到 ArchivedOrders 表
INSERT INTO ArchivedOrders (OrderID, CustomerID, OrderDate, ProductID, TotalAmount, Status)
SELECT OrderID, CustomerID, OrderDate, ProductID, TotalAmount, Status
FROM Orders
WHERE OrderDate < DATEADD(YEAR, -1, GETDATE());
-- 删除 Orders 表中超过 1 年的订单数据
DELETE FROM Orders
WHERE OrderDate < DATEADD(YEAR, -1, GETDATE());

-- 在 SQL Server Agent 中创建作业来执行归档操作
USE msdb;
GO
EXEC sp_add_job
    @job_name = N'ArchiveOldOrders';
GO
EXEC sp_add_jobstep
    @job_name = N'ArchiveOldOrders',
    @step_name = N'ArchiveOrdersStep',
    @subsystem = N'TSQL',
    @command = N'
        INSERT INTO ArchivedOrders (OrderID, CustomerID, OrderDate, ProductID, TotalAmount, Status)
        SELECT OrderID, CustomerID, OrderDate, ProductID, TotalAmount, Status
        FROM Orders
        WHERE OrderDate < DATEADD(YEAR, -1, GETDATE());
        DELETE FROM Orders
        WHERE OrderDate < DATEADD(YEAR, -1, GETDATE());
    ',
    @database_name = N'VGDB';
GO
-- 设置作业的调度，例如每天运行一次
EXEC sp_add_schedule
    @schedule_name = N'ArchiveOrdersDaily',
    @enabled = 1,
    @freq_type = 4, -- 每天
    @freq_interval = 1, -- 每天执行一次
    @active_start_time = 0;
GO
EXEC sp_attach_schedule
    @job_name = N'ArchiveOldOrders',
    @schedule_name = N'ArchiveOrdersDaily';
GO
-- 启动作业
EXEC sp_start_job @job_name = N'ArchiveOldOrders';
GO

-- 查询某个客户的历史订单
SELECT OrderID, CustomerID, OrderDate, ProductID, TotalAmount, Status
FROM ArchivedOrders
WHERE CustomerID = 1001
ORDER BY OrderDate DESC;

-- 在 Orders 表中添加 Archived 标志
ALTER TABLE Orders
ADD Archived BIT DEFAULT 0;
-- 将数据标记为已归档
UPDATE Orders
SET Archived = 1
WHERE OrderDate < DATEADD(YEAR, -1, GETDATE());
-- 查询未归档的数据
SELECT * FROM Orders WHERE Archived = 0;
-- 查询归档数据
SELECT * FROM Orders WHERE Archived = 1;

-- 创建 Orders 表并优化存储
CREATE TABLE Orders
(
    OrderID INT PRIMARY KEY CLUSTERED,  -- 聚集索引
    CustomerID INT,
    OrderDate DATETIME,
    ProductID INT,
    TotalAmount DECIMAL(10, 2),
    Status VARCHAR(20)
) 
ON [PRIMARY]
WITH (DATA_COMPRESSION = PAGE);  -- 启用数据页压缩以节省空间
-- 启用非聚集索引，用于优化查询
CREATE NONCLUSTERED INDEX idx_OrderDate
ON Orders(OrderDate)
WITH (DATA_COMPRESSION = PAGE);  -- 同样启用数据压缩

-- 创建分区函数
CREATE PARTITION FUNCTION pf_OrderDate (DATETIME)
AS RANGE RIGHT FOR VALUES ('2022-01-01', '2023-01-01', '2024-01-01');
-- 创建分区方案
CREATE PARTITION SCHEME ps_OrderDate
AS PARTITION pf_OrderDate
TO ([PRIMARY], [PRIMARY], [PRIMARY], [PRIMARY]);
-- 创建分区表
CREATE TABLE Orders
(
    OrderID INT PRIMARY KEY CLUSTERED, 
    CustomerID INT,
    OrderDate DATETIME,
    ProductID INT,
    TotalAmount DECIMAL(10, 2),
    Status VARCHAR(20)
) 
ON ps_OrderDate(OrderDate);  -- 按 OrderDate 列进行分区

-- 将 SQL Server 数据文件 (.mdf) 存储在 SSD 磁盘
-- 将日志文件 (.ldf) 存储在 SSD 磁盘
-- 将临时数据库文件 (.ndf) 存储在 SSD 磁盘

-- 查看当前内存设置
EXEC sp_configure 'show advanced options', 1;
RECONFIGURE;
EXEC sp_configure 'max server memory (MB)';
-- 设置最大内存为 16 GB
EXEC sp_configure 'max server memory (MB)', 16384;
RECONFIGURE;

-- 查看当前并行度配置
EXEC sp_configure 'max degree of parallelism';
-- 设置为 4，允许最多 4 个 CPU 并行处理查询
EXEC sp_configure 'max degree of parallelism', 4;
RECONFIGURE;

-- 数据文件 (.mdf) 存储在磁盘 A
-- 日志文件 (.ldf) 存储在磁盘 B
-- 临时数据库文件 (.ndf) 存储在磁盘 C

-- 进行完整备份
BACKUP DATABASE VGDB TO DISK = 'D:\Backups\VGDB_full.bak';
-- 进行差异备份
BACKUP DATABASE WGDB TO DISK = 'D:\Backups\VGDB_diff.bak' WITH DIFFERENTIAL;
-- 进行事务日志备份
BACKUP LOG VGDB TO DISK = 'D:\Backups\VGDB_log.trn';

-- 查看磁盘 I/O 状况
SELECT * FROM sys.dm_io_virtual_file_stats(NULL, NULL);
-- 查看查询执行计划的缓存
SELECT * FROM sys.dm_exec_query_stats;
-- 查看当前的索引使用情况
SELECT * FROM sys.dm_db_index_usage_stats;

-- 查看当前最大内存配置
EXEC sp_configure 'show advanced options', 1;
RECONFIGURE;
EXEC sp_configure 'max server memory (MB)';
-- 设置最大内存为 16 GB
EXEC sp_configure 'max server memory (MB)', 16384;  -- 16 GB
RECONFIGURE;

-- 查看当前的最大并行度设置
EXEC sp_configure 'max degree of parallelism';
-- 设置最大并行度为 4（适用于 4 核 CPU 的机器）
EXEC sp_configure 'max degree of parallelism', 4;
RECONFIGURE;

-- 查看数据库的恢复模式
SELECT name, recovery_model_desc
FROM sys.databases
WHERE name = 'VGDB';
-- 设置恢复模式为简单恢复模式
ALTER DATABASE VGDB
SET RECOVERY SIMPLE;

-- 启用自动更新统计信息
EXEC sp_configure 'auto update statistics', 1;
RECONFIGURE;
-- 启用自动创建统计信息
EXEC sp_configure 'auto create statistics', 1;
RECONFIGURE;

-- 将数据文件 (.mdf) 存储在磁盘 A（SSD）
-- 将日志文件 (.ldf) 存储在磁盘 B（SSD）
-- 将临时数据库文件 (.ndf) 存储在磁盘 C（SSD）

-- 启用表压缩
ALTER TABLE Orders REBUILD PARTITION = ALL WITH (DATA_COMPRESSION = PAGE);
-- 启用索引压缩
ALTER INDEX ALL ON Orders REBUILD PARTITION = ALL WITH (DATA_COMPRESSION = PAGE);

-- 创建一个定期执行的作业，执行索引重建任务
EXEC sp_add_job @job_name = 'RebuildIndexes', @enabled = 1;
EXEC sp_add_jobstep @job_name = 'RebuildIndexes', 
    @step_name = 'RebuildIndexStep', 
    @subsystem = 'TSQL', 
    @command = 'ALTER INDEX ALL ON Orders REBUILD',
    @retry_attempts = 3, 
    @retry_interval = 5;
-- 设置作业运行频率：每天凌晨 2 点执行
EXEC sp_add_schedule @schedule_name = 'RebuildIndexSchedule',
    @enabled = 1,
    @freq_type = 4, 
    @freq_interval = 1, 
    @active_start_time = 20000;
EXEC sp_attach_schedule @job_name = 'RebuildIndexes', @schedule_name = 'RebuildIndexSchedule';

-- 设置事务日志备份
BACKUP LOG VGDB TO DISK = 'D:\Backups\YourDatabase_log.trn';

-- 查看缓存的页面数量
DBCC SHOW_STATISTICS('Orders');
-- 强制清除缓存（有时可以用于测试）
DBCC FREEPROCCACHE;
DBCC DROPCLEANBUFFERS;

-- 假设 Orders 表结构如下：OrderID INT, CustomerID INT, OrderDate DATETIME, OrderStatus VARCHAR(20)
DECLARE @OrderData TABLE (OrderID INT, CustomerID INT, OrderDate DATETIME, OrderStatus VARCHAR(20));
-- 将订单数据插入临时表
INSERT INTO @OrderData (OrderID, CustomerID, OrderDate, OrderStatus)
VALUES
    (1, 101, '2024-11-01', 'Pending'),
    (2, 102, '2024-11-02', 'Shipped'),
    (3, 103, '2024-11-03', 'Delivered'),
    (4, 104, '2024-11-04', 'Cancelled');
-- 批量插入数据到 Orders 表
INSERT INTO Orders (OrderID, CustomerID, OrderDate, OrderStatus)
SELECT OrderID, CustomerID, OrderDate, OrderStatus
FROM @OrderData;

-- 批量更新订单状态
UPDATE Orders
SET OrderStatus = 'Shipped'
WHERE OrderStatus = 'Pending' AND OrderDate < '2024-11-01';

-- 删除过期的订单
DELETE FROM Orders
WHERE OrderDate < DATEADD(DAY, -30, GETDATE()) AND OrderStatus = 'Completed';

DECLARE @BatchSize INT = 1000;
DECLARE @StartRow INT = 0;
DECLARE @TotalRows INT;
-- 计算总记录数
SELECT @TotalRows = COUNT(*) FROM Orders WHERE OrderStatus = 'Pending';
-- 循环批量处理数据
WHILE @StartRow < @TotalRows
BEGIN
    -- 批量更新 1000 条数据
    UPDATE TOP (@BatchSize) Orders
    SET OrderStatus = 'Shipped'
    WHERE OrderStatus = 'Pending' AND OrderDate < '2024-11-01' AND OrderID > @StartRow;
    -- 更新已处理的行数
    SET @StartRow = @StartRow + @BatchSize;
END

BEGIN TRANSACTION;
BEGIN TRY
    -- 假设 Orders 表结构：OrderID INT, CustomerID INT, OrderDate DATETIME, OrderStatus VARCHAR(20)
    DECLARE @OrderData TABLE (OrderID INT, CustomerID INT, OrderDate DATETIME, OrderStatus VARCHAR(20));
    -- 批量插入订单数据
    INSERT INTO @OrderData (OrderID, CustomerID, OrderDate, OrderStatus)
    VALUES
        (5, 105, '2024-11-05', 'Pending'),
        (6, 106, '2024-11-06', 'Pending');
    INSERT INTO Orders (OrderID, CustomerID, OrderDate, OrderStatus)
    SELECT OrderID, CustomerID, OrderDate, OrderStatus
    FROM @OrderData;
    -- 提交事务
    COMMIT TRANSACTION;
END TRY
BEGIN CATCH
    -- 错误处理并回滚事务
    ROLLBACK TRANSACTION;
    PRINT 'Error occurred: ' + ERROR_MESSAGE();
END CATCH;

-- 删除 3 年前已完成或已取消的订单
DELETE FROM Orders
WHERE OrderDate < DATEADD(YEAR, -3, GETDATE()) 
    AND OrderStatus IN ('Completed', 'Cancelled');

-- 将 3 年前的已完成或已取消的订单移动到 ArchivedOrders 表
INSERT INTO ArchivedOrders (OrderID, CustomerID, OrderDate, OrderStatus)
SELECT OrderID, CustomerID, OrderDate, OrderStatus
FROM Orders
WHERE OrderDate < DATEADD(YEAR, -3, GETDATE()) 
    AND OrderStatus IN ('Completed', 'Cancelled');
-- 删除已归档的订单
DELETE FROM Orders
WHERE OrderDate < DATEADD(YEAR, -3, GETDATE()) 
    AND OrderStatus IN ('Completed', 'Cancelled');

-- 创建触发器，每天检查并删除 3 年前的订单
CREATE TRIGGER CleanOldOrders
ON Orders
AFTER INSERT, UPDATE
AS
BEGIN
    -- 清理过期订单：删除 3 年前的已完成或已取消订单
    DELETE FROM Orders
    WHERE OrderDate < DATEADD(YEAR, -3, GETDATE()) 
        AND OrderStatus IN ('Completed', 'Cancelled');
END;

DECLARE @BatchSize INT = 1000;
DECLARE @StartRow INT = 0;
DECLARE @TotalRows INT;
-- 计算需要删除的记录数
SELECT @TotalRows = COUNT(*) FROM Orders
WHERE OrderDate < DATEADD(YEAR, -3, GETDATE()) 
    AND OrderStatus IN ('Completed', 'Cancelled');
-- 分批次删除
WHILE @StartRow < @TotalRows
BEGIN
    -- 批量删除 1000 条数据
    DELETE TOP (@BatchSize) FROM Orders
    WHERE OrderDate < DATEADD(YEAR, -3, GETDATE()) 
        AND OrderStatus IN ('Completed', 'Cancelled')
        AND OrderID > @StartRow;
    -- 更新已删除的行数
    SET @StartRow = @StartRow + @BatchSize;
END

CREATE PROCEDURE CleanOldOrders
AS
BEGIN
    DELETE FROM Orders
    WHERE OrderDate < DATEADD(YEAR, -3, GETDATE()) 
        AND OrderStatus IN ('Completed', 'Cancelled');
END;

# 安装 Redis 客户端
pip install redis

import redis
import mysql.connector
import json
# 连接 Redis
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0, decode_responses=True)
# 连接 MySQL 数据库
def get_db_connection():
    return mysql.connector.connect(
        host="localhost",
        user="root",
        password="password",
        database="ecommerce"
    )
# 获取商品详情
def get_product_details(product_id):
    # 检查缓存
    cached_product = redis_client.get(f"product:{product_id}")
    if cached_product:
        print("从缓存中获取商品信息")
        return json.loads(cached_product)  # 反序列化 JSON 数据
    # 如果缓存中没有，查询数据库
    print("从数据库中获取商品信息")
    connection = get_db_connection()
    cursor = connection.cursor(dictionary=True)
    cursor.execute("SELECT * FROM Products WHERE ProductID = %s", (product_id,))
    product = cursor.fetchone()
    # 如果商品存在，缓存到 Redis 中
    if product:
        redis_client.setex(f"product:{product_id}", 3600, json.dumps(product))  # 缓存 1 小时
    cursor.close()
    connection.close()
    return product
# 更新商品信息并更新缓存
def update_product_details(product_id, name, price, stock, description):
    # 更新数据库
    connection = get_db_connection()
    cursor = connection.cursor()
    cursor.execute("""
        UPDATE Products
        SET ProductName = %s, Price = %s, Stock = %s, Description = %s
        WHERE ProductID = %s
    """, (name, price, stock, description, product_id))
    connection.commit()
    cursor.close()
    connection.close()
    # 更新缓存
    updated_product = {
        "ProductID": product_id,
        "ProductName": name,
        "Price": price,
        "Stock": stock,
        "Description": description
    }
    redis_client.setex(f"product:{product_id}", 3600, json.dumps(updated_product))  # 缓存 1 小时
# 示例：查询商品 101 的信息
product_info = get_product_details(101)
print(product_info)
# 示例：更新商品 101 的信息
update_product_details(101, "New Product Name", 199.99, 50, "Updated description")

# 安装 MySQL 客户端库
pip install mysql-connector-python

import mysql.connector
from concurrent.futures import ThreadPoolExecutor
import time
# 连接 MySQL 数据库
def get_db_connection():
    return mysql.connector.connect(
        host="localhost",
        user="root",
        password="123123",
        database="VGDB"
    )
# 执行查询：查询订单状态为指定状态的订单
def query_orders_by_status(status):
    connection = get_db_connection()
    cursor = connection.cursor(dictionary=True)
    query = "SELECT * FROM Orders WHERE OrderStatus = %s"
    cursor.execute(query, (status,))
    result = cursor.fetchall()
    cursor.close()
    connection.close()
    return result
# 执行并行查询
def fetch_orders():
    statuses = ['Completed', 'Pending']  # 定义我们需要查询的订单状态
    # 使用 ThreadPoolExecutor 并行查询
    with ThreadPoolExecutor(max_workers=2) as executor:
        # 提交查询任务
        futures = [executor.submit(query_orders_by_status, status) for status in statuses]
        # 获取查询结果
        results = [future.result() for future in futures]
    return results
# 示例：执行查询
if __name__ == "__main__":
    start_time = time.time()
    orders = fetch_orders()
    print("查询结果：", orders)
    print(f"查询用时: {time.time() - start_time}秒")

import asyncio
import mysql.connector
from concurrent.futures import ThreadPoolExecutor
# 异步查询数据库
async def query_orders_by_status_async(status, loop):
    # 使用 ThreadPoolExecutor 让数据库查询异步执行
    result = await loop.run_in_executor(None, query_orders_by_status, status)
    return result
# 执行查询：查询订单状态为指定状态的订单
def query_orders_by_status(status):
    connection = get_db_connection()
    cursor = connection.cursor(dictionary=True)
    query = "SELECT * FROM Orders WHERE OrderStatus = %s"
    cursor.execute(query, (status,))
    result = cursor.fetchall()
    cursor.close()
    connection.close()
    return result
# 异步并发查询
async def fetch_orders_concurrently():
    loop = asyncio.get_event_loop()
    statuses = ['Completed', 'Pending', 'Shipped']  # 查询多个状态的订单
    tasks = [query_orders_by_status_async(status, loop) for status in statuses]
    orders = await asyncio.gather(*tasks)  # 等待所有任务完成
    return orders
# 示例：执行并发查询
if __name__ == "__main__":
    start_time = time.time()
    asyncio.run(fetch_orders_concurrently())
    print(f"查询用时: {time.time() - start_time}秒")

-- 设置最大内存使用量为 16 GB
EXEC sp_configure 'max server memory', 16384;  -- 单位：MB
RECONFIGURE;
-- 设置最大并行度为 8 核 CPU
EXEC sp_configure 'max degree of parallelism', 8;
RECONFIGURE;
-- 设置查询的成本阈值为 10
EXEC sp_configure 'cost threshold for parallelism', 10;
RECONFIGURE;

-- 假设我们需要查询某个用户的订单信息，优化后的 SQL 查询
SELECT o.OrderID, o.OrderDate, o.TotalAmount, u.UserName
FROM Orders o
JOIN Users u ON o.UserID = u.UserID
WHERE o.OrderDate BETWEEN '2024-01-01' AND '2024-12-31'
  AND u.UserID = 12345
ORDER BY o.OrderDate DESC;

-- 为 UserID 列创建索引
CREATE INDEX idx_user_id ON Orders(UserID);
-- 为 OrderDate 列创建索引
CREATE INDEX idx_order_date ON Orders(OrderDate);
-- 为 UserID 和 OrderDate 的组合创建复合索引
CREATE INDEX idx_user_order_date ON Orders(UserID, OrderDate);

-- 重建所有表的索引
ALTER INDEX ALL ON Orders REBUILD;
ALTER INDEX ALL ON Users REBUILD;

-- 查看 SQL Server 实例当前的资源使用情况
SELECT * FROM sys.dm_exec_requests;
-- 查看 SQL Server 实例的内存使用情况
SELECT * FROM sys.dm_os_memory_clerks;
-- 查看 SQL Server 实例的磁盘 I/O 使用情况
SELECT * FROM sys.dm_io_virtual_file_stats(NULL, NULL);