精华内容
下载资源
问答
  • 2021-01-20 00:16:07

    MySQL数据库去重的方法

    ​ 数据库最近有很多重复的数据,数据量还有点大,本想着用代码解决,后来发现用SQL就能解决,这里记录一下

    看这条SQL

    DELETE consum_record

    FROM

    consum_record,

    (

    SELECT

    min(id) id,

    user_id,

    monetary,

    consume_time

    FROM

    consum_record

    GROUP BY

    user_id,

    monetary,

    consume_time

    HAVING

    count(*) > 1

    ) t2

    WHERE

    consum_record.user_id = t2.user_id

    AND consum_record.monetary = t2.monetary

    AND consum_record.consume_time = t2.consume_time

    AND consum_record.id > t2.id;

    首先是将重复的记录查出来另存到一个集合(临时表t2), 集合里是每种重复记录的最小ID

    consum_record.user_id = t2.user_id

    AND consum_record.monetary = t2.monetary

    AND consum_record.consume_time = t2.consume_time

    AND consum_record.id > t2.id

    这些关联是判断重复基准的字段

    根据条件,删除原表中id大于t2中id的记录

    到这里欢呼一句 SQL大法好

    还是要多学习啊!SQL也不能拖后腿

    但是在处理完成之后,数据库中的主键id不是连续的了,强迫症犯了

    下面是解决办法:

    ​ 我这边处理方式是:先删除主键id字段,然后再重新生成主键id字段

    更多相关内容
  • 数据库去重语句

    千次阅读 2021-01-15 03:41:48
    sql语句去重sql语句通过DISTINCT关键字去重, 用于返回唯一不同的值。DISTINCT关键字需要搭配SELECT 语句使用,语法为SELECT DISTINCT 列名称 FROM 表名称。如果指定了 SELECT DISTINCT,那么 ORDER BY 子句中的项就...

    sql语句去重

    sql语句通过DISTINCT关键字去重, 用于返回唯一不同的值。DISTINCT关键字需要搭配SELECT 语句使用,语法为SELECT DISTINCT 列名称 FROM 表名称。如果指定了 SELECT DISTINCT,那么 ORDER BY 子句中的项就必须出现在选择列表中,否则会出现错误。

    扩展资料:

    distinct这个关键字用来过滤掉多余的重复记录只保留一条,但往往只用它来返回不重复记录的条数,而不是用它来返回不重记录的所有值。其原因是distinct只有用二重循环查询来解决,而这样对于一个数据量非常大的站来说,无疑是会直接影响到效率的。

    distinct必须放在开头,distinct语句中select显示的字段只能是distinct指定的字段,其他字段是不可能出现的。

    sql语句去重

    ---你上面写的

    delete x

    from A x

    where x.id > (select min(id) from A y where x.A1 = y.A1 and x.A2=y.A2);

    --方法一

    delete y

    from A y

    where y.id not in

    (

    select min(id) id

    from A

    group by A1,A2

    ) x

    --方法二

    --第一步

    select min(id) id,A1,A2

    into #aa

    from A

    group by A1,A2

    --第二步

    truncate table A

    --第三步

    insert into A

    select *

    from #aa

    drop table #aa

    一句SQL查询 要求去除重复语句

    declare @tid nvarchar(50),@username nvarchar(50),@oldusername nvarchar(50),@str nvarchar(150),@sql nvarchar(max)

    set @str=''

    declare g_cursor cursor for

    SELECT t.tid,u.username

    FROM `pw_threads` AS t, pw_members AS u

    WHERE t.authorid = u.uid

    AND NOT isnull( u.head )

    ORDER BY postdate DESC

    open g_cursor

    fetch next from g_cursor into @tid,@username

    while @@FETCH_STATUS=0

    begin

    if @oldusername <> @username

    set @str+=''+@tid+''+','

    fetch next from g_cursor into @tid,@username

    end

    close g_cursor

    deallocate g_cursor

    if @str <> ''

    begin

    set @str=SUBSTRING(@str,1,LEN(@str)-1)

    set @sql='select top 3 * from `pw_threads` AS t where tid in (@tid)'

    exec @sql

    end

    关于SQl语句去重的,怎么去掉重复的内容

    可以采用组函数Sql来实现:

    第一:可以把重复的行找出来:

    select Dept_Guid,Category_Guid from 表名 group by Dept_Guid,Category_Guid havingcount(*)>1;

    第二:把这些数据插入到一个中转表中;

    SQL 略

    第三:把原表中的重复数据删除;

    SQL 略

    第四:把备份到中转表中的唯一化之后的数据,再插入原来的表中。

    SQL 略

    展开全文
  • 数据库去重

    2018-04-12 17:31:18
    转载地址:https://blog.csdn.net/anya/article/details/6407280/用SQL语句,删除掉重复项只保留一条在几千条记录里,存在着些相同的记录,如何能用SQL语句,删除掉重复的呢1、查找表中多余的重复记录,重复记录是根据...
    转载地址:https://blog.csdn.net/anya/article/details/6407280/

    用SQL语句,删除掉重复项只保留一条

    在几千条记录里,存在着些相同的记录,如何能用SQL语句,删除掉重复的呢
    1、查找表中多余的重复记录,重复记录是根据单个字段(peopleId)来判断
    select * from people
    where peopleId in (select peopleId from people group by peopleId having count(peopleId) > 1)

    2、删除表中多余的重复记录,重复记录是根据单个字段(peopleId)来判断,只留有rowid最小的记录
    delete from people
    where   peopleName in (select peopleName    from people group by peopleName      having count(peopleName) > 1)
    and   peopleId not in (select min(peopleId) from people group by peopleName     having count(peopleName)>1)

    3、查找表中多余的重复记录(多个字段)
    select * from vitae a
    where (a.peopleId,a.seq) in (select peopleId,seq from vitae group by peopleId,seq having count(*) > 1)

    4、删除表中多余的重复记录(多个字段),只留有rowid最小的记录
    delete from vitae a
    where (a.peopleId,a.seq) in (select peopleId,seq from vitae group by peopleId,seq having count(*) > 1)
    and rowid not in (select min(rowid) from vitae group by peopleId,seq having count(*)>1)

    5、查找表中多余的重复记录(多个字段),不包含rowid最小的记录
    select * from vitae a
    where (a.peopleId,a.seq) in (select peopleId,seq from vitae group by peopleId,seq having count(*) > 1)
    and rowid not in (select min(rowid) from vitae group by peopleId,seq having count(*)>1)   

    6.消除一个字段的左边的第一位:

    update tableName set [Title]=Right([Title],(len([Title])-1)) where Title like '村%'

    7.消除一个字段的右边的第一位:

    update tableName set [Title]=left([Title],(len([Title])-1)) where Title like '%村'

    8.假删除表中多余的重复记录(多个字段),不包含rowid最小的记录
    update vitae set ispass=-1
    where peopleId in (select peopleId from vitae group by peopleId




    eg:select * from payrecdb.dt_strongrelation x
    where (x.payOrRelUserID ,x.rcvOrRelUserID) in (select payOrRelUserID,rcvOrRelUserID from payrecdb.dt_strongrelation group by payOrRelUserID,rcvOrRelUserID having count(*) > 1)

    展开全文
  • 浅谈sql数据库去重

    2020-09-10 13:30:33
    关于sql去重,我简单谈一下自己的理解和经验,如果各位有建议或有不明白的欢迎多多指出。
  • 一、Oracle数据库去重(推荐放在在第6点) 1、环境准备 可以看到“ALLEN”和“SMITH”这两个人的数据重复了,现在要求表中name重复的数据只保留一行,其他的删除。 CREATE TABLE hwb( id int, name varchar(10...

    目录

    概述

    一、Oracle数据库去重(推荐放在在第6点)

    二、MySQL数据库去重

    三、sqlserver数据库去重

    四、pg数据库删除重复数据


    概述


    转发这个主要是有时会有重复数据的需求,留一个查询方法,大家有空也可以测试一下..


    一、Oracle数据库去重(推荐放在在第6点)

    1、环境准备

    可以看到“ALLEN”和“SMITH”这两个人的数据重复了,现在要求表中name重复的数据只保留一行,其他的删除。

    CREATE TABLE hwb(
        id int,
        name varchar(10)
    );
    
    INSERT INTO hwb VALUES(1, 'TOM');
    INSERT INTO hwb VALUES(2, 'ALLEN');
    INSERT INTO hwb VALUES(3, 'ALLEN');
    INSERT INTO hwb VALUES(4, 'SMITH');
    INSERT INTO hwb VALUES(5, 'SMITH');
    INSERT INTO hwb VALUES(6, 'SMITH');
    commit;
    SELECT * FROM hwb;

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    2、实现方法一:通过分组后,拿最小的id重复删除

     delete from hwb a where a.id  in      
       (select min(id) FROM hwb a group by name having count(name) > 1)

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    3、实现方法二:通过name相同,id不同的方式来判断

    DELETE FROM hwb a
     WHERE EXISTS (SELECT 1
              FROM hwb b
             WHERE a.name = b.name
               AND a.id > b.id);

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    4、实现方法三:用rowid代替id,替换删除

    DELETE FROM hwb a
     WHERE EXISTS (SELECT 1
              FROM hwb b
             WHERE a.name = b.name
               AND a.rowid > b.rowid);

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    5、实现方法四:通过分析函数根据name分组生成序号,然后删除序号大于1的数据。

    语法格式:row_number() over(partition by 分组列 order by 排序列 desc)

    在使用 row_number() over()函数时候,over()里头的分组以及排序的执行晚于 where 、group by、 order by 的执行。

    DELETE FROM hwb a
    WHERE ROWID IN (SELECT rid
                       FROM (SELECT ROWID as rid,
                                    ROW_NUMBER() OVER(PARTITION BY name ORDER BY id) AS seq
                               FROM hwb)
                      WHERE seq > 1);

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     


    6、【推荐】实现方法五:根据rowid删除

    DELETE FROM hwb a
     WHERE a.ROWID > (SELECT MIN(b.ROWID) FROM hwb b WHERE a.name = b.name);

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     


    二、MySQL数据库去重

    1、环境准备

    CREATE TABLE hwb(
        id BIGINT (4) not null,
        name varchar(10),
        PRIMARY KEY (id) 
    ) ENGINE = INNODB;
    
    INSERT INTO hwb VALUES(1, 'TOM');
    INSERT INTO hwb VALUES(2, 'ALLEN');
    INSERT INTO hwb VALUES(3, 'ALLEN');
    INSERT INTO hwb VALUES(4, 'SMITH');
    INSERT INTO hwb VALUES(5, 'SMITH');
    INSERT INTO hwb VALUES(6, 'SMITH');
    commit;
    SELECT * FROM hwb;

    2、实现方法一:通过分组后,拿最大/最小的id重复删除

    --重复删除多次
    delete from hwb 
    where id in (select id from 
           (select max(b.id) as id FROM hwb b group by name having count(name) > 1)c )
    
    --或者修改为以下,只需删除一次
    delete from hwb 
    WHERE
    NAME IN (select name from ( SELECT NAME FROM hwb b GROUP BY NAME HAVING count( NAME ) > 1 ) t)
    AND id NOT IN (select tt.id from (SELECT max(c.id ) as id FROM hwb c GROUP BY NAME HAVING count( NAME ) > 1 ) tt)

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    3、实现方法二:

    根据name分组,查找出id最小的,然后再查找id不包含刚才查出来的。这样就查询出了所有的重复数据(除了id最小的那行)

    delete from hwb 
    WHERE
     id NOT IN (select tt.id from (SELECT min(c.id ) as id FROM hwb c GROUP BY NAME ) tt)

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    4、实现方法三:通过name相同,id不同的方式来判断

    delete  from hwb  where  id in ( 
    select id from (
    select * from hwb a
    WHERE EXISTS (SELECT 1
              FROM hwb b
             WHERE a.name = b.name
               AND a.id > b.id))c );

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    5、实现方法四:用rowid代替id,替换删除

    在 Oracle 数据库的表中的每一行数据都有一个唯一的标识符,称为 rowid ,在 Oracle 内部通常就是使用它来访问数据的。

    而在 MySQL 中也有一个类似的隐藏列 _rowid 来标记唯一的标识。但是需要注意 _rowid 并不是一个真实存在的列,其本质是一个 非空唯一列 的别名。

    在某些情况下 _rowid 是不存在的,其只存在于以下情况:

    1)当表中存在一个 数字类型 的单列主键时, _rowid 其实就是指的是这个主键列

    2)当表中 不存在主键 但存在一个 数字类型 的 非空唯一列 时, _rowid 其实就是指的是对应 非空唯一列 。

    需要注意以下情况是不存在 _rowid 的

    1)主键列 或者 非空唯一列 的类型不是 数字类型

    2)主键 是联合主键

    3)唯一 列不是非空的。

    delete  from hwb  where  id in ( 
    select id from (
    select * from hwb a
    WHERE EXISTS (SELECT 1
              FROM hwb b
             WHERE a.name = b.name
               AND a._rowid > b._rowid))c );

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    ps:还可考虑表切换完成去重步骤。


    三、sqlserver数据库去重

    1、环境准备

    CREATE TABLE [dbo].[hwb] (
      [id] decimal(12)   NULL,
      [name] nvarchar(10) COLLATE Chinese_PRC_CI_AS  NOT NULL
    )
    GO
    
    ALTER TABLE [dbo].[hwb] SET (LOCK_ESCALATION = TABLE)
    GO
    
    INSERT INTO hwb VALUES(1, 'TOM');
    INSERT INTO hwb VALUES(2, 'ALLEN');
    INSERT INTO hwb VALUES(3, 'ALLEN');
    INSERT INTO hwb VALUES(4, 'SMITH');
    INSERT INTO hwb VALUES(5, 'SMITH');
    INSERT INTO hwb VALUES(6, 'SMITH');
    GO


    2、实现方法一:通过分组后,拿最大/最小的id重复删除

    --重复删除多次
    delete from hwb 
     where id  in
           (select min(id) FROM hwb a group by name having count(name) > 1)
    
    --或者修改为以下,只需删除一次
    select * from hwb 
    -- delete from hwb
    WHERE
    NAME IN (SELECT NAME FROM hwb b GROUP BY NAME HAVING count( NAME ) > 1 )
    AND id NOT IN (SELECT max(c.id ) as id FROM hwb c GROUP BY NAME HAVING count( NAME ) > 1 )

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    3、实现方法二:根据name分组,查找出id最小的,然后再查找id不包含刚才查出来的

    这样就查询出了所有的重复数据(除了id最小的那行)

    delete from hwb 
    WHERE
     id NOT IN (select tt.id from (SELECT min(c.id ) as id FROM hwb c GROUP BY NAME ) tt)

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    4、实现方法三:通过name相同,id不同的方式来判断

    DELETE FROM hwb a
     WHERE EXISTS (SELECT 1
              FROM hwb b
             WHERE a.name = b.name
               AND a.id > b.id);

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    5、实现方法四:用hash值代替id,替换删除

    %%lockres%%会返回聚集索引键的hash值,

    非聚集索引,%%lockres%%会返回非聚集索引键的hash值

    delete from hwb a
     WHERE EXISTS (SELECT 1
              FROM hwb b
             WHERE a.name = b.name
               AND a.%%lockres%% > b.%%lockres%%);

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    6、实现方法五:通过分析函数根据name分组生成序号,然后删除序号大于1的数据。

    语法格式:row_number() over(partition by 分组列 order by 排序列 desc)

    在使用 row_number() over()函数时候,over()里头的分组以及排序的执行晚于 where 、group by、 order by 的执行。

    DELETE FROM hwb a
    WHERE
    	id IN (
    	SELECT	b.id 
    	FROM	(SELECT id, ROW_NUMBER () OVER ( PARTITION BY name ORDER BY id ) AS seq FROM hwb) b 
    	WHERE	b.seq > 1 );

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    7、【推荐】实现方法六:根据hash值删除

    DELETE FROM hwb a
     WHERE a.%%lockres%% > (SELECT MIN(b.%%lockres%%) FROM hwb b WHERE a.name = b.name);

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     


    四、pg数据库删除重复数据

    1、环境准备

    set search_path to 'public'; 
    \dt   --list tables
    CREATE TABLE hwb(
        id INT PRIMARY KEY  NOT NULL,
        name CHAR(10));
    
    INSERT INTO hwb VALUES(1, 'TOM');
    INSERT INTO hwb VALUES(2, 'ALLEN');
    INSERT INTO hwb VALUES(3, 'ALLEN');
    INSERT INTO hwb VALUES(4, 'SMITH');
    INSERT INTO hwb VALUES(5, 'SMITH');
    INSERT INTO hwb VALUES(6, 'SMITH');
    SELECT * FROM hwb;

    2、实现方法一:通过分组后,拿最大/最小的id重复删除

    --重复删除多次
    delete from hwb 
    where id in (select max(b.id) as id FROM hwb b group by name having count(name) > 1)
    
    --或者修改为以下,只需删除一次
    delete  from hwb 
    WHERE
    NAME IN (SELECT NAME FROM hwb b GROUP BY NAME HAVING count(NAME) > 1)
    AND id NOT IN (SELECT max(c.id ) as id FROM hwb c GROUP BY NAME HAVING count( NAME ) > 1);

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    3、实现方法二:

    根据name分组,查找出id最小的,然后再查找id不包含刚才查出来的。这样就查询出了所有的重复数据(除了id最小的那行)

    delete  from hwb 
    WHERE id NOT IN (SELECT min(c.id ) as id FROM hwb c GROUP BY NAME );

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    4、实现方法三:通过name相同,id不同的方式来判断

    delete from hwb a
    WHERE EXISTS (SELECT 1
              FROM hwb b
             WHERE a.name = b.name
               AND a.id > b.id);

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    5、[推荐]实现方法四:用ctid代替id,替换删除

    delete from hwb a
    WHERE EXISTS (SELECT 1 FROM hwb b
    WHERE a.name = b.name AND a.ctid > b.ctid);
    
    --或者如下:
    select * from hwb WHERE ctid NOT IN (SELECT min(ctid) as id FROM hwb GROUP BY NAME );

     

    超详细的四类数据库去重实现方案汇总,值得收藏

     

    6、[最高效推荐]实现方法五:用ctid代替id,结合row_number替换删除

    delete FROM hwb a WHERE a.ctid = 
    ANY (array (SELECT ctid FROM (SELECT row_number() over(PARTITION BY NAME) as seq, ctid FROM hwb ) t 	
    WHERE t.seq > 1));

     

    超详细的四类数据库去重实现方案汇总,值得收藏

    本文转载至头条用户“波波说运维”

     

     

    展开全文
  • 数据库去重有很多方法,下面列出目前理解与使用的方法第一种通过group by分组,然后将分组后的数据写入临时表然后再写入另外的表,对于没有出现再group by后面的field可以用函数max,min提取,效率较高--适合情况:...
  • 一、distinct 位置1. 单独的distinct只能放在开头,否则报错,语法错误mysql>SELECTnickname,DISTINCT(openid)fromims_ewei_shop_member;[SQL]SELECTnickname,DISTINCT(openid)fromims_ewei_shop_member;...
  • 数据库去重操作

    2018-08-08 12:00:35
    $test_data = M('hot'); //实例化数据表 $data = $test_data-&gt;Distinct(true)-&gt;field('descriprion')-&... //利用distinct方法去重 $data = $test_data-&gt;group('description')-...
  • mysql数据库去重

    2021-01-18 18:16:11
    ##问题mysql数据库表osc_table_a中出现了重复记录,需要通过sql来去重,仅留下最早插入的记录。表osc_table_a:id row1 row2 row31 123 abc *****2 123 def *****3 123 abc *****4 456 ...
  • 例如数据库表中有以下数据 以下代码会返回user_login字段不同的数据 Db::table('think_user')->distinct(true)->field('user_login')->select(); 生成的SQL语句是:SELECT DISTINCT user_login FROM...
  • oracle 数据库去重查询

    万次阅读 2019-01-31 15:50:00
    oracle数据库中有如下一张表,包含id,loginid,name,researchtime等字段,其中name字段中的数据有重复,查询数据时要重复数据只取一条,利用row_number ()over(partition by 列 order by 列 desc)方法实现 ...
  • 千万级数据 在一张表中 如果没有索引 怎么样去重? 常规方法 distinct 或者是 先查重复的 再join 掉 但是会很慢 解决方法 意思是创建一个表b 创建唯一索引 在倒过去 把表b改名A
  • MongoDB数据库去重操作

    千次阅读 2018-11-02 11:34:26
    关于pymongo的去重方法, 网上找了老半天,都没有发现单独对...而且并不是说执行过后, 就把数据库中重复的内容删除了, 因此并没有达到我的需求 所以自己就重新尝试着写了一下去重的方法 def delete_repeat_d...
  • mysql去重面试总结前言:题目大概是这样的。建表:1、查找表中多余的重复记录,重复记录是根据单个字段(Id)来判断网上答案:select * from 表 where Id in (select Id from 表 group byId having count(Id) > 1)...
  • 重复数据在数据库执行更新操作 $insertAllSql = Db::name(self::$tableName)->strict(false)->fetchSql(true)->insertAll($value); $insertAllSql .= ' ON DUPLICATE KEY UPDATE province_id = values...
  • 数据库的实际操作中,经常会遇到这样的情况:不同id所对应的信息是相同的,即行数据相同。下面我将分别针对三种常用的数据库找出重复的记录,并将其进行删除。 一:SQL server数据库 delete [db_BaiDuDB]....
  • oracle 数据库 去重查询

    万次阅读 多人点赞 2017-05-22 14:34:11
    数据库多字段去重 方法介绍:distinct 关键字、group by 、row_number() over()
  • 因为周末几天的数据库出了点问题,在补充几天数据的时候,忘记更改了日期,导致补充到数据库的数据多了一些重复数据,如下图所示: 解决办法 经过资料查找,用到了rowid, row_number(), partition by, rowid是...
  • sql数据库去重实例

    2018-08-17 11:38:07
    实现数据库表多条件去除重复,在开发项目的过程中遇到类似的问题,所以总了一个例子
  • MongoDB数据库去重

    2018-03-22 21:07:00
    爬一个专利网站,主要工作流是先把列表页下所有的专利包括专利号、专利名称、URL放到数据库的一个文档info中,再抽取info中的URL进行爬取详情页,爬取列表页的信息做了一个去重,爬一个就在数据库里查一个。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 77,538
精华内容 31,015
关键字:

数据库去重