精华内容
下载资源
问答
  • 常用的关键字包括
    千次阅读
    2020-09-05 20:27:35

    MySQL(5.7)常用关键字

    1.in 关键字

    -- in关键字,用于判断某个字段的值,是否在指定的集合中
    -- 如果字段的值在集合中,则满足条件,该字段所在的数据将会被查询出来。
    
    -- 语法格式:
    	select * from 表名 where 字段名 [not]in (元素1,元素2,...);
    -- 参数说明:
    	元素1,元素2,……表示集合中的元素,即指定的条件范围(注:这里也可以嵌套sql语句)
    	not,可选参数,表示查询不在IN关键字指定集合,范围中的数据
    

    2. exists 关键字

    -- exists关键字,当 exists 里的条件语句能够返回记录时 (无论记录行多少,只要能返回),条件就为真,返回当前循环到的这条记录。反之如果 exists 里的条件语句不能返回记录行,则条件为假,那么当前循环到的这条记录被丢弃。
    -- exists 的条件就像是一个 boolean 条件,当有结果集则为 true,不能返回结果集则为 false。
    
    -- 语法格式:
    	select 字段名 from 表名 where [not] exists (sql语句);
    -- 参数说明:
    	sql... 条件语句,返回结果集
    	not,可选参数,表示查询不在结果集中的数据
    

    3. distinct 关键字

    -- distinct关键字,用于数据去重
    -- 常和聚合函数一起使用
    -- 语法格式:
    	select distinct 字段名 from 表名;
    	-- 将会去掉两行完全一样的数据
    
    -- 如果想去掉单一一列数据相同的数据,可以使用group by 进行分组
    -- 如果我们只需要计算某一个字段去重复后的总记录数可以 用 count(distinct 列名)聚合函数的方式获取。
    

    4. union 关键字

    -- union关键字,MySQL 是从 4.0 版本起开始加入的UNION 这个关键字
    -- MySQL也允许执行多个查询(多条SELECT语句),union可以将结果作为单个查询结果集返回。
    
    -- 语法格式:
    	select * from 表1 union [all] select * from 表2;
    -- 加all表示不对直接合并,不加则会对合并后结果进行一次去重操作
    -- union规则:
    -- 1. UNION必须由两条或两条以上的SELECT语句组成,语句之间用关键字UNION分隔(因此,如果组合4条SELECT语句,将要使用3个UNION关键字)。
    -- 2. UNION中的每个查询必须包含相同的列、表达式或聚集函数(不过各个列不需要以相同的次序列出)。
    -- 3. 列数据类型必须兼容:类型不必完全相同,但必须是DBMS可以隐含地转换的类型(例如,不同的数值类型或不同的日期类型)
    

    5. limit 关键字

    -- limit关键字,用于分页显示,常与排序order by 一起使用获取最大值或最小值
    
    -- 语法格式:
    	select 字段名 from 表名 limit m,n;
    
    -- 参数说明:
    	表示从第m行开始,共查询n行;
    	如果只有一个m,则表名从索引0开始,(MySQL中第一条数据索引为0)
    -- 注:MySQL5.0之后加入offset关键字,表示偏移量
    	select 字段名 from 表名 limit m,n;
    	select 字段名 from 表名 limit m offset n;
    	-- 这两条sql语句效果是一样的。
    

    7. as 关键字

    -- as 关键字,用于取别名
    
    -- 语法格式:
    	select 字段名 as 别名 from 表名 as 别名;
    
    -- 注意:表别名只在查询执行中使用。与列别名不一样,表别名不返回到客户机
    -- 优点:缩短SQL语句;允许在单条SELECT语句中多次使用相同的表;
    

    8. like 关键字

    -- like关键字,在 WHERE 子句中使用,用于某个字段的模糊搜索
    -- 使用 % 模糊搜索。%代表任意个任意字符
    -- 语法格式:
    	-- 查询name字段中包含五的
    	select * from users where name like '%五%';
    	-- 查询name字段中最后一个字符 为 五的
        select * from users where name like '%五';
        -- 查询name字段中第一个字符 为 王 的
        select * from users where name like '王%';
    -- 使用 _ 单个的下划线。表示一个任意字符,使用和%类似
        -- 查询表中 name 字段为两个字符的数据
        select * from users where name like '__';
        -- 查询 name 字段最后为五,的两个字符的数据
        select * from users where name like '_五';
        
    -- 注意:where子句中的like在使用%或者_进行模糊搜索时,效率不高。
    
    

    9. between 关键字

    -- between关键字,在 WHERE 子句中使用,用于选取介于两个值之间的数据范围
    
    -- 语法格式:
    	select 字段名 from 表名 where 字段名 [not] between m and n;
    	
    -- 参数说明:
    	m,n 表示查询范围在[m,n]的数据,左右闭合
    	not,可选参数, 表示查询范围为 <m 和 >n 的数据。
    -- 如果要查询 某个字段值小于某个值和大于某个值时,就只能用 and 了
    
    更多相关内容
  • C++最佳实践之常用关键字

    千次阅读 2022-06-29 09:29:18
    C++的常用关键字包括:auto、decltype、try、catch、class、constexpr、new、delete、const_cast、static_cast、dynamic_cast、reinterpret_cast、explicit、export、friend、mutable、using、namespace、noexcept、...

    C++的常用关键字包括:auto、decltype、bool、throw、try、catch、class、constexpr、new、delete、const_cast、static_cast、dynamic_cast、reinterpret_cast、explicit、export、friend、mutable、using、namespace、noexcept、nullptr、operator、private、protected、public、static_assert、template、typename、this、thread_local、typeid、virtual等。我们结合代码示例来介绍各个关键字。

    目录

    1、auto自动推断变量

    2、decltype推断变量类型

    3、bool布尔变量

    4、throw/try/catch异常处理

    5、class类与对象

    6、constexpr常量表达式

    7、new与delete管理对象

    8、类型转换

    9、explicit显式调用

    10、export全局引用

    11、friend友元函数

    12、mutable可变变量

    13、namespace命名空间

    14、noexcept禁止异常

    15、nullptr空指针

    16、private、protected和public

    17、typeid获取类型信息

    18、operator重载操作符

    19、template模板

    20、this指针

    21、thread_local线程私有

    22、virtual虚函数


    1、auto自动推断变量

    auto根据变量初始化来推断变量类型。示例如下:

    auto array = new int[8];

    2、decltype推断变量类型

    与auto不同的是,decltype是根据表达式来推断变量类型。语法格式如下:

    decltype(expression) var;

    表达式包括:变量、运算、函数等,示例如下:

    long add() {
        return 0;
    }
    
    void hello() {
        int a = 2;
        decltype(a) b; // b为int类型
        decltype(add()) c; // c为long类型
    }

    3、bool布尔变量

    bool关键字表示布尔变量,只有true或false两种变量值。

    4、throw/try/catch异常处理

    使用关键字throw抛出异常,使用try/catch来捕获异常。示例代码如下:

        try {
            std::string msg("This is a test exception");
            throw msg;
        } catch (const std::string &e) {
            printf("exception=%s", e.c_str());
        }

    5、class类与对象

    C++的类与java类相似,都是面向对象编程。类的声明示例如下:

    #include <string>
    
    class Person {
    private:
        int m_age;
        std::string m_name;
    public:
        void setAge(int age);
        int getAge();
        void setName(const std::string &name);
        std::string getName();
    };

    对应的类实现如下:

    #include "Person.h"
    
    void Person::setAge(int age) {
        m_age = age;
    }
    
    int Person::getAge() {
        return m_age;
    }
    
    void Person::setName(const std::string &name) {
        m_name = name;
    }
    
    std::string Person::getName() {
        return m_name;
    }

    创建Person类的对象实例:

        auto person = new Person();
        person->setAge(10);
        person->setName("frank");
        printf("name=%s, age=%d", person->getName().c_str(), person->getAge());

    6、constexpr常量表达式

    constexpr只能修饰带有return的函数。在C++20增加了consteval修饰常量表达式,不同的是,在编译期确定参数类型。示例如下:

    constexpr int hello(int a, int b) {
        return a + b;
    }

    另外,函数体内不能有赋值运算,否则有如下报错:

    subexpression not valid in a constant expression

    7、new与delete管理对象

    在C++提供关键字new来创建对象,delete释放对象。在C语言是用库函数malloc来申请内存,free来释放内存。要注意的是,释放数组需要加上[]。示例如下:

        // 创建对象
        auto person = new Person();
        // 释放对象
        delete person;
        // 创建数组
        auto array = new int[8];
        // 释放数组
        delete[] array;

    8、类型转换

    C++提供const_cast、static_cast、dynamic_cast和reinterpret_cast四种类型转换,如下表所示:

    const_cast用于修改const属性,接受指针或引用类型
    static_cast用于基本类型转换
    dynamic_cast用于有继承关系的类指针转换,支持类型检查
    reinterpret_cast用于指针类型转换

    类型转换的示例代码如下:

        // const_cast用于const属性
        const int a = 10;
        int &b = const_cast<int &> (a);
        // static_cast基本类型转换
        float x = 10.5f;
        int y = static_cast<int> (x);
        // dynamic_cast用于子类与父类转换
        SuperMan *superman = new SuperMan();
        superman->setAge(100);
        Person *person = dynamic_cast<Person*> (superman);
        // reinterpret_cast用于指针类型转换
        void *data = (void *) "hello";
        char *new_data = reinterpret_cast<char *> (data);

    9、explicit显式调用

    explicit用于修饰单参数的构造函数,被修饰的构造函数只能被显式调用,不能被隐式调用。示例如下:

    class Person {
    private:
        int m_age;
    public:
        explicit Person(int age);
    };

    10、export全局引用

    C语言有extern关键字用于声明全局变量,但是C++的模板没法用extern修饰。因此,提供export修饰在头文件声明的模板类或模板函数,其他源文件只要引用该头文件即可使用模板类或模板函数。

    11、friend友元函数

    friend关键字把函数声明为友元函数。声明函数为外部类的友元函数后,外部类可以通过友元函数访问该类的私有成员。示例代码如下:

    class Pointer;
    
    class Calculator {
    public:
        Pointer* add(Pointer &a, Pointer &b);
    };
    
    class Pointer {
        // 声明为Calculator的友元函数
        friend Pointer* Calculator::add(Pointer &a, Pointer &b);
    private:
        int m_x;
        int m_y;
    public:
        Pointer(int x, int y);
    };
    
    // Calculator访问Pointer的私有成员,通过对象访问
    Pointer* Calculator::add(Pointer &a, Pointer &b) {
        return new Pointer(a.m_x + b.m_x, a.m_y + b.m_y);
    }

    12、mutable可变变量

    mutable用于且只能修饰类的成员变量,与const修饰常量相反。比如,constexpr修饰的常量表达式不允许修改成员变量,而成员变量添加mutable修饰符后可修改。示例如下:

    class Person {
        
    private:
        mutable int m_age; 
    public:
        explicit Person(int age);
        constexpr int getAge();
    
    };
    
    constexpr int Person::getAge() {
        m_age += 10; // 修改成员变量
        return m_age;
    }

    非成员变量使用mutable修饰符会报错如下:

    'mutable' can only be applied to member variable

    13、namespace命名空间

    命名空间用于模块隔离,避免模块之间命名冲突。示例代码如下:

    namespace Learning {
        class Person {
    
        private:
            std::string m_name;
        public:
            void setName(const std::string &name);
            std::string getName();
        };
    }

    使用using引用命名空间,需要注意的是遵循最小原则。示例如下:

        // 直接命名空间引用
        Learning::Person *person1 = new Learning::Person();
        // 引入命名空间
        using namespace Learning;
        Person *person2 = new Person();

    14、noexcept禁止异常

    使用noexcept修饰函数禁止抛出异常,防止错误扩散。示例如下:

    std::string getName() noexcept;

    15、nullptr空指针

    在C语言使用NULL表示空指针,java使用null表示空指针,Object-C使用nil表示空指针。当然,今天的主角是C++,它使用nullptr表示空指针。

    16、private、protected和public

    与java类似,C++提供private、protected和public访问修饰符,可以修饰类、函数、变量。三者对比如下:

    private类内部访问
    proteted有继承关系的类可访问
    public类外部都可以访问

    17、typeid获取类型信息

    typeid用于获取类型信息的操作符,使用示例如下:

    typeid(a).name()

    基本类型对应的类型信息如下表:

    基本类型类型信息
    inti
    charc
    shorts
    doubled
    floatf
    longl

    18、operator重载操作符

    在C++中,字符串能够进行加法运算或比较运算,是因为使用operator重载。我们来看下重载加法运算的示例:

    class Point {
    
    private:
        int m_x;
        int m_y;
    public:
        Point(int x, int y);
        int getX();
        int getY();
        // 重载加法运算
        Point operator +(const Point &p) const {
            return {m_x + p.m_x, m_y + p.m_y};
        }
    };

    然后调用Point类的加法:

        Point p1(1, 2);
        Point p2(2, 3);
        Point point = p1 + p2;
        printf("point.x=%d, point.y=%d\n", point.getX(), point.getY());

    19、template模板

    template可以用于模板类或模板方法,支持不同数据类型的方法复用。示例如下:

    template <typename T>
    T add(T a, T b) {
        return a + b;
    }

    然后分别是int类型与float类型的加法运算:

        int a = 2, b = 3;
        int result1 = add(a, b);
        printf("int add=%d\n", result1);
        float c = 2.5f, d = 3.5f;
        float result2 = add(c, d);
        printf("float add=%f\n", result2);

    20、this指针

    this指针在类内部使用,可以访问类的所有成员。示例如下:

    Point::Point(int x, int y) {
        this->m_x = x;
        this->m_y = y;
    }

    21、thread_local线程私有

    thread_local用于表示线程私有变量,即每个线程都会存储一个变量的值,线程之间互不共享,是C++提供的存储期关键字。与thread_local类似的存储期关键字还有:auto、register、static、extern,各个关键字对比如下:

    auto自动存储期
    register自动存储期,位于寄存器
    static静态存储期
    extern程序存储期,全局使用
    thread_local线程存储期,线程私有

    22、virtual虚函数

    虚函数是C++的多态机制,使用virtual关键字声明,允许通过基类指针访问基类与派生类的同名函数。基类的析构函数需要声明为虚函数,否则调用不到派生类的析构函数,导致内存泄漏。示例代码如下:

    class Animal {
    protected:
        std::string m_name;
    public:
        Animal(const std::string &name);
        // 析构函数声明为虚函数
        virtual ~Animal();
    };
    
    class Cat : public Animal {
    public:
        Cat(const std::string &name);
        ~Cat();
    };

    基类与派生类的实现:

    Animal::Animal(const std::string &name) {
        m_name = name;
    }
    
    Animal::~Animal() noexcept {
        printf("Animal release\n");
    }
    
    Cat::Cat(const std::string &name) : Animal(name) {
        m_name = name;
    }
    
    Cat::~Cat() noexcept {
        printf("Cat release\n");
    }

    测试代码,创建Cat类,然后释放:

        Animal *cat = new Cat("cat");
        delete cat;

    打印输出如下,先调用派生类析构函数,再调用基类析构函数:

    Cat release
    Animal release

    展开全文
  • 主要介绍了Delphi常用关键字用法,包括了各个常用的关键字及其详细用法,需要的朋友可以参考下
  • Java基础常用关键字

    2022-08-05 17:27:50
    Java基础常用关键字 , 重写 tostring , equals 方法

     一,常用关键字

    1)super  ,   this  关键字

     我们可以在子类的方法或构造器中。通过使用"super . 属性“或"super • 方法"的方式,显式的调用
    父类中声明的属性或方法。但是,通常情况下,我们习惯省略"super.
     特殊情況:当子类和父类中定义了同名的属性时,我们要想在子类中调用父类中声明的属性,则必须使用super.的方式
    使用"super •属性”的方式,表明调用的是父类中声明的属性。
    特殊情况:当子类重写了父类中的方法以后,我们想在子类的方法中调用父类中被重写的方法时,则必须显式的使用"super •方法“的方式,表明调用的是父类中被重写的方法。

    super调用构造器
    我们可以在子类的构造器中显式的使用"super(形参列表)"的方式,调用父类中声明的指定的构造器"super(形参列表)“的使用,必须声明在子类构造器的首行!
    我们在类的构造器中,针对于"this(形参列表)“或"super(形参列表)“只能二选一,不能同时出现
    在构造器的首行,没有明确的声明"this(形参列表)“或"super(形参列表)“,则默认调用的是父类中空参的构造:
    在类的多个构造器中,至少有一个类的构造器中使用了"super(形参列表)",调用父类中的构造器

    this是在当前类使用表明当前属性或方法

    2)final  最终的

    >final 可以用来修饰变量(包括类属性、对象属性、局部变量和形参)、方法(包括类方法和对象方法)和类。

    >使用 final 关键字声明类,就是把类定义定义为最终类,不能被继承,或者用于修饰方法,该方法不能被子类重写

    修饰类

    final class 类名 {//类体}


     修饰方法

    修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

    final修饰变量就称为一个常量

    3)static  静态的

    static可以用来修饰:属性、方法、代码块、内部类

    3.1 , 使用static修饰属性:静态变量(或类变量)

    private static String name;

     属性,按是否使用static修饰,又分为:静态属性 vS 非静态属性(实例变量)
    实例变量:我们创建了类的多个对象,每个对家都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时,不会导致其他对家中同样的属性值的修改。
    静态变量:我们创建了类的多个对象,多个对象共享同一个静态变量。当通过某一个对象修改静态变量时,会导致其他对家调用此静态变量时,是修改过了的。

     静态变量随着类的加载而加载。可以通过“类•静态变量"的方式进行调用

     3.2  ,使用static修饰方法:静态方法

    public static String show(){
            return name  +"\t" + "性别是:" + sex;
        }

     随着类的加载而加载,可以通过"类.静态方法"的方式进行调用

     静态方法中,只能调用静态的方法或属性
    非静态方法中,既可以调用非静态的方法或属性,也可以调用静态的方法或属性

     在静态的方法内,不能使用this关键字super关键字

    static  final 用来修饰属性就是一个全局常量  要大写 

     private static final String name = "张三";

    4) extends继承

    Penguin类继承Animal类 

    在 Java 中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类,所以 extends 只能继承一个类。 

    public class Animal { 
        private String name;   
        private int id; 
        public Animal(String myName, int myid) { 
            //初始化属性值
        } 
        public void eat() {  //吃东西方法的具体实现  } 
        public void sleep() { //睡觉方法的具体实现  } 
    } 
     
    public class Penguin  extends  Animal{ 
    }

    5) implements  实现

     使用 implements 关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔)。

    public interface A {
        public void eat();
        public void sleep();
    }
     
    public interface B {
        public void show();
    }
     
    public class C implements A,B {
    }

    6) abstract  抽象的

    修饰类 , 修饰方法称为抽象类 , 抽象方法

     具体用法参考抽象笔记

    7)interface   接口

    public interface NameOfInterface
    {
       //任何类型 final, static 字段
       //抽象方法
    }

     8)instanceof    运算符用于多态向下转型

     public static void show(Animal a)  {
          a.eat();  
            // 类型判断
            if (a instanceof Cat)  {  // 猫做的事情 
                Cat c = (Cat)a;  
                c.work();  
            } else if (a instanceof Dog) { // 狗做的事情 
                Dog c = (Dog)a;  
                c.work();  
            }  
        }  

    二,重写 tostring  ,  equals 方法 

     9)重写tostring  方法

    9.1 ,当我们输出一个对象的引用是,实际上就是调用当前对象的tostring方法我们自定义的类可以重写tostring方法返回对象的实体内容。否则会输出地址。

    快捷键:Alt + Insert 

     @Override
        public String toString() {
            return "Study{" +
                    "name='" + name + '\'' +
                    ", sex='" + sex + '\'' +
                    '}';
        }

     10)重写equals 方法

    >只适用于引用数据类型

    Object类中定义的equals方法作用跟 "==" 的作用是相同的都是比较两个对象的地址值是否相同,如果要判断两个对象的实体内容是否相同则要重写  equals 方法

    快捷键:Alt + Insert 

     @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Study study = (Study) o;
            return Objects.equals(name, study.name) && Objects.equals(sex, study.sex);
        }

    展开全文
  • 模糊查询** - 通配符与LIKE通配符规则LIKE关键字 - 开启通配符匹配**6.AS** - 起别名7.计算字段函数7.1.CONCAT( ) - 拼接7.2.LTrim( )与Rtrim( ) - 删除左边/右边的所有空格7.3.UPPER( ) / LOWER( ) - 转换为大写/...

    1.LIMIT - 分页

    基本用法

    # 第一种:LIMIT offset, rows
    SELECT name
    FROM product
    LIMIT 0, 10;
    
    # 第二种:LIMIT rows
    SELECT name
    FROM product
    LIMIT 10;
    

    可以省略offset,表示从0开始查询(不过这样子就不是用来实现分页了)

    上述两条语句均表示:在查询出的结果当中,从偏移量为0的数据开始,往下截取10条数据。

    SQL优化

    首先需要说明:使用LIMIT关键字的时候,offset越大,查询效率越低。

    以下方的SQL为例(offset为9999)

    # 从偏移量为9999的数据开始,往下获取10条数据
    SELECT *
    FROM product
    LIMIT 9999, 10;
    

    实际上该语句查询出了(10000 + 10 = 10010)条数据,根据offset,舍弃了前面的1W条数据

    这样的做法效率是非常低的。优化有如下思路:

    思路一:通过索引覆盖,第一步先查出10010条数据的id,第二步根据id回表进一步查询。

    这样前面的1W条数据就只需要查询出id即可,不再需要回表,大大提升查询效率。

    # 通过索引覆盖 + 子查询提升分页查询效率
    SELECT name
    FROM product
    WHERE id <= (
     SELECT id
     FROM product
     LIMIT 9999, 1
    )
    LIMIT 10;
    
    • 子查询表示查询第10000条数据的id(从偏移量为9999的数据开始,往下截取1条数据
    • 由于id通常是自增的,WHERE子句则表示获取id >= 第10000条数据id的10条数据

    2.BETWEEN … AND … - 范围查找

    # 查询id∈[20,30]的数据
    SELECT name
    FROM product
    WHERE id BETWEEN 20 AND 30;
    

    注意:是闭区间

    3.IN - 在确定的集合内查找

    # 在确定的集合内查找
    SELECT *
    FROM product
    WHERE name IN ('奥利奥', '薯片', '泡面');
    

    通常搭配子查询一起使用,如:

    # 查询大一所有学生的名字:
    # 子查询中根据 grade = '大一' 查出班级id,
    # 外查询使用IN,根据子查询的id查出学生名字。
    SELECT name
    FROM student
    WHERE student_class_id IN (
        SELECT id
        FROM student_class
        WHERE grade = '大一';
    );
    

    需要注意的是,INBETWEEN…AND有所不同:

    • IN:其后是一个具象的集合,而不是一个抽象的范围,如:IN (20, 30)表示必须是20或30;
    • BETWEEN…AND:对数字字段限定抽象范围,如:**BETWEEN **20 AND 30表示[20, 30]。

    在MyBatis中,可以用<foreach>标签来设置IN后面的集合:

    假设传入DAO层的列表 idList=[1, 2, 3, 4, 5],那么在mapper.xml中可以这么写:

    <select id="listNameById" resultType="Product">
    	SELECT name
    	FROM product 
    	WHERE id IN
    	<foreach collection="idList" item="id" open="(" close=")" separator=",">
    		#{id}
    	</foreach>
    </select>
    
    • collection:传入列表的形参名;
    • item:遍历列表时,取出的元素的引用;
    • open:SQL的首部,无脑写 “(” 即可;
    • close:SQL的尾部,无脑写 “)” 即可;
    • separator:分隔字符串

    IN 在MySQL5.5之前,不走索引;MySQL5.5后会根据字段唯一性来决定:

    SELECT *
    FROM user
    WHERE name IN ("zhangSan", "liSi");
    

    走不走索引,需要先判断表中名为"zhangSan"或"liSi"的数据多不多:

    • 不多:走索引;
    • 多(经测试有可能为30%):全表扫描。

    4.AND和OR - AND的优先级高于OR

    AND的优先级高于OR,但更加推荐的用法是添加括号。

    5.模糊查询 - 通配符与LIKE

    通配符规则

    注意:通配符如果在开头(‘_bc’、‘%bc’),查询时就不会走索引

    通配符主要有两种:

    • %:匹配任意(包括0)个字符(说白了,可有可无)
    • _:匹配一个字符

    举个栗子:

    • ‘%bcd’:匹配以bcd结尾的;
    • ‘abc%’:匹配以abc开头的;
    • ‘%bc%’:匹配包括bc的;
    • ‘_bcd’:匹配以bcd结尾,且前面有且只有一个字符的;
    • ‘abc_’:匹配以abc开头,且后面有且只有一个字符的;
    • ‘_bc_’:匹配包含bc,且前后都仅有一个字符的;
    • ‘_bc%’:匹配包含bc,且之前仅有一个字符的(之后可以有任意个,包括0个)。

    LIKE关键字 - 开启通配符匹配

    # 情况1:LIKE后面拼接通配符 - 依照通配符规则开启模糊查询
    # 查询所有name以"油炸"开头的商品
    SELECT *
    FROM product
    WHERE name LIKE '油炸%';
    
    # 情况2:LIKE后面没有拼接通配符 - 等价于"="
    # 查询name为"薯片"的商品
    SELECT *
    FROM product
    WHERE name LIKE '薯片';
    

    在MyBatis中,若以某关键字进行模糊查询,可以使用CONCAT( )进行拼接:

    <select id="listByKey" resultType="Product">
     SELECT *
     FROM product
     WHERE name LIKE CONCAT(#{key}, '%')
    </select>
    

    这里是将传入的key与’%'拼接,作为新的通配符字符串使用。

    6.AS - 起别名

    # 为name起别名为product_name
    SELECT name AS product_name
    FROM product
    WHERE id = 1;
    

    若在SELECT中起别名,不可在WHERE中使用别名

    以下是错误的SQL语句

    SELECT name AS student_name

    FROM student

    WHERE student_name =张三’;

    • SQL的执行顺序:FROM -> WHERE -> SELECT
    • 因此在执行WHERE的时候,SELECT还未执行,即别名还不存在,因此不可调用。

    注意:联表查询时,应对同名字段起别名

    如果某个查询使用了联表查询,而连接的表中有字段名相同的字段,

    且恰好使用的是resultMap,则必须要对其中的某一字段名起别名。

    <!-- 根据班级id查询学生列表 -->
    <select id="listByStudentClassId" resultMap="studentMap">
    SELECT stuent.id,
    	   student.name,
    	   studentClass.name AS studentClassName
    	FROM student LEFT JOIN studentClass ON student.studentClassId = studentClass.id
    </select>
    
    <!-- 可以看到:学生姓名与班级名称的字段名都是name,此时需要对其中一个字段起别名,封装时使用别名 -->
    <resultMap id="studentMap" type="student">
    	<id property="id" column="id"/>
    	<result property="name" column="name"/>
    	<result property="studentClassName" column="studentClassName"/>
    </resultMap>
    

    不可以在resultMap中用"表名.字段名"作为column

    image-20220401210019561

    7.计算字段函数

    7.1.CONCAT( ) - 拼接

    可以用在SELECT后,也可以用在WHERE后,用法如下:

    # 情况1:用在SELECT后,通常搭配别名使用:
    # 查出id为1的数据的name(薯片),
    # 将name与"新品 - "进行拼接(新品 - 薯片),
    # 最后为新的数据起别名为"new_product_name"并返回。
    SELECT CONCAT('新品 - ', name) AS new_product_name
    FROM product
    WHERE id = 1;
    
    # 情况2:用在WHERE后
    SELECT id
    FROM product
    WHERE name LIKE CONCAT('油炸', '%')
    

    7.2.LTrim( )与Rtrim( ) - 删除左边/右边的所有空格

    # 删除字段左边所有的空格
    SELECT LTrim(name)
    FROM student;
    
    # 删除字段右边所有的空格
    SELECT RTrim(name)
    FROM student;
    

    7.3.UPPER( ) / LOWER( ) - 转换为大写/小写

    # 结果转换成大写
    SELECT UPPER(name)
    FROM student
    WHERE id = 1;
    
    # 结果转换成小写
    SELECT LOWER(name)
    FROM student
    WHERE id = 1;
    

    7.4.算数计算:可以直接在SELECT后的内容进行算数计算

    # price为单价,quantity为数量
    # 将二者相乘后的结果起别名为总价total_price返回
    SELECT id,
    	  name,
    	  (price * quantity) AS total_price
    FROM product
    WHERE id = 1;
    

    8.聚集函数

    基本的聚集函数

    聚集函数功能
    AVG( )返回平均值
    COUNT( )返回行数
    MAX( )返回最大值
    MIN( )返回最小值
    SUM( )返回结果中某列之和
    # 获取商品总数
    SELECT SUM(quantity)
    FROM product;
    

    DISTINCT( ) - 去重

    # 去除重名的商品
    SELECT DISTINCT(name)
    FROM product;
    

    聚集函数搭配使用

    聚集函数并不是只能使用一个,一个SQL可以有多个聚集函数一起使用

    # 同时使用多个聚集函数
    SELECT COUNT(*) AS num,
    	   MIN(price) AS min_price,
    	   MAX(price) AS max_price,
    	   AVG(price) AS avg_price
    FROM product;
    

    9.子查询

    作为 WHERE 中 IN 的查询条件

    # 查询大一所有学生的名字:
    # 子查询中根据 grade = '大一' 查出班级id,
    # 外查询使用IN,根据子查询的id查出学生名字。
    SELECT name
    FROM student
    WHERE student_class_id IN (
        SELECT id
        FROM student_class
        WHERE grade = '大一'
    );
    

    搭配别名,作为查询结果返回

    # 查询出两个字段name、student_class_name
    SELECT name,
    	  (SELECT name
           FROM student_class) AS student_class_name
    FROM student
    

    10.UNION - 并

    将多组查询结果合并返回:

    # UNION - 将两个查询结果合并
    # 查询1
    SELECT name
    FROM product
    WHERE price <= 5
    # UNION - 默认去重(UNION UNIQUE)
    UNION
    # 查询2
    SELECT name
    FROM product
    WHERE id IN (1000, 2000);
    
    • UNION UNIQUE:默认,在查询结果相等时去除重复;
    • UNION ALL:不去重展示完整数据。

    11.JOIN - 联表查询

    INNER JOIN - 内连接

    内连接相当于等值查询。

    # 等值查询
    SELECT *
    FROM student, student_class
    WHERE student.student_class_id = student_class.id
    
    # 内连接 - 相当于等值查询
    SELECT *
    FROM student LEFT JOIN student_class ON student.student_class_id = student_class.id
    

    内连接时,只保留两个表中共有的数据,最终结果必定是完整数据

    image-20220402192106782

    LEFT JOIN - 左外连接

    左外连接的特点是:最终数据量必定与左表一致

    image-20220402192557889

    左外连接时,左表中未连接成功的数据也会保留,而右表中未完成连接的字段值为null

    展开全文
  • oracle数据库常用关键字汇总!Oracle基础数据类型:4类:字符型:字符串char(最大2000), nchar(最大1000, 支持Unicode)--->固定长度varchar2(最大4000), nvarchar2(最大2000, 支持Unicode)--->可变长度数字类型...
  • Robotframework中常用关键字
  • java中常用关键字

    2022-03-22 16:44:18
    static关键字的用法 (1)用法: 1.static关键字表示静态.能与属性,方法,代码块,内部类等一起使用. 2.static修饰属性和方法时,可以直接通过类名.属性或类名.方法访问. 3.静态变量: 一个类中,静态变量只分配一块...
  • SeleniumLibrary常用关键字 1.1 browserManagement 关键字 参数 释义 备注 Open Browser [browser/url] 打开浏览器 Close Browser null 关闭浏览器 Close All Browsers null 关闭所有已打开浏览器 ...
  • C语言中包含一些常见的关键字,而这类关键字对于整个程序的效率等都会造成一定的影响,因此在C语言编程中需要重点注意。一、volatile关键字volatile影响编译器编译的结果,告诉编译器volatile变量是随时可能发生...
  • C语言常用关键字详解

    千次阅读 2019-08-31 18:45:41
    由ASCII标准定义的C语言关键字共32个: 数据关键字12个:char,double,float,enum,float,int,long,short,signed,struct,union,void 控制语句关键字12个:for,do,while,break,continue,if,else,goto...
  • mysql、postgresql常用关键字

    千次阅读 2018-08-24 18:02:05
    mysql、postgresql常用关键字 updating from fuyuaaa mysql case case when 条件 then 结果 end 例子: count(distinct(case when a &amp;gt; 0 then b end)) --统计a&amp;gt;0时,b的数量 ...
  • AppiumLibrary常用关键字

    2021-03-16 18:57:13
    通过上一章节,open application关键字的使用,相信大家对手机自动化充满了兴趣,那么今天这一章节,主要介绍AppiumLibrary中常用关键字的使用。一、实用函数关键字含义实例备注Click Button点击按钮Click Button ...
  • Oracle常用关键字

    千次阅读 2018-11-17 21:46:45
    DBA_OBJECTS 所有用户对象的基本信息(包括素引,表,视图,序列等); CAT 当前用户可以访问的所有的基表 ; TAB 当前用户创建的所有基表,视图,同义词等; DICT 构成数据字典的所有表的信息;   ...
  • 1、in关键字。in的效率高于or。 in (value1,value2,...) 或者not in (value1,value2,...) 2、between ... and ... between value1 and value2或者not between value1 and value2 3、like,“%”匹配任意...
  • 等待页面不包含元素:Wait Until Page Does Not Contain Element 等待页面不包含文本:Wait Until Page Does Not Contain 3、页面滑动 滑动:swipe ${start_x} ${start_y} ${end_x} ${end_y} 滚动:...
  • SQL基础-常用关键字

    2019-12-20 19:07:58
    DDL(Data Definition Languages)数据定义语言,常用关键字包括create、drop、alter等 0.连接数据库 $mysql -u root -p connection id 表示的是连接次数 1.创建数据库 CREATE DATABASE dnname 2.默认的数据库 ...
  • php中类的常用关键字包括有:锁(fianl)、有点类似与this关键字(self)、静态属性(static)、常量关键字(const)下面我来给大家整理整理。类中的常用关键字1.fianl:锁2.self:有点类似与this关键字3.static:静态属性4....
  • JAVA的常用关键字有哪些?发布时间:2020-05-25 21:46:00来源:亿速云阅读:133作者:鸽子下表是java中经常会用到的关键字:一:用于定义访问权限修饰符的关键字:1) public 公共的public 关键字是可以应用于类、...
  • Java常用关键字总结

    千次阅读 2021-03-25 09:10:59
    常用关键字汇总图 详细解释用于定义访问控制修饰符的关键字控制范围图 public(公共的)1、public 关键字是可以应用于类、方法或字段(在类中声明的变量)的访问控制修饰符。2、可以在其他任何类或包中引用 public 类、...
  • 常用的sql关键字

    2019-12-09 21:22:23
    从效率上说,UNION ALL 要比UNION快很多,所以,如果可以确认合并的两个结果集中不包含重复数据且不需要排序时的话,那么就使用UNION ALL。 简单应用 将一个表的内容弄成两份到一个输出中: select * from...
  • selenium-Selenium常用关键字和用法总结

    千次阅读 多人点赞 2019-07-01 22:32:41
    1)要搜索一个产品,需要先找到搜索框和搜索按钮,接着通过键盘输入要查询的关键字,最后用鼠标单击搜索按钮,提交搜索请求; 2)Selenium提供了很多find_element_by方法定位页面元素,正常定位的话,相应的...
  • 主篇主要是对 static、final、super、this、native、transient这6个关键字进行简单讲解。一、staticstatic关键字可以修饰变量、方法、代码块及内部类。/*** static 关键字学习* @author kobe**/public class ...
  • Qt常用关键字 一、Qt数据类型 二、Qt函数类型 三、Qt枚举类型 四、Qt运算符重载函数类型
  • 一、同步(synchronized)和异步(asynchronized)  1、同步(synchronized)简单说可以理解为共享的意思,如果资源不是共享的,就没必要进行同步。...线程1调用了带有synchronized关键字的方法methodA,...
  • 常用C#关键字详解教程(比较全面)

    千次阅读 2021-05-20 15:15:08
    不论你是新手还是老手,是否对C#的某些关键字有些摸不到头脑呢?现在我就和大家一起学习一下这些关键字的含义类型Void用作方法的返回类型时,void 关键字指定方法不返回值。在方法的参数列表中不允许使用 void。采用...
  • mysql笔记(一),常用关键字和函数

    千次阅读 2017-12-06 15:48:26
    模糊查询like 关键字select * from tableName where name = '张_';//一个下划线代表匹配一个字符select * from tableName where name = '张%';// %代表匹配0到N个字符 在 xx 与 xx 之间between 关键字select * from ...
  • -- SQL执行顺序的几个关键字 约束是实施引用完整性的重要部分; 索引可改善数据检索的性能; 触发器可以执行运行前后的处理; 安全选项可以用来管理数据访问; #(一)查询顺序 SELECT 查询列表 7 FROM 表1 别名 1 ...
  • 常用关键字》 在初学者刚接触C语言的时候,对各种关键字的含义以及用法了解的都不是很深刻,对关键字有了更深刻的理解才能加快我们的学习,接下来我就带领初学者们来了解一下: 一、数据类型关键字12个 <1&...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 384,775
精华内容 153,910
热门标签
关键字:

常用的关键字包括