精华内容
下载资源
问答
  • where和that的区别
    千次阅读
    2016-12-25 17:28:01
        使用MySQL执行update的时候报错:Error Code: 1175. You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column To disable safe mode, toggle the option in Preferences -> SQL Queries and reconnect.
    
        在delete或者update的时候,都可能会出现这种警告/报错,这主要是因为版本较新的MySQL是在safe-updates模式下进行sql操作的,这个模式会导致在非主键条件下无法执行update或者delete
        修改方式:单独执行一条SQL
    
        set sql_safe_updates=0; /*取消安全模式*/
        这样就可以直接执行没有带key值的SQL语句
    
        那么,在sql_safe_updates=1的条件如何执行SQL呢?我采取的是在where条件下加上id>0这一句,即:
    
    delete from _table where content='I'm fool' and id>0
    更多相关内容
  • SQL中where与having的区别

    千次阅读 2021-06-02 16:42:20
    SQL中where与having的区别 目录 SQL中where与having的区别 创建表 插入数据 进行聚合操作 # WHERE是在聚合之前进行数据行的过滤而HAVING实在聚合之后进行新数据的过滤; 即在SQL语法中WHERE语法的执行早于...

    SQL中where与having的区别

    目录

    SQL中where与having的区别

    创建表

    插入数据

    进行聚合操作


    # WHERE是在聚合之前进行数据行的过滤而HAVING实在聚合之后进行新数据的过滤;

    即在SQL语法中WHERE语法的执行早于GROUP BY,而GOUP BY 早于HAVING的执行;

    # WHERE filters rows before grouping (i.e. GROUP BY) while HAVING filters rows after grouping.

    创建表

    包含字段:名称、年龄、种族、使用的装备

    -- Create table called adventurers
    CREATE TABLE adventurers (
        -- string variable
        name varchar(255),
        -- integer variable
        age int,
        -- string variable
        race varchar(255),
        -- string variable
        weapon varchar(255)
    )

    插入数据

    在表中插入四条数据

    -- Insert into the table adventurers
    INSERT INTO adventurers (name, age, race, weapon)
    VALUES ('Fjoak Doom-Wife', 28, 'Human', 'Axe'),
           ('Alooneric Cortte', 29, 'Human', 'Bow'),
           ('Piperel Ramsay', 35, 'Elf', 'Axe'),
           ('Casimir Yardley', 14, 'Elf', 'Bow')

    进行聚合操作

    使用where筛选年龄大约15岁的角色

    -- Retrieve the race and average age from the table
    SELECT race, AVG(age) FROM adventurers
    -- Grouped by race
    GROUP BY race
    -- That are older than 15
    WHERE age > 15

    使用having,在聚合后的结果中选取年龄大约20的结果;

    -- Retrieve the race and average age from the table
    SELECT race, age, AVG(age) FROM adventurers
    -- Grouped by race
    GROUP BY race age
    -- That are older than 20
    HAVING age > 20

     

    参考:Group Rows With Conditions

    参考:SQL

    参考:SQL中where与having的区别

    展开全文
  • numpy高级教程之np.where和np.piecewise

    万次阅读 多人点赞 2018-09-25 16:07:35
    np.piecewise也前面讲过的where、select、choose一样,属于高级应用,而且实现的功能也有类似的,即根据相关的条件,进行筛选,然后对漫步不同条件的元素进行相关的操作,这个操作可以来源与函数、lambda表达式等...

    欢迎关注“勇敢AI”公众号,更多python学习、数据分析、机器学习、深度学习原创文章与大家分享,还有更多电子资源、教程、数据集下载。勇敢AI,一个专注于人工智能AI的公众号。

    ==================================================================================

           关于numpy的教程,前面已经总结了不少文章,且前面已经写过了numpy的高级应用之select和choose,需要的同学可以看我的博客或者是在我博客里面的微信公众平台,对这两个函数有特别清晰的介绍。今天的文章主要是看一下np.where和np.piecewise,以及掩码数组。

    一、np.where()函数详解

    顾名思义,该函数所实现的也是类似于查找的功能,where即在哪里的意思,前面的select和choose即选择的意思,这有一些类似。实际上,where函数提供了“查找”的更高级的功能。

    1、where函数的定义

    numpy.where(condition[, xy])  

    If only condition is given, return condition.nonzero().

    Parameters:

    condition : array_like, bool

    When True, yield x, otherwise yield y.

    x, y : array_like, optional

    Values from which to choose. xy and condition need to be broadcastable to some shape.

    Returns:

    out : ndarray or tuple of ndarrays

    If both x and y are specified, the output array contains elements of x where condition is True, and elements from y elsewhere.

    If only condition is given, return the tuple condition.nonzero(), the indices where condition is True.

    解释:

    该函数可以接受一个必选参数condition,注意该参数必须是array型的,只不过元素是true或者是false

    x,y是可选参数:如果条件为真,则返回x,如果条件为false,则返回y,注意condition、x、y三者必须要能够“广播”到相同的形状

    返回结果:返回的是数组array或者是元素为array的tuple元组,如果只有一个condition,则返回包含array的tuple,如果是有三个参数,则返回一个array。后面会详细介绍。

    总结:numpy实际上是条件操作的高度封装,可以说numpy.where函数是三元表达式x if condition else y的矢量化版本。定义一个布尔数组和两个值数组,它返回的结果实际上就是查找的元素的“位置”或者是“索引”或者是“坐标”。位置、索引、坐标是等价的意思,通俗的说就是返回的值就是元素到底在哪里。

    2、只含有一个参数condition的实际案例

    (1)condition是一维的

    a = np.array([2,4,6,8,10])
    a_where=np.where(a > 5)             # 返回索引,a>5得到的是array。
    print(a_where)
    print(a[np.where(a > 5)])        # 等价于 a[a>5],布尔索引
    
    b=np.array([False,True,False,True,False])
    print(np.where(b))

    打印的结果为如下:

    (array([2, 3, 4], dtype=int64),) #返回的2,3,4即对应于元素大于5(True)的元素的索引位置,即第3、4、5个元素,以array得形式返回
    [ 6  8 10]
    (array([1, 3], dtype=int64),)  #返回元素中为True的元素所对应的位置索引,即第2个和第4个元素,以array的形式返回。

    (2)condition是二维的

    a=np.array([[1,2,3,4,5],[2,3,4,5,6],[3,4,5,6,7],[4,5,6,7,8]])  #二维数组
    a_where=np.where(a>3)
    print(a_where)
    print(a[a_where])
    

    运行结果为:

    (array([0, 0, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3], dtype=int64), array([3, 4, 2, 3, 4, 1, 2, 3, 4, 0, 1, 2, 3, 4], dtype=int64))
    [4 5 4 5 6 4 5 6 7 4 5 6 7 8]

    对于第一个返回的结果,我们可以看到,它返回的是一个元组tuple,元组的第一个元素是一个array,它的值来源于满足条件的元素的行索引,两个0行的,三个1行的,四个2行的,五个3行的;元祖的第二个元素也是一个array,它的值来源于满足条件的元素的列索引。

    再看一个例子

    b=np.where([[0, 3,2], [0,4, 0]])
    print(b)
    

    返回结果为:

    (array([0, 0, 1], dtype=int64), array([1, 2, 1], dtype=int64))

    #返回的依然是一个元组tuple,第一个元素是一个array,来源于行,第二个元素也是一个array,来源于列。注意,这一没有删选条件啊,因为where的参数就是b而不是什么,b>1,b>2之类的布尔表达式,那是怎么回事呢,实际上,它是经过进一步处理了的,将0元素看成是false,将大于0的全部当成是true,与下面的运行结果是完全等价的。

    c=np.array([[False,True,True],[False,True,False]])
    print(np.where(c))
    

    输出结果为: (array([0, 0, 1], dtype=int64), array([1, 2, 1], dtype=int64)) #同上面完全一样

    (3)condition是多维的——以三维为例

    a=[
        [
            [1,2,3],[2,3,4],[3,4,5]
        ],
        [
            [0,1,2],[1,2,3],[2,3,4]
        ]
    ]
    a=np.array(a)
    print(a.shape)  #形状为(2,3,3)
    a_where=np.where(a>3)
    print(a_where)
    

    运行结果为:

    (array([0, 0, 0, 1], dtype=int64),

    array([1, 2, 2, 2], dtype=int64),

    array([2, 1, 2, 2], dtype=int64)) 

    同上,返回的是一个元组,第一个元素是array类型,来源于第一个维度满足条件的索引,第二个元素是array类型,来源于第二个维度满足条件的索引,第三个元素是array类型,来源于第三个维度满足条件的索引。

    总结:针对上面的讲述,where的作用就是返回一个数组中满足条件的元素(True)的索引,且返回值是一个tuple类型,tuple的每一个元素均为一个array类型,array的值即对应某一纬度上的索引。

    在之给定一个参数condition的时候,np.where(condition)和condition.nonzero()是完全等价的。

    3、包含三个参数condition、x、y 的实际案例

    a = np.arange(10)
    a_where=np.where(a,1,-1)
    print(a_where)      
    
    a_where_1=np.where(a > 5,1,-1)
    print(a_where_1)
    
    b=np.where([[True,False], [True,True]],    #第一个参数
                 [[1,2], [3,4]],               #第二个参数
                 [[9,8], [7,6]]                #第三个参数
                )             
    
    print(b)
    

    运行结果为:

    [-1  1  1  1  1  1  1  1  1  1]
    [-1 -1 -1 -1 -1 -1  1  1  1  1]
    [[1 8]
     [3 4]]

    对于第一个结果,因为只有第一个是0,即false,故而用-1替换了,后面的都大于0,即true,故而用1替换了

    对于第二个结果,前面的6个均为false,故而用-1替换,后面的四个为true,则用1替换

    对于第三个结果,

    第一个True对应的索引位置为(0,0),true在第二个参数中寻找,(0,0)对应于元素1

    第二个false对应的索引位置为(0,1),false在第三个参数中寻找,(0,1)对应于元素8

    第三个True对应的索引位置为(1,0),true在第二个参数中寻找,(0,0)对应于元素3

    第四个True对应的索引位置为(1,1),true在第二个参数中寻找,(0,0)对应于元素4

    总结:在使用三个参数的时候,要注意,condition、x、y必须具有相同的维度或者是可以广播成相同的形状,否则会报错,它返回的结果是一个列表,同原始的condition具有相同的维度和形状。

    总结:通过上面的讲述,已经了解到了np.where函数的强大之处,它的本质上就是选择操作,但是如果我们自己编写条件运算,使用if-else或者是列表表达式这样的语句,效率低下,故而推荐使用np.where。

    二、np.piecewise函数详解

    np.piecewise也和前面讲过的where、select、choose一样,属于高级应用,而且实现的功能也有类似的,即根据相关的条件,进行筛选,然后对漫步不同条件的元素进行相关的操作,这个操作可以来源与函数、lambda表达式等,并得到新的结果。

    1、np.piecewise的定义

    numpy.piecewise(xcondlistfunclist*args**kw)

    Evaluate a piecewise-defined function.

    Given a set of conditions and corresponding functions, evaluate each function on the input data wherever its condition is true.

    Parameters:

    x : ndarray or scalar

    The input domain.

    condlist : list of bool arrays or bool scalars

    Each boolean array corresponds to a function in funclist. Wherever condlist[i] is True, funclist[i](x) is used as the output value.

    Each boolean array in condlist selects a piece of x, and should therefore be of the same shape as x.

    The length of condlist must correspond to that of funclist. If one extra function is given, i.e. iflen(funclist) == len(condlist) + 1, then that extra function is the default value, used wherever all conditions are false.

    funclist : list of callables, f(x,*args,**kw), or scalars

    Each function is evaluated over x wherever its corresponding condition is True. It should take a 1d array as input and give an 1d array or a scalar value as output. If, instead of a callable, a scalar is provided then a constant function (lambda x: scalar) is assumed.

    args : tuple, optional

    Any further arguments given to piecewise are passed to the functions upon execution, i.e., if called piecewise(..., ..., 1, 'a'), then each function is called as f(x, 1, 'a').

    kw : dict, optional

    Keyword arguments used in calling piecewise are passed to the functions upon execution, i.e., if calledpiecewise(..., ..., alpha=1), then each function is called as f(x, alpha=1).

    Returns:

    out : ndarray

    The output is the same shape and type as x and is found by calling the functions in funclist on the appropriate portions of x, as defined by the boolean arrays in condlist. Portions not covered by any condition have a default value of 0.

    参数一 x:表示要进行操作的对象

    参数二:condlist,表示要满足的条件列表,可以是多个条件构成的列表

    参数三:funclist,执行的操作列表,参数二与参数三是对应的,当参数二为true的时候,则执行相对应的操作函数。

    返回值:返回一个array对象,和原始操作对象x具有完全相同的维度和形状

    2、np.piecewise的实际案例

    (1)案例一

    x = np.arange(0,10)
    print(x)
    xx=np.piecewise(x, [x < 4, x >= 6], [-1, 1])
    print(xx)
    

    运行结果为:

    [0 1 2 3 4 5 6 7 8 9]
    [-1 -1 -1 -1  0  0  1  1  1  1]

    即将元素中小于4的用-1替换掉,大于等于6的用1替换掉,其余的默认以0填充。其实这里的替换和填充就是function,这不过这里的function跟简单粗暴,都用同一个数替换了。实际上,上面的代码完全等价于下面的代码:

    x = np.arange(0,10)
    
    def func1(y):
        return -1
    
    def func2(y):
        return 1
    xxx=np.piecewise(x, [x < 4, x >= 6], [func1, func2])
    print(xxx)
    

    运行结果为:

     [-1 -1 -1 -1  0  0  1  1  1  1]  #同上面一样

    (2)案例二——定义相关的操作函数

    x = np.arange(0,10)
    
    #元素进行平方
    def func2(y):
        return 1ef func1(y):
        return y**2
    
    #元素乘以100
    def func2(y):
        return y*100
    xxx=np.piecewise(x, [x < 4, x >= 6], [func1, func2])
    print(xxx)
    

    运行结果为:

    [  0   1   4   9   0   0 600 700 800 900]

    (3)案例三——使用lambda表达式

    x = np.arange(0,10)
    
    xxxx=np.piecewise(x, [x < 4, x >= 6], [lambda x:x**2, lambda x:x*100])
    print(xxxx)
    

    运行结果为:

    [  0   1   4   9   0   0 600 700 800 900]

    总结:piecewise的处理方法快捷方便,比自己编写循环和条件语句的执行效率高很多,推荐多使用。

     

    展开全文
  • 数据库多表查询之 where和INNER JOIN

    万次阅读 多人点赞 2018-07-05 10:40:47
    在使用left jion时,on和where条件的区别如下: 1、 on条件是在生成临时表时使用的条件,它不管on中的条件是否为真,都会返回左边表中的记录。 2、where条件是在临时表生成好后,再对临时表进行过滤的条件。这时...

    https://blog.csdn.net/u013372487/article/details/52622491?locationNum=1

    https://blog.csdn.net/qingtanlang/article/details/2133816

    http://www.cnblogs.com/drake-guo/p/6101531.html

    https://blog.csdn.net/huyr_123/article/details/61616547

    在多表查询中,一些SQL开发人员更喜欢使用WHERE来做join,比如:

    SELECT a.ID, b.Name, b.Date FROM Customers a, Sales b WHERE a.ID = b.ID;
    • 1

    缺点:在上面语句中,实际上是创建了两张表的笛卡尔积,所有可能的组合都会被创建出来。在笛卡尔连接中,在上面的例子中,如果有1000顾客和1000条销售记录,这个查询会先产生1000000个结果,然后通过正确的 ID过滤出1000条记录。 这是一种低效利用数据库资源,数据库多做100倍的工作。 在大型数据库中,笛卡尔连接是一个大问题,对两个大表的笛卡尔积会创建数10亿或万亿的记录。

    为了避免创建笛卡尔积,应该使用INNER JOIN :

    SELECT a.ID, b.Name, b.Date FROM Customers a INNER JOIN Sales b ON a.ID = b.ID;
    • 1

    优点:如上面语句,使用inner join 这样数据库就只产生等于ID 的1000条目标结果。增加了查询效率。

    有些数据库系统会识别出 WHERE连接并自动转换为 INNER JOIN。在这些数据库系统中,WHERE 连接与INNER JOIN 就没有性能差异。但是, INNER JOIN 是所有数据库都能识别的,因此DBA会建议在你的环境中使用它。

    INNER JOIN(内连接,或等值连接):获取两个表中字段匹配关系的记录。
    LEFT JOIN(左连接):获取左表所有记录,即使右表没有对应匹配的记录。
    RIGHT JOIN(右连接): 与 LEFT JOIN 相反,用于获取右表所有记录,即使左表没有对应匹配的记录。
    • 1
    • 2
    • 3

    注意: 
    1、INNER JOIN 等同于 JOIN; 
    2、示意图: 
    这里写图片描述这里写图片描述这里写图片描述

    这里写图片描述


    我在练习MySQL操作语句时,使用一条完全没有错误的语句:

    update students set name='drake' where name='chuan';

     

    却报了如下错误:

    Error Code: 1175. You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column To disable safe mode, toggle the option in Preferences -> SQL Queries and reconnect.
    简单翻译一下:
    你正在使用 安全更新模式(safe upate mode)并且你在尝试 update 一个表时 没有用带有键的列 作为where条件,在首选项中切换选项。

     

    初学者在修改一个值时可能会用以下语句:

    update t set col='new_value' 

     

    而这正是很多人常犯的错误。因为他没有限定条件,会将表中所有的记录都修改一遍。

    为了防止这种错误出现,我们可以开启安全更新模式(safe update mode)

     

    set [global] SQL_SAFE_UPDATES = 1;

     

     

    update操作中:当where条件中列(column)没有索引可用且无limit限制时会拒绝更新。where条件为常量且无limit限制时会拒绝更新。

    delete操作中: 当①where条件为常量,②或where条件为空,③或where条件中 列(column)没有索引可用且无limit限制时拒绝删除。

     

    需要注意的是:

    update操作中,where可以为常量  ,where条件中列(column)可以没有索引。但是需要有limit限制。

    然而delete要严格一些:where不能为常量,且where条件中列(column)不能没有索引!


    1 .WHERE子句中使用的连接语句,在数据库语言中,被称为隐性连接。INNER JOIN……ON子句产生的连接称为显性连接。(其他JOIN参数也是显性连接)WHERE 和INNER JOIN产生的连接关系,没有本质区别,结果也一样。但是!隐性连接随着数据库语言的规范和发展,已经逐渐被淘汰,比较新的数据库语言基本上已经抛弃了隐性连接,全部采用显性连接了。

    2 .无论怎么连接,都可以用join子句,但是连接同一个表的时候,注意要定义别名,否则产生错误!

    a> left join:理解为“有效连接”,两张表中都有的数据才会显示left join:理解为“有左显示”,比如on a.field=b.field,则显示a表中存在的全部数据及a//b中都有的数据,A中有、B没有的数据以null显示

    b> right join:理解为“有右显示”,比如on a.field=b.field,则显示B表中存在的全部数据及a//b中都有的数据,B中有、A没有的数据以null显示

    c> full join:理解为“全连接”,两张表中所有数据都显示,实际就是inner +(left-inner)+(right-inner)

    3 .join可以分主次表   外联接有三种类型:完全外联,左联,右联.
    完全外联包含两张表的所有记录.
    左联是以左边的表为主,右边的为辅,右联则相反


    语法格式:
        其实 INNER JOIN ……ON的语法格式可以概括为:
        FROM (((表1 INNER JOIN 表2 ON 表1.字段号=表2.字段号) INNER JOIN 表3 ON 表1.字段号=表3.字段号) INNER JOIN 表4 ON Member.字段号=表4.字段号) INNER JOIN 表X ON Member.字段号=表X.字段号
        您只要套用该格式就可以了。
        
        现成格式范例:
        虽然我说得已经比较明白了,但为照顾初学者,我还是以本会员注册系统为例,提供一些现成的语法格式范例,大家只要修改其中的数据表名称和字段名称即可。
        
        连接两个数据表的用法:
        FROM Member INNER JOIN MemberSort ON Member.MemberSort=MemberSort.MemberSort
        语法格式可以概括为:
        FROM 表1 INNER JOIN 表2 ON 表1.字段号=表2.字段号
        
        连接三个数据表的用法:
        FROM (Member INNER JOIN MemberSort ON Member.MemberSort=MemberSort.MemberSort) INNER JOIN MemberLevel ON Member.MemberLevel=MemberLevel.MemberLevel 
        语法格式可以概括为:
        FROM (表1 INNER JOIN 表2 ON 表1.字段号=表2.字段号) INNER JOIN 表3 ON 表1.字段号=表3.字段号
        
        连接四个数据表的用法:
        FROM ((Member INNER JOIN MemberSort ON Member.MemberSort=MemberSort.MemberSort) INNER JOIN MemberLevel ON Member.MemberLevel=MemberLevel.MemberLevel) INNER JOIN MemberIdentity ON Member.MemberIdentity=MemberIdentity.MemberIdentity
        语法格式可以概括为:
        FROM ((表1 INNER JOIN 表2 ON 表1.字段号=表2.字段号) INNER JOIN 表3 ON 表1.字段号=表3.字段号) INNER JOIN 表4 ON Member.字段号=表4.字段号
        
        连接五个数据表的用法:
        FROM (((Member INNER JOIN MemberSort ON Member.MemberSort=MemberSort.MemberSort) INNER JOIN MemberLevel ON Member.MemberLevel=MemberLevel.MemberLevel) INNER JOIN MemberIdentity ON Member.MemberIdentity=MemberIdentity.MemberIdentity) INNER JOIN Wedlock ON Member.Wedlock=Wedlock.Wedlock
        语法格式可以概括为:
        FROM (((表1 INNER JOIN 表2 ON 表1.字段号=表2.字段号) INNER JOIN 表3 ON 表1.字段号=表3.字段号) INNER JOIN 表4 ON Member.字段号=表4.字段号) INNER JOIN 表5 ON Member.字段号=表5.字段号



    left join :左连接,返回左表中所有的记录以及右表中连接字段相等的记录。

    right join :右连接,返回右表中所有的记录以及左表中连接字段相等的记录。

    inner join: 内连接,又叫等值连接,只返回两个表中连接字段相等的行。

    full join:外连接,返回两个表中的行:left join + right join。

    cross join:结果是笛卡尔积,就是第一个表的行数乘以第二个表的行数。

    关键字: on

    数据库在通过连接两张或多张表来返回记录时,都会生成一张中间的临时表,然后再将这张临时表返回给用户。

    在使用left jion时,on和where条件的区别如下:

    1、 on条件是在生成临时表时使用的条件,它不管on中的条件是否为真,都会返回左边表中的记录。

    2、where条件是在临时表生成好后,再对临时表进行过滤的条件。这时已经没有left join的含义(必须返回左边表的记录)了,条件不为真的就全部过滤掉。

    假设有两张表:

    表1:tab2

    idsize
    110
    220
    330

    表2:tab2

    sizename
    10AAA
    20BBB
    20CCC

    两条SQL:
    1、select * form tab1 left join tab2 on (tab1.size = tab2.size) where tab2.name=’AAA’
    2、select * form tab1 left join tab2 on (tab1.size = tab2.size and tab2.name=’AAA’)

    第一条SQL的过程:

     

    1、中间表
    on条件:
    tab1.size = tab2.size
    tab1.idtab1.sizetab2.sizetab2.name
    11010AAA
    22020BBB
    22020CCC
    330(null)(null)

     

      
    2、再对中间表过滤
    where 条件:
    tab2.name=’AAA’
    tab1.idtab1.sizetab2.sizetab2.name
    11010AAA

     

      

     

    第二条SQL的过程:

     

    1、中间表
    on条件:
    tab1.size = tab2.size and tab2.name=’AAA’
    (条件不为真也会返回左表中的记录)
    tab1.idtab1.sizetab2.sizetab2.name
    11010AAA
    220(null)(null)
    330(null)(null)

     

     

    其实以上结果的关键原因就是left join,right join,full join的特殊性,不管on上的条件是否为真都会返回left或right表中的记录,full则具有left和right的特性的并集。 而inner jion没这个特殊性,则条件放在on中和where中,返回的结果集是相同的。


    连接查询与子查询

    初步实践证明:连接查询的性能优于子查询,所以能用连接查询的地方尽量少用子查询

    连接查询

    连接查询是将两个或多个的表按某个条件连接起来,从中选取需要的数据,连接查询是同时查询两个或两个以上的表的使用的。当不同的表中存在相同意义的字段时,可以通过该字段来连接这几个表。

     

         1.内连接查询

                内连接查询是一种最常用的连接查询。内查询可以查询两个或两个以上的表。举例说明两个表的连接查询。当该字段的值相等时,就查询出该记录。

          举个栗子~

           SELECT  num,name,employee.d_id,sex,d_name,function

                   FROM employee ,department

                    WHERE employee.d_id=department.d_id;

     

          2.外连接查询

                基本语法:

                     SELECT 属性名列表

                                    FROM 表名1  LEFT | RIGHT JOIN 表名2

                                    ON 表名1.属性1=表名2.属性2;

     

     

    • 左连接查询

                       进行左连接查询时,可以查出表1的表中所有记录,而表2所指的表中,只能查询出匹配的记录

     

    • 右连接查询

                      进行右连接查询时,可以查出表2的表中所有记录,而表1所指的表中,只能查询出匹配的记录

         3.复合·条件查询

                      在连接查询时,也可以增加其他的限制条件,使查询结果更加准确。

     

     

    子查询

           子查询是将一个查询语句嵌套在另外一个查询语句中,内层查询语句的查询结果,可以为外层查询语句提供查询条件。

              举个栗子~IN

              SELECT   *   FROM   employee

                           WHERE  d_id   IN

                             (SELECT   d_id    FROM   department);

              还 举个栗子~比较运算符

              SELECT  id ,name, score FROM computer_stu

                        WHERE  score>=

                               (SELECT score FROM scholarship

                                  WHERE level=1);

               还 举个栗子~EXISTS(表示存在,使用EXISTS关键字时,内层查询语句不反悔查询的记录,而是返回一个真假值)

              SELECT  *   FROM employee

                            WHERE EXISTS

                           ( SELECT d_name FROM department

                                        WHERE d_id =1003);

                还 举个栗子~ANY(表示满足其中任一条件)

                    如查询获得任意一个奖学金的最低分,即只要获得奖学金都满足条件

              SELECT * FROM computer_stu

                     WHERE score >=ANY

                             ( SELECT score FROM scholarship);

                   最后一个栗子~ALL(表示满足所有条件)

                    如查询获得最高奖学金的记录

               SELECT * FROM computer_stu

                      WHERE score >=ALL

                             ( SELECT score FROM scholarship);

     



    展开全文
  •  今日用MySQL Workbench进行数据库的管理更新时,执行一个更新的语句碰到以下错误提示:Error Code: 1175You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column...
  • 2、一旦加上where,则显示的结果等同于inner join; 先写结论: 过滤条件放在: where后面:是先连接然生成临时查询结果,然后再筛选 on后面:先根据条件过滤筛选,再连 生成临时查询结果 table1 left joi...
  • sql数据库多表查询之 where和INNER JOIN

    千次阅读 2019-03-27 16:11:59
    在多表查询中,一些SQL开发人员更喜欢使用WHERE来做join,比如: SELECT a.ID, b.Name, b.Date FROM Customers a, Sales b...在笛卡尔连接中,在上面的例子中,如果有1000顾客1000条销售记录,这个查询会先产生100...
  • Python中where()函数的用法详解

    千次阅读 2021-02-03 10:10:37
    本文主要大家介绍了详解Python中where()函数的用法,小编觉得挺不错的,现在分享给大家,也给大家做个参,希望能帮助到大家。where()的用法首先强调一下,where()函数对于不同的输入,返回的只是不同的。1当数组是...
  • Which statements are true regarding the WHERE and HAVING clauses in a SELECT statement? (Choose all that apply.) A. The HAVING clause can be used with aggregate functions in subqueries. B. Th
  • Linux下的用户一般都了解的一个命令应给非man莫属吧,但怎样才能更好的发挥的它的最大效用,另一个很实用的命令whereis不得不提:whereis:用来查询文件的二进制代码、源文件、man手册的位置等、看一下在Linux下它的...
  • SQL:WHERE子句中的IF子句

    千次阅读 2021-05-04 02:38:50
    您可以使用CASE如下:WHERE OrderNumber LIKE CASE WHEN IsNumeric(@OrderNumber) = 1 THEN @OrderNumber ELSE '%' + @OrderNumber END或者你可以使用像@JReed指出的IF语句。你应该可以做到这一点,没有任何IF或...
  • MySQL查询优化之一-WHERE语句优化

    千次阅读 2018-01-18 13:51:34
    MySQL查询优化之一-WHERE语句优化 ...QQ技术交流群:12951803 环境: MySQL版本:5.5.15 ... 这些示例使用SELECT语句,但是相同的优化适用于DELETEUPDATE语句中的WHERE语句。 查询速度比较快的一些示例:
  • 在高性能mysql第三版中的6.7.9节中有这样一段话:因为order by引入了文件排序,而where条件是在文件排序操作之前取值的,所以这条查询会返回表中的全部记录,解决这个问题的办法是让变量的赋值取值发生在执行查询...
  • I am trying to SELECT the the rows where a certain condition is met multiple times and how many times that condition is met.For example, for the table:Animal ID NumKids PostCodeCow 12...
  • 微信小程序云开发where查询语句字段名字段值都可以是变量想要实现的功能遇到的问题js代码 想要实现的功能 界面代码 // An highlighted block <view class="team_button"> <view bindtap="team_add" ...
  • Collection Collections 有什么区别

    万次阅读 2019-04-30 23:30:39
    Collection Collections 有什么区别? Collection是JDK中集合层次结构中的最根本的接口。定义了集合类的基本方法。源码中的解释: * The root interface in the <i>collection hierarchy</i>. A...
  • POSTGRESQL / mysql 索引区别(where)

    千次阅读 2016-03-17 11:48:28
    For example, given an index on (a, b, c) and a query condition WHERE a = 5 AND b >= 42 AND c , the index would have to be scanned from the first entry with a = 5 and b = 42 up through the last entry ...
  • layui的table的where缓存问题

    千次阅读 2019-09-19 17:47:14
    版本:layui-v2.4.3 原因在于这里: that.config = $.extend(true, {... that.config.where = that.config.firstWhere; 将初始化table时的条件,从新备份一份,为了再次重载table,依旧可以执行初始化的限制条件 ...
  • MySQL的查询执行计划中,Extra列经常会出现“Using where; Using index”。 MySQL官方手册解释: Using indexThe column information is retrieved from the table using only information in the index tree ...
  • sql_safe_updates参数可以限制不带where条件的update/delete语句执行失败,这个参数设置后,可以防止业务bug/漏洞导致把整个表都更新或者删除(线上发生过的案例),也可以防止DBA在线误操作更新/删除整张表。...
  • SQL join where 等多条件连用

    千次阅读 2017-03-23 22:13:00
    本文转 For simplicity, assume all relevant fields are NOT NULL. You can do: ... table1.this, table2.that, table2.somethingelse FROM table1, table2 WHERE table1.foreignkey = table2.p
  • Using where:表示优化器需要通过索引回表查询数据; Using index:表示直接访问索引就足够获取到所需要的数据,不需要通过索引回表; Using index condition:在5.6版本后加入的新特性(Index Condition Push...
  • <p>I suspect that the way I made it work (with the db object) smells bad. <p>Any suggestions? <pre><code>var ( orderBy string count uint where = map[string]interface{}{} data []ActorsWithFilms ...
  • I'm using the Laravel Eloquent query builder and I have a query where I want a WHERE clause on mult
  • SQL SELECT WHERE字段包含单词

    千次阅读 2020-05-08 09:21:57
    #4楼 select * from table where name regexp '^word[1-3]$' 要么 select * from table where name in ('word1','word2','word3') #5楼 Note that if you use LIKE to determine if a string is a substring of ...
  • Keras: Mergemerge区别、Sequencial()Model()区别

    万次阅读 多人点赞 2018-12-05 10:29:55
    本篇博客主要整合一些本人在阅读时感觉很有用的连接,非原创。 一、Mergemerge简介 Keras中提供了Mergemerge两个不同的功能(新的...关于这两者的区别,请详见链接:“Merge” versus “merge”, what is...
  • pandas where函数用法

    万次阅读 2018-09-22 23:04:42
    Series.where(cond, other=nan, inplace=False, axis=None, level=None, errors=‘raise’, try_cast=False, raise_on_error=None) 如果 cond 为真,保持原来的值,否则替换为other, inplace为真标识在原数据上操作...
  • WHERE中使用CASE

    千次阅读 2019-03-23 10:28:15
    CASE statements allow you to categorize data that you’re interested in – and exclude data you’re not interested in. In order to do this, you can use a CASE statement as a filter in the W...
  • 1、np.where(condition, x, y) condition:条件 x:满足条件时函数的输出 y:不满足条件时的输出 >>> import numpy as np >>> x = np.arange(6).reshape(2, 3) >>> x array([[0, 1, 2], ...
  • Oracle游标之select for update和where current of 语句 2013年06月27日 10:57:09  luckystar2008  阅读数:3150 转载 http://hanjiangduqiao.blog.163.com/blog/static/613105442011431111153601   ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 637,624
精华内容 255,049
热门标签
关键字:

where和that的区别