junyi's blog

hahahahaha

0%

Posted on Edited on In

简介

  • 记录B站up主全嘻嘻分享的关于职场经验的笔记

25岁没人告诉我，趁早知道的10个职场真相

  • 毕业两年，跳槽四次

    • 如果有大厂背景，可以考虑
    • 如果没有，坚决不会再看。在猎头来看，没有大厂背景，又换了三四分工作，只有一种可能就是能力不太强

  • 五年工作经验的履历，在这个履历上比较需要看的是什么

    • 做到了什么，而不是做了什么。因为五年的时间，一定经历了一些完整的项目周期，所以他有没有通过自己来帮助项目达到了一个增长
    • 五年经验的人，其实还是一个执行层。执行层最好的简历是要通过量化来去表现的: 做了什么，做到了什么，到底是多少，YoY增长是多少

  • 工作经验五年以内的职场人，三个快速建立职场竞争力的建议

    • 五年以内的人收入一定是比较有限的，所以第一条建议是要多花一些资金来投资到自己。
      • 人力本身是一个资本，如果你把时间拉长到20年到30年的周期来看，前五年挣的钱一定是最少的。在这个地方如果把钱存下来对你的未来不会有帮助
    • 从年新10万到100万最重要的一点是要跟对人，有很强的执行力。所以，0-5年的同学尽量要花时间去了解自己，去了解你的老板。
      • 在面试的时候，可能你的老板在筛选你，但你同时也在筛选你的老板。
    • 从沟通的维度来看，老板问的一些问题，不要说no，就是要说yes。在输出并且的过程中，可以给出自己不同的建立
      • 五年以内的小白尽量不要太刺头。因为一个组织一个团队带给你的价值，是远远高于你自己能够去摸爬滚打学习得到的
    • 不要毕业即创业
      • 更希望看到的是一个毕业生五年以内，能够在大厂中得到历练和提升，超过五年之后，再去考虑创业或者中小厂
    • 很多年轻人，在职场中做很多无用的社交，就好像是来交朋友的，这个其实不是一个正确的选择。不需要在职场交朋友
      • 我认为年轻人应该积攒的人脉是一种有用的社交
      • 在比较早期的时候，认识所有人都是不平等的。在你跟对方来说是比较平级的时候，是认识一个人最好的时候，而不是你永远作为一个后辈，一个特别嫩的人去跟大佬打交道
      • 资源什么时候会成为资源，是当你对别人也能够提供相等的可以交换的东西的时候，这个资源对你才是有价值的。
      • 大家还是为了做事在一起的，而并不是为了交朋友在一起的

  • 非常破坏自己职场竞争力，千万不要干的三件事

    • 不要为了利益影响自己的职业操守，不能犯法或者不遵守职业道德
    • 社交的红线不要碰。尽量不碰八卦和领导隐私
    • 有一些人忽略了平台增长和经济增长给他带来的红利，他认为自己的能力要高于一个平台。不要把平台红利等同于个人能力。

  • 职业第一优先级：选行业

  • 行业选择永远是第一位的。选择行业的风口，一定是最重要的。

  • 爆雷行业或公司很伤害履历。在一个正常的人才市场很难通过一次跳槽完成四五倍。

    • 跳槽的时候，大家其实要掂量掂量自己的身价，翻两倍，翻三倍，翻四倍轻松的完成了一次跳槽，有可能代价在后面。
    • 那些给百分之五十的涨幅的工作，都要小心一点。

  • 行业趋势很重要。

  • 选择市场要关注好宏观局势

    • 要去看宏观，新兴的经济体正在那里出现。

  • 业务水平是第二位的。在行业内的业务水平是不是在平均水平之上。

  • 运气也是一种能力。

  • 最不重要的就是在同事里受欢迎的程度。这个对于自己的简历的加分，基本上是看不到的。

  • 没进公司时，学历重要。学历更多的是一个敲门砖

  • 进公司后，老板人品更重要

  • 新业务，能力更重要。一群好人不一定能够做成一件事

  • 成熟业务，人品更重要。如果组织架构已经健全了，那么人品还是很重要的。

  • 专业度跟年龄成反比的行业，成长概率小

  • 对于一个人来说，什么时候是他可以考虑跳槽的时候了？

    • 一定是一个外面拉的因素，就是外面有更好的条件吸引你。
    • 一个是内部推的因素，就是有一些事情你待的很不舒服一定要走了

  • 可以裸辞吗？

    • 特别不建议。
    • 无论竞争力多强，在就业市场上如果裸辞了，那么下一个雇主一定会考虑有多大的问题，才会没有机会的情况下才走

  • 如果一个人开始有跳槽的想法了，接下来他要做的步骤是那些？

    • 一般的职场小白先在领英职场上

  • 被裁员了，怎么办？

    • 跟老板要一个好的推荐信，对于未来再去看机会找工作的时候的背景调查环节有些帮助。
    • 跟老板谈好条件
    • 没有足够十全的把握和证据的话，员工尽量不要选择仲裁这条路
      • 第一是周期很长
      • 第二胜算也很低
      • 第三仲裁记录会影响后面的求职
    • 如果这个事情发生了
      • 首先要问为什么，然后说那我做什么可以不裁我，如果一定要裁我的话，我该怎么做。
      • 可以把问题再抛回去，让对方给你一个答案

  • 35岁被优化是一个事实吗？

    • 你在你的这个年龄一定要取得你这个年龄对等的职位。取得与年龄对等的职位
      • 如果猎头35岁还是一个顾问我基本上不会考虑
    • 要慎重地加入新业务
      • 加入公司新业务一定要多方取证，了解到底靠不靠谱
    • 主动找自己的猎头，缩小信息差。如果不把自己的品牌打出去的话，别人不知道你
    • 用时薪去理解自己的收入
    • 差异化自己的竞争力
      • 不去做老板擅长的领域，因为他太擅长了。
      • 找老板不愿意做，不擅长做，或者短时间内不能做或者顾不上做的事情，自己去做你会变成一个更被需要的人，就这么简单

  • 职场的背叛有很多

  • 职场有真正的信任吗？

    • 有真正的利益就会有真正的信任。
    • 得到信任最好的方式时建立共同的利益。

Posted on Edited on In

简介

  • PCL(Point Cloud Library)常用的编程技巧

pcl::PointCloudpcl::PointXYZ对象怎么转为pcl::PointCloudpcl::PointXYZ::Ptr 指针

将 pcl::PointCloud<pcl::PointXYZ> 对象转换为 pcl::PointCloud<pcl::PointXYZ>::Ptr 指针可以通过以下几种方法实现，具体取决于您希望如何进行转换。这里提供了两种常用的方法：

  1. 使用 boost::make_shared（或 std::make_shared）：

    您可以使用 boost::make_shared 或 C++11 中的 std::make_shared 来创建一个智能指针，并将其指向现有的 pcl::PointCloud<pcl::PointXYZ> 对象。这种方法非常简洁，因为它利用了智能指针的构造函数，而无需手动进行分配和释放。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #include <pcl/point_cloud.h>
    #include <pcl/point_types.h>
    #include <boost/make_shared.hpp>  // 或者 #include <memory>（C++11）

    int main()
    {
        pcl::PointCloud<pcl::PointXYZ> cloud; // 假设已经有一个点云对象
        
        // 使用 boost::make_shared（或 std::make_shared）进行转换
        pcl::PointCloud<pcl::PointXYZ>::Ptr cloudPtr = boost::make_shared<pcl::PointCloud<pcl::PointXYZ>>(cloud);
        
        // 使用 cloudPtr 进行操作
        
        return 0;
    }

  2. 使用显式赋值：

    另一种方法是通过显式赋值创建指针并将其指向现有的 pcl::PointCloud<pcl::PointXYZ> 对象。这种方法需要手动进行指针的分配和释放。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #include <pcl/point_cloud.h>
    #include <pcl/point_types.h>

    int main()
    {
        pcl::PointCloud<pcl::PointXYZ> cloud; // 假设已经有一个点云对象
        
        // 创建指针并赋值
        pcl::PointCloud<pcl::PointXYZ>::Ptr cloudPtr(new pcl::PointCloud<pcl::PointXYZ>(cloud));
        
        // 使用 cloudPtr 进行操作
        
        return 0;
    }

这两种方法都能将现有的 pcl::PointCloud<pcl::PointXYZ> 对象转换为 pcl::PointCloud<pcl::PointXYZ>::Ptr 指针。您可以根据您的代码风格和需求选择其中之一。需要注意的是，在任何情况下，确保在不再需要智能指针时正确释放内存，以避免内存泄漏。

vtkDebugLeaksManager 定义

vtkDebugLeaksManager 是 Visualization Toolkit（VTK）库中的一个类，用于在调试和测试过程中检测内存泄漏。VTK 是一个用于处理和可视化科学和工程数据的开源软件系统。它提供了广泛的功能，包括图形渲染、图像处理、体积可视化、几何建模等，常用于科学计算、医学图像处理和工程仿真等领域。

vtkDebugLeaksManager 类主要用于在程序执行过程中跟踪 VTK 对象的创建和销毁，以帮助开发者发现是否有未释放的内存资源。它通常在开发和测试阶段使用，因为在正式发布的代码中，应该尽量避免内存泄漏。

该类的定义和使用可以在 VTK 的源代码中找到，下面是一个可能的伪代码示例，演示了它的基本用法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <vtkDebugLeaksManager.h>

int main() {
    // 启用内存泄漏检测
    vtkDebugLeaksManager::GetInstance()->SetDebugLeaks(true);

    // ... 创建和使用 VTK 对象 ...

    // 在程序结束前，析构 VTK 对象

    // 输出内存泄漏信息
    vtkDebugLeaksManager::GetInstance()->DumpLeaks(std::cerr);

    // 禁用内存泄漏检测
    vtkDebugLeaksManager::GetInstance()->SetDebugLeaks(false);

    return 0;
}

请注意，上述示例是伪代码，实际的使用方式可能会有所不同，具体取决于你所编写的代码和项目的需求。如果你正在使用 VTK 并且想要了解更多关于 vtkDebugLeaksManager 类的详细信息，建议查阅 VTK 的官方文档或源代码。

Posted on Edited on In

简介

  • PCL(Point Cloud Library) 相关的理论基础知识

pcl::MomentOfInertiaEstimation 类 详解

pcl::MomentOfInertiaEstimation 是 PCL（Point Cloud Library）中的一个类，用于计算点云的惯性矩信息。它可以用于分析点云的形状特征，例如计算点云的主轴、最小包围盒等。这些信息对于识别点云中的物体形状和姿态等任务非常有用。

以下是 pcl::MomentOfInertiaEstimation 类的主要功能和使用方法的详解：

  1. 功能：
    pcl::MomentOfInertiaEstimation 可以计算点云的惯性矩信息，如主轴、最小包围盒、质心等。这些信息可以用于分析点云的形状特征，识别物体的形状和方向。

  2. 使用方法：
    使用 pcl::MomentOfInertiaEstimation 需要将其实例化并设置输入点云。以下是一个简单的示例代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    #include <pcl/features/moment_of_inertia_estimation.h>
    #include <pcl/point_types.h>
    #include <pcl/io/pcd_io.h>

    int main()
    {
        // 读取点云数据
        pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
        pcl::io::loadPCDFile<pcl::PointXYZ>("input.pcd", *cloud);

        // 创建 MomentOfInertiaEstimation 对象
        pcl::MomentOfInertiaEstimation<pcl::PointXYZ> moi;
        moi.setInputCloud(cloud);
        moi.compute();

        // 获取计算的惯性矩信息
        pcl::PointXYZ min_point, max_point, mass_center;
        Eigen::Matrix3f rotational_matrix;
        moi.getAABB(min_point, max_point);
        moi.getOBB(min_point, max_point, mass_center, rotational_matrix);

        return 0;
    }

    在上述示例中，我们加载一个点云文件，创建了一个 pcl::MomentOfInertiaEstimation 对象，设置了输入点云，然后计算了惯性矩信息。使用 getAABB 可以获取轴对齐的包围盒的最小和最大点，而使用 getOBB 可以获取定向包围盒的最小和最大点、质心以及旋转矩阵。

总之，pcl::MomentOfInertiaEstimation 类使您能够计算点云的惯性矩信息，这对于分析点云的形状特征以及识别物体的形状和方向非常有用。这种信息在点云处理和计算机视觉应用中具有广泛的应用价值。

pcl::StatisticalOutlierRemoval 类 详解

pcl::StatisticalOutlierRemoval 是 PCL（Point Cloud Library）中的一个滤波器类，用于去除点云中的统计离群点（Outliers），以提高点云的质量和准确性。统计离群点通常是与点云的噪声或异常值相关的，它们可能会影响点云处理和分析的结果。

以下是 pcl::StatisticalOutlierRemoval 类的主要功能和使用方法的详解：

  1. 功能：
    pcl::StatisticalOutlierRemoval 通过计算每个点的邻域中点的平均距离和标准差，将与平均距离差异较大的点标记为离群点，并将其从点云中移除。这有助于去除噪声或异常值，从而提高点云的质量。

  2. 使用方法：
    使用 pcl::StatisticalOutlierRemoval 需要将其实例化并设置相关参数，如输入点云、平均距离阈值、标准差倍数等。以下是一个简单的示例代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    #include <pcl/filters/statistical_outlier_removal.h>
    #include <pcl/point_types.h>
    #include <pcl/io/pcd_io.h>

    int main()
    {
        // 读取点云数据
        pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
        pcl::io::loadPCDFile<pcl::PointXYZ>("input.pcd", *cloud);

        // 创建 StatisticalOutlierRemoval 滤波器对象
        pcl::StatisticalOutlierRemoval<pcl::PointXYZ> sor;

        // 设置输入点云
        sor.setInputCloud(cloud);

        // 设置邻域的平均距离
        sor.setMeanK(50);  // 邻域内的点数

        // 设置标准差倍数，用于确定离群点的阈值
        sor.setStddevMulThresh(1.0);

        // 执行滤波，输出到新的点云对象
        pcl::PointCloud<pcl::PointXYZ>::Ptr filtered_cloud(new pcl::PointCloud<pcl::PointXYZ>);
        sor.filter(*filtered_cloud);

        // 将去除离群点后的点云保存到文件
        pcl::io::savePCDFile<pcl::PointXYZ>("output.pcd", *filtered_cloud);

        return 0;
    }

    在上述示例中，我们加载一个点云文件，创建了一个 pcl::StatisticalOutlierRemoval 滤波器对象，设置了输入点云、平均距离阈值和标准差倍数，然后执行滤波操作，并将结果保存到文件。

总之，pcl::StatisticalOutlierRemoval 是 PCL 中用于去除统计离群点的滤波器类。通过识别并去除噪声或异常值，您可以提高点云的质量和准确性，从而更好地支持点云处理和分析任务。

pcl::VoxelGrid 类 详解

pcl::VoxelGrid 是 PCL（Point Cloud Library）中的一个滤波器类，用于进行点云的下采样操作，以降低点云数据量并保留点云的结构特征。下采样可以有效减少点云数据量，提高处理效率，并在某些应用中用于去除噪声。

以下是 pcl::VoxelGrid 类的主要功能和使用方法的详解：

  1. 功能：
    pcl::VoxelGrid 通过将点云分割成立方体（或称为体素）并选择每个体素中的一个点来降低点云的密度。这个过程会保留点云的整体结构特征，同时减少不必要的数据点。

  2. 使用方法：
    要使用 pcl::VoxelGrid，您需要创建一个该类的实例，然后设置滤波器的输入和输出，并调整体素大小以控制下采样程度。下面是一个简单的示例代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    #include <pcl/filters/voxel_grid.h>
    #include <pcl/point_types.h>
    #include <pcl/io/pcd_io.h>

    int main()
    {
        // 读取点云数据
        pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
        pcl::io::loadPCDFile<pcl::PointXYZ>("input.pcd", *cloud);

        // 创建 VoxelGrid 滤波器对象
        pcl::VoxelGrid<pcl::PointXYZ> voxel_filter;

        // 设置输入点云
        voxel_filter.setInputCloud(cloud);

        // 设置体素大小（下采样的尺寸）
        voxel_filter.setLeafSize(0.01f, 0.01f, 0.01f); // 每个维度的体素大小

        // 执行滤波，输出到新的点云对象
        pcl::PointCloud<pcl::PointXYZ>::Ptr filtered_cloud(new pcl::PointCloud<pcl::PointXYZ>);
        voxel_filter.filter(*filtered_cloud);

        // 将下采样后的点云保存到文件
        pcl::io::savePCDFile<pcl::PointXYZ>("output.pcd", *filtered_cloud);

        return 0;
    }

    在上述示例中，我们加载一个点云文件，创建了一个 pcl::VoxelGrid 滤波器对象，设置了输入点云，设置了体素大小，然后执行滤波操作，并将结果保存到文件。

总之，pcl::VoxelGrid 是 PCL 中用于点云下采样的重要滤波器类。它可以帮助您减少点云数据量，提高处理效率，并在一些应用中去除噪声。

pcl::PointCloudpcl::PointXYZ::Ptr 详解

pcl::PointCloud<pcl::PointXYZ>::Ptr 是PCL库中用于表示点云数据的智能指针类型的一部分。让我们一步一步来详解这个类型：

  1. pcl::PointCloud: 这是PCL库中表示点云数据的主要类。它是一个模板类，可以通过指定点的类型来实例化。例如，在这里，我们使用pcl::PointXYZ作为点的类型。pcl::PointXYZ表示一个具有三个浮点数字段（x、y、z坐标）的点。

  2. pcl::PointXYZ: 这是对模板类pcl::PointCloud的实例化，将pcl::PointXYZ作为点的类型参数。这意味着我们创建了一个存储pcl::PointXYZ类型点的点云对象。

  3. ::Ptr: 这是一个后缀，表示我们正在声明一个指向点云对象的智能指针。在C++中，指针是一种引用数据的方式，而智能指针是一种更安全的指针，它会自动管理资源的分配和释放，从而避免内存泄漏等问题。

综合起来，pcl::PointCloud<pcl::PointXYZ>::Ptr 是一个指向存储pcl::PointXYZ类型点的点云对象的智能指针。使用智能指针的好处是，它会在不再需要对象时自动释放内存，避免内存泄漏，并且可以更方便地进行资源管理。

在PCL中，您可以使用类似下面的代码来声明和操作这种类型的智能指针：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>

int main()
{
    // 声明一个指向 pcl::PointXYZ 类型点云对象的智能指针
    pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);

    // 添加点到点云对象中
    pcl::PointXYZ point;
    point.x = 1.0;
    point.y = 2.0;
    point.z = 3.0;
    cloud->push_back(point);

    // 使用智能指针操作点云对象
    std::cout << "Number of points in the cloud: " << cloud->size() << std::endl;

    return 0;
}

在上述示例中，我们声明了一个名为cloud的智能指针，它指向一个存储pcl::PointXYZ类型点的点云对象。然后，我们添加一个点到点云对象中，并使用智能指针操作该点云对象。

总而言之，pcl::PointCloud<pcl::PointXYZ>::Ptr 是PCL中用于表示点云数据并进行智能指针管理的重要类型。它使您能够更方便地创建、操作和管理点云数据。

pcl::removeNaNFromPointCloud() 函数 详解

pcl::removeNaNFromPointCloud() 函数是 Point Cloud Library（PCL）中的一个全局函数，用于从点云数据中移除包含 NaN（Not-a-Number）值的点。

以下是关于 pcl::removeNaNFromPointCloud() 函数的详细解释：

  • 函数签名：函数的签名如下：

    1
    2
    3
    4
    5
    6
    template <typename PointT>
    void pcl::removeNaNFromPointCloud(
        const pcl::PointCloud<PointT> &cloud_in,
        pcl::PointCloud<PointT> &cloud_out,
        std::vector<int> &index_mapping,
        float bad_point = std::numeric_limits<float>::quiet_NaN());

  • 模板参数：

    • PointT：点的数据类型。你需要提供点云中点的实际数据类型，例如 pcl::PointXYZ、pcl::PointXYZRGB 等。

  • 参数：

    • cloud_in：输入的点云数据对象，类型为 pcl::PointCloud<PointT>。
    • cloud_out：移除 NaN 值后的输出点云数据对象，类型为 pcl::PointCloud<PointT>。
    • index_mapping：一个整数向量，用于存储输入点云中有效点的索引映射到输出点云的索引。可以用于重新映射索引关系。
    • bad_point（可选）：表示无效点的数值，默认为 std::numeric_limits<float>::quiet_NaN()。

  • 功能：

    • 该函数用于从输入的点云数据中移除包含 NaN 值的点，并将有效的点存储在输出点云数据对象中。
    • 函数还会返回一个索引映射，该映射表示输入点云中有效点的索引与输出点云中的索引之间的关系。

  • 示例：

    1
    2
    3
    4
    5
    6
    7
    8
    pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
    // 从某处加载点云数据到 cloud

    pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filtered(new pcl::PointCloud<pcl::PointXYZ>);
    std::vector<int> index_mapping;
    pcl::removeNaNFromPointCloud(*cloud, *cloud_filtered, index_mapping);

    // cloud_filtered 现在包含了没有 NaN 值的有效点

  • 注意事项：

    • pcl::removeNaNFromPointCloud() 函数可以用于在处理点云数据之前移除无效的 NaN 值，以确保数据的有效性。
    • index_mapping 向量可以帮助你在移除 NaN 值后保持有效点的索引关系，以便在后续处理中使用。

总之，pcl::removeNaNFromPointCloud() 函数是用于从点云数据中移除 NaN 值的有用函数，以确保在处理和可视化点云数据时不会受到无效数据的影响。

pcl::visualization::PCLVisualizer::spinOnce() 函数 详解

pcl::visualization::PCLVisualizer::spinOnce() 函数是 Point Cloud Library（PCL）中 pcl::visualization::PCLVisualizer 类的一个成员函数，用于在可视化窗口中执行一次事件循环，以响应用户的交互操作和更新可视化。

以下是关于 spinOnce() 函数的详细解释：

  • 函数签名：函数的签名如下：

    1
    2
    3
    bool pcl::visualization::PCLVisualizer::spinOnce(
        int time = 1,
        bool force_redraw = false);

  • 参数：

    • time：事件循环的持续时间（毫秒），默认为1毫秒。这个参数控制函数在循环内等待多长时间，以便检测用户输入和更新可视化。
    • force_redraw：一个布尔值，用于指定是否强制重新绘制可视化窗口。如果设置为 true，则会在循环内强制重新绘制窗口。

  • 功能：

    • 该函数在可视化窗口中执行一次事件循环，用于检测用户的交互操作（例如鼠标、键盘事件）以及更新可视化内容。它会等待一段时间，以便检测输入和更新。
    • 如果有用户交互操作或更新，函数将返回 true。如果没有任何交互操作或更新，函数将返回 false。

  • 示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("PointCloud Viewer"));

    // 添加点云到可视化窗口
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
    // 从某处加载点云数据到 cloud

    pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> color_handler(cloud);
    viewer->addPointCloud(cloud, color_handler, "cloud");

    // 进入事件循环
    while (!viewer->wasStopped()) {
        viewer->spinOnce();
    }

  • 注意事项：

    • 在调用 spinOnce() 函数之后，程序将在事件循环中等待，直到用户进行交互操作或更新，或者直到可视化窗口被关闭。
    • 在循环中使用 spinOnce() 可以实现交互式操作和动态更新，但要确保循环不会被阻塞，以便及时响应用户的操作。

总之，pcl::visualization::PCLVisualizer::spinOnce() 函数是用于在可视化窗口中执行一次事件循环的重要函数，用于检测用户的交互操作和更新可视化内容。

pcl::visualization::PCLVisualizer::updatePointCloud() 函数 详解

pcl::visualization::PCLVisualizer::updatePointCloud() 函数是 Point Cloud Library（PCL）中 pcl::visualization::PCLVisualizer 类的一个成员函数，用于更新已经添加到可视化窗口中的点云数据。

以下是关于 updatePointCloud() 函数的详细解释：

  • 函数签名：函数的签名如下：

    1
    2
    3
    4
    void pcl::visualization::PCLVisualizer::updatePointCloud(
        const PointCloudT &cloud,
        const PointCloudColorHandler<PointT> &color_handler,
        const std::string &id = "cloud");

  • 参数：

    • cloud：新的点云数据，类型为 PointCloudT，可以是 pcl::PointCloud<pcl::PointXYZ>、pcl::PointCloud<pcl::PointXYZRGB> 等。
    • color_handler：用于指定点云的颜色处理器，例如 pcl::visualization::PointCloudColorHandlerCustom。
    • id：要更新的点云的标识符。

  • 功能：

    • 该函数用于更新已经添加到 pcl::visualization::PCLVisualizer 对象中的点云数据。你可以用新的点云数据替换已有的点云数据，从而实现动态更新和可视化。

  • 示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("PointCloud Viewer"));

    pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
    // 从某处加载点云数据到 cloud

    pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> color_handler(cloud);

    // 添加点云到可视化窗口
    viewer->addPointCloud(cloud, color_handler, "cloud");

    // 更新点云数据
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr newCloud(new pcl::PointCloud<pcl::PointXYZRGB>);
    // 从某处加载新的点云数据到 newCloud

    // 更新点云
    viewer->updatePointCloud(newCloud, color_handler, "cloud");

  • 注意事项：

    • updatePointCloud() 函数用于更新已添加的点云，你需要提供新的点云数据和对应的颜色处理器。
    • 点云的更新将在调用 spin() 或 spinOnce() 方法后生效，以确保更新能够在可视化窗口中显示出来。

总之，pcl::visualization::PCLVisualizer::updatePointCloud() 函数是一个重要的函数，用于在可视化窗口中更新已添加的点云数据，以实现动态更新和交互式操作。

pcl::visualization::PCLVisualizer::addPointCloud() 函数 详解

pcl::visualization::PCLVisualizer::addPointCloud() 函数是 Point Cloud Library（PCL）中 pcl::visualization::PCLVisualizer 类的一个成员函数，用于将点云添加到可视化窗口中进行显示和交互。

以下是关于 addPointCloud() 函数的详细解释：

  • 函数签名：函数的签名如下：

    1
    2
    3
    4
    5
    void pcl::visualization::PCLVisualizer::addPointCloud(
        const PointCloudT &cloud,
        const PointCloudColorHandler<PointT> &color_handler,
        const std::string &id = "cloud",
        int viewport = 0);

  • 参数：

    • cloud：要添加的点云对象，类型为 PointCloudT，可以是 pcl::PointCloud<pcl::PointXYZ>、pcl::PointCloud<pcl::PointXYZRGB> 等。
    • color_handler：用于指定点云的颜色处理器，可以是 pcl::visualization::PointCloudColorHandlerCustom 或其他颜色处理器。
    • id（可选）：点云的标识符，用于在之后进行引用。默认为 “cloud”。
    • viewport（可选）：指定要在哪个视口中添加点云。默认为视口0，通常情况下只有一个视口。

  • 功能：

    • 该函数用于在 pcl::visualization::PCLVisualizer 对象中添加一个点云，以便在可视化窗口中显示和交互。
    • 你可以使用不同的颜色处理器来设置点云的颜色，例如使用 PointCloudColorHandlerCustom 来设置每个点的颜色。

  • 示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("PointCloud Viewer"));

    // 创建点云对象
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
    // 从某处加载点云数据到 cloud

    // 创建颜色处理器
    pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> color_handler(cloud);

    // 添加点云到可视化窗口
    viewer->addPointCloud(cloud, color_handler, "cloud");

  • 注意事项：

    • 你需要在调用 addPointCloud() 函数之前创建并加载好点云数据对象。
    • 如果要添加多个点云，你可以通过提供不同的标识符来区分它们。
    • 添加点云之后，你需要调用 spin() 或 spinOnce() 方法来更新显示和交互。

总之，pcl::visualization::PCLVisualizer::addPointCloud() 函数是用于将点云添加到可视化窗口中的重要函数，允许你在可视化中呈现和交互式操作点云数据。

pcl::visualization::PCLVisualizer::addPointCloudpcl::PointXYZRGB() 函数 详解

pcl::visualization::PCLVisualizer::addPointCloud<pcl::PointXYZRGB>() 函数是 Point Cloud Library（PCL）中 pcl::visualization::PCLVisualizer 类的一个成员函数的模板化版本，用于将带有颜色信息的 pcl::PointCloud<pcl::PointXYZRGB> 类型的点云添加到可视化窗口中进行显示和交互。

以下是关于 addPointCloud<pcl::PointXYZRGB>() 函数的详细解释：

  • 函数签名：函数的签名如下：

    1
    2
    3
    4
    void pcl::visualization::PCLVisualizer::addPointCloud<pcl::PointXYZRGB>(
        const typename pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr &cloud,
        const std::string &id = "cloud",
        int viewport = 0);

  • 模板参数：

    • pcl::PointXYZRGB：点云数据的类型。这里的 pcl::PointXYZRGB 表示点云中的每个点都具有 XYZ 坐标和 RGB 颜色信息。

  • 参数：

    • cloud：要添加的 pcl::PointCloud<pcl::PointXYZRGB> 类型的点云对象，使用 ConstPtr 类型传递。
    • id（可选）：点云的标识符，用于在之后进行引用。默认为 “cloud”。
    • viewport（可选）：指定要在哪个视口中添加点云。默认为视口0，通常情况下只有一个视口。

  • 功能：

    • 该函数用于在 pcl::visualization::PCLVisualizer 对象中添加一个 pcl::PointXYZRGB 类型的点云，以便在可视化窗口中显示和交互。

  • 示例：

    1
    2
    3
    4
    5
    6
    7
    8
    pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("PointCloud Viewer"));

    // 创建点云对象
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
    // 从某处加载点云数据到 cloud

    // 添加点云到可视化窗口
    viewer->addPointCloud<pcl::PointXYZRGB>(cloud, "cloud");

  • 注意事项：

    • 你需要在调用 addPointCloud<pcl::PointXYZRGB>() 函数之前创建并加载好 pcl::PointXYZRGB 类型的点云数据对象。
    • 如果要添加多个点云，你可以通过提供不同的标识符来区分它们。
    • 添加点云之后，你需要调用 spin() 或 spinOnce() 方法来更新显示和交互。

总之，pcl::visualization::PCLVisualizer::addPointCloud<pcl::PointXYZRGB>() 函数是用于将 pcl::PointXYZRGB 类型的点云添加到可视化窗口中的模板化函数，允许你在可视化中呈现和交互式操作带有颜色信息的点云数据。

pcl::visualization::PCLVisualizer::removeAllPointClouds()

pcl::visualization::PCLVisualizer::removeAllPointClouds() 函数是 Point Cloud Library（PCL）中 pcl::visualization::PCLVisualizer 类的一个成员函数，用于从可视化窗口中移除所有已添加的点云。

以下是关于 removeAllPointClouds() 函数的详细解释：

  • 函数签名：函数的签名如下：

    1
    void pcl::visualization::PCLVisualizer::removeAllPointClouds(const std::string &id = std::string())

  • 参数：

    • id（可选）：一个字符串参数，用于指定要移除的点云的标识符。如果提供了标识符，函数将只移除具有相同标识符的点云。如果未提供标识符，则函数将移除所有已添加的点云。

  • 功能：

    • 当你在 pcl::visualization::PCLVisualizer 对象中添加多个点云之后，你可以使用 removeAllPointClouds() 函数一次性将所有点云从可视化窗口中移除。这对于清除之前的点云可视化，以便更新和重新绘制场景非常有用。

  • 示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("PointCloud Viewer"));

    // 添加多个点云
    viewer->addPointCloud(cloud1, "cloud1");
    viewer->addPointCloud(cloud2, "cloud2");
    viewer->addPointCloud(cloud3, "cloud3");

    // 移除所有点云
    viewer->removeAllPointClouds();

  • 注意事项：

    • 如果你希望只移除特定标识符的点云，可以提供相应的标识符作为函数参数。
    • 在使用 removeAllPointClouds() 函数之后，如果需要重新添加点云，你需要重新调用 addPointCloud() 或其他相关的添加函数。

总之，pcl::visualization::PCLVisualizer::removeAllPointClouds() 函数是一个方便的方法，用于一次性移除 pcl::visualization::PCLVisualizer 对象中的所有已添加的点云，从而清空可视化窗口，以便更新或重新绘制点云数据。

pcl::PointCloud 类 详解

pcl::PointCloud 类是 Point Cloud Library（PCL）中用于表示点云数据的基础类模板。它提供了一种统一的方式来存储不同类型的点云数据，如 pcl::PointXYZ、pcl::PointXYZRGB 等。pcl::PointCloud 类提供了一些成员函数和数据结构，用于管理点云数据和相关操作。

以下是关于 pcl::PointCloud 类的一些详细信息：

  • 模板参数：pcl::PointCloud 是一个模板类，你需要通过指定点的数据类型来实例化它。例如：

    1
    pcl::PointCloud<pcl::PointXYZ> cloud;

  • 数据结构：pcl::PointCloud 类中的数据结构主要包含了一个 std::vector 或其他容器来存储点的数据。点的数据结构由模板参数决定。

  • 成员函数：pcl::PointCloud 类提供了许多成员函数，用于对点云数据进行访问、操作和处理。例如，你可以使用 points 成员来访问点云中的所有点，使用 size() 成员获取点云中点的数量等。

  • 添加和删除点：你可以使用 push_back() 成员函数向点云中添加新的点，使用 resize() 函数更改点云的大小。通过直接访问 points 成员，你可以修改和删除点。

  • 点的访问：你可以通过索引访问点云中的特定点，如 cloud[i]，以及通过点的属性（例如 XYZ 坐标、颜色等）来访问点的属性。

  • 迭代器：pcl::PointCloud 支持迭代器，允许你在点云数据上进行迭代操作。

  • 坐标系：点云数据的坐标系通常与传感器或数据来源的坐标系一致。你需要根据实际情况进行坐标系转换。

  • 颜色和属性：如果你的点云数据包含颜色信息或其他属性，可以使用相应的数据类型来实例化 pcl::PointCloud。

  • 示例：以下是一个简单的示例，展示如何创建、添加和访问点云数据：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #include <pcl/point_cloud.h>
    #include <pcl/point_types.h>

    int main() {
        pcl::PointCloud<pcl::PointXYZ> cloud;

        pcl::PointXYZ point;
        point.x = 1.0;
        point.y = 2.0;
        point.z = 3.0;

        cloud.push_back(point);

        for (const auto& p : cloud.points) {
            std::cout << "Point: (" << p.x << ", " << p.y << ", " << p.z << ")" << std::endl;
        }

        return 0;
    }

总之，pcl::PointCloud 类是 Point Cloud Library 中用于表示点云数据的核心类模板，适用于各种点云数据的存储、访问和处理需求。你可以根据点云的属性选择相应的数据类型来实例化该类，以便处理不同类型的点云数据。

pcl::PointCloudpcl::PointXYZRGB 详解

pcl::PointCloud<pcl::PointXYZRGB> 是 Point Cloud Library（PCL）中的一个模板类，用于表示包含颜色信息的点云数据。这个模板类表示一个点云，其中每个点都具有三维坐标和RGB颜色值。

以下是关于 pcl::PointCloud<pcl::PointXYZRGB> 类的一些详细信息：

  • 模板参数：pcl::PointCloud<pcl::PointXYZRGB> 是一个模板类，其中 pcl::PointXYZRGB 是点的数据类型。pcl::PointXYZRGB 包含三个浮点数表示点的XYZ坐标，以及一个 RGB 颜色值。

  • 数据结构：每个点由三个浮点数（X、Y、Z）和一个 32 位 RGB 颜色值组成。RGB 颜色值由 8 位的红、绿、蓝分量组成，分别表示颜色的强度。

  • 创建点云对象：要使用 pcl::PointCloud<pcl::PointXYZRGB>，你可以实例化一个点云对象，如：

    1
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGB>);

  • 添加点：你可以使用 push_back 方法添加点到点云对象中，每个点都需要设置坐标和颜色值：

    1
    2
    3
    4
    5
    6
    7
    8
    pcl::PointXYZRGB point;
    point.x = 1.0;
    point.y = 2.0;
    point.z = 3.0;
    point.r = 255;   // 红色分量
    point.g = 0;     // 绿色分量
    point.b = 0;     // 蓝色分量
    cloud->points.push_back(point);

  • 访问点云数据：你可以通过索引访问点云中的点，并读取其坐标和颜色信息。

  • 可视化：pcl::PointCloud<pcl::PointXYZRGB> 类型的点云可以使用 pcl::visualization::PCLVisualizer 进行可视化，显示每个点的颜色。

这只是关于 pcl::PointCloud<pcl::PointXYZRGB> 类的一些基本信息。要详细了解它的更多功能和用法，可以查阅 PCL 的官方文档和示例代码。这个类在处理包含颜色信息的点云数据时非常有用，适用于各种需要在可视化中呈现彩色点云的应用场景。

PCL 详解

PCL（Point Cloud Library）是一个用于处理三维点云数据的开源库，旨在为点云数据处理、滤波、分割、特征提取、配准、可视化等任务提供一系列丰富的功能。以下是关于 PCL 的详细解释：

  1. 点云数据：点云是一种表示三维空间中离散点的数据结构。它可以由激光雷达、摄像头或其他传感器采集得到。每个点包含坐标信息和可能的其他属性，如颜色、法线等。

  2. PCL 功能：PCL 提供了一系列用于处理点云数据的模块和算法，包括但不限于以下功能：

    • 滤波（Filtering）：用于去除噪声、下采样、平滑化等。
    • 分割（Segmentation）：将点云分割为具有相似属性的子集，例如，将物体从背景中分离出来。
    • 特征提取（Feature Extraction）：从点云中提取出特定的局部或全局特征，如法线、曲率、表面描述子等。
    • 配准（Registration）：将多个点云对齐，使其在同一坐标系下。
    • 表面重建（Surface Reconstruction）：基于离散点创建平滑的三维模型表面。
    • 可视化（Visualization）：将点云数据以交互式的方式显示在屏幕上，以便进行可视化分析。
    • IO 操作（Input/Output）：加载和保存点云数据的功能，支持多种点云数据格式。

  3. 使用 PCL：要使用 PCL，首先需要安装 PCL 库并包含相应的头文件。然后，你可以在你的代码中使用 PCL 提供的类和函数来处理点云数据。下面是一个简单的示例代码，演示如何加载点云数据、对其进行降采样并可视化：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    #include <pcl/io/pcd_io.h>
    #include <pcl/point_types.h>
    #include <pcl/filters/voxel_grid.h>
    #include <pcl/visualization/cloud_viewer.h>

    int main()
    {
        pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
        pcl::io::loadPCDFile("input_cloud.pcd", *cloud);

        pcl::VoxelGrid<pcl::PointXYZ> voxel_filter;
        voxel_filter.setInputCloud(cloud);
        voxel_filter.setLeafSize(0.01f, 0.01f, 0.01f);
        pcl::PointCloud<pcl::PointXYZ>::Ptr filtered_cloud(new pcl::PointCloud<pcl::PointXYZ>);
        voxel_filter.filter(*filtered_cloud);

        pcl::visualization::CloudViewer viewer("Point Cloud Viewer");
        viewer.showCloud(filtered_cloud);
        while (!viewer.wasStopped()) {}

        return 0;
    }

以上只是 PCL 提供的一小部分功能示例。PCL 提供了丰富的模块和算法，可以用于处理多种点云数据处理任务。如果你需要处理三维点云数据，PCL 可能是一个强大且适用的工具。详细的文档和示例可以在 PCL 官方网站或文档中找到。

pcl::PCLVisualizer 类 详解

pcl::PCLVisualizer 是 Point Cloud Library（PCL）中的一个类，用于可视化点云和其他3D数据。它提供了一个交互式的图形用户界面，允许用户浏览和交互式地操作点云数据，同时还支持在可视化窗口中添加各种图形元素和标记。

以下是关于 pcl::PCLVisualizer 类的一些详细信息：

  • 功能概述：pcl::PCLVisualizer 提供了多种功能，包括显示点云、网格、几何对象，添加文本、标记、线条、箭头等，支持不同的渲染器和视图，以及交互式操作点云数据。

  • 创建对象：要使用 pcl::PCLVisualizer，你需要实例化一个对象。例如：

    1
    pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("PointCloud Viewer"));

  • 添加点云：可以使用 addPointCloud 方法将点云添加到可视化窗口：

    1
    2
    3
    pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
    // 从某处加载点云数据到 cloud
    viewer->addPointCloud(cloud, "cloud");

  • 交互操作：pcl::PCLVisualizer 支持各种交互操作，如旋转、平移、缩放、选择等。你可以使用鼠标和键盘来操作可视化窗口中的点云数据。

  • 添加其他图形元素：除了点云，你还可以添加其他图形元素，如箭头、线条、文本、几何对象等。

  • 更新显示：每当你添加、修改或删除可视化元素时，需要调用 viewer->spinOnce() 或 viewer->spin() 方法来更新显示。

  • 关闭窗口：通过 viewer->close() 方法可以关闭可视化窗口。

  • 视角设置：你可以设置视角、相机参数、背景颜色等，以控制显示效果。

  • 自定义交互：pcl::PCLVisualizer 还允许你定义自己的交互回调函数，以实现特定的交互逻辑。

这只是关于 pcl::PCLVisualizer 类的一些基本信息。要详细了解它的功能和用法，建议查阅 PCL 的官方文档和示例代码。该类是 PCL 中用于可视化点云数据和其他3D数据的强大工具，适用于在开发中实时查看、分析和交互式操作点云数据。

Posted on Edited on In

简介

  • QT 应用程序开发 理论基础

QT按钮组件

  • QT中有六种按钮组件，分别是按压按钮QPushButton、工具按钮QToolButton、单选按钮QRadioButton、多选按钮QCheckBox、命令链接按钮QCommandLinkButton、按钮盒QButtonBox

QPushButton

QPushButton组件简介

  • QPushButton组件用于接受用户点击事件，能够显示提示字符串，是功能性组件，需要父组件作为容器，能够在父组件中进行定位，用于执行命令或触发事件。
  • QPushButton的类继承如下：
    • QPushButton ：public QAbstractButton ：pubic QWidget ：public QObject, public QPaintDevice

QPushButton组件属性

  • QPushButton 组件属性设置选项：
    • A、name：组件对应源代码中的名字。
    • B、text：组件对应图形界面中显示的名字。
    • C、font：设置text的字体。
    • D、enabled：组件是否可用。

QPushButton组件常用成员函数

1
QPushButton：：QPushButton（const QString &text，QWidget *parent，const char *name = 0);
  • 构造一个名称为name，父对象为parent并且文本为text的按压按钮。
1
void QAbstractButton：：setText（const QString &）
  • 设置按钮上显示的文本。
1
QString QAbstractButton：：text（）const
  • 返回按钮上显示的文本。
1
void QAbstractButton：：pressed（）[signal]
  • 当按下按钮时，发射信号。
1
void QAbstractButton：：clicked（）[signal]
  • 当单击按钮时，发射信号。
1
+ void QAbstractButton：：released（）[signal]
  • 当释放按钮时，发射信号。

Qt程序需要配置那些内容

  • Qt的几个编译工具: moc, uic, rcc.这几个工具在Qt Assistant中都可以直接搜索到介绍界面，下面简单说一下各自的功能
    • moc: 元对象编译器(Meta Object Compiler)，用来处理带有Q_OBJECT宏的类。我们在声明class的时候，继承QObject，再私有声明Q_OBJECT宏就可以使用Qt的信号和槽了，实际上是Qt利用moc将各个类所需要的元对象代码(meta-object code)补充好了。(moc读取一个头文件，补充其中带有Q_OBJECT宏类的元对象代码，一般生成一个moc_ClassName.cpp文件)
    • uic: 用户界面编译器(User Interface Compiler)，用来编译ui界面文件的
    • rcc: 资源编译器(Resource Compiler)，把qrc文件编译成对应的C++代码
  • 所以在CMake工程中使用Qt首先要搞明白如何调用这些工具

moc uic rcc 自动调用

  • 首先对于 moc uic rcc处理的方法

    1
    2
    3
    set(CMAKE_AUTOMOC ON)
    set(CMAKE_AUTORCC ON)
    set(CMAKE_AUTOUIC ON)

  • 设置了这几个变量之后，会在需要时自动调用这几个编译器。

  • 在添加 exe 时的语法:

    1
    add_executable(TestQtCMake WIN32 src/main.cpp src/mainWindow.cpp src/mainwindow.h src/mainwindow.ui)

  • 其中 WIN32 的参数可能需要提示一下

    • 如果提供了 WIN32，则将设置WIN32_EXECUTABLE变量为ON，此时将生成一个界面程序而不是控制台程序。

添加Qt模块和生成执行文件

  • 添加库，使用了 find_package()函数，示例如下

    1
    find_package(Qt5 COMPONENTS Widgets REQUIRED)

  • 首先，要使用find_package()函数，需要提供一个.cmake文件，如何让CMake知道这个文件，可以采用两个方法

    • 设置环境变量CMAKE_PREFIX_PATH为Qt5安装位置，这是官方Qt-CMake教程中的推荐做法
    • 设置CMake中Qt5_DIR变量，值为QT5Config.cmake文件的位置。示例如下
      1
      set(Qt5_DIR D:\Qt514\5.14.0\msvc2017_64\lib\cmake\Qt5)

  • 从上方目录可以看出来，这个.cmake文件是不同Qt版本和不同编译平台都有一套，所以对于官方推荐做法笔者并不是很推荐，难不成当需要换平台的时候还需要去改环境变量

  • 将Qt库链接到可执行文件

    1
    target_link_libraries(TestQtCMake Qt5::Widgets)

运行时依赖处理

  • 对于缺少dll文件，可以在环境变量中是设置Path，把Qt的bin目录添加进来
  • 在windows平台使用官方的 windeployqt 工具，就在上述的bin目录下，传入exe文件路径就可以将该exe依赖的Qt文件全部打包到目录下，命令示例
    1
    windeployqt.exe TestQtCMake.exe

小结

  • 要在CMake中使用Qt，需要以下几步
    • 设置变量CMAKE_AUTO***为ON以启动 rcc uic moc编译器
    • 设置变量QT5_DIR变量定位.cmake文件，使用find_package()函数定位Qt的库文件，使用target_link_libraries()函数链接Qt库
    • 使用windeployqt工具打包依赖项

Posted on Edited on In

简介

  • 点云相关的理论基础笔记

存储为PLY点云文件格式常用的第三方库有哪些？

许多第三方库支持PLY（Polygon File Format）点云文件格式的读写和处理。这些库可以帮助你轻松地在不同编程语言中处理PLY格式的点云数据。以下是一些常用的第三方库，用于处理PLY点云文件格式：

  1. **Point Cloud Library (PCL)**：PCL 是一个功能强大的开源库，主要用于点云处理。它提供了丰富的点云数据结构和算法，并支持多种点云文件格式，包括PLY。PCL 提供了用于读取和写入PLY文件的函数，以及用于点云处理的各种工具和算法。

  2. Open3D：Open3D 是另一个开源的库，用于三维数据处理，包括点云。它支持PLY格式以及其他格式，提供了点云的读写和可视化功能，同时还提供了各种点云处理算法。

  3. VTK（Visualization Toolkit）：VTK 是一个开源的可视化库，它也支持PLY点云文件格式的读写。VTK 不仅用于可视化，还提供了点云数据处理的一些功能，可以在各种应用中使用。

  4. libigl：libigl 是一个用于几何处理和可视化的C++库，它支持PLY格式以及其他各种几何数据格式。虽然它主要用于三维模型处理，但也可以用于点云数据。

  5. Pyply：Pyply 是一个用于Python的库，专门用于读写和处理PLY点云文件。它提供了简单的接口，适用于快速处理PLY格式的点云数据。

  6. **Assimp (Open Asset Import Library)**：Assimp 是一个用于导入和导出3D模型和场景的库，它支持多种3D数据格式，包括PLY格式。虽然主要用于模型导入，但也可以用于点云数据。

这些库提供了在不同编程语言中处理PLY点云文件格式的方式，具体的选择取决于你的编程语言偏好和项目需求。无论你使用哪个库，它们都可以帮助你轻松读取、写入和处理PLY格式的点云数据。

常见的点云文件格式有哪些 详解

点云文件格式是用于存储和交换点云数据的规范化文件格式。这些格式具有不同的特性，包括数据结构、支持的属性、压缩方式和应用范围。以下是一些常见的点云文件格式：

  1. PLY（Polygon File Format）：PLY 格式是一种通用的文件格式，用于存储三维模型和点云数据。它支持多种属性，包括坐标、颜色、法线、纹理坐标等。PLY 格式非常灵活，可适应各种应用，包括计算机图形学、三维建模和点云处理。

  2. LAS/LAZ（LiDAR Data Exchange）：LAS 格式和其压缩版本 LAZ 通常用于存储激光雷达数据。这些格式支持点云的坐标、强度、分类、时间戳等信息，同时支持数据的索引和压缩。LAS 格式经常用于地理信息系统（GIS）和激光雷达数据。

  3. PCD（Point Cloud Data）：PCD 格式是 Point Cloud Library (PCL) 的默认文件格式，用于存储点云数据。它支持点云的坐标和颜色信息，同时支持多种数据类型。PCD 格式通常用于点云处理和机器视觉应用。

  4. XYZ 格式：XYZ 格式是一种非常简单的格式，其中每行包含一个点的 x、y、z 坐标。这种格式特别适用于小型点云数据的快速存储和交换。它通常不包括其他属性信息。

  5. ASC（ASCII）格式：ASCII 格式是一种文本文件格式，其中点的坐标和属性信息以文本形式存储。这种格式易于阅读和编辑，通常包括 x、y、z 坐标以及可能的其他属性，如颜色、法线、强度等。ASCII 格式适用于简单的点云数据或进行手动编辑和调试。

  6. PTS 格式：PTS 格式是一种使用于粒子云（点云）数据的格式，通常用于科学和工程领域。PTS 格式支持点的坐标、颜色和法线信息。

  7. OBJ（Wavefront .obj）：OBJ 格式通常用于存储三维模型数据，但也可以用于存储点云数据。它支持点的坐标、颜色和纹理坐标，是一种通用的三维数据交换格式。

这些格式的选择通常取决于数据的来源、用途、处理工具和库的支持。不同的格式可能适用于不同的应用领域，因此在选择格式时要考虑与特定应用和工具的兼容性。此外，有一些格式支持附加信息，如颜色、法线和纹理，使其更适合于多用途的点云数据存储。

点云数据一般的存储工具有什么 详解

点云数据的存储工具是用于创建、管理、读取和写入点云数据的软件或库。这些工具有助于在计算机视觉、机器学习、三维建模、虚拟现实等领域中处理点云数据。以下是一些常见的点云数据存储工具：

  1. **Point Cloud Library (PCL)**：PCL 是一个功能强大的开源库，专门用于点云处理。它提供了丰富的点云数据结构和算法，以及用于点云数据的文件 I/O（输入/输出）功能，支持多种点云文件格式，如PLY、PCD、LAS 等。PCL 是一个非常受欢迎的点云处理工具，可用于点云的读取、写入、滤波、配准、分割和特征提取等操作。

  2. **PointCloud2 (ROS)**：ROS（Robot Operating System）中提供了 PointCloud2 消息类型，用于在机器人和机器视觉应用中传输点云数据。ROS 的 PointCloud2 消息类型允许在ROS系统中轻松传输、发布和订阅点云数据，使其成为机器人和自动化应用中的强大工具。

  3. LasPy：LasPy 是一个用于处理 LAS 格式点云数据的 Python 库。LAS 格式通常用于激光雷达数据，而 LasPy 可以用于读取和写入 LAS 文件，以及进行基本的点云处理操作。

  4. Potree：Potree 是一个用于将点云数据转换为Web浏览器可视化的开源工具。它可以将点云数据转换为点云切片格式，以实现高性能的在线点云可视化。Potree支持多种点云格式，包括LAS、PLY和PCD。

  5. CloudCompare：CloudCompare是一个开源的点云处理和三维建模工具，它具有强大的点云文件处理功能，可以导入、导出和转换多种点云格式，如PLY、LAS、XYZ等。它还提供了许多点云处理工具，用于可视化、滤波、配准和分析点云数据。

  6. Blender：Blender 是一个开源的三维建模和渲染软件，它具有强大的点云导入和处理功能，用于将点云数据与建模和渲染操作集成。Blender支持多种点云格式，如PLY和LAS。

  7. Velodyne LiDAR Software Suite：Velodyne LiDAR提供的软件套件包括用于处理激光雷达点云数据的工具，这些工具专门用于Velodyne激光雷达数据的读取、处理和分析。

这些工具和库可以根据需要进行点云数据的读取、写入、处理和分析。具体选择哪个工具通常取决于数据的来源、应用场景和开发环境。不同的工具可能支持不同的点云文件格式，因此在选择工具时要考虑与特定数据格式的兼容性。

点云是什么 详解

点云是一种用来表示三维空间中对象或场景的数据结构，它由大量的点构成，每个点都包含有关其在三维坐标空间中的位置和其他属性的信息。点云通常以坐标值的形式存储，表示空间中的离散点。这些点可以包含额外的信息，如颜色、法线方向、强度、反射率等，取决于点云的来源和应用领域。

以下是有关点云的详细解释：

  1. 数据来源：点云数据通常通过各种传感器和技术来获取，包括激光雷达、立体摄影、深度相机、超声波传感器等。这些传感器可以在不同领域中使用，例如地理信息系统、机器视觉、自动驾驶、建筑信息模型（BIM）等。

  2. 点的属性：每个点云中的点可以包含不同的属性信息，具体取决于数据的来源和应用。通常，点的主要属性是其三维坐标，但还可以包含颜色信息（RGB或RGBA）、法线向量、反射率、强度等。这些属性有助于描述点在空间中的位置、外观和其他特征。

  3. 用途：点云在许多领域中都有广泛的应用，包括但不限于：

    • 地理信息系统（GIS）：用于地形建模、城市规划、资源管理和环境监测。
    • 计算机视觉：用于物体识别、三维重建、姿态估计和物体分割。
    • 自动驾驶：用于车辆感知和环境建模。
    • 工业制造和质量控制：用于检测和分析制造过程中的缺陷和形状。
    • 建筑信息建模（BIM）：用于建筑和基础设施项目中的设计和监测。
    • 虚拟现实和增强现实：用于创建沉浸式虚拟环境和互动应用。

  4. 数据处理：点云数据通常需要进行处理和分析，以便进一步的应用。这包括点云的滤波、去噪、配准（将不同视角或时间的点云对齐）、分割（将点云分为不同的对象或部分）、特征提取（寻找点云中的关键特征点或曲面）、可视化等操作。这些处理步骤有助于点云数据更好地用于特定应用。

总之，点云是一种强大的三维数据表示形式，可用于多种应用领域，以捕捉和分析真实世界中的三维信息。点云技术在科学、工程和计算机图形学中具有重要作用，可以帮助人们理解和处理三维空间中的复杂数据。

计算机视觉中的点云是什么 详解

计算机视觉中的点云是一种用于表示和处理三维空间信息的数据结构。点云由大量的三维点构成，每个点都包含有关其在三维坐标空间中的位置和其他属性的信息。这些点通常以坐标值的形式存储，表示了物体或场景的离散采样点。计算机视觉中的点云广泛应用于多个领域，如物体识别、三维重建、姿态估计、物体分割、虚拟现实和增强现实等。

以下是有关计算机视觉中的点云的详细解释：

  1. 数据来源：点云数据可以通过各种传感器和技术来获取，如激光扫描、深度相机、双目摄影、结构光扫描等。这些传感器用于捕捉现实世界中的物体或场景，并将其转换为三维点的集合。这些点可以包含有关物体的几何信息以及其他属性，如颜色、法线向量或强度。

  2. 应用领域：计算机视觉中的点云在多个应用领域中发挥作用，包括但不限于：

    • 物体识别和分类：点云可用于识别和分类三维物体。通过提取点云的特征，可以训练机器学习模型来识别不同类别的物体。
    • 三维重建：通过融合从不同视角或传感器获得的点云数据，可以创建物体或场景的三维模型，用于虚拟现实、游戏开发、建筑信息建模等。
    • 姿态估计：点云可用于估计物体或人体的姿态。这在动作捕捉、手势识别和机器人视觉中有广泛应用。
    • 物体分割：通过分析点云数据的几何特征，可以将物体分割成不同的部分，从而更好地理解物体的结构。
    • 虚拟现实和增强现实：点云用于创建沉浸式虚拟环境和实时跟踪现实世界物体的位置和姿态，以实现增强现实应用。

  3. 数据处理：点云数据通常需要进行处理和分析，以适应特定的计算机视觉任务。这包括点云的滤波、去噪、配准（将多个点云对齐）、特征提取、分割、物体识别等操作。这些处理步骤有助于从点云中提取有用的信息，并用于机器学习或计算机视觉算法。

总之，计算机视觉中的点云是一个重要的三维数据表示形式，用于处理和分析三维空间中的信息。它在许多应用中发挥关键作用，帮助计算机理解和处理现实世界中的三维数据。

点云和RGB图之间的关系是什么 详解

点云和RGB图像之间存在密切的关系，它们通常一起使用，以提供更全面的关于三维世界的信息。下面详细解释了点云和RGB图像之间的关系：

  1. 点云数据：点云是一个三维数据结构，由许多离散的点组成，每个点包含了其在三维坐标空间中的位置信息。这些点通常来自激光扫描、深度相机、结构光扫描等传感器，或通过三维重建技术生成。点云数据用于精确表示和捕捉物体和场景的三维几何信息，包括形状、大小和位置。

  2. RGB图像：RGB图像是二维图像，由红、绿和蓝三个颜色通道组成，每个像素都有对应的颜色信息。这种图像通常来自标准的彩色相机，可以捕捉物体的外观和颜色信息。RGB图像提供了在二维平面上的物体外观信息，但没有提供深度信息。

点云和RGB图像之间的关系如下：

  1. 融合信息：点云和RGB图像通常一起使用，以提供更全面的关于物体或场景的信息。点云提供了三维几何信息，包括物体的形状和位置，而RGB图像提供了外观和颜色信息。通过将它们结合起来，可以更好地理解和描述三维世界。

  2. 视觉感知：结合点云和RGB图像可以实现更高级的视觉感知任务，如物体识别、姿态估计、物体跟踪等。通过将点云的深度信息与RGB图像的颜色信息相结合，计算机可以更准确地理解物体的位置和形状，并执行更精确的任务。

  3. 虚拟环境和增强现实：点云和RGB图像的结合对于虚拟现实（VR）和增强现实（AR）应用非常有用。通过将点云数据与实时捕获的RGB图像进行比对，可以在虚拟环境中放置虚拟对象，并更自然地与真实世界互动。

  4. 三维重建：点云通常用于三维重建应用，其中它们与RGB图像结合以创建真实世界的三维模型。这对于建筑信息建模、文化遗产保护和地理信息系统等领域非常有用。

总之，点云和RGB图像之间的关系是一种互补关系，它们共同提供了关于物体和场景的深度、形状、位置和颜色等方面的信息，使计算机能够更全面地理解和处理三维世界的数据。这对于许多计算机视觉和虚拟现实应用非常重要。

点云和深度图之间的关系是什么 详解

点云和深度图之间有密切的关系，它们都提供了关于三维世界的信息，但它们以不同的方式表示和捕捉这些信息。下面详细解释了点云和深度图之间的关系：

  1. 点云数据：点云是一个三维数据结构，由大量离散的点组成，每个点包含有关其在三维坐标空间中的位置信息。这些点通常来自激光扫描、深度相机、结构光扫描等传感器，或通过三维重建技术生成。点云数据用于精确表示和捕捉物体和场景的三维几何信息，包括形状、大小和位置。

  2. 深度图：深度图是一种二维图像，其中每个像素值表示从相机或传感器到物体表面的距离，也称为深度值或距离值。深度图是一种灰度图像，其中每个像素的灰度级别对应于物体的距离，通常以米为单位。深度图通常由深度传感器或双目相机生成。

点云和深度图之间的关系如下：

  1. 深度信息：深度图提供了关于场景中各个点的距离信息，它们通常以灰度值表示。这些距离信息是点云数据的一部分，因为点云中的每个点都包含其在三维空间中的位置，这可以根据深度信息计算得出。

  2. 点云的生成：点云数据通常是通过从深度图中提取三维坐标来生成的。对于每个深度图像素，根据深度信息，可以将其转换为三维坐标（x、y、z），并将这些坐标组成点云。这些点的坐标是从深度图像到三维空间的反投影。

  3. 信息补充：点云提供了比深度图更丰富的信息，因为它不仅包括距离信息，还包括有关每个点的几何和形状信息。深度图缺乏物体的外观和纹理信息，而点云可以提供这些信息，使计算机能够更全面地理解三维场景。

  4. 应用：点云和深度图通常一起使用，以支持各种计算机视觉和机器视觉任务，如物体识别、物体定位、姿态估计、三维重建、虚拟现实和增强现实等。通过结合点云和深度图，计算机能够更准确地感知和理解三维世界。

总之，点云和深度图都是用于捕捉和表示三维世界信息的工具，它们互补并在各种应用中协同工作，以提供更详细和全面的三维数据。深度图提供距离信息，而点云提供了几何和形状信息，结合使用可实现更多的视觉和机器视觉任务。

深度图和RGB图之间的关系是什么 详解

深度图（Depth Map）和RGB图（RGB Image）之间有密切的关系，它们通常一起使用以提供有关三维世界的更全面信息。深度图提供了关于场景中各个点的距离信息，而RGB图提供了有关物体的颜色和外观信息。以下是深度图和RGB图之间的关系的详细解释：

  1. 深度图：深度图是一种二维图像，其每个像素包含有关场景中对应点距离相机的信息，通常以灰度值表示。这些深度值通常以米（或其他长度单位）为单位，并表示每个像素距离相机的距离。深度图通常是由深度传感器、双目相机或结构光等设备生成的。

  2. RGB图：RGB图是一种二维图像，由红、绿和蓝三个颜色通道组成，每个像素有相应的颜色信息。RGB图捕捉物体的颜色、纹理和外观信息，但通常不包含关于物体距离的信息。

深度图和RGB图之间的关系如下：

  1. 对应关系：深度图和RGB图像通常具有相同的分辨率，这意味着每个深度图的像素都与RGB图像的像素相对应。这意味着你可以通过像素位置来匹配深度图中的深度值与RGB图像中的颜色信息。

  2. 信息补充：深度图提供了有关场景中物体距离的信息，这是RGB图所没有的。通过结合深度图和RGB图，你可以获得更全面的信息，既包括物体的颜色、纹理和外观，又包括它们的三维位置和距离。

  3. 深度感知：深度图用于感知场景的三维几何，如物体之间的距离和相对位置。这对于物体识别、物体定位、姿态估计和避障等任务非常有用。

  4. 视觉效果：深度图和RGB图的结合可用于在计算机图形中实现更逼真的视觉效果。例如，它们可用于实现景深效果，其中前景和背景的模糊程度根据深度信息进行调整。

总之，深度图和RGB图在计算机视觉和计算机图形学中常常一起使用，以提供更完整的三维世界信息。它们的结合可以用于多种应用，包括虚拟现实、增强现实、物体识别、三维重建和模拟等领域。深度信息和颜色信息的结合可以帮助计算机更好地理解和模拟现实世界。

Posted on Edited on In

简介

  • PostgresQL 关系型数据库

什么是数据库？

  • 数据库（Database）是按照数据结构来组织、存储和管理数据的仓库。
  • 每个数据库都有一个或多个不同的 API 用于创建，访问，管理，搜索和复制所保存的数据。
  • 我们也可以将数据存储在文件中，但是在文件中读写数据速度相对较慢。
  • 所以，现在我们使用关系型数据库管理系统（RDBMS）来存储和管理的大数据量。所谓的关系型数据库，是建立在关系模型基础上的数+ 据库，借助于集合代数等数学概念和方法来处理数据库中的数据。
  • ORDBMS（对象关系数据库系统）是面向对象技术与传统的关系数据库相结合的产物，查询处理是 ORDBMS 的重要组成部分，它的性能+ 优劣将直接影响到DBMS 的性能。
  • ORDBMS在原来关系数据库的基础上，增加了一些新的特性。
  • RDBMS 是关系数据库管理系统，是建立实体之间的联系，最后得到的是关系表。
  • OODBMS 面向对象数据库管理系统，将所有实体都看成对象，并将这些对象类进行封装，对象之间的通信通过消息 OODBMS 对象关系数据库在实质上还是关系数据库

ORDBMS 术语

  • 在我们开始学习 PostgreSQL 数据库前，让我们先了解下 ORDBMS 的一些术语：
    • 数据库: 数据库是一些关联表的集合。
    • 数据表: 表是数据的矩阵。在一个数据库中的表看起来像一个简单的电子表格。
    • 列: 一列(数据元素) 包含了相同的数据, 例如邮政编码的数据。
    • 行：一行（=元组，或记录）是一组相关的数据，例如一条用户订阅的数据。
    • 冗余：存储两倍数据，冗余降低了性能，但提高了数据的安全性。
    • 主键：主键是唯一的。一个数据表中只能包含一个主键。你可以使用主键来查询数据。
    • 外键：外键用于关联两个表。
    • 复合键：复合键（组合键）将多个列作为一个索引键，一般用于复合索引。
    • 索引：使用索引可快速访问数据库表中的特定信息。索引是对数据库表中一列或多列的值进行排序的一种结构。类似于书籍的目录。
    • 参照完整性: 参照的完整性要求关系中不允许引用不存在的实体。与实体完整性是关系模型必须满足的完整性约束条件，目的是保证数+ 据的一致性。

PostgreSQL 特征

  • 函数：通过函数，可以在数据库服务器端执行指令程序。
  • 索引：用户可以自定义索引方法，或使用内置的 B 树，哈希表与 GiST 索引。
  • 触发器：触发器是由SQL语句查询所触发的事件。如：一个INSERT语句可能触发一个检查数据完整性的触发器。触发器通常由INSERT或UPDATE语句触发。 多版本并发控制：PostgreSQL使用多版本并发控制（MVCC，Multiversion concurrency control）系统进行并发控制，该系统向每个用户提供了一个数据库的”快照”，用户在事务内所作的每个修改，对于其他的用户都不可见，直到该事务成功提交。
  • 规则：规则（RULE）允许一个查询能被重写，通常用来实现对视图（VIEW）的操作，如插入（INSERT）、更新（UPDATE）、删除（DELETE）。
  • 数据类型：包括文本、任意精度的数值数组、JSON 数据、枚举类型、XML 数据等。
  • 全文检索：通过 Tsearch2 或 OpenFTS，8.3版本中内嵌 Tsearch2。
  • NoSQL：JSON，JSONB，XML，HStore 原生支持，至 NoSQL 数据库的外部数据包装器。
  • 数据仓库：能平滑迁移至同属 PostgreSQL 生态的 GreenPlum，DeepGreen，HAWK 等，使用 FDW 进行 ETL。

Linux 上安装 PostgreSQL (Ubuntu 安装 PostgreSQL)

  • Ubuntu 可以使用 apt-get 安装 PostgreSQL：

    1
    2
    sudo apt-get update
    sudo apt-get install postgresql postgresql-client

  • 安装完毕后，系统会创建一个数据库超级用户 postgres，密码为空。

    • sudo -i -u postgres

  • 这时使用以下命令进入 postgres，输出以下信息，说明安装成功：

    1
    2
    3
    4
    5
    ~$ psql
    psql (9.5.17)
    Type "help" for help.

    postgres=#

  • 输入以下命令退出 PostgreSQL 提示符：

    • \q

  • PostgreSQL 安装完成后默认是已经启动的，但是也可以通过下面的方式来手动启动服务。

    1
    2
    3
    sudo /etc/init.d/postgresql start   # 开启
    sudo /etc/init.d/postgresql stop    # 关闭
    sudo /etc/init.d/postgresql restart # 重启

Posted on Edited on In

简介

  • 机器人学相关理论基础

机械臂行业

  • 机械手臂是一种固定或移动式的机器，其构造通常由一系列互相链接或相对滑动的零件组成，工作方式主要通过沿着X，Y，Z轴上做线性运动以到达目标位置，从而实现物体的抓取或者移动，能够实现自动控制，可重复程序设计，多自由度(轴)

  • 国际企业

    • ABB
    • 发那科
    • 安川电机
    • ADEPT Technology
    • UR

  • 本土企业

    • 新松机器人
    • 埃斯顿
    • 大族激光
    • 越疆科技
    • 埃夫特
    • 汇川技术
    • 新时达

  • 机械臂的应用领域

    • 工业制造
    • 医疗保健
    • 军事
    • 物流仓储
    • 农业
    • 家庭服务

机器人领域 推荐著作

  • 机器人学导论

    • 综合性入门教材，内容涉及正/逆运动学、静力变换、操作臂动力学、轨迹规划、机械设计、控制等。

  • 机器人学，机器视觉与控制-MATLAB算法基础

    • Peter Corke编写的机器人入门教材，书中的实例很多，都使用机器人工具箱编写，配合Matlab可以边看边试！

  • Principles of Robot Motion：Theory, Algorithms, and Implementations

    • 主要讲解基于传感器的规划、概率规划、定位与映射、动态与非完整系统的运动规划。

  • Planning Algorithms

    • 这本书提出了多种不同规划算法的统一处理。运动规划、离散规划、不确定性规划、基于传感器的规划、可见性、决策理论规划、博弈论、信息空间、强化学习、非线性系统、轨迹规划、非完整规划和动态规划

  • Rigid Body Dynamics Algorithms

    • 最佳刚体动力学算法的综合集合，Github上也拥有很多不错的资源。

  • 机器人操作的数学导论

    • 从数学的角度系统地介绍了机器人操作的运动学、动力学、控制及运动规划内容，主要包含旋量理论、指数积建模，机器人动力学等内容

  • 机器人学-建模、规划与控制

    • 深入讲解机器人的建模、轨迹运动、运动控制等内容。基础入门强烈推荐！

  • 机器人技术手册

    • 日本机器人学会出品，一本超全的百科全书类型。特别适合作为工具查漏翻查

  • Springer Handbook of Roboticsd

    • 机器人研究人员、该领域新人和相关学科学者的权威参考

机械臂中的正解FK和逆解IK是什么

在机械臂控制中，正解（Forward Kinematics，FK）和逆解（Inverse Kinematics，IK）是两个重要的概念。

  1. 正解（Forward Kinematics，FK）：
    正解是指根据机械臂的关节角度或长度等参数，推导出末端执行器（例如机械臂末端的位置和姿态）的运动学表达式或方程式的过程。FK描述了输入到机械臂关节的位置、速度或加速度等参数，从而计算出末端执行器的位置和姿态。FK用于确定机械臂末端在给定关节参数下的运动轨迹，通常是一个从关节空间到工作空间的映射。

  2. 逆解（Inverse Kinematics，IK）：
    逆解是指根据已知末端执行器的位置和姿态，确定使机械臂末端达到这个位置和姿态所需的关节角度或长度等参数的过程。IK可以被用来解决给定目标位置和姿态时，计算出机械臂关节参数的问题。在实际应用中，逆解通常是更为复杂和困难的问题，因为一个末端位置和姿态通常对应着多个可能的解。

FK和IK在机器人学和机械臂控制中扮演着重要的角色，FK用于描述机械臂的运动学特性，而IK则允许机械臂在空间中实现特定的末端目标。这些概念对于控制和规划机械臂的运动非常重要，特别是在自动化生产线、工业机器人和虚拟仿真等领域中。

机器人 目标坐标系 末端坐标系 基底坐标系

在机器人学中，通常使用三种坐标系来描述机器人的运动和位置：目标坐标系、末端坐标系和基底坐标系。

  1. 目标坐标系（Target Coordinate System）： 这是机器人执行任务时所需达到的目标位置的坐标系。在目标坐标系中定义了机器人需要完成的具体任务的坐标和方向信息。机器人的动作控制通常是根据目标坐标系来规划和执行的。

  2. 末端坐标系（End-Effector Coordinate System）： 这是机器人末端执行器（通常是机械手、夹爪等）的坐标系。末端坐标系描述了末端执行器的位置和方向，是机器人进行具体操作时的参考坐标系。机器人执行任务时，末端坐标系的变化反映了机器人末端执行器的运动和姿态。

  3. 基底坐标系（Base Coordinate System）： 这是机器人整体结构的参考坐标系。基底坐标系通常与机器人的固定部分（例如机器人底座）相关联，用于描述机器人整体的位置和方向。基底坐标系的选择对机器人运动的规划和控制起着重要的作用。

这三个坐标系之间的关系和转换是机器人控制和规划中的关键问题。通过准确描述这些坐标系之间的变换关系，可以更有效地控制机器人的运动，使其在工作空间内完成任务。

机器人 世界坐标系 基底坐标系

在机器人学中，世界坐标系和基底坐标系是两个相关但不同的概念。

  1. 世界坐标系（World Coordinate System）： 世界坐标系是一个全局坐标系，通常被用作机器人工作空间中的参考坐标系。它是一个固定的坐标系，用于描述整个机器人系统在其运动范围内的位置和方向。世界坐标系的选择通常取决于特定应用的需要，以提供方便的参考点。

  2. 基底坐标系（Base Coordinate System）： 基底坐标系是机器人本身固有的坐标系，通常与机器人底座或底部连接的结构相关联。这是机器人运动的起点和参考点。机器人的关节和执行器运动通常是相对于基底坐标系进行描述的。基底坐标系的选择对机器人的运动规划和控制非常重要。

在一般情况下，机器人控制和规划涉及到将基底坐标系中的运动转换到世界坐标系中，或者反之。这涉及到位姿变换，包括平移和旋转。

例如，如果你想让机器人执行一个在世界坐标系中指定的任务，你可能需要将任务的坐标转换为机器人基底坐标系中的坐标，以便机器人能够正确执行任务。反之，如果你想获取机器人当前的位置和方向，你可能需要将机器人基底坐标系中的信息转换为世界坐标系中的信息，以便提供一个全局的参考框架。

这种坐标系的变换在机器人学和自动化控制中是非常常见的，因为它允许机器人在不同坐标系中进行运动和交互。

机器人 轨迹规划是什么

在机器人学和自动化领域，轨迹规划是指通过一系列的动作，规划出机器人从一个起始点到达目标点或完成任务的路径。这个路径通常被称为轨迹，而规划这样的轨迹则需要考虑一系列的因素，如避障、动力学、工作空间限制等。

轨迹规划的目标是使机器人能够在给定的环境中，以安全、有效、并且可能最优的方式达到目标。以下是轨迹规划的一些关键概念：

  1. 起始点和目标点： 轨迹规划通常始于机器人当前的位置（起始点）并以某个目标位置为终点。

  2. 运动约束： 考虑到机器人的动力学、速度、加速度等方面的限制，确保规划出的轨迹是机器人能够执行的。

  3. 避障： 考虑到环境中的障碍物，确保规划的轨迹不会碰撞到障碍物。这可能涉及到路径规划算法，例如 A*、Dijkstra、RRT（Rapidly Exploring Random Trees）等。

  4. 工作空间： 考虑到机器人工作的空间限制，确保规划的轨迹在工作空间内。

  5. 优化： 有时候，除了满足上述条件，还希望规划出的轨迹是最优的，例如最短路径或最短时间。

  6. 实时性： 在某些情况下，轨迹规划需要在实时性要求下执行，以适应不断变化的环境。

轨迹规划可以应用于各种类型的机器人，包括工业机械臂、移动机器人、飞行器等。不同类型的机器人可能需要不同的轨迹规划方法，因为它们的动力学和环境条件可能有很大的差异。

Posted on Edited on In

简介

  • 机器人学的仿真工具

机器人仿真 robodk是什么

RoboDK（Robot Development Kit）是一种用于机器人仿真和离线编程的软件平台。它允许用户在虚拟环境中模拟和测试工业机器人的运动，以及为这些机器人生成程序代码。RoboDK支持多种不同类型的工业机器人，包括ABB、Fanuc、KUKA、Universal Robots等。

主要功能包括：

  1. 机器人仿真： 用户可以在RoboDK中创建一个虚拟环境，包括工作台、机器人和其他相关设备。通过仿真，用户可以预先测试和优化机器人的运动，避免在实际生产中出现问题。

  2. 离线编程： RoboDK允许用户在虚拟环境中为机器人生成程序代码，然后将这些代码直接应用到实际的机器人系统中。这种离线编程的方法可以减少生产线的停机时间，提高生产效率。

  3. 支持多种机器人品牌： RoboDK具有广泛的机器人品牌支持，使其适用于多种不同类型的工业机器人。用户可以选择并模拟其特定品牌和型号的机器人。

  4. 路径规划和碰撞检测： RoboDK能够进行路径规划和碰撞检测，确保生成的机器人程序在实际操作中是安全和有效的。

总的来说，RoboDK是一个用于机器人系统仿真和离线编程的强大工具，可帮助用户优化他们的制造流程，提高生产效率。

Posted on Edited on In

简介

  • sql编程语言的基本语法

1.3 SQL SELECT语句

  • SELECT 语句用于从数据库中选取数据。结果被存储在一个结果表中，称为结果集。

  • SQL SELECT 语法

    1
    2
    SELECT column1, column2, ...
    FROM table_name;
    • SELECT * FROM table_name;

  • 参数说明：

    • column1, column2, …：要选择的字段名称，可以为多个字段。如果不指定字段名称，则会选择所有字段。
    • table_name：要查询的表名称。

  • 大多数数据库软件系统都允许使用编程函数在结果集中进行导航，比如：Move-To-First-Record、Get-Record-Content、Move-To-Next-Record 等等。

  • 类似这些编程函数不在本教程讲解之列。如需学习通过函数调用访问数据的知识，请访问我们的 ADO 教程 或者 PHP 教程。

1.3 SQL SELECT DISTINCT 语句

  • SELECT DISTINCT 语句用于返回唯一不同的值。

  • 在表中，一个列可能会包含多个重复值，有时您也许希望仅仅列出不同（distinct）的值。DISTINCT 关键词用于返回唯一不同的值。

  • SQL SELECT DISTINCT 语法

    1
    2
    SELECT DISTINCT column1, column2, ...
    FROM table_name;

  • 参数说明：

    • column1, column2, …：要选择的字段名称，可以为多个字段。如果不指定字段名称，则会选择所有字段。
    • table_name：要查询的表名称。

  • SELECT DISTINCT 实例

    • 下面的 SQL 语句仅从 “Websites” 表的 “country” 列中选取唯一不同的值，也就是去掉 “country” 列重复值：
    • SELECT DISTINCT country FROM Websites;

1.3 SQL WHERE 子句

  • WHERE 子句用于过滤记录。

  • WHERE 子句用于提取那些满足指定条件的记录。

  • SQL WHERE 语法

    1
    2
    3
    SELECT column1, column2, ...
    FROM table_name
    WHERE condition;

  • 参数说明：

    • column1, column2, …：要选择的字段名称，可以为多个字段。如果不指定字段名称，则会选择所有字段。
    • table_name：要查询的表名称。

  • WHERE 子句实例

    • 下面的 SQL 语句从 “Websites” 表中选取国家为 “CN” 的所有网站：
    • SELECT * FROM Websites WHERE country='CN';

1.4 SQL AND & OR 运算符

  • AND & OR 运算符用于基于一个以上的条件对记录进行过滤。

  • 如果第一个条件和第二个条件都成立，则 AND 运算符显示一条记录。

  • 如果第一个条件和第二个条件中只要有一个成立，则 OR 运算符显示一条记录。

  • AND 运算符实例

    • 下面的 SQL 语句从 “Websites” 表中选取国家为 “CN” 且alexa排名大于 “50” 的所有网站：
      1
      2
      3
      SELECT * FROM Websites
      WHERE country='CN'
      AND alexa > 50;

  • OR 运算符实例

    • 下面的 SQL 语句从 “Websites” 表中选取国家为 “USA” 或者 “CN” 的所有客户：
      1
      2
      3
      SELECT * FROM Websites
      WHERE country='USA'
      OR country='CN';

  • 结合 AND & OR

    • 您也可以把 AND 和 OR 结合起来（使用圆括号来组成复杂的表达式）。
    • 下面的 SQL 语句从 “Websites” 表中选取 alexa 排名大于 “15” 且国家为 “CN” 或 “USA” 的所有网站：
      1
      2
      3
      SELECT * FROM Websites
      WHERE alexa > 15
      AND (country='CN' OR country='USA');

1.5 SQL ORDER BY 关键字

  • ORDER BY 关键字用于对结果集进行排序。

  • ORDER BY 关键字用于对结果集按照一个列或者多个列进行排序。

  • ORDER BY 关键字默认按照升序对记录进行排序。如果需要按照降序对记录进行排序，您可以使用 DESC 关键字。

  • SQL ORDER BY 语法

    1
    2
    3
    SELECT column1, column2, ...
    FROM table_name
    ORDER BY column1, column2, ... ASC|DESC;

  • 参数解析：

    • column1, column2, …：要排序的字段名称，可以为多个字段。
    • ASC：表示按升序排序。
    • DESC：表示按降序排序。

  • ORDER BY 实例

    • 下面的 SQL 语句从 “Websites” 表中选取所有网站，并按照 “alexa” 列排序：
      1
      2
      SELECT * FROM Websites
      ORDER BY alexa;

  • ORDER BY DESC 实例

    • 下面的 SQL 语句从 “Websites” 表中选取所有网站，并按照 “alexa” 列降序排序：
      1
      2
      SELECT * FROM Websites
      ORDER BY alexa DESC;

  • ORDER BY 多列

    • 下面的 SQL 语句从 “Websites” 表中选取所有网站，并按照 “country” 和 “alexa” 列排序：
      1
      2
      SELECT * FROM Websites
      ORDER BY country,alexa;

1.5 SQL INSERT INTO 语句

  • INSERT INTO 语句用于向表中插入新记录。

  • INSERT INTO 语句可以有两种编写形式。

    • 第一种形式无需指定要插入数据的列名，只需提供被插入的值即可：
      1
      2
      INSERT INTO table_name
      VALUES (value1,value2,value3,...);
    • 第二种形式需要指定列名及被插入的值：
      1
      2
      INSERT INTO table_name (column1,column2,column3,...)
      VALUES (value1,value2,value3,...);

  • 参数说明：

    • table_name：需要插入新记录的表名。
    • column1, column2, …：需要插入的字段名。
    • value1, value2, …：需要插入的字段值。

  • INSERT INTO 实例

    • 假设我们要向 “Websites” 表中插入一个新行。
      1
      2
      INSERT INTO Websites (name, url, alexa, country)
      VALUES ('百度','https://www.baidu.com/','4','CN');
    • 在指定的列插入数据
    • 下面的 SQL 语句将插入一个新行，但是只在 “name”、”url” 和 “country” 列插入数据（id 字段会自动更新）：
      1
      2
      INSERT INTO Websites (name, url, country)
      VALUES ('stackoverflow', 'http://stackoverflow.com/', 'IND');

1.6 SQL UPDATE 语句

  • UPDATE 语句用于更新表中的记录。

  • UPDATE 语句用于更新表中已存在的记录。

  • SQL UPDATE 语法

    1
    2
    3
    UPDATE table_name
    SET column1 = value1, column2 = value2, ...
    WHERE condition;

  • 参数说明：

    • table_name：要修改的表名称。
    • column1, column2, …：要修改的字段名称，可以为多个字段。
    • value1, value2, …：要修改的值，可以为多个值。
    • condition：修改条件，用于指定哪些数据要修改

  • 请注意 SQL UPDATE 语句中的 WHERE 子句！

  • WHERE 子句规定哪条记录或者哪些记录需要更新。如果您省略了 WHERE 子句，所有的记录都将被更新！

  • SQL UPDATE 实例

    • 假设我们要把 “菜鸟教程” 的 alexa 排名更新为 5000，country 改为 USA。
      1
      2
      3
      UPDATE Websites 
      SET alexa='5000', country='USA' 
      WHERE name='菜鸟教程';

1.7 SQL DELETE 语句

  • DELETE 语句用于删除表中的记录。

  • DELETE 语句用于删除表中的行。

  • SQL DELETE 语法

    1
    2
    DELETE FROM table_name
    WHERE condition;

  • 参数说明：

    • table_name：要删除的表名称。
    • condition：删除条件，用于指定哪些数据要删除

  • SQL DELETE 实例

    • 假设我们要从 “Websites” 表中删除网站名为 “Facebook” 且国家为 USA 的网站。
      1
      2
      DELETE FROM Websites
      WHERE name='Facebook' AND country='USA';

  • 删除所有数据

    • 您可以在不删除表的情况下，删除表中所有的行。这意味着表结构、属性、索引将保持不变：
    • DELETE FROM table_name;

sql 常用语句

SQL（Structured Query Language）是一种用于管理关系型数据库的编程语言。下面是一些SQL编程语言中常用的语句：

  1. 数据库操作语句：

    • 创建数据库：CREATE DATABASE database_name;
    • 删除数据库：DROP DATABASE database_name;
    • 切换数据库：USE database_name;

  2. 表操作语句：

    • 创建表：CREATE TABLE table_name (column1 datatype, column2 datatype, ...);
    • 删除表：DROP TABLE table_name;
    • 修改表结构：ALTER TABLE table_name ADD column_name datatype;

  3. 数据操作语句：

    • 插入数据：INSERT INTO table_name (column1, column2, ...) VALUES (value1, value2, ...);
    • 更新数据：UPDATE table_name SET column1 = value1, column2 = value2 WHERE condition;
    • 删除数据：DELETE FROM table_name WHERE condition;
    • 查询数据：SELECT column1, column2, ... FROM table_name WHERE condition;

  4. 数据过滤语句：

    • 条件过滤：使用WHERE子句进行条件筛选，例如：WHERE column_name = value。
    • 范围过滤：使用BETWEEN和IN进行范围筛选，例如：WHERE column_name BETWEEN value1 AND value2。
    • 模糊搜索：使用LIKE进行模糊匹配，例如：WHERE column_name LIKE '%value%'。

  5. 数据排序和限制语句：

    • 排序数据：使用ORDER BY子句对结果进行排序，例如：ORDER BY column_name ASC/DESC。
    • 限制结果：使用LIMIT子句限制结果集的数量，例如：LIMIT n。

  6. 数据聚合和统计语句：

    • 聚合函数：使用聚合函数对数据进行计算，如COUNT、SUM、AVG、MIN、MAX等，例如：SELECT COUNT(*) FROM table_name。
    • 分组数据：使用GROUP BY子句对结果进行分组，例如：GROUP BY column_name。
    • 过滤分组：使用HAVING子句对分组结果进行过滤，例如：HAVING condition。

这些是SQL编程语言中常用的一些语句，可以用于创建和管理数据库、操作数据、查询数据和进行数据分析。具体的语法和用法可能会根据数据库管理系统的不同而有所差异，因此在实际使用时需要参考相应的数据库文档和语法规范。

ORDER 详解

在SQL中，ORDER BY子句用于对查询结果进行排序。它可以按照一个或多个列的值进行升序（ASC）或降序（DESC）排序。以下是ORDER BY子句的详细解释：

基本语法：

1
2
3
SELECT column1, column2, ...
FROM table_name
ORDER BY column1 [ASC|DESC], column2 [ASC|DESC], ...;
  • SELECT：用于指定要查询的列。
  • FROM：用于指定要查询的表名。
  • ORDER BY：用于指定排序规则。
  • column1, column2, …：要按照其值进行排序的列名。
  • ASC：升序排列（默认值）。
  • DESC：降序排列。

示例：
假设有一个名为”employees”的表，包含以下列：id、name和salary。我们将使用该表作为示例来说明ORDER BY的使用：

1
2
3
SELECT id, name, salary
FROM employees
ORDER BY salary DESC;

上述示例将返回按照salary列的值降序排列的结果集。结果集中的记录将按照salary的值从高到低排序。

1
2
3
SELECT id, name, salary
FROM employees
ORDER BY name ASC, salary DESC;

上述示例将返回首先按照name列的值升序排列，如果name相同，则按照salary列的值降序排列的结果集。

需要注意的是，ORDER BY子句的位置应该位于查询语句的最后，以便在执行排序之前获取查询结果。

ORDER BY子句在SQL中非常有用，它使我们能够按照特定的列或多个列对查询结果进行排序，以满足特定的排序需求。

Posted on Edited on In

简介

  • sql语法常用技巧

批量删除

在SQL中，您可以使用DELETE语句来删除数据。要实现批量删除，您可以使用DELETE语句结合适当的条件或子查询来删除符合特定条件的多个记录。以下是一些示例：

  1. 删除符合条件的记录：

    1
    DELETE FROM table_name WHERE condition;

    将table_name替换为要删除记录的表名，condition替换为符合删除条件的条件表达式。

  2. 删除来自另一个查询的记录：

    1
    DELETE FROM table_name WHERE column_name IN (SELECT column_name FROM another_table WHERE condition);

    这将删除从另一个查询结果中选择的记录。将table_name替换为要删除记录的表名，column_name替换为要匹配的列名，another_table替换为另一个查询的表名，condition替换为适当的条件。

  3. 删除所有记录：

    1
    DELETE FROM table_name;

    这将删除指定表中的所有记录。将table_name替换为要删除记录的表名。

请注意，在执行批量删除操作时要谨慎。确保您理解删除操作的影响，并在执行之前备份重要数据。

希望这些示例能帮助您理解如何在SQL中进行批量删除。如有其他问题，请随时提问。

查询某个表单有多少条记录

  • select count(*) from table_name;

mysql 5.7 不用密码也能登录的问题

  • 在ubuntu下载mysql后，用mysql命令就可以直接登录数据库了，这是因为在mysql.user表里有个plugin的字段，root这个用户的值是auth_socket, 需要把它改成mysql_native_password。
  • 具体步骤如下：
    • use mysql;
    • update user set authentication_string=PASSWORD("密码") where user=‘root‘;
    • update user set plugin="mysql_native_password";
    • flush privileges;
    • quit;

SQL 脚本

  • 像编写shell脚本一样，只不过语句换成了SQL语句
  • 编写完成之后，通过mysql -u root -p password 进入到sql命令窗口，执行指令source /sql.sh执行sql脚本

Posted on Edited on In

简介

  • sql的相关理论知识

ODB 详解

ODB（Object-Relational Mapping Database）是一个开源的 C++ 对象关系映射（ORM）工具，用于将 C++ 对象和数据库之间进行映射。它提供了一个简洁的接口和代码生成工具，用于自动生成和维护数据库访问代码。以下是关于 ODB 的一些详解：

  1. 定义数据模型：使用 ODB，你可以使用 C++ 类来定义数据模型。通过在类声明中添加 ODB 注解，你可以指定类和成员变量与数据库表格和字段的映射关系。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    class Person {
        public:
            // ODB 表格声明
            #pragma db table("people")
            class DbTable {
                public:
                    // ODB 字段声明
                    #pragma db id
                    int id;
                    std::string name;
                    int age;
            };

            // 成员变量与表格字段的映射
            int id;
            std::string name;
            int age;

            // ...
    };

  2. 代码生成工具：ODB 提供了一个代码生成工具，用于根据定义的数据模型自动生成数据库访问代码。你可以使用 ODB 编译器来处理类定义文件，并生成与数据库交互的代码。

    1
    odb --std c++14 --database sqlite --generate-query --generate-schema Person.hpp

  3. 查询和持久化：使用 ODB，你可以通过简单的 C++ 语法进行数据库查询和持久化操作。ODB 提供了类型安全的查询接口，支持复杂的查询条件和结果集的处理。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    odb::query<Person> q(odb::query<Person>::name == "John" && odb::query<Person>::age > 18);
    odb::result<Person> result(db.query<Person>(q));

    for (const auto& person : result) {
        // 处理查询结果
    }

    Person person;
    person.name = "Jane";
    person.age = 25;
    db.persist(person);

  4. 事务处理：ODB 支持事务操作，你可以使用 odb::transaction 对象来管理一系列数据库操作的原子性。

    1
    2
    3
    4
    5
    {
        odb::transaction txn(db);
        // 执行一系列的数据库操作
        txn.commit(); // 提交事务
    }

  5. 错误处理：ODB 使用异常来处理错误情况。当出现错误时，它会抛出异常，你可以使用 try-catch 块来捕获并处理这些异常。

    1
    2
    3
    4
    5
    try {
        // 执行数据库操作
    } catch (const odb::exception& e) {
        // 处理异常
    }

ODB 提供了详细的文档和示例代码，以帮助你更深入地了解和使用它。你可以在 ODB 的官方网站上找到更多信息：https://www.codesynthesis.com/products/odb/

需要注意的是，ODB 是一个功能强大且全面的 C++ ORM 工具，它提供了许多高级特性和灵活性。使用 ODB 需要一些学习和配置的成本，但它能够显著简化和加速与数据库的交互。

希望这些详解能够帮助你更好地理解和使用 ODB！如果你有更多问题，请随时提问。

ORMpp 详解

ORMpp 是一个轻量级的 C++ ORM（对象关系映射）库，专为 SQLite3 数据库设计。它提供了简单的接口和注解，用于定义数据模型和数据库关系。以下是关于 ORMpp 的一些详解：

  1. 定义数据模型：使用 ORMpp，你可以使用 C++ 结构体或类来定义数据模型。你可以使用注解来标记成员变量，指定表格名称、字段名称、字段类型和约束等。

    1
    2
    3
    4
    5
    6
    7
    struct Person {
        ORMPP_ENTITY(Person) // 声明实体

        ORMPP_ID(int, id) // 主键字段
        ORMPP_FIELD(std::string, name) // 字符串字段
        ORMPP_FIELD(int, age) // 整数字段
    };

  2. 数据库迁移：ORMpp 支持数据库迁移，可以自动创建和更新数据库表格结构。你可以使用 ormpp::data_migration 对象来定义表格的创建、修改和删除操作。

    1
    2
    3
    4
    ormpp::data_migration dm;
    dm.create_table<Person>(); // 创建表格
    dm.add_column<Person>("address", "TEXT"); // 添加字段
    dm.drop_table<Person>(); // 删除表格

  3. 查询构建器：ORMpp 提供了查询构建器，使得构建 SQL 查询变得更加简单。你可以使用链式方法来构建查询条件、排序和限制。

    1
    2
    3
    4
    ormpp::sql_query query;
    query.select("*").from<Person>().where(ormpp::c(&Person::age) > 18).order_by("name").limit(10);

    auto results = db.query(query);

  4. 事务处理：ORMpp 支持事务操作，你可以使用 ormpp::transaction 对象来管理一系列数据库操作的原子性。

    1
    2
    3
    4
    5
    {
        ormpp::transaction txn(db);
        // 执行一系列的数据库操作
        txn.commit(); // 提交事务
    }

  5. 错误处理：ORMpp 使用异常来处理错误情况。当出现错误时，它会抛出异常，你可以使用 try-catch 块来捕获并处理这些异常。

    1
    2
    3
    4
    5
    try {
        // 执行数据库操作
    } catch (const std::exception& e) {
        // 处理异常
    }

ORMpp 提供了清晰的文档和示例代码，以帮助你更详细地了解和使用它。你可以在 ORMpp 的 GitHub 页面上找到更多信息：https://github.com/qicosmos/ormpp

需要注意的是，ORMpp 是一个轻量级的 C++ ORM 库，它在简化 SQLite3 数据库的使用过程中提供了便捷的接口和功能。但在使用之前，你仍然需要熟悉 SQL 查询语句和 SQLite3 数据库的概念。

希望这些详解能够帮助你更好地理解和使用 ORMpp！如果你有更多问题，请随时提问。

SQLite Modern C++ 详解

SQLite Modern C++ 是一个基于 C++11 的轻量级 SQLite3 封装库，提供了简单而直观的接口，使在 C++ 项目中使用 SQLite3 数据库更加便捷。以下是关于 SQLite Modern C++ 的一些详解：

  1. 面向对象接口：SQLite Modern C++ 提供了面向对象的接口，使用类和方法来操作数据库。你可以创建表格类来表示数据库表格，使用成员变量和方法来操作表格中的数据。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    // 定义表格类
    struct Person {
        int id;
        std::string name;
        int age;
    };

    // 插入数据
    Person person{1, "John Doe", 25};
    db.insert(person);

    // 查询数据
    auto results = db.select<Person>("SELECT * FROM people");
    for (const auto& person : results) {
        // 处理查询结果
    }

  2. 类型安全：SQLite Modern C++ 在运行时执行类型检查，确保查询和绑定的类型正确。这可以避免在 SQL 查询中出现类型不匹配的错误。

  3. 查询构建器：SQLite Modern C++ 提供了查询构建器，允许你以链式方式构建 SQL 查询，而不需要手动拼接 SQL 语句。

    1
    2
    3
    4
    5
    6
    7
    8
    auto query = db
        .select("id", "name")
        .from("people")
        .where("age > ?", 18)
        .order_by("name")
        .limit(10);

    auto results = query.execute();

  4. 事务处理：SQLite Modern C++ 支持事务操作，你可以使用 transaction 对象来管理一系列数据库操作的原子性。

    1
    2
    3
    4
    5
    {
        transaction txn(db);
        // 执行一系列的数据库操作
        txn.commit(); // 提交事务
    }

  5. 错误处理：SQLite Modern C++ 使用异常来处理错误情况。当出现错误时，它会抛出异常，你可以使用 try-catch 块来捕获并处理这些异常。

    1
    2
    3
    4
    5
    try {
        // 执行数据库操作
    } catch (const std::exception& e) {
        // 处理异常
    }

SQLite Modern C++ 提供了清晰的文档和示例代码，以帮助你更详细地了解和使用它。你可以在 SQLite Modern C++ 的 GitHub 页面上找到更多信息：https://github.com/SqliteModernCpp/sqlite_modern_cpp

需要注意的是，SQLite Modern C++ 是一个轻量级的封装库，它在简化 SQLite3 数据库的使用过程中提供了便捷的接口，但在使用之前，你仍然需要熟悉 SQL 查询语句和 SQLite3 数据库的概念。

希望这些详解能够帮助你更好地理解和使用 SQLite Modern C++！如果你有更多问题，请随时提问。

SQLite3 ORM 常用第三方库

在 C++ 中，有几个常用的第三方库可用于提供 SQLite3 ORM（对象关系映射）功能。以下是一些常用的 C++ SQLite3 ORM 第三方库：

  1. **SQLite Modern C++**：SQLite Modern C++ 是一个轻量级的 C++ 封装库，提供了简单而直观的接口，使得在 C++ 项目中使用 SQLite3 数据库更加便捷。它支持对象关系映射和查询构建器，并提供了对数据库的增删改查操作的封装。

    GitHub 地址：https://github.com/SqliteModernCpp/sqlite_modern_cpp

  2. SQLiteCpp：SQLiteCpp 是一个基于 C++11 的 SQLite3 封装库，提供了面向对象的接口，使得在 C++ 项目中使用 SQLite3 更加简单和方便。它支持对象关系映射和事务处理，并提供了简洁的 API 来进行数据库操作。

    GitHub 地址：https://github.com/SRombauts/SQLiteCpp

  3. ORMpp：ORMpp 是一个轻量级的 C++ ORM 库，专为 SQLite3 数据库设计。它提供了简单的接口和注解，用于定义数据模型和数据库关系。ORMpp 支持数据库迁移、查询构建器和事务处理等功能。

    GitHub 地址：https://github.com/iansimon/ormpp

  4. Qt SQL：Qt 是一个功能强大的 C++ 框架，其中的 Qt SQL 模块提供了对各种数据库的访问功能，包括 SQLite3。使用 Qt SQL，你可以通过对象关系映射和查询构建器来操作 SQLite3 数据库。

    官方网站：https://www.qt.io/

这些库都可以帮助你在 C++ 中使用 SQLite3 数据库，并提供了不同程度的 ORM 功能。你可以根据项目需求、库的易用性和适配性来选择最适合的库。

需要注意的是，这些库都是第三方工具，你需要根据你的项目要求和预期的功能选择适合的库，并仔细阅读它们的文档和示例代码以了解如何使用它们。

希望这些信息对你有帮助！如有更多问题，请随时提问。

C++ REST SDK 详解

C++ REST SDK（又称为 Casablanca）是一个功能强大的 C++ 库，用于构建基于 HTTP 的客户端和服务器应用程序。它提供了一组丰富的功能和工具，用于处理网络请求、JSON 解析、异步任务等。以下是关于 C++ REST SDK 的一些详解：

  1. HTTP 客户端：C++ REST SDK 提供了一个强大的 HTTP 客户端库，用于发送和接收 HTTP 请求和响应。你可以通过创建 http_client 对象，指定请求的 URI、方法、头部、消息正文等来发起 HTTP 请求。

    1
    2
    web::http::client::http_client client(U("http://example.com"));
    web::http::http_response response = client.request(web::http::methods::GET).get();

  2. HTTP 服务器：C++ REST SDK 允许你创建基于 HTTP 的服务器应用程序。你可以创建一个 http_listener 对象，并为特定的 URI 和方法注册处理程序来处理传入的请求。

    1
    2
    3
    4
    5
    web::http::experimental::listener::http_listener listener(U("http://localhost:8080"));
    listener.support(web::http::methods::GET, [](web::http::http_request request) {
        // 处理 GET 请求
    });
    listener.open().wait();

  3. 异步任务和并发：C++ REST SDK 使用异步任务模型来处理并发操作。它提供了 pplx::task 类，用于处理异步操作和等待任务完成。

    1
    2
    3
    4
    5
    6
    7
    pplx::task<std::string> task = client.request(web::http::methods::GET).then([](web::http::http_response response) {
        return response.extract_string();
    });

    task.then([](const std::string& content) {
        // 处理异步任务结果
    }).wait();

  4. JSON 解析和序列化：C++ REST SDK 提供了用于解析和序列化 JSON 数据的工具。你可以使用 web::json::value 类来表示和操作 JSON 对象和数组。

    1
    2
    3
    4
    5
    6
    web::json::value json;
    json[U("name")] = web::json::value::string(U("John"));
    json[U("age")] = web::json::value::number(25);

    web::json::value::string_t name = json[U("name")].as_string();
    int age = json[U("age")].as_integer();

  5. 其他功能：C++ REST SDK 还提供了许多其他功能，如支持 HTTPS、网络代理、cookie 管理、身份验证等。

C++ REST SDK 的 GitHub 页面提供了详细的文档和示例代码，以帮助你更深入地了解和使用它：https://github.com/microsoft/cpprestsdk

C++ REST SDK 是一个强大而全面的库，适用于构建基于 HTTP 的客户端和服务器应用程序。它可以帮助你轻松处理网络请求、JSON 数据和异步操作。

希望这些详解能够帮助你更好地理解和使用 C++ REST SDK！如果你有更多问题，请随时提问。

OTL 详解

OTL（OCCI Template Library）是一个用于 C++ 的通用数据库访问库，它提供了高性能和灵活的接口，用于访问多种数据库。以下是关于 OTL 的一些详解：

  1. 支持多种数据库：OTL 支持多种常见的数据库系统，包括 Oracle、Microsoft SQL Server、IBM DB2、MySQL、PostgreSQL 等。你可以使用相同的接口和代码来访问不同类型的数据库，而不需要学习和使用特定数据库的 API。

  2. 面向对象接口：OTL 提供了面向对象的接口，通过类和方法来操作数据库。它使用了现代 C++ 特性，如模板和 RAII（资源获取即初始化），使得代码更加清晰和易于维护。

  3. 连接管理：使用 OTL，你可以通过提供连接字符串来建立和管理与数据库的连接。连接字符串包括数据库类型、主机名、端口号、用户名、密码等信息。

    1
    2
    otl_connect db;
    db.rlogon("username/password@tnsname");

  4. 查询执行：使用 OTL，你可以通过编写 SQL 查询语句来与数据库进行交互。你可以直接执行原始的 SQL 语句，也可以使用绑定变量和查询构建器来构建和执行查询。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    otl_stream stream;
    stream.open(1, "SELECT name, age FROM users WHERE age > :age", db);
    stream << 18;

    while (!stream.eof()) {
        std::string name;
        int age;
        stream >> name >> age;
        
        // 处理查询结果
    }

  5. 事务处理：OTL 支持事务操作，你可以使用事务对象来管理一系列数据库操作的原子性。

    1
    2
    3
    4
    5
    otl_trans transaction(db);

    // 执行一系列的数据库操作

    transaction.commit();

  6. 错误处理：OTL 使用异常来处理错误情况。当出现错误时，它会抛出相应的异常，你可以使用 try-catch 块来捕获并处理这些异常。

    1
    2
    3
    4
    5
    try {
        // 执行数据库操作
    } catch (otl_exception& ex) {
        // 处理异常
    }

  7. 灵活性和可扩展性：OTL 具有灵活和可扩展的架构，你可以通过编写自定义的 OTL 数据库后端适配器来支持其他数据库系统。

OTL 提供了详细的文档和示例代码，以帮助你更深入地了解和使用它。你可以在 OTL 的官方网站上找到更多信息：http://otl.sourceforge.net/

需要注意的是，OTL 是一个相对底层的库，使用它需要对 SQL 查询语句和数据库概念有一定的了解。

希望这些详解能够帮助你更好地理解和使用 OTL！如果你有更多问题，请随时提问。

SOCI 详解

SOCI（The C++ Database Access Library）是一个通用的数据库访问库，它提供了简单和一致的接口，用于在 C++ 中访问多种不同类型的数据库。下面是关于 SOCI 的一些详解：

  1. 支持多种数据库：SOCI 支持多种常见的数据库系统，包括 SQLite、MySQL、PostgreSQL、Oracle、ODBC 等。你可以使用相同的接口和代码来访问不同类型的数据库，而不需要学习和使用特定数据库的 API。

  2. 面向对象接口：SOCI 提供了面向对象的接口，通过类和方法来操作数据库。它使用了现代 C++ 特性，如模板和 RAII（资源获取即初始化），使得代码更加清晰和易于维护。

  3. 连接管理：使用 SOCI，你可以通过提供连接字符串来建立和管理与数据库的连接。连接字符串包括数据库类型、主机名、端口号、用户名、密码等信息。

    1
    soci::session sql("mysql://user:password@localhost/mydatabase");

  4. 查询执行：使用 SOCI，你可以通过编写 SQL 查询语句来与数据库进行交互。你可以直接执行原始的 SQL 语句，也可以使用绑定变量和查询构建器来构建和执行查询。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    soci::rowset<row> rs = (sql.prepare << "SELECT name, age FROM users WHERE age > :age", soci::use(18));

    for (const auto& r : rs) {
        std::string name;
        int age;
        r.get<0>(name);
        r.get<1>(age);
        
        // 处理查询结果
    }

  5. 事务处理：SOCI 支持事务操作，你可以使用事务对象来管理一系列数据库操作的原子性。

    1
    2
    3
    4
    5
    soci::transaction tr(sql);

    // 执行一系列的数据库操作

    tr.commit(); // 提交事务

  6. 错误处理：SOCI 使用异常来处理错误情况。当出现错误时，它会抛出相应的异常，你可以使用 try-catch 块来捕获并处理这些异常。

    1
    2
    3
    4
    5
    try {
        // 执行数据库操作
    } catch (const soci::soci_error& e) {
        // 处理异常
    }

  7. 灵活性和可扩展性：SOCI 具有灵活和可扩展的架构，你可以通过编写自定义后端适配器来支持其他数据库系统。

SOCI 提供了丰富的文档和示例代码，以帮助你更详细地了解和使用它。你可以在 SOCI 的官方网站上找到更多信息：http://soci.sourceforge.net/

需要注意的是，SOCI 是一个相对底层的库，使用它需要对 SQL 查询语句和数据库概念有一定的了解。

希望这些详解能够帮助你更好地理解和使用 SOCI！如果你有更多问题，请随时提问。

sqlitecpp 详解

SQLiteCpp 是一个在 C++ 中使用 SQLite 数据库的轻量级封装库。它提供了简单且直观的面向对象的接口，使得在 C++ 项目中使用 SQLite 数据库更加便捷。

以下是 SQLiteCpp 的一些主要特点和用法的详解：

  1. 面向对象接口：SQLiteCpp 提供了一个面向对象的接口，通过类和方法来操作数据库。它使用了现代 C++ 特性，如 RAII（资源获取即初始化）和异常处理，使得代码更加清晰和易于维护。

  2. 数据库连接：使用 SQLite::Database 类可以创建和管理与 SQLite 数据库的连接。你可以通过指定数据库文件的路径来打开数据库连接，也可以使用内存数据库。

    1
    SQLite::Database db("example.db"); // 打开名为 "example.db" 的数据库文件连接

  3. 查询执行：你可以使用 SQLite::Statement 类执行 SQL 查询语句，并通过绑定参数和读取结果集来与数据库交互。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    SQLite::Statement query(db, "SELECT * FROM users WHERE age > ?");
    query.bind(1, 18);

    while (query.executeStep()) {
        std::string name = query.getColumn(1);
        int age = query.getColumn(2);

        // 处理查询结果
    }

  4. 事务处理：SQLiteCpp 支持事务操作，通过 SQLite::Transaction 类可以实现简单的事务控制，保证一系列的数据库操作的原子性。

    1
    2
    3
    4
    5
    SQLite::Transaction transaction(db);

    // 执行一系列的数据库操作

    transaction.commit(); // 提交事务

  5. 数据库操作：SQLiteCpp 提供了许多便捷的方法来执行数据库操作，包括插入、更新、删除等。

    1
    2
    3
    4
    SQLite::Statement insert(db, "INSERT INTO users (name, age) VALUES (?, ?)");
    insert.bind(1, "John Doe");
    insert.bind(2, 25);
    insert.exec(); // 执行插入操作

  6. 错误处理：SQLiteCpp 在出现错误时会抛出异常，你可以使用 try-catch 块来捕获并处理这些异常。

    1
    2
    3
    4
    5
    try {
        // 执行数据库操作
    } catch (std::exception& e) {
        // 处理异常
    }

SQLiteCpp 提供了丰富的文档和示例代码，以帮助你更详细地了解和使用它。你可以在它的 GitHub 页面上找到更多信息：https://github.com/SRombauts/SQLiteCpp

需要注意的是，尽管 SQLiteCpp 简化了在 C++ 中使用 SQLite 数据库的过程，你仍然需要熟悉 SQL 查询语句和 SQLite 数据库的概念。

希望这些详解能够帮助你更好地理解和使用 SQLiteCpp！如果你有更多问题，请随时提问。

sqlite3 orm 第三方工具 推荐

在 C++ 中，有几个流行的第三方工具可用于提供 SQLite3 ORM（对象关系映射）功能。以下是一些常用的 C++ SQLite3 ORM 第三方库：

  1. SQLiteCpp：SQLiteCpp 是一个轻量级的 C++ 封装库，提供了对 SQLite 数据库的面向对象访问接口。它使用现代 C++ 特性，简化了与 SQLite 数据库的交互，支持查询构建、事务处理等功能。

    GitHub 地址：https://github.com/SRombauts/SQLiteCpp

  2. SOCI：SOCI 是一个通用的数据库访问库，支持多种数据库，包括 SQLite。它提供了面向对象的接口，可以简化数据库操作，包括查询、插入、更新等。

    GitHub 地址：https://github.com/SOCI/soci

  3. OTL：OTL（OCCI Template Library）是一个通用的数据库访问库，也支持 SQLite 数据库。它提供了面向对象的接口，支持事务处理、预编译语句等功能。

    官方网站：http://otl.sourceforge.net/

  4. C++ REST SDK：C++ REST SDK 是一个功能强大的 C++ 库，提供了丰富的功能，包括 HTTP 客户端/服务器、JSON 解析、异步任务等。它也提供了对 SQLite 数据库的支持，可以用作 ORM。

    GitHub 地址：https://github.com/microsoft/cpprestsdk

这些库都可以帮助你在 C++ 中使用 SQLite3 数据库，并提供了不同程度的 ORM 功能。你可以根据项目的需求、库的易用性和适配性来选择最适合的库。

需要注意的是，这些库都是第三方工具，你需要根据你的项目要求和预期的功能选择适合的库，并仔细阅读它们的文档和示例代码以了解如何使用它们。

希望这些推荐对你有所帮助！如有更多问题，请随时提问。

sql语法和mysql 关系

SQL（Structured Query Language）是一种用于管理关系型数据库系统的编程语言。它提供了一套标准化的语法和操作，用于查询、操作和管理数据库中的数据。MySQL是一个开源的关系型数据库管理系统（RDBMS），它支持使用SQL语言进行数据库操作。

SQL语法定义了一组规则和约定，用于编写查询和操作数据库的语句。它包括以下几个主要方面：

  1. 数据定义语言（DDL）：DDL用于定义数据库的结构和模式。它包括创建数据库、创建表、定义表的列和约束等操作。例如，使用DDL语句可以创建一个名为”employees”的表，定义其列和数据类型：

    1
    2
    3
    4
    5
    6
    CREATE TABLE employees (
        id INT PRIMARY KEY,
        name VARCHAR(50),
        age INT,
        salary DECIMAL(10, 2)
    );

  2. 数据操作语言（DML）：DML用于插入、更新和删除数据库中的数据。它包括INSERT、UPDATE和DELETE语句，用于执行相应的操作。例如，使用DML语句可以向”employees”表中插入一条新记录：

    1
    2
    INSERT INTO employees (id, name, age, salary)
    VALUES (1, 'John Doe', 30, 50000);

  3. 数据查询语言（DQL）：DQL用于从数据库中检索数据。它包括SELECT语句，用于查询和过滤数据。例如，使用DQL语句可以查询”employees”表中年龄大于等于25岁的员工：

    1
    SELECT * FROM employees WHERE age >= 25;

  4. 数据控制语言（DCL）：DCL用于控制数据库用户的访问权限和安全性。它包括GRANT和REVOKE语句，用于授予和撤销用户的权限。例如，使用DCL语句可以授予用户”john”对”employees”表的SELECT权限：

    1
    GRANT SELECT ON employees TO john;

MySQL是一个流行的关系型数据库管理系统，它实现了SQL语言标准，并提供了额外的功能和扩展。MySQL支持大多数SQL语法的标准化操作，如DDL、DML、DQL和DCL。通过MySQL，你可以创建和管理数据库，创建表和索引，执行查询和数据操作，以及控制用户的权限。

总而言之，SQL是一种用于管理关系型数据库的标准化语言，而MySQL是一个实现了SQL标准的关系型数据库管理系统。通过使用SQL语法，你可以在MySQL数据库中执行各种操作，包括创建和定义数据库结构、插入、更新和删除数据，以及查询和检索数据。

SQL

  • SQL 是用于访问和处理数据库的标准的计算机语言。
  • 在本教程中，您将学到如何使用 SQL 访问和处理数据系统中的数据，这类数据库包括：MySQL、SQL Server、Access、Oracle、Sybase、DB2 等等。

1.1 SQL 简介

  • SQL (Structured Query Language:结构化查询语言) 是用于管理关系数据库管理系统（RDBMS）。
  • SQL 的范围包括数据插入、查询、更新和删除，数据库模式创建和修改，以及数据访问控制。

1.1.1 SQL 是什么

  • SQL 指结构化查询语言，全称是 Structured Query Language。
  • SQL 让您可以访问和处理数据库，包括数据插入、查询、更新和删除。
  • SQL 在1986年成为 ANSI（American National Standards Institute 美国国家标准化组织）的一项标准，在 1987 年成为国际标准化组织（ISO）标准。

1.1.2 SQL 能做什么

  • SQL 面向数据库执行查询
  • SQL 可从数据库取回数据
  • SQL 可在数据库中插入新的记录
  • SQL 可更新数据库中的数据
  • SQL 可从数据库删除记录
  • SQL 可创建新数据库
  • SQL 可在数据库中创建新表
  • SQL 可在数据库中创建存储过程
  • SQL 可在数据库中创建视图
  • SQL 可以设置表、存储过程和视图的权限

1.1.3 SQL 是一种标准 - 但是…

  • 虽然 SQL 是一门 ANSI（American National Standards Institute 美国国家标准化组织）标准的计算机语言，但是仍然存在着多种不同版本的 SQL 语言。

  • 然而，为了与 ANSI 标准相兼容，它们必须以相似的方式共同地来支持一些主要的命令（比如 SELECT、UPDATE、DELETE、INSERT、WHERE 等等）。

  • 注释：除了 SQL 标准之外，大部分 SQL 数据库程序都拥有它们自己的专有扩展！

1.1.4 RDBMS

  • RDBMS 指关系型数据库管理系统，全称 Relational Database Management System。
  • RDBMS 是 SQL 的基础，同样也是所有现代数据库系统的基础，比如 MS SQL Server、IBM DB2、Oracle、MySQL 以及 Microsoft Access。
  • RDBMS 中的数据存储在被称为表的数据库对象中。
  • 表是相关的数据项的集合，它由列和行组成。

1.2 SQL 语法

1.2.1 数据库表

  • 一个数据库通常包含一个或多个表。每个表有一个名字标识（例如:”Websites”）,表包含带有数据的记录（行）。

1.2.2 SQL 语句

  • SQL 对大小写不敏感：SELECT 与 select 是相同的。

  • 某些数据库系统要求在每条 SQL 语句的末端使用分号。

  • 分号是在数据库系统中分隔每条 SQL 语句的标准方法，这样就可以在对服务器的相同请求中执行一条以上的 SQL 语句。

1.2.3 一些最重要的 SQL 命令

  • SELECT - 从数据库中提取数据
  • UPDATE - 更新数据库中的数据
  • DELETE - 从数据库中删除数据
  • INSERT INTO - 向数据库中插入新数据
  • CREATE DATABASE - 创建新数据库
  • ALTER DATABASE - 修改数据库
  • CREATE TABLE - 创建新表
  • ALTER TABLE - 变更（改变）数据库表
  • DROP TABLE - 删除表
  • CREATE INDEX - 创建索引（搜索键）
  • DROP INDEX - 删除索引

Posted on Edited on In

简介

  • sqlite3 常用技巧

设置唯一列 约束

在 SQLite3 中，可以通过添加 UNIQUE 约束来设置唯一列，确保列中的值在表中是唯一的。这意味着您不能在该列中插入重复的值。

以下是在 SQLite3 中设置唯一列的方法：

1
2
3
4
5
CREATE TABLE table_name (
  column1 data_type UNIQUE,
  column2 data_type,
  ...
);

在上述示例中，column1 被设置为唯一列。如果在 column1 中插入一个已经存在的值，SQLite3 将会抛出一个错误并拒绝插入。

需要注意的是，唯一约束可以应用于单个列，也可以应用于多个列。如果将多个列一起设置为唯一约束，这些列的组合值在表中将是唯一的。

例如，将多个列设置为唯一：

1
2
3
4
5
6
CREATE TABLE table_name (
  column1 data_type,
  column2 data_type,
  ...
  UNIQUE(column1, column2)
);

在上述示例中，column1 和 column2 的组合值将是唯一的。

另外，如果您想在已有的表中添加唯一约束，可以使用 ALTER TABLE 命令。

1
2
ALTER TABLE table_name
ADD CONSTRAINT constraint_name UNIQUE (column1);

请注意，在添加唯一约束之前，您需要确保列中的数据没有重复值，否则会导致添加约束失败。

总的来说，通过添加 UNIQUE 约束，可以在 SQLite3 中设置唯一列，确保表中的特定列的值是唯一的，避免插入重复的数据。

设置主键和自增

在 SQLite3 中，设置主键和自增可以通过以下方式实现：

设置主键：

在 SQLite3 中，主键可以通过在列定义中添加 PRIMARY KEY 约束来设置。

1
2
3
4
5
CREATE TABLE table_name (
  column1 data_type PRIMARY KEY,
  column2 data_type,
  ...
);

在上述示例中，column1 被设置为主键。

设置自增：

在 SQLite3 中，可以使用 INTEGER 数据类型和 AUTOINCREMENT 关键字来设置自增列。自增列在插入数据时会自动递增，确保数据的唯一性。

1
2
3
4
5
6
CREATE TABLE table_name (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  column1 data_type,
  column2 data_type,
  ...
);

在上述示例中，id 列被设置为自增列，并作为主键。需要注意的是，AUTOINCREMENT 关键字只适用于主键列，且如果列设置为自增，插入数据时不需要为该列提供值，数据库会自动为其生成递增的值。

请注意，在 SQLite3 中，如果不显式地指定主键和自增列，SQLite3 会默认为每个表创建一个名为 “rowid” 的隐藏列，它将作为主键并自动递增。因此，如果不特别需要指定主键名称，可以直接使用默认的 “rowid” 列。

总之，以上就是在 SQLite3 中设置主键和自增的方法。根据您的需求，可以选择显式地指定主键和自增列的名称，也可以使用默认的 “rowid” 列来满足自增的需求。

  • 示例：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    algorithm       camera          task            user            warning_record
    sqlite> CREATE TABLE event_subscribers (id INT AUTO_INCREMENT PRIMARY KEY,  name TEXT, address TEXT, appKeyId TEXT, appKeySecret TEXT);
    sqlite> .schema event_subscribers 
    CREATE TABLE event_subscribers (id INT AUTO_INCREMENT PRIMARY KEY,  name TEXT, address TEXT, appKeyId TEXT, appKeySecret TEXT);
    sqlite> insert into event_subscribers (name, address, appKeyId, appKeyScret) values ("aaa", "http://helloworld.cn", "bbb", "ccc");
    Parse error: table event_subscribers has no column named appKeyScret
    sqlite>  insert into event_subscribers (name, address, appKeyId, appKeySecret) values ("aaa", "http://helloworld.cn", "bbb", "ccc");
    sqlite> select * from event_subscribers;
    |aaa|http://helloworld.cn|bbb|ccc
    sqlite> insert into event_subscribers (name, address, appKeyId, appKeySecret) values ("aaa", "http://helloworld.cn", "bbb", "ccc");
    sqlite> select * from event_subscribers;
    |aaa|http://helloworld.cn|bbb|ccc
    |aaa|http://helloworld.cn|bbb|ccc
    sqlite> drop event_subscribers;
    Parse error: near "event_subscribers": syntax error
      drop event_subscribers;
           ^--- error here
    sqlite> drop table event_subscribers;
    sqlite> CREATE TABLE event_subscribers (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, address TEXT, appKeyId TEXT, appKeySecret TEXT);
    sqlite> insert into event_subscribers (name, address, appKeyId, appKeySecret) values ("aaa", "http://helloworld.cn", "bbb", "ccc");
    sqlite> select * from event_subscribers;
    1|aaa|http://helloworld.cn|bbb|ccc
    sqlite> insert into event_subscribers (name, address, appKeyId, appKeySecret) values ("aaa", "http://helloworld.cn", "bbb", "ccc");
    sqlite> select * from event_subscribers;
    1|aaa|http://helloworld.cn|bbb|ccc
    2|aaa|http://helloworld.cn|bbb|ccc
    sqlite>

Posted on Edited on In

简介

Update 语句

  • 简介

    • SQLite 的 UPDATE 查询用于修改表中已有的记录。可以使用带有 WHERE 子句的 UPDATE 查询来更新选定行，否则所有的行都会被更新

  • 语法：

    1
    2
    3
    UPDATE table_name
    SET column1 = value1, column2 = value2...., columnN = valueN
    WHERE [condition];

  • 注 ：

    • 您可以使用 AND 或 OR 运算符来结合 N 个数量的条件。

删除表

  • 简介：

    • SQLite 的 DROP TABLE 语句用来删除表定义及其所有相关数据、索引、触发器、约束和该表的权限规范
    • 使用此命令时要特别注意，因为一旦一个表被删除，表中所有信息也将永远丢失。

  • 语法：

    • DROP TABLE database_name.table_name;

  • 示例：

    • 让我们先确认 COMPANY 表已经存在，然后我们将其从数据库中删除。
    • sqlite>.tables
    • COMPANY test.COMPANY

  • 把它从数据库中删除，如下：

    • sqlite>DROP TABLE COMPANY;

  • 现在，如果尝试 .TABLES 命令，那么将无法找到 COMPANY 表了：

    • sqlite>.tables

命令

  • .help : 显示各种重要的 SQLite 点命令的列表

  • .tables

SQLite是一种轻量级的嵌入式关系型数据库管理系统，具有简单、快速、可靠的特点。以下是一些常用的SQLite命令：

  1. 打开或创建数据库：

    1
    sqlite3 database_name.db

    该命令将打开名为database_name.db的数据库。如果数据库不存在，则会创建一个新的数据库。

  2. 显示数据库中的所有表：

    1
    .tables

    该命令将列出数据库中的所有表。

  3. 显示表结构：

    1
    .schema table_name

    该命令将显示名为table_name的表的结构，包括列名、数据类型和约束等信息。

  4. 执行SQL查询：

    1
    SELECT * FROM table_name;

    该命令将执行一个SELECT查询，并显示table_name表中的所有行。

  5. 插入数据：

    1
    INSERT INTO table_name (column1, column2, ...) VALUES (value1, value2, ...);

    该命令将在table_name表中插入一行数据，指定列和对应的值。

  6. 更新数据：

    1
    UPDATE table_name SET column1 = value1, column2 = value2, ... WHERE condition;

    该命令将更新满足条件WHERE的行，设置指定列的新值。

  7. 删除数据：

    1
    DELETE FROM table_name WHERE condition;

    该命令将从table_name表中删除满足条件WHERE的行。

  8. 创建表：

    1
    2
    3
    4
    5
    CREATE TABLE table_name (
        column1 datatype constraint,
        column2 datatype constraint,
        ...
    );

    该命令将创建一个新的表，指定列名、数据类型和约束等信息。

  9. 删除表：

    1
    DROP TABLE table_name;

    该命令将删除名为table_name的表。

这只是SQLite命令的一小部分，SQLite还提供了许多其他命令和功能，如索引、事务、连接等。您可以参考SQLite官方文档或其他资源来了解更多有关SQLite的命令和功能。

简介

SQLite 是一种嵌入式关系型数据库管理系统 (RDBMS)，它是一个轻量级、高效、自包含的数据库引擎。与传统的客户端-服务器模式的数据库不同，SQLite 是以库的形式嵌入到应用程序中，应用程序可以直接与数据库文件进行交互，而无需独立的数据库服务器。

以下是 SQLite 的一些特点和用途：

  1. 轻量级：SQLite 是一个轻量级的数据库引擎，它的核心库非常小巧，不依赖于外部服务器或配置。这使得 SQLite 在嵌入式系统、移动设备和资源受限的环境中非常适用。

  2. 自包含：SQLite 数据库以单个文件的形式存储，并且包含了完整的数据库结构和数据。这意味着应用程序可以直接操作一个 SQLite 数据库文件，而无需额外的数据库管理系统。

  3. 事务支持：SQLite 支持 ACID（原子性、一致性、隔离性和持久性）事务特性，它可以确保数据库的完整性和一致性。

  4. SQL 兼容：SQLite 支持 SQL 查询语言，可以使用标准的 SQL 语句进行数据库操作，包括数据的查询、插入、更新和删除等。

  5. 广泛应用：由于其轻量级和自包含的特性，SQLite 在各种应用场景中得到广泛应用，包括嵌入式系统、移动应用程序、桌面应用程序、Web 浏览器、数据分析和开发测试等。

在使用 SQLite 时，你可以通过编写 SQL 语句或使用相应的 SQLite API 来创建数据库、定义表结构、插入和查询数据等操作。同时，有许多编程语言和框架提供了对 SQLite 的支持和封装，使得在不同的开发环境中使用 SQLite 更加便捷。

SQLite 是C语言接口的

安装

以下是在 Linux 系统上编译和安装 SQLite 的基本步骤：

  1. 下载源代码：访问 SQLite 的官方网站（https://www.sqlite.org/index.html）并下载最新版本的源代码压缩包。

  2. 解压源代码：使用命令行解压下载的源代码压缩包。例如，可以使用以下命令解压名为 “sqlite.tar.gz” 的压缩包：

    1
    tar xzf sqlite.tar.gz

  3. 进入源代码目录：切换到解压后的源代码目录。例如，如果解压后的目录名为 “sqlite-x.x.x”，可以使用以下命令进入该目录：

    1
    cd sqlite-x.x.x

  4. 配置编译选项：运行以下命令来配置编译选项，其中 prefix 是指定安装目录的路径：

    1
    ./configure --prefix=/path/to/installation

    你可以根据需要指定其他选项，如启用或禁用特定功能。可以运行 ./configure --help 命令查看可用的配置选项。

  5. 编译源代码：运行以下命令来编译源代码：

    1
    make

  6. 安装 SQLite：运行以下命令以将 SQLite 安装到指定的安装目录：

    1
    make install

    注意确保你有足够的权限来将文件安装到指定目录。

  7. 完成安装：安装完成后，你可以在指定的安装目录中找到 SQLite 的可执行文件和相关库文件。

完成上述步骤后，你已成功编译和安装了 SQLite。你可以使用 SQLite 的命令行工具或在你的应用程序中使用 SQLite 库进行数据库操作。记得参考 SQLite 的文档和相关资源，以了解如何使用 SQLite 进行数据库管理和操作。

查看数据库表

要查看 SQLite 数据库中的表，你可以使用 SQLite 提供的命令行工具 sqlite3 或编写一个简单的 C++ 程序来执行查询。

使用命令行工具 sqlite3，按照以下步骤进行操作：

  1. 打开终端或命令提示符。

  2. 运行以下命令来连接到 SQLite 数据库文件：

    1
    sqlite3 your_database.db

    将 your_database.db 替换为实际的数据库文件名。

  3. 连接成功后，你将进入 SQLite 的命令行界面。运行以下命令来查看数据库中的表：

    1
    .tables

    这将显示数据库中所有的表的列表。

  4. 若要查看特定表的详细结构，可以使用以下命令：

    1
    .schema table_name

    将 table_name 替换为实际的表名。

使用 C++ 程序来查看数据库表，你可以编写类似以下的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <iostream>
#include <sqlite3.h>

int main() {
    sqlite3* db;
    int rc;

    // 打开数据库连接
    rc = sqlite3_open("your_database.db", &db);
    if (rc) {
        std::cerr << "无法打开数据库: " << sqlite3_errmsg(db) << std::endl;
        return rc;
    }

    // 查询表名
    const char* selectTablesSQL = "SELECT name FROM sqlite_master WHERE type='table';";
    rc = sqlite3_exec(db, selectTablesSQL, [](void* data, int argc, char** argv, char** /*azColName*/) -> int {
        for (int i = 0; i < argc; i++) {
            std::cout << argv[i] << " ";
        }
        std::cout << std::endl;
        return 0;
    }, nullptr, nullptr);
    if (rc != SQLITE_OK) {
        std::cerr << "无法查询表: " << sqlite3_errmsg(db) << std::endl;
        return rc;
    }

    // 关闭数据库连接
    sqlite3_close(db);

    return 0;
}

将代码中的 "your_database.db" 替换为实际的数据库文件名，然后编译和运行程序。它将连接到数据库文件并执行查询来获取表名列表，并将其打印到控制台。

Posted on Edited on In

简介

  • sqlite3使用过程中遇到的理论，问题和解决方法

database is locked

“sqlite3 database is locked” 是指在使用 SQLite 数据库时遇到了并发访问的冲突。当一个进程或连接正在执行写操作（例如插入、更新或删除数据）时，SQLite 会将数据库文件锁定，以防止其他进程同时对同一数据库执行写操作，以维护数据的完整性。

如果在一个进程中对数据库文件执行写操作时，另一个进程或连接也试图执行写操作，就会发生冲突，此时就会出现 “sqlite3 database is locked” 错误。

这种情况通常出现在以下几种情况下：

  1. 并发访问：多个进程或连接同时尝试对同一个数据库执行写操作。
  2. 错误的连接管理：在一个连接中开始了一个事务（transaction），但没有正确地提交或回滚该事务，导致其他连接无法访问数据库。
  3. 长时间的写操作：一个进程或连接执行了一个耗时很长的写操作，阻塞了其他进程或连接的写操作。

解决 “sqlite3 database is locked” 错误的方法包括：

  1. 确保正确管理连接和事务：在使用完数据库连接后，应该及时关闭连接或者正确地提交或回滚事务，以释放数据库锁定。
  2. 等待并重试：如果出现锁定错误，可以通过等待一段时间后再次尝试执行操作，以便等待其他进程或连接释放数据库锁定。
  3. 优化并发访问：如果并发访问是一个常见问题，可以考虑优化数据库结构、调整访问模式或使用锁定机制来避免冲突。

需要注意的是，”sqlite3 database is locked” 错误通常是由并发访问引起的，因此在设计和编写应用程序时，应该考虑到数据库并发访问的情况，并采取适当的措施来避免冲突。

Posted on Edited on In

简介

  • sqlite3 理论知识相关笔记

SQLite 简介

  • SQLite是一个软件库，实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。SQLite是一个增长最快的数据库引擎，这是在普及方面的增长，与它的尺寸大小无关。SQLite 源代码不受版权限制

  • 什么是SQLite

    • SQLite是一个进程内的库，实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。它是一个零配置的数据库，这意味着与其他数据库不一样，您不需要在系统中配置。
    • 就像其他数据库，SQLite 引擎不是一个独立的进程，可以按应用程序需求进行静态或动态连接。SQLite 直接访问其存储文件

  • 为什么要用SQLite

    • 不需要一个单独的服务器进程或操作的系统（无服务器的）。
    • SQLite 不需要配置，这意味着不需要安装或管理。
    • 一个完整的 SQLite 数据库是存储在一个单一的跨平台的磁盘文件。
    • SQLite 是非常小的，是轻量级的，完全配置时小于 400KiB，省略可选功能配置时小于250KiB。
    • SQLite 是自给自足的，这意味着不需要任何外部的依赖。
    • SQLite 事务是完全兼容 ACID 的，允许从多个进程或线程安全访问。
    • SQLite 支持 SQL92（SQL2）标准的大多数查询语言的功能。
    • SQLite 使用 ANSI-C 编写的，并提供了简单和易于使用的 API。
    • SQLite 可在 UNIX（Linux, Mac OS-X, Android, iOS）和 Windows（Win32, WinCE, WinRT）中运行。

  • SQLite 命令

    • 与关系数据库进行交互的标准 SQLite 命令类似于 SQL。命令包括 CREATE、SELECT、INSERT、UPDATE、DELETE 和 DROP。这些命令基于它们的操作性质可分为以下几种：
    • DDL - 数据定义语言
      • CREATE : 创建一个新的表，一个表的视图，或者数据库中的其他对象。
      • ALERT : 修改数据库中的某个已有的数据库对象，比如一个表。
      • DROP : 删除整个表，或者表的视图，或者数据库中的其他对象。
    • DML - 数据操作语言
      • INSERT : 创建一条记录
      • UPDATE : 修改记录
      • DELETE : 删除记录
    • DQL - 数据查询语言
      • SELECT : 从一个或多个表中检索某些记录

SQLite 命令

  • 本章将向您讲解 SQLite 编程人员所使用的简单却有用的命令。这些命令被称为 SQLite 的点命令，这些命令的不同之处在于它们不以分号 ; 结束。
  • 如需获取可用的点命令的清单，可以在任何时候输入 “.help”。例如：
    • sqlite>.help
  • .backup ?DB? FILE
    • 备份 DB 数据库（默认是 “main”）到 FILE 文件。
  • .bail ON|
    • OFF
    • 发生错误后停止。默认为 OFF。
  • .databases
    • 列出数据库的名称及其所依附的文件。
  • .dump ?TABLE?
    • 以 SQL 文本格式转储数据库。如果指定了 TABLE 表，则只转储匹配 LIKE 模式的 TABLE 表。
  • .echo ON|OFF
    • 开启或关闭 echo 命令。
  • .exit
    • 退出 SQLite 提示符。
  • .explain ON|OFF
    • 开启或关闭适合于 EXPLAIN 的输出模式。如果没有带参数，则为 EXPLAIN on，即开启 EXPLAIN。
  • .header(s) ON|OFF
    • 开启或关闭头部显示。
  • .help
    • 显示消息。
  • .import FILE TABLE
    • 导入来自 FILE 文件的数据到 TABLE 表中。
  • .indices ?TABLE?
    • 显示所有索引的名称。如果指定了 TABLE 表，则只显示匹配 LIKE 模式的 TABLE 表的索引。
  • .load FILE ?ENTRY?
    • 加载一个扩展库。
  • .log FILE|off
    • 开启或关闭日志。FILE 文件可以是 stderr（标准错误）/stdout（标准输出）。
  • .mode MODE
    • 设置输出模式，MODE 可以是下列之一：
      • csv 逗号分隔的值
      • column 左对齐的列
      • html HTML 的 代码
      • insert TABLE 表的 SQL 插入（insert）语句
      • line 每行一个值
      • list 由 .separator 字符串分隔的值
      • tabs 由 Tab 分隔的值
      • tcl TCL 列表元素
      • .nullvalue STRING
        • 在 NULL 值的地方输出 STRING 字符串。
      • .output FILENAME
        • 发送输出到 FILENAME 文件。
      • .output stdout
        • 发送输出到屏幕。
      • .print STRING…
        • 逐字地输出 STRING 字符串。
      • .prompt MAIN CONTINUE
        • 替换标准提示符。
      • .quit
        • 退出 SQLite 提示符。
      • .read FILENAME
        • 执行 FILENAME 文件中的 SQL。
      • .schema ?TABLE?
        • 显示 CREATE 语句。如果指定了 TABLE 表，则只显示匹配 LIKE 模式的 TABLE 表。
      • .separator STRING
        • 改变输出模式和 .import 所使用的分隔符。
      • .show
        • 显示各种设置的当前值。
      • .stats ON|OFF
        • 开启或关闭统计。
      • .tables ?PATTERN?
        • 列出匹配 LIKE 模式的表的名称。
      • .timeout MS
        • 尝试打开锁定的表 MS 毫秒。
      • .width NUM NUM
        • 为 “column” 模式设置列宽度。
      • .timer ON|OFF
        • 开启或关闭 CPU 定时器。

        • SQLite 语法

        • SQLite 是遵循一套独特的称为语法的规则和准则。

        • 大小写敏感性

          • 有个重要的点值得注意，SQLite 是不区分大小写的，但也有一些命令是大小写敏感的，比如 GLOB 和 glob 在 SQLite 的语句中有不同的含义。

        • 注释

          • SQLite 注释是附加的注释，可以在 SQLite 代码中添加注释以增加其可读性，他们可以出现在任何空白处，包括在表达式内和其他 SQL 语句的中间，但它们不能嵌套。
          • SQL 注释以两个连续的 “-“ 字符（ASCII 0x2d）开始，并扩展至下一个换行符（ASCII 0x0a）或直到输入结束，以先到者为准。
          • 您也可以使用 C 风格的注释，以 “/“ 开始，并扩展至下一个 “/“ 字符对或直到输入结束，以先到者为准。SQLite的注释可以跨越多行。
          • sqlite>.help – 这是一个简单的注释

        • SQLite 语句

          • 所有的 SQLite 语句可以以任何关键字开始，如 SELECT、INSERT、UPDATE、DELETE、ALTER、DROP 等，所有的语句以分号 ; 结束。

        SQLite 数据类型

        • SQLite 数据类型是一个用来指定任何对象的数据类型的属性。SQLite 中的每一列，每个变量和表达式都有相关的数据类型。

        • 您可以在创建表的同时使用这些数据类型。SQLite 使用一个更普遍的动态类型系统。在 SQLite 中，值的数据类型与值本身是相关的，而不是与它的容器相关。

        • SQLite存储类

          • 每个存储在 SQLite 数据库中的值都具有以下存储类之一：
          • NULL : 值是一个 NULL 值。
          • INTEGER : 值是一个带符号的整数，根据值的大小存储在 1、2、3、4、6 或 8 字节中。
          • REAL : 值是一个浮点值，存储为 8 字节的 IEEE 浮点数字。
          • TEXT : 值是一个文本字符串，使用数据库编码（UTF-8、UTF-16BE 或 UTF-16LE）存储。
          • BLOB : 值是一个 blob 数据，完全根据它的输入存储。

        • Date与Time数据类型

          • SQLite 没有一个单独的用于存储日期和/或时间的存储类，但 SQLite 能够把日期和时间存储为 TEXT、REAL 或 INTEGER 值。
          • TEXT : 格式为 “YYYY-MM-DD HH:MM:SS.SSS” 的日期。
          • REAL : 从公元前 4714 年 11 月 24 日格林尼治时间的正午开始算起的天数。
          • INTEGER : 从 1970-01-01 00:00:00 UTC 算起的秒数。
          • 您可以以任何上述格式来存储日期和时间，并且可以使用内置的日期和时间函数来自由转换不同格式。

        SQLite 创建数据库

        • SQLite 的 sqlite3 命令被用来创建新的 SQLite 数据库。您不需要任何特殊的权限即可创建一个数据。

        • 语法

          • sqlite3 命令的基本语法如下：
            • $ sqlite3 DatabaseName.db
          • 通常情况下，数据库名称在 RDBMS 内应该是唯一的。
          • 另外我们也可以使用 .open 来建立新的数据库文件：
            • sqlite>.open test.db
          • 上面的命令创建了数据库文件 test.db，位于 sqlite3 命令同一目录下。
          • 打开已存在数据库也是用 .open 命令，以上命令如果 test.db 存在则直接会打开，不存在就创建它。

        • .dump 命令

          • 您可以在命令提示符中使用 SQLite .dump 点命令来导出完整的数据库在一个文本文件中，如下所示：
            • $sqlite3 testDB.db .dump > testDB.sql
          • 上面的命令将转换整个 testDB.db 数据库的内容到 SQLite 的语句中，并将其转储到 ASCII 文本文件 testDB.sql 中。您可以通过简单的方式从生成的 testDB.sql 恢复，如下所示：
            • $sqlite3 testDB.db < testDB.sql
          • 此时的数据库是空的，一旦数据库中有表和数据，您可以尝试上述两个程序。

        SQLite 附加数据库

        • 假设这样一种情况，当在同一时间有多个数据库可用，您想使用其中的任何一个。SQLite 的 ATTACH DATABASE 语句是用来选择一个特定的数据库，使用该命令后，所有的 SQLite 语句将在附加的数据库下执行。

        • 语法

          • SQLite 的 ATTACH DATABASE 语句的基本语法如下：
            • ATTACH DATABASE file_name AS database_name;
          • 如果数据库尚未被创建，上面的命令将创建一个数据库，如果数据库已存在，则把数据库文件名称与逻辑数据库 ‘Alias-Name’ 绑定在一起。
          • 打开的数据库和使用 ATTACH附加进来的数据库的必须位于同一文件夹下。

        • 实例

          • 如果想附加一个现有的数据库 testDB.db，则 ATTACH DATABASE 语句将如下所示：
            • sqlite> ATTACH DATABASE 'testDB.db' as 'TEST';
          • 使用 SQLite .database 命令来显示附加的数据库。
        1
        2
        3
        4
        5
        sqlite> .database
        seq  name             file
        ---  ---------------  ----------------------
        0    main             /home/sqlite/testDB.db
        2    test             /home/sqlite/testDB.db

    • 数据库名称 main 和 temp 被保留用于主数据库和存储临时表及其他临时数据对象的数据库。这两个数据库名称可用于每个数据库连接，且不应该被用于附加，否则将得到一个警告消息，如下所示

      1
      2
      3
      4
      sqlite>  ATTACH DATABASE 'testDB.db' as 'TEMP';
      Error: database TEMP is already in use
      sqlite>  ATTACH DATABASE 'testDB.db' as 'main';
      Error: database main is already in use；

    SQLite 分离数据库

    • SQLite 的 DETACH DATABASE 语句是用来把命名数据库从一个数据库连接分离和游离出来，连接是之前使用 ATTACH 语句附加的。如果同一个数据库文件已经被附加上多个别名，DETACH 命令将只断开给定名称的连接，而其余的仍然有效。您无法分离 main 或 temp 数据库。

    • 如果数据库是在内存中或者是临时数据库，则该数据库将被摧毁，且内容将会丢失。

    • 语法

      • SQLite 的 DETACH DATABASE ‘Alias-Name’ 语句的基本语法如下：
        • DETACH DATABASE 'Alias-Name';
      • 在这里，’Alias-Name’ 与您之前使用 ATTACH 语句附加数据库时所用到的别名相同。

    SQLite 创建表

    • SQLite 的 CREATE TABLE 语句用于在任何给定的数据库创建一个新表。创建基本表，涉及到命名表、定义列及每一列的数据类型。

    • 语法

      • CREATE TABLE 语句的基本语法如下：
        1
        2
        3
        4
        5
        6
        7
        CREATE TABLE database_name.table_name(
           column1 datatype  PRIMARY KEY(one or more columns),
           column2 datatype,
           column3 datatype,
           .....
           columnN datatype,
        );
      • CREATE TABLE 是告诉数据库系统创建一个新表的关键字。CREATE TABLE 语句后跟着表的唯一的名称或标识。您也可以选择指定带有 table_name 的 database_name。

    • 实例

      • 下面是一个实例，它创建了一个 COMPANY 表，ID 作为主键，NOT NULL 的约束表示在表中创建纪录时这些字段不能为 NULL：
        1
        2
        3
        4
        5
        6
        7
        sqlite> CREATE TABLE COMPANY(
           ID INT PRIMARY KEY     NOT NULL,
           NAME           TEXT    NOT NULL,
           AGE            INT     NOT NULL,
           ADDRESS        CHAR(50),
           SALARY         REAL
        );
      • 让我们再创建一个表，我们将在随后章节的练习中使用：
        1
        2
        3
        4
        5
        sqlite> CREATE TABLE DEPARTMENT(
           ID INT PRIMARY KEY      NOT NULL,
           DEPT           CHAR(50) NOT NULL,
           EMP_ID         INT      NOT NULL
        );
      • 您可以使用 SQLIte 命令中的 .tables 命令来验证表是否已成功创建，该命令用于列出附加数据库中的所有表。
        1
        2
        sqlite>.tables
        COMPANY     DEPARTMENT
      • 您可以使用 SQLite .schema 命令得到表的完整信息，如下所示：
        1
        2
        3
        4
        5
        6
        7
        8
        sqlite>.schema COMPANY
        CREATE TABLE COMPANY(
           ID INT PRIMARY KEY     NOT NULL,
           NAME           TEXT    NOT NULL,
           AGE            INT     NOT NULL,
           ADDRESS        CHAR(50),
           SALARY         REAL
        );

    SQLite 删除表

    • SQLite 的 DROP TABLE 语句用来删除表定义及其所有相关数据、索引、触发器、约束和该表的权限规范。

    • 使用此命令时要特别注意，因为一旦一个表被删除，表中所有信息也将永远丢失。

    • 语法

      • DROP TABLE 语句的基本语法如下。您可以选择指定带有表名的数据库名称，如下所示
        • DROP TABLE database_name.table_name;

    SQLite Insert 语句

    • SQLite 的 INSERT INTO 语句用于向数据库的某个表中添加新的数据行。

    • 语法

      • INSERT INTO 语句有两种基本语法，如下所示：
        1
        2
        INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)]  
        VALUES (value1, value2, value3,...valueN);
      • 在这里，column1, column2,…columnN 是要插入数据的表中的列的名称。
      • 如果要为表中的所有列添加值，您也可以不需要在 SQLite 查询中指定列名称。但要确保值的顺序与列在表中的顺序一致。SQLite 的 INSERT INTO 语法如下：
        1
        INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

    • 使用一个表来填充另一个表

      • 您可以通过在一个有一组字段的表上使用 select 语句，填充数据到另一个表中。下面是语法：
        1
        2
        3
        4
        INSERT INTO first_table_name [(column1, column2, ... columnN)] 
           SELECT column1, column2, ...columnN 
           FROM second_table_name
           [WHERE condition];

    SQLite Select 语句

    • SQLite 的 SELECT 语句用于从 SQLite 数据库表中获取数据，以结果表的形式返回数据。这些结果表也被称为结果集。

    • 语法

      • SQLite 的 SELECT 语句的基本语法如下：
        • SELECT column1, column2, columnN FROM table_name;
      • 在这里，column1, column2…是表的字段，他们的值即是您要获取的。如果您想获取所有可用的字段，那么可以使用下面的语法：
        • SELECT * FROM table_name;

    SQLite 运算符

    • SQLite 运算符是什么？

      • 运算符是一个保留字或字符，主要用于 SQLite 语句的 WHERE 子句中执行操作，如比较和算术运算。
      • 运算符用于指定 SQLite 语句中的条件，并在语句中连接多个条件。
        • 算术运算符
        • 比较运算符
        • 逻辑运算符
        • 位运算符

    • SQLite 算术运算符

      • 假设变量 a=10，变量 b=20，则：
      • + : 加法 : 把运算符两边的值相加 a + b 将得到 30
      • - : 减法 : 左操作数减去右操作数 a - b 将得到 -10
      • * : 乘法 : 把运算符两边的值相乘 a * b 将得到 200
      • / : 除法 : 左操作数除以右操作数 b / a 将得到 2
      • % : 取模 : 左操作数除以右操作数后得到的余数 b % a 将得到 0

    • SQLite 比较运算符

      • 假设变量 a=10，变量 b=20，则：
      • == 检查两个操作数的值是否相等，如果相等则条件为真。 (a == b) 不为真。
      • = 检查两个操作数的值是否相等，如果相等则条件为真。 (a = b) 不为真。
      • != 检查两个操作数的值是否相等，如果不相等则条件为真。 (a != b) 为真。
      • <> 检查两个操作数的值是否相等，如果不相等则条件为真。 (a <> b) 为真。
      • > 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 (a > b) 不为真。
      • < 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 (a < b) 为真。
      • >= 检查左操作数的值是否大于等于右操作数的值，如果是则条件为真。 (a >= b) 不为真。
      • <= 检查左操作数的值是否小于等于右操作数的值，如果是则条件为真。 (a <= b) 为真。
      • !< 检查左操作数的值是否不小于右操作数的值，如果是则条件为真。 (a !< b) 为假。
      • !> 检查左操作数的值是否不大于右操作数的值，如果是则条件为真。 (a !> b) 为真。

    • SQLite 逻辑运算符

      • 下面是 SQLite 中所有的逻辑运算符列表。
      • AND AND : 运算符允许在一个 SQL 语句的 WHERE 子句中的多个条件的存在。
      • BETWEEN : BETWEEN 运算符用于在给定最小值和最大值范围内的一系列值中搜索值。
      • EXISTS : EXISTS 运算符用于在满足一定条件的指定表中搜索行的存在。
      • IN : IN 运算符用于把某个值与一系列指定列表的值进行比较。
      • NOT IN : IN 运算符的对立面，用于把某个值与不在一系列指定列表的值进行比较。
      • LIKE : LIKE 运算符用于把某个值与使用通配符运算符的相似值进行比较。
      • GLOB : GLOB 运算符用于把某个值与使用通配符运算符的相似值进行比较。GLOB 与 LIKE 不同之处在于，它是大小写敏感的。
      • NOT : NOT 运算符是所用的逻辑运算符的对立面。比如 NOT EXISTS、NOT BETWEEN、NOT IN，等等。它是否定运算符。
      • OR : OR 运算符用于结合一个 SQL 语句的 WHERE 子句中的多个条件。
      • IS NULL : NULL 运算符用于把某个值与 NULL 值进行比较。
      • IS : IS 运算符与 = 相似。
      • IS NOT : IS NOT 运算符与 != 相似。
      • || : 连接两个不同的字符串，得到一个新的字符串。
      • UNIQUE : UNIQUE 运算符搜索指定表中的每一行，确保唯一性（无重复）。

    • SQLite 位运算符

      • 下表中列出了 SQLite 语言支持的位运算符。假设变量 A=60，变量 B=13，则：
      • & : 如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。 (A & B) 将得到 12，即为 0000 1100
      • | : 如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。 (A | B) 将得到 61，即为 0011 1101
      • ~ : 二进制补码运算符是一元运算符，具有”翻转”位效应，即0变成1，1变成0。 (~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
      • << : 二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 A << 2 将得到 240，即为 1111 0000
      • >> : 二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 A >> 2 将得到 15，即为 0000 1111

    SQLite 表达式

    • 表达式是一个或多个值、运算符和计算值的SQL函数的组合。

    • SQL 表达式与公式类似，都写在查询语言中。您还可以使用特定的数据集来查询数据库。

    • 语法

      • 假设 SELECT 语句的基本语法如下：
        1
        2
        3
        SELECT column1, column2, columnN 
        FROM table_name 
        WHERE [CONDITION | EXPRESSION];

    • SQLite - 布尔表达式

      • SQLite 的布尔表达式在匹配单个值的基础上获取数据。语法如下：
        1
        2
        3
        SELECT column1, column2, columnN 
        FROM table_name 
        WHERE SINGLE VALUE MATCHING EXPRESSION;

    • SQLite - 数值表达式

      • 这些表达式用来执行查询中的任何数学运算。语法如下：
        1
        2
        SELECT numerical_expression as  OPERATION_NAME
        [FROM table_name WHERE CONDITION] ;
      • 在这里，numerical_expression 用于数学表达式或任何公式。下面的实例演示了 SQLite 数值表达式的用法：
        1
        2
        sqlite> SELECT (15 + 6) AS ADDITION
        ADDITION = 21
      • 有几个内置的函数，比如 avg()、sum()、count()，等等，执行被称为对一个表或一个特定的表列的汇总数据计算。
        1
        2
        sqlite> SELECT COUNT(*) AS "RECORDS" FROM COMPANY; 
        RECORDS = 7

    • SQLite - 日期表达式

      • 日期表达式返回当前系统日期和时间值，这些表达式将被用于各种数据操作。
        1
        2
        sqlite>  SELECT CURRENT_TIMESTAMP;
        CURRENT_TIMESTAMP = 2013-03-17 10:43:35

    SQLite Where 子句

    • SQLite的 WHERE 子句用于指定从一个表或多个表中获取数据的条件。

    • 如果满足给定的条件，即为真（true）时，则从表中返回特定的值。您可以使用 WHERE 子句来过滤记录，只获取需要的记录。

    • WHERE 子句不仅可用在 SELECT 语句中，它也可用在 UPDATE、DELETE 语句中，等等，这些我们将在随后的章节中学习到。

    • 语法：

      • SQLite 的带有 WHERE 子句的 SELECT 语句的基本语法如下：
        1
        2
        3
        SELECT column1, column2, columnN 
        FROM table_name
        WHERE [condition]
      • 您还可以使用比较或逻辑运算符指定条件，比如 >、<、=、LIKE、NOT，等等

    • 下面的 SELECT 语句列出了 NAME 以 ‘Ki’ 开始的所有记录，’Ki’ 之后的字符不做限制

      1
      2
      3
      4
      sqlite> SELECT * FROM COMPANY WHERE NAME LIKE 'Ki%';
      ID          NAME        AGE         ADDRESS     SALARY
      ----------  ----------  ----------  ----------  ----------
      6           Kim         22          South-Hall  45000.0

    • 下面的 SELECT 语句列出了 NAME 以 ‘Ki’ 开始的所有记录，’Ki’ 之后的字符不做限制：

      1
      2
      3
      4
      sqlite> SELECT * FROM COMPANY WHERE NAME GLOB 'Ki*';
      ID          NAME        AGE         ADDRESS     SALARY
      ----------  ----------  ----------  ----------  ----------
      6           Kim         22          South-Hall  45000.0

    • 下面的 SELECT 语句列出了 AGE 的值为 25 或 27 的所有记录：

      1
      2
      3
      4
      5
      6
      sqlite> SELECT * FROM COMPANY WHERE AGE IN ( 25, 27 );
      ID          NAME        AGE         ADDRESS     SALARY
      ----------  ----------  ----------  ----------  ----------
      2           Allen       25          Texas       15000.0
      4           Mark        25          Rich-Mond   65000.0
      5           David       27          Texas       85000.0

    • 下面的 SELECT 语句列出了 AGE 的值既不是 25 也不是 27 的所有记录：

      1
      2
      3
      4
      5
      6
      7
      sqlite> SELECT * FROM COMPANY WHERE AGE NOT IN ( 25, 27 );
      ID          NAME        AGE         ADDRESS     SALARY
      ----------  ----------  ----------  ----------  ----------
      1           Paul        32          California  20000.0
      3           Teddy       23          Norway      20000.0
      6           Kim         22          South-Hall  45000.0
      7           James       24          Houston     10000.0

    • 下面的 SELECT 语句列出了 AGE 的值在 25 与 27 之间的所有记录：

      1
      2
      3
      4
      5
      6
      sqlite> SELECT * FROM COMPANY WHERE AGE BETWEEN 25 AND 27;
      ID          NAME        AGE         ADDRESS     SALARY
      ----------  ----------  ----------  ----------  ----------
      2           Allen       25          Texas       15000.0
      4           Mark        25          Rich-Mond   65000.0
      5           David       27          Texas       85000.0

    • 下面的 SELECT 语句使用 SQL 子查询，子查询查找 SALARY > 65000 的带有 AGE 字段的所有记录，后边的 WHERE 子句与 EXISTS 运算符一起使用，列出了外查询中的 AGE 存在于子查询返回的结果中的所有记录：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      sqlite> SELECT AGE FROM COMPANY 
              WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);
      AGE
      ----------
      32
      25
      23
      25
      27
      22
      24

    • 下面的 SELECT 语句使用 SQL 子查询，子查询查找 SALARY > 65000 的带有 AGE 字段的所有记录，后边的 WHERE 子句与 > 运算符一起使用，列出了外查询中的 AGE 大于子查询返回的结果中的年龄的所有记录：

      1
      2
      3
      4
      5
      sqlite> SELECT * FROM COMPANY 
              WHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY > 65000);
      ID          NAME        AGE         ADDRESS     SALARY
      ----------  ----------  ----------  ----------  ----------
      1           Paul        32          California  20000.0

    SQLite AND/OR 运算符

    • SQLite 的 AND 和 OR 运算符用于编译多个条件来缩小在 SQLite 语句中所选的数据。这两个运算符被称为连接运算符。

    • 这些运算符为同一个 SQLite 语句中不同的运算符之间的多个比较提供了可能。

    • AND 运算符

      • AND 运算符允许在一个 SQL 语句的 WHERE 子句中的多个条件的存在。使用 AND 运算符时，只有当所有条件都为真（true）时，整个条件为真（true）。
      • 例如，只有当 condition1 和 condition2 都为真（true）时，[condition1] AND [condition2] 为真（true）。

    • 语法

      • 带有 WHERE 子句的 AND 运算符的基本语法如下：
        1
        2
        3
        SELECT column1, column2, columnN 
        FROM table_name
        WHERE [condition1] AND [condition2]...AND [conditionN];
      • 您可以使用 AND 运算符来结合 N 个数量的条件。SQLite 语句需要执行的动作是，无论是事务或查询，所有由 AND 分隔的条件都必须为真（TRUE）。

    • OR 运算符

      • OR 运算符也用于结合一个 SQL 语句的 WHERE 子句中的多个条件。使用 OR 运算符时，只要当条件中任何一个为真（true）时，整个条件为真（true）。
      • 例如，只要当 condition1 或 condition2 有一个为真（true）时，[condition1] OR [condition2] 为真（true）。

    • 语法

      • 带有 WHERE 子句的 OR 运算符的基本语法如下：
        1
        2
        3
        SELECT column1, column2, columnN 
        FROM table_name
        WHERE [condition1] OR [condition2]...OR [conditionN]
      • 您可以使用 OR 运算符来结合 N 个数量的条件。SQLite 语句需要执行的动作是，无论是事务或查询，只要任何一个由 OR 分隔的条件为真（TRUE）即可。

    SQLite Update 语句

    • SQLite 的 UPDATE 查询用于修改表中已有的记录。可以使用带有 WHERE 子句的 UPDATE 查询来更新选定行，否则所有的行都会被更新。

    • 语法

      • 带有 WHERE 子句的 UPDATE 查询的基本语法如下：
        1
        2
        3
        UPDATE table_name
        SET column1 = value1, column2 = value2...., columnN = valueN
        WHERE [condition];
      • 您可以使用 AND 或 OR 运算符来结合 N 个数量的条件。

    • 如果您想修改 COMPANY 表中 ADDRESS 和 SALARY 列的所有值，则不需要使用 WHERE 子句，UPDATE 查询如下：

      • sqlite> UPDATE COMPANY SET ADDRESS = 'Texas', SALARY = 20000.00;

    SQLite Delete 语句

    • SQLite 的 DELETE 查询用于删除表中已有的记录。可以使用带有 WHERE 子句的 DELETE 查询来删除选定行，否则所有的记录都会被删除。

    • 语法

      • 带有 WHERE 子句的 DELETE 查询的基本语法如下：
        1
        2
        DELETE FROM table_name
        WHERE [condition];
      • 您可以使用 AND 或 OR 运算符来结合 N 个数量的条件。

    SQLite Like 子句

    • SQLite 的 LIKE 运算符是用来匹配通配符指定模式的文本值。如果搜索表达式与模式表达式匹配，LIKE 运算符将返回真（true），也就是 1。这里有两个通配符与 LIKE 运算符一起使用：

      • 百分号 （%）
      • 下划线 （_）

    • 百分号（%）代表零个、一个或多个数字或字符。下划线（_）代表一个单一的数字或字符。这些符号可以被组合使用。

    • 语法

      • % 和 _ 的基本语法如下：
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        SELECT column_list 
        FROM table_name
        WHERE column LIKE 'XXXX%'

        or 

        SELECT column_list 
        FROM table_name
        WHERE column LIKE '%XXXX%'

        or

        SELECT column_list 
        FROM table_name
        WHERE column LIKE 'XXXX_'

        or

        SELECT column_list 
        FROM table_name
        WHERE column LIKE '_XXXX'

        or

        SELECT column_list 
        FROM table_name
        WHERE column LIKE '_XXXX_'

    • 您可以使用 AND 或 OR 运算符来结合 N 个数量的条件。在这里，XXXX 可以是任何数字或字符串值。

    • 实例

      • 下面一些实例演示了 带有 ‘%’ 和 ‘_’ 运算符的 LIKE 子句不同的地方：
      • WHERE SALARY LIKE '200%' 查找以 200 开头的任意值
      • WHERE SALARY LIKE '%200%' 查找任意位置包含 200 的任意值
      • WHERE SALARY LIKE '_00%' 查找第二位和第三位为 00 的任意值
      • WHERE SALARY LIKE '2_%_%' 查找以 2 开头，且长度至少为 3 个字符的任意值
      • WHERE SALARY LIKE '%2' 查找以 2 结尾的任意值
      • WHERE SALARY LIKE '_2%3' 查找第二位为 2，且以 3 结尾的任意值
      • WHERE SALARY LIKE '2___3' 查找长度为 5 位数，且以 2 开头以 3 结尾的任意值

    • 下面是一个实例，它显示 COMPANY 表中 AGE 以 2 开头的所有记录：

      • sqlite> SELECT * FROM COMPANY WHERE AGE LIKE '2%';

    • 下面是一个实例，它显示 COMPANY 表中 ADDRESS 文本里包含一个连字符（-）的所有记录：

      • sqlite> SELECT * FROM COMPANY WHERE ADDRESS LIKE '%-%';

    SQLite Glob 子句

    • SQLite 的 GLOB 运算符是用来匹配通配符指定模式的文本值。如果搜索表达式与模式表达式匹配，GLOB 运算符将返回真（true），也就是 1。与 LIKE 运算符不同的是，GLOB 是大小写敏感的，对于下面的通配符，它遵循 UNIX 的语法。

      • * ：匹配零个、一个或多个数字或字符。
      • ? ：代表一个单一的数字或字符。
      • [...] ：匹配方括号内指定的字符之一。例如，[abc] 匹配 “a”、”b” 或 “c” 中的任何一个字符。
      • [^...] ：匹配不在方括号内指定的字符之一。例如，[^abc] 匹配不是 “a”、”b” 或 “c” 中的任何一个字符的字符。

    • 以上这些符号可以被组合使用

    • 语法

        • 和 ? 的基本语法如下：
          1
          2
          3
          4
          5
          6
          7
          8
          9
          10
          11
          12
          13
          14
          15
          16
          17
          18
          19
          20
          21
          22
          23
          24
          25
          26
          27
          28
          SELECT FROM table_name
          WHERE column GLOB 'XXXX*'

          or 

          SELECT FROM table_name
          WHERE column GLOB '*XXXX*'

          or

          SELECT FROM table_name
          WHERE column GLOB 'XXXX?'

          or

          SELECT FROM table_name
          WHERE column GLOB '?XXXX'

          or

          SELECT FROM table_name
          WHERE column GLOB '?XXXX?'

          or

          SELECT FROM table_name
          WHERE column GLOB '????'

    • 您可以使用 AND 或 OR 运算符来结合 N 个数量的条件。在这里，XXXX 可以是任何数字或字符串值。

    • 实例

      • 下面一些实例演示了 带有 ‘*’ 和 ‘?’ 运算符的 GLOB 子句不同的地方：
        • WHERE SALARY GLOB '200*' 查找以 200 开头的任意值
        • WHERE SALARY GLOB '*200*' 查找任意位置包含 200 的任意值
        • WHERE SALARY GLOB '?00*' 查找第二位和第三位为 00 的任意值
        • WHERE SALARY GLOB '2??' 查找以 2 开头，且长度为 3 个字符的任意值，例如，它可能匹配 “200”、”2A1”、”2B2” 等值。
        • WHERE SALARY GLOB '*2' 查找以 2 结尾的任意值
        • WHERE SALARY GLOB '?2*3' 查找第二位为 2，且以 3 结尾的任意值
        • WHERE SALARY GLOB '2???3' 查找长度为 5 位数，且以 2 开头以 3 结尾的任意值

    • [...] 通配符

      • [...] 表达式用于匹配方括号内指定的字符集中的任何一个字符。

    • 实例 1：匹配以 “A” 或 “B” 开头的产品名称。

      • SELECT * FROM products WHERE product_name LIKE '[AB]%';

    • 这将匹配以 “A” 或 “B” 开头的产品名称。

    • 实例 2：匹配以 “1”、”2” 或 “3” 开头的电话号码。

      • SELECT * FROM customers WHERE phone_number LIKE '[123]%';

    • 这将匹配以 “1”、”2” 或 “3” 开头的电话号码。

    • [^...] 通配符

      • [^...] 表达式用于匹配不在方括号内指定的字符集中的任何字符。

    • 实例 1：匹配不以 “X” 或 “Y” 开头的产品代码。

      • SELECT * FROM products WHERE product_code LIKE '[^XY]%';

    • 这将匹配不以 “X” 或 “Y” 开头的产品

    • 实例 2：匹配不包含数字字符的用户名。

      • SELECT * FROM users WHERE username LIKE '[^0-9]%';

    • 这将匹配不以数字字符开头的用户名。

    SQLite Limit 子句

    • SQLite 的 LIMIT 子句用于限制由 SELECT 语句返回的数据数量。

    • 语法

      • 带有 LIMIT 子句的 SELECT 语句的基本语法如下：
        1
        2
        3
        SELECT column1, column2, columnN 
        FROM table_name
        LIMIT [no of rows]
      • 下面是 LIMIT 子句与 OFFSET 子句一起使用时的语法：
        1
        2
        3
        SELECT column1, column2, columnN 
        FROM table_name
        LIMIT [no of rows] OFFSET [row num]
      • SQLite 引擎将返回从下一行开始直到给定的 OFFSET 为止的所有行，如下面的最后一个实例所示

    • 但是，在某些情况下，可能需要从一个特定的偏移开始提取记录。下面是一个实例，从第三位开始提取 3 个记录：

      • sqlite> SELECT * FROM COMPANY LIMIT 3 OFFSET 2;

    SQLite Order By

    • SQLite 的 ORDER BY 子句是用来基于一个或多个列按升序或降序顺序排列数据。

    • 语法

      • ORDER BY 子句的基本语法如下：
        1
        2
        3
        4
        SELECT column-list 
        FROM table_name 
        [WHERE condition] 
        [ORDER BY column1, column2, .. columnN] [ASC | DESC];
      • ASC 默认值，从小到大，升序排列
      • DESC 从大到小，降序排列

    • 您可以在 ORDER BY 子句中使用多个列，确保您使用的排序列在列清单中：

      1
      2
      3
      4
      5
      6
      7
      SELECT
         select_list
      FROM
         table
      ORDER BY
          column_1 ASC,
          column_2 DESC;

    • column_1 与 column_2 如果后面不指定排序规则，默认为 ASC 升序，以上语句按 column_1 升序，column_2 降序读取，等价如下语句：

      1
      2
      3
      4
      5
      6
      7
      SELECT
         select_list
      FROM
         table
      ORDER BY
          column_1,
          column_2 DESC;

    • 下面是一个实例，它会将结果按 NAME 和 SALARY 升序排序：

      • sqlite> SELECT * FROM COMPANY ORDER BY NAME, SALARY ASC;

    SQLite Group By

    • SQLite 的 GROUP BY 子句用于与 SELECT 语句一起使用，来对相同的数据进行分组。

    • 在 SELECT 语句中，GROUP BY 子句放在 WHERE 子句之后，放在 ORDER BY 子句之前。

    • 语法

      • 下面给出了 GROUP BY 子句的基本语法。GROUP BY 子句必须放在 WHERE 子句中的条件之后，必须放在 ORDER BY 子句之前。
        1
        2
        3
        4
        5
        SELECT column-list
        FROM table_name
        WHERE [ conditions ]
        GROUP BY column1, column2....columnN
        ORDER BY column1, column2....columnN
      • 您可以在 GROUP BY 子句中使用多个列。确保您使用的分组列在列清单中。

    SQLite Having 子句

    • HAVING 子句允许指定条件来过滤将出现在最终结果中的分组结果。

    • WHERE 子句在所选列上设置条件，而 HAVING 子句则在由 GROUP BY 子句创建的分组上设置条件。

    • 语法

      • 下面是 HAVING 子句在 SELECT 查询中的位置：
        1
        2
        3
        4
        5
        6
        SELECT
        FROM
        WHERE
        GROUP BY
        HAVING
        ORDER BY
      • 在一个查询中，HAVING 子句必须放在 GROUP BY 子句之后，必须放在 ORDER BY 子句之前。下面是包含 HAVING 子句的 SELECT 语句的语法：
        1
        2
        3
        4
        5
        6
        SELECT column1, column2
        FROM table1, table2
        WHERE [ conditions ]
        GROUP BY column1, column2
        HAVING [ conditions ]
        ORDER BY column1, column2

    • 下面是一个实例，它将显示名称计数大于 2 的所有记录：

      • sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) > 2;

    SQLite Distinct 关键字

    • SQLite 的 DISTINCT 关键字与 SELECT 语句一起使用，来消除所有重复的记录，并只获取唯一一次记录。

    • 有可能出现一种情况，在一个表中有多个重复的记录。当提取这样的记录时，DISTINCT 关键字就显得特别有意义，它只获取唯一一次记录，而不是获取重复记录。

    • 语法

      • 用于消除重复记录的 DISTINCT 关键字的基本语法如下：
        1
        2
        3
        SELECT DISTINCT column1, column2,.....columnN 
        FROM table_name
        WHERE [condition]

    • 现在，让我们在上述的 SELECT 查询中使用 DISTINCT 关键字：

      • sqlite> SELECT DISTINCT name FROM COMPANY;

    SQLite 约束

    • 约束是在表的数据列上强制执行的规则。这些是用来限制可以插入到表中的数据类型。这确保了数据库中数据的准确性和可靠性。

    • 约束可以是列级或表级。列级约束仅适用于列，表级约束被应用到整个表。

    • 以下是在 SQLite 中常用的约束

      • NOT NULL 约束：确保某列不能有 NULL 值。
      • DEFAULT 约束：当某列没有指定值时，为该列提供默认值。
      • UNIQUE 约束：确保某列中的所有值是不同的。
      • PRIMARY Key 约束：唯一标识数据库表中的各行/记录。
      • CHECK 约束：CHECK 约束确保某列中的所有值满足一定条件。

    • NOT NULL 约束

      • 默认情况下，列可以保存 NULL 值。如果您不想某列有 NULL 值，那么需要在该列上定义此约束，指定在该列上不允许 NULL 值。
      • NULL 与没有数据是不一样的，它代表着未知的数据。

    • 实例

      • 例如，下面的 SQLite 语句创建一个新的表 COMPANY，并增加了五列，其中 ID、NAME 和 AGE 三列指定不接受 NULL 值：
        1
        2
        3
        4
        5
        6
        7
        CREATE TABLE COMPANY(
           ID INT PRIMARY KEY     NOT NULL,
           NAME           TEXT    NOT NULL,
           AGE            INT     NOT NULL,
           ADDRESS        CHAR(50),
           SALARY         REAL
        );

    • DEFAULT 约束

      • DEFAULT 约束在 INSERT INTO 语句没有提供一个特定的值时，为列提供一个默认值

    • 实例

      • 例如，下面的 SQLite 语句创建一个新的表 COMPANY，并增加了五列。在这里，SALARY 列默认设置为 5000.00。所以当 INSERT INTO 语句没有为该列提供值时，该列将被设置为 5000.00。
        1
        2
        3
        4
        5
        6
        7
        CREATE TABLE COMPANY(
           ID INT PRIMARY KEY     NOT NULL,
           NAME           TEXT    NOT NULL,
           AGE            INT     NOT NULL,
           ADDRESS        CHAR(50),
           SALARY         REAL    DEFAULT 50000.00
        );

    • UNIQUE 约束

      • UNIQUE 约束防止在一个特定的列存在两个记录具有相同的值。在 COMPANY 表中，例如，您可能要防止两个或两个以上的人具有相同的年龄。

    • 实例

      • 例如，下面的 SQLite 语句创建一个新的表 COMPANY，并增加了五列。在这里，AGE 列设置为 UNIQUE，所以不能有两个相同年龄的记录：
        1
        2
        3
        4
        5
        6
        7
        CREATE TABLE COMPANY(
           ID INT PRIMARY KEY     NOT NULL,
           NAME           TEXT    NOT NULL,
           AGE            INT     NOT NULL UNIQUE,
           ADDRESS        CHAR(50),
           SALARY         REAL    DEFAULT 50000.00
        );

    • PRIMARY KEY 约束

      • PRIMARY KEY 约束唯一标识数据库表中的每个记录。在一个表中可以有多个 UNIQUE 列，但只能有一个主键。在设计数据库表时，主键是很重要的。主键是唯一的 ID。
      • 我们使用主键来引用表中的行。可通过把主键设置为其他表的外键，来创建表之间的关系。由于”长期存在编码监督”，在 SQLite 中，主键可以是 NULL，这是与其他数据库不同的地方。
      • 主键是表中的一个字段，唯一标识数据库表中的各行/记录。主键必须包含唯一值。主键列不能有 NULL 值。
      • 一个表只能有一个主键，它可以由一个或多个字段组成。当多个字段作为主键，它们被称为复合键。
      • 如果一个表在任何字段上定义了一个主键，那么在这些字段上不能有两个记录具有相同的值。

    • 实例

      • 已经看到了我们创建以 ID 作为主键的 COMAPNY 表的各种实例：
        1
        2
        3
        4
        5
        6
        7
        CREATE TABLE COMPANY(
           ID INT PRIMARY KEY     NOT NULL,
           NAME           TEXT    NOT NULL,
           AGE            INT     NOT NULL,
           ADDRESS        CHAR(50),
           SALARY         REAL
        );

    • CHECK 约束

      • CHECK 约束启用输入一条记录要检查值的条件。如果条件值为 false，则记录违反了约束，且不能输入到表

    • 实例

      • 例如，下面的 SQLite 创建一个新的表 COMPANY，并增加了五列。在这里，我们为 SALARY 列添加 CHECK，所以工资不能为零
        1
        2
        3
        4
        5
        6
        7
        CREATE TABLE COMPANY3(
           ID INT PRIMARY KEY     NOT NULL,
           NAME           TEXT    NOT NULL,
           AGE            INT     NOT NULL,
           ADDRESS        CHAR(50),
           SALARY         REAL    CHECK(SALARY > 0)
        );

    • 删除约束

      • SQLite 支持 ALTER TABLE 的有限子集。在 SQLite 中，ALTER TABLE 命令允许用户重命名表，或向现有表添加一个新的列。重命名列，删除一列，或从一个表中添加或删除约束都是不可能的。

    SQLite Join

    • SQLite 的 Join 子句用于结合两个或多个数据库中表的记录。JOIN 是一种通过共同值来结合两个表中字段的手段。

    • SQL 定义了三种主要类型的连接：

      • 交叉连接 - CROSS JOIN
      • 内连接 - INNER JOIN
      • 外连接 - OUTER JOIN

    • 交叉连接 - CROSS JOIN

      • 交叉连接（CROSS JOIN）把第一个表的每一行与第二个表的每一行进行匹配。如果两个输入表分别有 x 和 y 行，则结果表有 x*y 行。由于交叉连接（CROSS JOIN）有可能产生非常大的表，使用时必须谨慎，只在适当的时候使用它们。
      • 交叉连接的操作，它们都返回被连接的两个表所有数据行的笛卡尔积，返回到的数据行数等于第一个表中符合查询条件的数据行数乘以第二个表中符合查询条件的数据行数。
      • 下面是交叉连接（CROSS JOIN）的语法：
        • SELECT ... FROM table1 CROSS JOIN table2 ...
      • 基于上面的表，我们可以写一个交叉连接（CROSS JOIN），如下所示：
        • sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;

    • 内连接 - INNER JOIN

      • 内连接（INNER JOIN）根据连接谓词结合两个表（table1 和 table2）的列值来创建一个新的结果表。查询会把 table1 中的每一行与 table2 中的每一行进行比较，找到所有满足连接谓词的行的匹配对。当满足连接谓词时，A 和 B 行的每个匹配对的列值会合并成一个结果行。
      • 内连接（INNER JOIN）是最常见的连接类型，是默认的连接类型。INNER 关键字是可选的。
      • 下面是内连接（INNER JOIN）的语法：
        • SELECT ... FROM table1 [INNER] JOIN table2 ON conditional_expression ...
      • 为了避免冗余，并保持较短的措辞，可以使用 USING 表达式声明内连接（INNER JOIN）条件。这个表达式指定一个或多个列的列表：
        • SELECT ... FROM table1 JOIN table2 USING ( column1 ,... ) ...
      • 自然连接（NATURAL JOIN）类似于 JOIN…USING，只是它会自动测试存在两个表中的每一列的值之间相等值：
        • SELECT ... FROM table1 NATURAL JOIN table2...
      • 基于上面的表，我们可以写一个内连接（INNER JOIN），如下所示：
        1
        2
        sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
                ON COMPANY.ID = DEPARTMENT.EMP_ID;

    • 外连接 - OUTER JOIN

      • 外连接（OUTER JOIN）是内连接（INNER JOIN）的扩展。虽然 SQL 标准定义了三种类型的外连接：LEFT、RIGHT、FULL，但 SQLite 只支持 左外连接（LEFT OUTER JOIN）。
      • 外连接（OUTER JOIN）声明条件的方法与内连接（INNER JOIN）是相同的，使用 ON、USING 或 NATURAL 关键字来表达。最初的结果表以相同的方式进行计算。一旦主连接计算完成，外连接（OUTER JOIN）将从一个或两个表中任何未连接的行合并进来，外连接的列使用 NULL 值，将它们附加到结果表中。
      • 下面是左外连接（LEFT OUTER JOIN）的语法：
        • SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...
      • 为了避免冗余，并保持较短的措辞，可以使用 USING 表达式声明外连接（OUTER JOIN）条件。这个表达式指定一个或多个列的列表：
        • SELECT ... FROM table1 LEFT OUTER JOIN table2 USING ( column1 ,... ) ...
      • 基于上面的表，我们可以写一个外连接（OUTER JOIN），如下所示：
        1
        2
        sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
                ON COMPANY.ID = DEPARTMENT.EMP_ID;

    SQLite Unions 子句

    • SQLite的 UNION 子句/运算符用于合并两个或多个 SELECT 语句的结果，不返回任何重复的行。

    • 为了使用 UNION，每个 SELECT 被选择的列数必须是相同的，相同数目的列表达式，相同的数据类型，并确保它们有相同的顺序，但它们不必具有相同的长度

    • 语法

      • UNION 的基本语法如下：
        1
        2
        3
        4
        5
        6
        7
        8
        9
        SELECT column1 [, column2 ]
        FROM table1 [, table2 ]
        [WHERE condition]

        UNION

        SELECT column1 [, column2 ]
        FROM table1 [, table2 ]
        [WHERE condition]
      • 这里给定的条件根据需要可以是任何表达式。

    • UNION ALL 子句

      • UNION ALL 运算符用于结合两个 SELECT 语句的结果，包括重复行。
      • 适用于 UNION 的规则同样适用于 UNION ALL 运算符。
      • UNION ALL 的基本语法如下：
        1
        2
        3
        4
        5
        6
        7
        8
        9
        SELECT column1 [, column2 ]
        FROM table1 [, table2 ]
        [WHERE condition]

        UNION ALL

        SELECT column1 [, column2 ]
        FROM table1 [, table2 ]
        [WHERE condition]
      • 这里给定的条件根据需要可以是任何表达式。

    SQLite NULL 值

    • SQLite 的 NULL 是用来表示一个缺失值的项。表中的一个 NULL 值是在字段中显示为空白的一个值。

    • 带有 NULL 值的字段是一个不带有值的字段。NULL 值与零值或包含空格的字段是不同的，理解这点是非常重要的。

    • 语法

      • 创建表时使用 NULL 的基本语法如下：
        1
        2
        3
        4
        5
        6
        7
        SQLite> CREATE TABLE COMPANY(
           ID INT PRIMARY KEY     NOT NULL,
           NAME           TEXT    NOT NULL,
           AGE            INT     NOT NULL,
           ADDRESS        CHAR(50),
           SALARY         REAL
        );
      • 在这里，NOT NULL 表示列总是接受给定数据类型的显式值。这里有两个列我们没有使用 NOT NULL，这意味着这两个列可以为 NULL。
      • 带有 NULL 值的字段在记录创建的时候可以保留为空。

    • NULL 值在选择数据时会引起问题，因为当把一个未知的值与另一个值进行比较时，结果总是未知的，且不会包含在最后的结果中。

    • 实例

      • 让我们使用 UPDATE 语句来设置一些允许空值的值为 NULL，如下所示：
        • sqlite> UPDATE COMPANY SET ADDRESS = NULL, SALARY = NULL where ID IN(6,7);
      • 接下来，让我们看看 IS NOT NULL 运算符的用法，它用来列出所有 SALARY 不为 NULL 的记录：
        1
        2
        3
        sqlite> SELECT  ID, NAME, AGE, ADDRESS, SALARY
                FROM COMPANY
                WHERE SALARY IS NOT NULL;

    SQLite 别名

    • 您可以暂时把表或列重命名为另一个名字，这被称为别名。使用表别名是指在一个特定的 SQLite 语句中重命名表。重命名是临时的改变，在数据库中实际的表的名称不会改变。

    • 列别名用来为某个特定的 SQLite 语句重命名表中的列。

    • 语法

      • 表 别名的基本语法如下：
        1
        2
        3
        SELECT column1, column2....
        FROM table_name AS alias_name
        WHERE [condition];
      • 列 别名的基本语法如下：
        1
        2
        3
        SELECT column_name AS alias_name
        FROM table_name
        WHERE [condition];

    SQLite 触发器(Trigger)

    • SQLite 触发器（Trigger）是数据库的回调函数，它会在指定的数据库事件发生时自动执行/调用。以下是关于 SQLite 的触发器（Trigger）的要点：

      • SQLite 的触发器（Trigger）可以指定在特定的数据库表发生 DELETE、INSERT 或 UPDATE 时触发，或在一个或多个指定表的列发生更新时触发。
      • SQLite 只支持 FOR EACH ROW 触发器（Trigger），没有 FOR EACH STATEMENT 触发器（Trigger）。因此，明确指定 FOR EACH ROW 是可选的。
      • WHEN 子句和触发器（Trigger）动作可能访问使用表单 NEW.column-name 和 OLD.column-name 的引用插入、删除或更新的行元素，其中 column-name 是从与触发器关联的表的列的名称。
      • 如果提供 WHEN 子句，则只针对 WHEN 子句为真的指定行执行 SQL 语句。如果没有提供 WHEN 子句，则针对所有行执行 SQL 语句。
      • BEFORE 或 AFTER 关键字决定何时执行触发器动作，决定是在关联行的插入、修改或删除之前或者之后执行触发器动作。
      • 当触发器相关联的表删除时，自动删除触发器（Trigger）。
      • 要修改的表必须存在于同一数据库中，作为触发器被附加的表或视图，且必须只使用 tablename，而不是 database.tablename。
      • 一个特殊的 SQL 函数 RAISE() 可用于触发器程序内抛出异常。

    • 语法

      • 创建 触发器（Trigger） 的基本语法如下：
        1
        2
        3
        4
        5
        CREATE  TRIGGER trigger_name [BEFORE|AFTER] event_name 
        ON table_name
        BEGIN
         -- 触发器逻辑....
        END;
      • 在这里，event_name 可以是在所提到的表 table_name 上的 INSERT、DELETE 和 UPDATE 数据库操作。您可以在表名后选择指定 FOR EACH ROW。
      • 以下是在 UPDATE 操作上在表的一个或多个指定列上创建触发器（Trigger）的语法：
        1
        2
        3
        4
        5
        CREATE  TRIGGER trigger_name [BEFORE|AFTER] UPDATE OF column_name 
        ON table_name
        BEGIN
         -- 触发器逻辑....
        END;

    • 列出触发器（TRIGGERS）

      • 您可以从 sqlite_master 表中列出所有触发器，如下所示：
        1
        2
        sqlite> SELECT name FROM sqlite_master
        WHERE type = 'trigger';

    • 删除触发器（TRIGGERS）

      • 下面是 DROP 命令，可用于删除已有的触发器：
        1
        sqlite> DROP TRIGGER trigger_name;

    SQLite 索引(Index)

    • 索引（Index）是一种特殊的查找表，数据库搜索引擎用来加快数据检索。简单地说，索引是一个指向表中数据的指针。一个数据库中的索引与一本书的索引目录是非常相似的。

    • 拿汉语字典的目录页（索引）打比方，我们可以按拼音、笔画、偏旁部首等排序的目录（索引）快速查找到需要的字。

    • 索引有助于加快 SELECT 查询和 WHERE 子句，但它会减慢使用 UPDATE 和 INSERT 语句时的数据输入。索引可以创建或删除，但不会影响数据。

    • 使用 CREATE INDEX 语句创建索引，它允许命名索引，指定表及要索引的一列或多列，并指示索引是升序排列还是降序排列。

    • 索引也可以是唯一的，与 UNIQUE 约束类似，在列上或列组合上防止重复条目。

    • CREATE INDEX 命令

      • CREATE INDEX 的基本语法如下：
      • CREATE INDEX index_name ON table_name;

    • 单列索引

      • 单列索引是一个只基于表的一个列上创建的索引。基本语法如下：
        1
        2
        CREATE INDEX index_name
        ON table_name (column_name);

    • 唯一索引

      • 使用唯一索引不仅是为了性能，同时也为了数据的完整性。唯一索引不允许任何重复的值插入到表中。基本语法如下：
        1
        2
        CREATE UNIQUE INDEX index_name
        on table_name (column_name);

    • 组合索引

      • 组合索引是基于一个表的两个或多个列上创建的索引。基本语法如下：
        1
        2
        CREATE INDEX index_name
        on table_name (column1, column2);

    • 是否要创建一个单列索引还是组合索引，要考虑到您在作为查询过滤条件的 WHERE 子句中使用非常频繁的列。

    • 如果只使用到一个列，则选择使用单列索引。如果在作为过滤的 WHERE 子句中有两个或多个列经常使用，则选择使用组合索引。

    • 隐式索引

      • 隐式索引是在创建对象时，由数据库服务器自动创建的索引。索引自动创建为主键约束和唯一约束。

    • DROP INDEX 命令

      • 一个索引可以使用 SQLite 的 DROP 命令删除。当删除索引时应特别注意，因为性能可能会下降或提高。
      • 基本语法如下：
        • DROP INDEX index_name;

    • 什么情况下要避免使用索引？

      • 虽然索引的目的在于提高数据库的性能，但这里有几个情况需要避免使用索引。使用索引时，应重新考虑下列准则：
        • 索引不应该使用在较小的表上。
        • 索引不应该使用在有频繁的大批量的更新或插入操作的表上。
        • 索引不应该使用在含有大量的 NULL 值的列上。
        • 索引不应该使用在频繁操作的列上。

    SQLite Indexed By

    • “INDEXED BY index-name” 子句规定必须需要命名的索引来查找前面表中值。

    • 如果索引名 index-name 不存在或不能用于查询，然后 SQLite 语句的准备失败。

    • “NOT INDEXED” 子句规定当访问前面的表（包括由 UNIQUE 和 PRIMARY KEY 约束创建的隐式索引）时，没有使用索引。

    • 然而，即使指定了 “NOT INDEXED”，INTEGER PRIMARY KEY 仍然可以被用于查找条目。

    • 语法

      • 下面是 INDEXED BY 子句的语法，它可以与 DELETE、UPDATE 或 SELECT 语句一起使用：
        1
        2
        3
        4
        SELECT|DELETE|UPDATE column1, column2...
        INDEXED BY (index_name)
        table_name
        WHERE (CONDITION);

    SQLite Alter 命令

    • SQLite 的 ALTER TABLE 命令不通过执行一个完整的转储和数据的重载来修改已有的表。您可以使用 ALTER TABLE 语句重命名表，使用 ALTER TABLE 语句还可以在已有的表中添加额外的列。

    • 在 SQLite 中，除了重命名表和在已有的表中添加列，ALTER TABLE 命令不支持其他操作。

    • 语法

      • 用来重命名已有的表的 ALTER TABLE 的基本语法如下：
        1
        ALTER TABLE database_name.table_name RENAME TO new_table_name;
      • 用来在已有的表中添加一个新的列的 ALTER TABLE 的基本语法如下：
        1
        ALTER TABLE database_name.table_name ADD COLUMN column_def...;

    SQLite Truncate Table

    • 在 SQLite 中，并没有 TRUNCATE TABLE 命令，但可以使用 SQLite 的 DELETE 命令从已有的表中删除全部的数据。

    • 语法

      • DELETE 命令的基本语法如下：
        • sqlite> DELETE FROM table_name;
      • 但这种方法无法将递增数归零。
      • 如果要将递增数归零，可以使用以下方法：
        • sqlite> DELETE FROM sqlite_sequence WHERE name = 'table_name';
      • 当 SQLite 数据库中包含自增列时，会自动建立一个名为 sqlite_sequence 的表。这个表包含两个列：name 和 seq。name 记录自增列所在的表，seq 记录当前序号（下一条记录的编号就是当前序号加 1）。如果想把某个自增列的序号归零，只需要修改 sqlite_sequence 表就可以了。

    SQLite 视图(View)

    • 视图（View）只不过是通过相关的名称存储在数据库中的一个 SQLite 语句。视图（View）实际上是一个以预定义的 SQLite 查询形式存在的表的组合。
    • 视图（View）可以包含一个表的所有行或从一个或多个表选定行。视图（View）可以从一个或多个表创建，这取决于要创建视图的 SQLite 查询。
    • 视图（View）是一种虚表，允许用户实现以下几点：
      • 用户或用户组查找结构数据的方式更自然或直观。
      • 限制数据访问，用户只能看到有限的数据，而不是完整的表。
      • 汇总各种表中的数据，用于生成报告。
    • SQLite 视图是只读的，因此可能无法在视图上执行 DELETE、INSERT 或 UPDATE 语句。但是可以在视图上创建一个触发器，当尝试 DELETE、INSERT 或 UPDATE 视图时触发，需要做的动作在触发器内容中定义。

    SQLite 事务(Transaction)

    • 事务（Transaction）是一个对数据库执行工作单元。事务（Transaction）是以逻辑顺序完成的工作单位或序列，可以是由用户手动操作完成，也可以是由某种数据库程序自动完成。

    • 事务（Transaction）是指一个或多个更改数据库的扩展。例如，如果您正在创建一个记录或者更新一个记录或者从表中删除一个记录，那么您正在该表上执行事务。重要的是要控制事务以确保数据的完整性和处理数据库错误。

    • 实际上，您可以把许多的 SQLite 查询联合成一组，把所有这些放在一起作为事务的一部分进行执行。

    • 事务的属性

      • 事务（Transaction）具有以下四个标准属性，通常根据首字母缩写为 ACID：
        • 原子性（Atomicity）：确保工作单位内的所有操作都成功完成，否则，事务会在出现故障时终止，之前的操作也会回滚到以前的状态。
        • 一致性（Consistency）：确保数据库在成功提交的事务上正确地改变状态。
        • 隔离性（Isolation）：使事务操作相互独立和透明。
        • 持久性（Durability）：确保已提交事务的结果或效果在系统发生故障的情况下仍然存在。

    • 事务控制

      • 使用下面的命令来控制事务：
        • BEGIN TRANSACTION：开始事务处理。
        • COMMIT：保存更改，或者可以使用 END TRANSACTION 命令。
        • ROLLBACK：回滚所做的更改。
      • 事务控制命令只与 DML 命令 INSERT、UPDATE 和 DELETE 一起使用。他们不能在创建表或删除表时使用，因为这些操作在数据库中是自动提交的。

    • BEGIN TRANSACTION 命令

      • 事务（Transaction）可以使用 BEGIN TRANSACTION 命令或简单的 BEGIN 命令来启动。此类事务通常会持续执行下去，直到遇到下一个 COMMIT 或 ROLLBACK 命令。不过在数据库关闭或发生错误时，事务处理也会回滚。以下是启动一个事务的简单语法：
        1
        2
        3
        4
        5
        BEGIN;

        or 

        BEGIN TRANSACTION;

    • COMMIT 命令

      • COMMIT 命令是用于把事务调用的更改保存到数据库中的事务命令。
      • COMMIT 命令把自上次 COMMIT 或 ROLLBACK 命令以来的所有事务保存到数据库。
      • COMMIT 命令的语法如下：
        1
        2
        3
        4
        5
        COMMIT;

        or

        END TRANSACTION;

    • ROLLBACK 命令

      • ROLLBACK 命令是用于撤消尚未保存到数据库的事务的事务命令。
      • ROLLBACK 命令只能用于撤销自上次发出 COMMIT 或 ROLLBACK 命令以来的事务。
      • ROLLBACK 命令的语法如下：
        1
        ROLLBACK;

    SQLite 子查询

    • 子查询或称为内部查询、嵌套查询，指的是在 SQLite 查询中的 WHERE 子句中嵌入查询语句。

    • 一个 SELECT 语句的查询结果能够作为另一个语句的输入值。

    • 子查询可以与 SELECT、INSERT、UPDATE 和 DELETE 语句一起使用，可伴随着使用运算符如 =、<、>、>=、<=、IN、BETWEEN 等。

    • 以下是子查询必须遵循的几个规则：

      • 子查询必须用括号括起来。
      • 子查询在 SELECT 子句中只能有一个列，除非在主查询中有多列，与子查询的所选列进行比较。
      • ORDER BY 不能用在子查询中，虽然主查询可以使用 ORDER BY。可以在子查询中使用 GROUP BY，功能与 ORDER BY 相同。
      • 子查询返回多于一行，只能与多值运算符一起使用，如 IN 运算符。
      • BETWEEN 运算符不能与子查询一起使用，但是，BETWEEN 可在子查询内使用。

    • SELECT 语句中的子查询使用

      • 子查询通常与 SELECT 语句一起使用。基本语法如下：
        1
        2
        3
        4
        5
        6
        SELECT column_name [, column_name ]
        FROM   table1 [, table2 ]
        WHERE  column_name OPERATOR
              (SELECT column_name [, column_name ]
              FROM table1 [, table2 ]
              [WHERE])

    • INSERT 语句中的子查询使用

      • 子查询也可以与 INSERT 语句一起使用。INSERT 语句使用子查询返回的数据插入到另一个表中。在子查询中所选择的数据可以用任何字符、日期或数字函数修改。
      • 基本语法如下：
        1
        2
        3
        4
        INSERT INTO table_name [ (column1 [, column2 ]) ]
                   SELECT [ *|column1 [, column2 ]
                   FROM table1 [, table2 ]
                   [ WHERE VALUE OPERATOR ]

    • UPDATE 语句中的子查询使用

      • 子查询可以与 UPDATE 语句结合使用。当通过 UPDATE 语句使用子查询时，表中单个或多个列被更新
      • 基本语法如下：
        1
        2
        3
        4
        5
        6
        UPDATE table
        SET column_name = new_value
        [ WHERE OPERATOR [ VALUE ]
           (SELECT COLUMN_NAME
           FROM TABLE_NAME)
           [ WHERE) ]

    • DELETE 语句中的子查询使用

      • 子查询可以与 DELETE 语句结合使用，就像上面提到的其他语句一样。
      • 基本语法如下：
        1
        2
        3
        4
        5
        DELETE FROM TABLE_NAME
        [ WHERE OPERATOR [ VALUE ]
           (SELECT COLUMN_NAME
           FROM TABLE_NAME)
           [ WHERE) ]

    SQLite Autoincrement (自动递增)

    • SQLite 的 AUTOINCREMENT 是一个关键字，用于表中的字段值自动递增。我们可以在创建表时在特定的列名称上使用 AUTOINCREMENT 关键字实现该字段值的自动增加。

    • 关键字 AUTOINCREMENT 只能用于整型（INTEGER）字段。

    • 语法

      • AUTOINCREMENT 关键字的基本用法如下：
        1
        2
        3
        4
        5
        6
        7
        CREATE TABLE table_name(
           column1 INTEGER AUTOINCREMENT,
           column2 datatype,
           column3 datatype,
           .....
           columnN datatype,
        );

    • 实例

      • 假设要创建的 COMPANY 表如下所示：
        1
        2
        3
        4
        5
        6
        7
        sqlite> CREATE TABLE COMPANY(
           ID INTEGER PRIMARY KEY   AUTOINCREMENT,
           NAME           TEXT      NOT NULL,
           AGE            INT       NOT NULL,
           ADDRESS        CHAR(50),
           SALARY         REAL
        );

    SQLite Explain (解释)

    • 在 SQLite 语句之前，可以使用 “EXPLAIN” 关键字或 “EXPLAIN QUERY PLAN” 短语，用于描述表的细节。

    • 如果省略了 EXPLAIN 关键字或短语，任何的修改都会引起 SQLite 语句的查询行为，并返回有关 SQLite 语句如何操作的信息。

      • 来自 EXPLAIN 和 EXPLAIN QUERY PLAN 的输出只用于交互式分析和排除故障。
      • 输出格式的细节可能会随着 SQLite 版本的不同而有所变化。
      • 应用程序不应该使用 EXPLAIN 或 EXPLAIN QUERY PLAN，因为其确切的行为是可变的且只有部分会被记录。

    • 语法

      • EXPLAIN 的语法如下：
        • EXPLAIN [SQLite Query]
      • EXPLAIN QUERY PLAN 的语法如下：
        • EXPLAIN QUERY PLAN [SQLite Query]

    SQLite Vacuum

    • VACUUM 命令通过复制主数据库中的内容到一个临时数据库文件，然后清空主数据库，并从副本中重新载入原始的数据库文件。这消除了空闲页，把表中的数据排列为连续的，另外会清理数据库文件结构。
    • 如果表中没有明确的整型主键（INTEGER PRIMARY KEY），VACUUM 命令可能会改变表中条目的行 ID（ROWID）。VACUUM 命令只适用于主数据库，附加的数据库文件是不可能使用 VACUUM 命令。
    • 如果有一个活动的事务，VACUUM 命令就会失败。VACUUM 命令是一个用于内存数据库的任何操作。由于 VACUUM 命令从头开始重新创建数据库文件，所以 VACUUM 也可以用于修改许多数据库特定的配置参数。

    SQLite 日期 & 时间

    • SQLite 支持以下五个日期和时间函数：

    • date(timestring, modifier, modifier, ...) 以 YYYY-MM-DD 格式返回日期。

    • time(timestring, modifier, modifier, ...) 以 HH:MM:SS 格式返回时间。

    • datetime(timestring, modifier, modifier, ...) 以 YYYY-MM-DD HH:MM:SS 格式返回。

    • julianday(timestring, modifier, modifier, ...) 这将返回从格林尼治时间的公元前 4714 年 11 月 24 日正午算起的天数。

    • strftime(format, timestring, modifier, modifier, ...) 这将根据第一个参数指定的格式字符串返回格式化的日期。具体格式见下边讲解。

    • 上述五个日期和时间函数把时间字符串作为参数。时间字符串后跟零个或多个 modifier 修饰符。strftime() 函数也可以把格式字符串 format 作为其第一个参数。下面将为您详细讲解不同类型的时间字符串和修饰符。

    • 时间字符串

      • 一个时间字符串可以采用下面任何一种格式：
        • YYYY-MM-DD 2010-12-30
        • YYYY-MM-DD HH:MM 2010-12-30 12:10
        • YYYY-MM-DD HH:MM:SS.SSS 2010-12-30 12:10:04.100
        • MM-DD-YYYY HH:MM 12-30-2010 12:10
        • HH:MM 12:10
        • YYYY-MM-DDTHH:MM 2010-12-30 12:10
        • HH:MM:SS 12:10:01
        • YYYYMMDD HHMMSS 20101230 121001
        • now 2013-05-07
      • 您可以使用 “T” 作为分隔日期和时间的文字字符。

    • 修饰符（Modifier）

      • 时间字符串后边可跟着零个或多个的修饰符，这将改变有上述五个函数返回的日期和/或时间。任何上述五大功能返回时间。修饰符应从左到右使用，下面列出了可在 SQLite 中使用的修饰符：
        • NNN days
        • NNN hours
        • NNN minutes
        • NNN.NNNN seconds
        • NNN months
        • NNN years
        • start of month
        • start of year
        • start of day
        • weekday N
        • unixepoch
        • localtime
        • utc

    • 格式化

      • SQLite 提供了非常方便的函数 strftime() 来格式化任何日期和时间。您可以使用以下的替换来格式化日期和时间：
      • %d 一月中的第几天，01-31
      • %f 带小数部分的秒，SS.SSS
      • %H 小时，00-23
      • %j 一年中的第几天，001-366
      • %J 儒略日数，DDDD.DDDD
      • %m 月，00-12
      • %M 分，00-59
      • %s 从 1970-01-01 算起的秒数
      • %S 秒，00-59
      • %w 一周中的第几天，0-6 (0 is Sunday)
      • %W 一年中的第几周，01-53
      • %Y 年，YYYY
      • %% % symbol

    • 实例

      • 现在让我们使用 SQLite 提示符尝试不同的实例。下面是计算当前日期：
        1
        2
        sqlite> SELECT date('now');
        2013-05-07
      • 下面是计算当前月份的最后一天：
        1
        2
        sqlite> SELECT date('now','start of month','+1 month','-1 day');
        2013-05-31
      • 下面是计算给定 UNIX 时间戳 1092941466 的日期和时间：
        1
        2
        sqlite> SELECT datetime(1092941466, 'unixepoch');
        2004-08-19 18:51:06
      • 下面是计算给定 UNIX 时间戳 1092941466 相对本地时区的日期和时间：
        1
        2
        sqlite> SELECT datetime(1092941466, 'unixepoch', 'localtime');
        2004-08-19 11:51:06
      • 下面是计算当前的 UNIX 时间戳：
        1
        2
        sqlite> SELECT strftime('%s','now');
        1367926057
      • 下面是计算美国”独立宣言”签署以来的天数：
        1
        2
        sqlite> SELECT julianday('now') - julianday('1776-07-04');
        86504.4775830326
      • 下面是计算从 2004 年某一特定时刻以来的秒数：
        1
        2
        sqlite> SELECT strftime('%s','now') - strftime('%s','2004-01-01 02:34:56');
        295001572
      • 下面是计算当年 10 月的第一个星期二的日期：
        1
        2
        sqlite> SELECT date('now','start of year','+9 months','weekday 2');
        2013-10-01
      • 下面是计算从 UNIX 纪元算起的以秒为单位的时间（类似 strftime(‘%s’,’now’) ，不同的是这里有包括小数部分）：
        1
        2
        sqlite> SELECT (julianday('now') - 2440587.5)*86400.0;
        1367926077.12598
      • 在 UTC 与本地时间值之间进行转换，当格式化日期时，使用 utc 或 localtime 修饰符，如下所示：
        1
        2
        3
        4
        sqlite> SELECT time('12:00', 'localtime');
        05:00:00
        sqlite>  SELECT time('12:00', 'utc');
        19:00:00

    SQLite 常用函数

    • SQLite 有许多内置函数用于处理字符串或数字数据。下面列出了一些有用的 SQLite 内置函数，且所有函数都是大小写不敏感，这意味着您可以使用这些函数的小写形式或大写形式或混合形式。欲了解更多详情，请查看 SQLite 的官方文档：

    • SQLite COUNT 函数

      • SQLite COUNT 聚集函数是用来计算一个数据库表中的行数。

    • SQLite MAX 函数

      • SQLite MAX 聚合函数允许我们选择某列的最大值。

    • SQLite MIN 函数

      • SQLite MIN 聚合函数允许我们选择某列的最小值。

    • SQLite AVG 函数

      • SQLite AVG 聚合函数计算某列的平均值。

    • SQLite SUM 函数

      • SQLite SUM 聚合函数允许为一个数值列计算总和。

    • SQLite RANDOM 函数

      • SQLite RANDOM 函数返回一个介于 -9223372036854775808 和 +9223372036854775807 之间的伪随机整数。

    • SQLite ABS 函数

      • SQLite ABS 函数返回数值参数的绝对值。

    • SQLite UPPER 函数

      • SQLite UPPER 函数把字符串转换为大写字母。

    • SQLite LOWER 函数

      • SQLite LOWER 函数把字符串转换为小写字母。

    • SQLite LENGTH 函数

      • SQLite LENGTH 函数返回字符串的长度。

    • SQLite sqlite_version 函数

      • SQLite sqlite_version 函数返回 SQLite 库的版本。

    • 实例

      • SQLite COUNT 函数
      • SQLite COUNT 聚集函数是用来计算一个数据库表中的行数。 
        1
        sqlite> SELECT count(*) FROM COMPANY;
      • SQLite MAX 函数
      • SQLite MAX 聚合函数允许我们选择某列的最大值。 
        1
        sqlite> SELECT max(salary) FROM COMPANY;
      • SQLite MIN 函数
      • SQLite MIN 聚合函数允许我们选择某列的最小值。 
        1
        sqlite> SELECT min(salary) FROM COMPANY;
      • SQLite AVG 函数
      • SQLite AVG 聚合函数计算某列的平均值。 
        1
        sqlite> SELECT avg(salary) FROM COMPANY;
      • SQLite SUM 函数
      • SQLite SUM 聚合函数允许为一个数值列计算总和。 
        1
        sqlite> SELECT sum(salary) FROM COMPANY;
      • SQLite RANDOM 函数
      • SQLite RANDOM 函数返回一个介于 -9223372036854775808 和 +9223372036854775807 之间的伪随机整数。 
        1
        sqlite> SELECT random() AS Random;
      • SQLite ABS 函数
      • SQLite ABS 函数返回数值参数的绝对值。 
        1
        sqlite> SELECT abs(5), abs(-15), abs(NULL), abs(0), abs("ABC");
      • SQLite UPPER 函数
      • SQLite UPPER 函数把字符串转换为大写字母。 
        1
        sqlite> SELECT upper(name) FROM COMPANY;
      • SQLite LOWER 函数
      • SQLite LOWER 函数把字符串转换为小写字母。 
        1
        sqlite> SELECT lower(name) FROM COMPANY;
      • SQLite LENGTH 函数
      • SQLite LENGTH 函数返回字符串的长度。 
        1
        sqlite> SELECT name, length(name) FROM COMPANY;
      • SQLite sqlite_version 函数
      • SQLite sqlite_version 函数返回 SQLite 库的版本。 
        1
        sqlite> SELECT sqlite_version() AS 'SQLite Version';

Posted on Edited on In

简介

  • sqlpp11 理论基础

详解

sqlpp11 是一个 C++ 编程库，提供了一种类型安全的 SQL 查询构建和执行方式。它使用 C++ 的强类型系统和模板元编程技术，允许开发者以类型安全的方式构建 SQL 查询，同时提供了对多种关系型数据库的支持。

以下是关于 sqlpp11 的一些详细说明：

1. 类型安全的 SQL 查询构建： sqlpp11 允许开发者使用 C++ 类型和表达式来构建 SQL 查询，这种方式可以在编译时捕获错误和类型不匹配，并提供更好的代码安全性和可维护性。

2. 支持多种关系型数据库： sqlpp11 支持多种常见的关系型数据库，如 MySQL、PostgreSQL、SQLite 和 Microsoft SQL Server 等，使开发者可以使用相同的接口和查询语法来操作不同的数据库系统。

3. 查询表达式和条件： sqlpp11 提供了丰富的查询表达式和条件，包括等于、不等于、小于、大于、逻辑运算符等，以及通用函数和聚合函数等，使开发者可以构建复杂的查询条件和数据转换。

4. 插入、更新和删除数据： sqlpp11 提供了方便的接口和语法来执行插入、更新和删除数据的操作，使开发者可以通过简单的代码调用来完成数据库操作。

5. 事务支持： sqlpp11 支持数据库事务的操作，允许开发者在事务中执行一系列的数据库操作，并保证数据的一致性和完整性。

6. 数据库迁移支持： sqlpp11 提供了数据库迁移的支持，允许开发者定义数据库表结构的变化和版本控制，以方便数据库结构的升级和维护。

使用 sqlpp11，开发者可以在 C++ 程序中以一种类型安全的方式构建和执行 SQL 查询，而无需手动编写 SQL 语句。这样可以减少错误和调试的工作量，提高代码的可读性和可维护性。然而，使用 sqlpp11 仍然需要对关系型数据库和 SQL 语法有一定的了解，以便正确地构建查询和操作数据库。

Posted on Edited on In

简介

  • Anaconda

linux Anaconda是什么

Anaconda 是一个开源的Python和R语言发行版本，用于进行科学计算、机器学习、大数据处理和数据科学工作。它包含了许多常用的科学计算和数据分析的库，以及用于管理环境和包依赖关系的工具。

以下是 Anaconda 的一些主要特点：

  1. 包管理器： Anaconda 包含了一个名为 conda 的包管理器，它可以用于安装、卸载、更新和管理Python包及其依赖关系。conda 也支持虚拟环境的创建和管理。

  2. 环境管理： Anaconda 允许用户创建多个独立的Python环境，每个环境可以有自己的包和依赖关系，以便更好地隔离不同项目的运行环境。

  3. 预装科学计算工具： Anaconda 预装了很多科学计算和数据分析常用的库，如NumPy、SciPy、Pandas、Matplotlib等。这些工具使得进行数据科学和机器学习工作更加方便。

  4. 跨平台： Anaconda 可以在 Windows、Linux 和 macOS 等多个操作系统上运行，提供了跨平台的支持。

  5. 大数据处理： Anaconda 包含了用于大数据处理的工具，如Dask、Apache Arrow等。

  6. 社区支持： Anaconda 拥有庞大的用户社区，提供了丰富的文档、教程和支持资源。

  7. 可扩展性： Anaconda 是一个可扩展的平台，用户可以通过 conda 安装其他第三方包，也可以通过 pip 等其他包管理器进行扩展。

Anaconda 的目标是使科学计算和数据科学的工作流更加简便，减少环境配置和依赖管理的复杂性。通过使用Anaconda，用户可以更轻松地搭建和管理Python环境，从而专注于解决实际问题。

linux Anaconda 详解

Anaconda 是一个用于科学计算和数据科学的开源发行版，它包括了许多用于科学计算的软件包，如NumPy、SciPy、Pandas、Jupyter等。Anaconda提供了一个便捷的方式来安装、管理和升级这些科学计算工具，同时也包括了一个自己的包管理工具 conda。

下面是有关 Linux 中 Anaconda 的安装和使用的详解：

安装 Anaconda：

  1. 下载 Anaconda：

    访问 Anaconda 官方网站 下载适合你系统的 Anaconda 安装包。选择 Python 3.x 版本。

  2. 安装 Anaconda：

    打开终端，切换到你下载 Anaconda 安装包的目录，然后运行以下命令：

    1
    bash Anaconda3-<版本号>-Linux-x86_64.sh

    这将启动 Anaconda 安装程序。按照提示进行操作，你可以选择是否将 Anaconda 添加到你的环境变量中，以便在终端中使用 conda 命令。

  3. 激活 Anaconda：

    安装完成后，你可能需要关闭并重新打开终端，或者运行以下命令来激活 Anaconda：

    1
    source ~/.bashrc

    你可以根据你使用的 Shell 不同，使用 ~/.bashrc、~/.bash_profile 或 ~/.zshrc 等文件。

使用 Anaconda：

  1. 创建和管理环境：

    • 创建一个新环境：

      1
      conda create --name myenv python=3.8

    • 激活环境：

      1
      conda activate myenv

    • 安装包：

      1
      conda install numpy pandas matplotlib

  2. 使用 Jupyter Notebook：

    在激活环境后，你可以使用以下命令启动 Jupyter Notebook：

    1
    jupyter notebook

    这将在你的浏览器中打开 Jupyter Notebook 界面。

  3. 退出环境：

    1
    conda deactivate

  4. 更新 Anaconda：

    你可以定期更新 Anaconda 及其包：

    1
    conda update --all

这些是安装和使用 Anaconda 的一些建议步骤。请注意，Anaconda 自带了一个 Python 版本，你在创建新环境时可以选择使用该版本，因此在安装 Anaconda 之后通常不需要再额外安装 Python。

linux VSCode python3 配置conda指定环境的python解析器

在VSCode中配置Conda环境的Python解释器涉及几个步骤。以下是详细的步骤：

  1. 安装VSCode插件:

    • 在VSCode中，点击左侧的扩展图标（或者按 Ctrl + Shift + X），在搜索框中输入 “Python”。
    • 安装 “Python” 扩展，这个扩展由 Microsoft 提供，并提供了与 Python 相关的功能。

  2. 安装并配置Conda:

    • 确保已经安装了Conda。如果没有安装，你可以从官方网站下载并安装Conda。
    • 创建一个新的Conda环境，例如：
      1
      conda create --name myenv python=3.8
    • 激活新创建的环境：
      1
      conda activate myenv

  3. 配置VSCode使用Conda环境:

    • 打开VSCode，点击左下角的 “选择解释器”。
    • 选择 “Python: Select Interpreter”，然后选择 “Enter interpreter path”。
    • 输入Conda环境的路径，通常位于Conda安装目录的 envs 文件夹中，例如：
      1
      /path/to/anaconda3/envs/myenv/bin/python
    • 确定选择的解释器是正确的。

  4. 安装Jupyter支持（如果需要）:

    • 如果你在Conda环境中使用Jupyter Notebooks，你可能还需要安装VSCode的Jupyter扩展。
    • 在VSCode中，点击左侧的扩展图标，搜索 “Jupyter” 并安装 “Jupyter” 扩展。

  5. 重新启动VSCode:

    • 在所有配置更改后，重新启动VSCode以确保所有更改都生效。

通过这些步骤，你应该能够在VSCode中成功配置并使用Conda环境的Python解释器。

Posted on Edited on In

简介

  • sqlpp11 常用的编程技巧

简单示例

以下是一个简单的示例，演示如何在 C++ 中使用 sqlpp11 进行数据库查询：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
#include <sqlpp11/sqlpp11.h>
#include <sqlpp11/mysql/connection.h>

SQLPP_ALIAS_PROVIDER(left);
SQLPP_ALIAS_PROVIDER(right);

int main() {
    // 创建数据库连接
    sqlpp::mysql::connection db("database", "user", "password", "host");

    // 定义表对象和别名
    auto user = test::user{};
    auto u = test::user.as(left);
    auto v = test::user.as(right);

    // 执行查询操作
    auto query = db.select(u.name)
                     .from(u)
                     .join(v)
                     .on(u.id == v.id)
                     .where(u.age >= 18)
                     .group_by(u.name)
                     .order_by(u.name.asc());

    // 打印查询结果
    for (const auto& row : query) {
        std::cout << "Name: " << row.name << std::endl;
    }

    return 0;
}

在上述示例中，我们假设使用了名为 “database” 的 MySQL 数据库，并提供了正确的用户名、密码和主机信息。

该示例演示了如何进行简单的数据库查询操作。我们定义了一个名为 “user” 的表对象，并使用别名 u 和 v 来引用该表。然后，我们使用 db.select() 来选择查询字段，使用 db.from() 来指定要查询的表，使用 db.join() 和 db.on() 进行表连接操作，使用 db.where() 来指定查询条件，使用 db.group_by() 和 db.order_by() 来进行分组和排序。

最后，我们通过遍历查询结果，并输出每一行的 “name” 字段。

请注意，以上示例只是一个简单的演示，实际使用时需要根据数据库的实际结构和需求进行相应的修改和配置。

Posted on Edited on In

简介

  • DBeaser 工具相关理论基础知识

DBeaver 详解

DBeaver是一款开源的、通用的数据库工具，用于管理和开发各种类型的数据库。它提供了一个强大的用户界面，支持多种数据库管理系统，包括MySQL、PostgreSQL、Oracle、SQL Server、SQLite、DB2等。以下是对DBeaver的详细解释：

  1. 跨平台支持：DBeaver是跨平台的数据库工具，可以在Windows、macOS和Linux操作系统上运行，使其非常适合开发人员和数据库管理员。

  2. 多数据库支持：DBeaver支持多种关系数据库管理系统（RDBMS）和NoSQL数据库，包括但不限于MySQL、PostgreSQL、Oracle、SQL Server、SQLite、DB2、MongoDB等。这意味着你可以在一个应用程序中管理和查询各种不同类型的数据库。

  3. 强大的查询工具：DBeaver提供了一个功能丰富的SQL查询工具，具有语法高亮、自动完成、查询计划分析和结果集导出等功能。你可以轻松地编写和执行SQL查询。

  4. 数据库连接管理：DBeaver允许你设置和管理多个数据库连接，你可以创建连接配置文件，包括连接URL、用户名、密码等。这使得切换不同数据库服务器非常方便。

  5. 元数据导航：你可以浏览数据库的元数据，包括表、视图、存储过程、触发器等。DBeaver提供了一个直观的界面，以帮助你理解数据库结构。

  6. 数据编辑：DBeaver允许你浏览和编辑表中的数据。你可以通过图形界面进行插入、更新和删除操作，而无需编写SQL。

  7. 图表和图形化查询：DBeaver提供了图表和图形化查询功能，允许你可视化数据和查询结果。这对于数据分析和可视化非常有用。

  8. 插件支持：DBeaver支持插件，这意味着你可以扩展其功能，添加新的数据库驱动程序或自定义功能。

  9. 导入和导出数据：你可以使用DBeaver导入和导出数据，支持多种数据格式，如CSV、Excel、JSON等。

  10. 版本控制：DBeaver集成了版本控制系统，如Git，以帮助你跟踪和管理SQL脚本的变化。

  11. 安全性：DBeaver提供了安全性功能，如SSH隧道和加密连接，以保护数据库通信的安全性。

  12. 社区支持：DBeaver拥有一个活跃的社区，提供了广泛的文档、教程和支持，使用户能够更好地使用这个工具。

总的来说，DBeaver是一个功能强大的数据库管理工具，适用于开发人员、数据库管理员和数据分析师。它的跨平台性、多数据库支持、SQL查询工具以及图形化功能使其成为一个受欢迎的选择，用于管理和操作各种数据库。

Posted on Edited on In

简介

  • avx指令集 相关的理论基础

avx指令集是什么

AVX（Advanced Vector Extensions）是英特尔公司推出的一种x86微处理器指令集扩展，用于提高向量化操作的性能。AVX指令集引入了256位宽的YMM寄存器，用于存储更大的数据向量，从而在单个指令周期内执行更多的操作。这对于涉及并行计算、多媒体处理、科学计算等需要处理大量数据的应用程序非常有用。

AVX指令集引入了新的指令，允许一次性处理更多的数据元素。例如，AVX指令可以同时对8个单精度浮点数或4个双精度浮点数执行运算，从而在适当的情况下显著提高了计算性能。

AVX指令集的扩展版本，如AVX2和AVX-512，进一步引入了更多的指令和寄存器，用于更大规模的向量化操作，从而进一步提高了性能。AVX-512甚至支持处理512位宽的数据向量，适用于高度计算密集型的任务。

总之，AVX指令集是用于提高x86微处理器向量化计算性能的重要技术，特别适用于需要处理大规模数据集的计算任务。

avx指令集 详解

AVX（Advanced Vector Extensions）指令集是英特尔推出的一种x86微处理器指令集扩展，用于加速向量化操作和并行计算。AVX引入了更宽的寄存器和新的指令，以便在单个指令周期内执行更多的操作。以下是AVX指令集的一些详细信息：

  1. 扩展寄存器： AVX引入了256位宽的YMM寄存器，相较于之前的128位宽XMM寄存器，它可以存储更多的数据元素。这使得一次可以对更多数据进行操作，从而提高并行计算性能。

  2. 新数据类型： AVX引入了新的数据类型，如256位宽的单精度浮点数（float）和双精度浮点数（double），分别命名为YMM单精度浮点寄存器（YMM0-YMM15）和YMM双精度浮点寄存器（YMM0-YMM15）。

  3. 向量化指令： AVX引入了一系列向量化指令，可以一次性对多个数据元素执行相同的操作。例如，AVX指令可以同时执行加法、减法、乘法、除法等操作，从而在单个指令周期内处理多个数据元素。

  4. 指令格式： AVX指令的操作数可以是256位宽的YMM寄存器，也可以是内存中的256位宽数据。指令使用VEX前缀来识别AVX指令，这有助于与之前的指令集区分开来。

  5. 对齐要求： 为了获得最佳性能，AVX指令通常要求数据在内存中按照特定的对齐方式存储。这可以通过对齐指令（如VMOVDQU）或使用对齐内存分配来实现。

  6. 异常处理： AVX指令引入了新的异常处理机制，以适应更宽的数据和更多的操作。这包括对浮点运算异常、数据溢出等情况的处理。

  7. 指令覆盖范围： AVX指令集包含了一系列的算术、逻辑、移位、比较等操作，使得它适用于广泛的计算任务，从图形和多媒体处理到科学计算和密码学。

  8. 编程支持： 使用AVX指令集编程需要使用适当的编译器和工具链。在编写代码时，开发人员可以利用编译器的向量化优化来自动使用AVX指令集。

  9. 后续扩展： AVX指令集的扩展版本，如AVX2和AVX-512，进一步引入了更多的指令和寄存器，以提高向量化性能。AVX-512甚至支持处理更大宽度的数据向量。

总之，AVX指令集是x86架构中的重要创新，通过引入更宽的寄存器和向量化指令，提高了计算性能，特别适用于需要处理大规模数据集的并行计算任务。