“已经把所有简称整理出来了”

这样的话，假设你已经把简称存到了 A表 的 name列 里，且原始字符串不存在歧义（可能判断出多个小区），那么可以使用like或者instr函数进行关联.假设原字符串存在于B表的ADDR列

select * from B LEFT JOIN A ON B.ADDR LIKE CONCAT(‘%’,A.NAME,‘%’);
select * from B LEFT JOIN A ON INSTR(B.ADDR,A.NAME)>0;

当然也可以使用标量子查询，方法类似。

没有设置启动光盘，请确保选择了正确的启动光盘

你这个格式像个json又不是json，这样输出出来，应用识别不了啊，而且你这分组啥都没做，直接一个select *查给应用，让应用自己做分组展示不好么？
下面这个是在mysql 8.0版本输出json信息

with t as(
select ‘张三’ name,‘四川’ province ,‘30岁’ age union all
select ‘李四’,‘北京’,‘20岁’ union all
select ‘王五’,‘四川’,‘22岁’)

select json_objectagg(province,j) from (
select province,JSON_ARRAYAGG(json_object(‘name’,name,‘province’,province,‘age’,age)) j from t group by province) x

declare
v_emp varchar2(1000);
begin
  select ‘员工Gee的工作是：’ || b.job_title || ‘，他的薪水是：’ || a.salary
    into v_emp
    from hr.employees a, hr.jobs b
   where a.job_id = b.job_id
     and last_name = ‘Gee’;
     dbms_output.put_line(v_emp);
end;

把 number(5) 改成 number
oracle里的参数类型都是不要标长度的，无论是过程参数还是游标参数

去你11g的库里，把这个type "type_split"的代码复制到12c里创建一下

1. 你这是用的什么操作系统？
2. 点开详细资料，看里面说了些啥？

从oracle支持网站检索得到，19c版本支持在win10 64位系统上运行，不支持在32位系统上运行，另外，家庭版也不支持

这张单据存到数据库里，常见的是用两张表，

单据头表：退货单号、退货日期、厂商编号、采购员、检验员
单据行表：退货单号、商品编号、（型号）、（等级）、退货数量、单价

厂商名称，从厂商基础信息表里面取；
商品名称从商品基础信息表里取;
型号和规格是存单据表还是从商品基础信息表里取，主要看商品基础架构和业务逻辑设计是怎样的；
单据行表里的金额，用退货数量乘以单价计算得到；
总金额根据上面计算出来的金额再进行求和得到。

我猜你这个数据是每个会员只有一行记录，后面的开始时间结束时间间隔时间很长，甚至可能达到几年，你想得到的结果是每天都有一行记录，然后对于每一个会员都要和每天来进行匹配，也就是说要将这个开始日期结束日期展开到每一天，然后再进行count。
不确定你是用的什么数据库，一般也就两种方式，
第一种，先明确你是想查哪天到哪天的数据，然后找个日历表，每天都有一行的那种，把这个日历表和你的表关联起来，关联条件为 "日期表.日期 between 会员表.开始日期 and 会员表.结束日期",然后"group by 日期表.日期"，前面 "select 日期表.日期,count(1)"即可
第二种，不使用实体的日历表，而是使用with递归出一个日历表，后面的步骤和第一种一样了。
至于unix_timestamp转换，不同数据库方式不一样，而且也不麻烦，就不多说了

方法一，再union all一行求和的select
方法二，使用rollup

with tmp(name,l) as ( –实际数据
    select ‘李’,‘画画’ from dual union all
    select ‘张’,‘吃饭/睡觉’ from dual union all
    select ‘王’,‘抽烟/喝酒/打球’ from dual
),
t(name,L,lvl) as
 (select name, regexp_substr(L, ‘[^/]+’, 1, 1) L, 2 lvl
    from tmp
  union all
  select x.name, regexp_substr(x.L, ‘[^/]+’, 1, t.lvl), t.lvl + 1
    from tmp x, t
   where t.name = x.name
     and regexp_count(x.L, ‘[^/]+’) >= t.lvl)
select NAME, L from t;

建议把里面用到的表的表结构也提供一下，这样答题人可以自行验证下是否正确。
这个基本功能是可以实现的，但是做不到百分百的转换，比如最后面这个获取错误信息，两个数据库里的定义是不一样的，有几个值在oracle里没有，还有那个host也是要根据这个存储过程的调用方式来看是加到数据库触发器里还是加到应用代码里。再一个就是“@WaitList”这玩意建议提前建一个临时表，就不需要转成oracle的数组来处理了

下面这个语法基本已经调整得查不多了，但是没有你的表，就没有全部改完，尤其是有些字段类型不知道是什么，比如说日期处理什么的，像那个convert我就暂时没改，剩下的你自己应该能改了吧

已按对应的字段类型，修改了相关函数，编译无报错了，这个全局临时表是会话级的，多会话并发不会产生冲突，会话结束后表里就没数据了。
不确定你的oracle的版本，如果是18c以上，可以用私有临时表（或叫专用临时表），效果和你之前的这个差不多。

create global temporary table WaitList (wlId int,
    isremark int,orderid int,
    Entertime date, NewEntertime date,
    ConcludeEntertime date,
    ReasonName varchar2(100), 
    UpdateFlag Int);
CREATE OR REPLACE FUNCTION fn_getname
   RETURN VARCHAR2
IS
   l_owner    VARCHAR2 (30);
   l_name     VARCHAR2 (30);
   l_lineno   NUMBER;
   l_type     VARCHAR2 (30);
BEGIN
   OWA_UTIL.who_called_me (l_owner, l_name, l_lineno, l_type);
   RETURN l_owner || ‘.’ || l_name;
END;
/
create or replace procedure P_SetPosition_Waitlist_mz(sys_id       varchar2, –子系统ID
                                                      ctrllerid    varchar2, –诊区ID
                                                      queueid      varchar2, –队列ID
                                                      userid       varchar2, –用户
                                                      callerid     varchar2, –诊室
                                                      worktype     in out varchar2, –班别
                                                      smsno        varchar2, –ID唯一值
                                                      ReasonName   varchar2, –备注说明
                                                      BeLateForMin int, –迟到分钟
                                                      neworderid   in out int, –调整位置
                                                      Flag         int, –标志
                                                      O_Error      Out int, –错误标志
                                                      ErrMsg       Out varchar2 –错误提示
                                                      ) as

BEGIN

  O_Error := 0;
  ErrMsg  := ‘’;
  –处理记录  
  if worktype IS NULL THEN
    worktype := (case
                  when TO_CHAR(SYSDATE, ‘HH24:MI:SS’) <
                       ‘13’ || CHR(58) || ‘30’ || CHR(58) || ‘00’ then
                   0
                  else
                   1
                end);
  END IF;
  if sys_id IS NULL THEN
  
    O_Error := 2;
    ErrMsg  := ‘子系统ID为空值’;
  end IF;
  if ctrllerid IS NULL THEN
    O_Error := 2;
    ErrMsg  := ‘诊区ID为空值’;
  end IF;
  if queueid IS NULL THEN
    O_Error := 3;
    ErrMsg  := ‘队列ID为空值’;
  end IF;
  if smsno IS NULL THEN
    ErrMsg  := ‘ID唯一值为空值’;
    O_Error := 4;
  end IF;

  if NVL(neworderid, 0) < 1 THEN
    O_Error := 5;
    ErrMsg  := ‘调整位置必须大于0’;
  end IF;

  delete WaitList where 1 = 1;

  insert into WaitList
    (wlId,
     orderid,
     isremark,
     Entertime,
     NewEntertime,
     ConcludeEntertime,
     ReasonName,
     UpdateFlag)
    select wlID,
           ROW_NUMBER() OVER(order by(Case
             When Remark1 = ‘未报到’ then
              0
             else
              1
           end) DESC, nvl(PriorId, 0) DESC, isremark DESC /1优先号/, ConcludeEnterTime ASC, qno ASC) as orderid,
           isremark,
           EnterTime,
           NewEnterTime,
           ConcludeEnterTime,
           remark1,
           0
      from (select wlID,
                   isremark,
                   to_date( EnterTime,‘yyyy-mm-dd hh24:mi:ss’) EnterTime,
                   NewEnterTime,
                   ConcludeEnterTime,
                   qno,
                   remark1,
                   nvl(PriorId, 0) as PriorId
              From v_JH_waitlist_mz
             where CtrllerID = CtrllerID
               and QueueID = QueueID
               and Remark1 <> ‘未报到’
               and worktype = worktype
               and trunc(to_date(EnterTime,‘yyyy-mm-dd hh24:mi:ss’))=trunc( sysdate)
               and curstatus = 0
               and wlID <> smsno
            union all
            select wlID,
                   isremark,
                   to_date( EnterTime, ‘yyyy-mm-dd hh24:mi:ss’) EnterTime,
                   NewEnterTime,
                   ConcludeEnterTime,
                   qno,
                   remark1,
                   nvl(PriorId, 0) as PriorId
              From v_JH_waitlist_mz
             where wlID = smsno
               and worktype = worktype) v;

  declare
    tmporderId    int;
    TempwlId      int;
    tmporderId2   int;
    countOrderId2 int;
    EnterTime     varchar2(30);
  begin
  
    select Orderid, EnterTime
      into tmporderId2, EnterTime
      from WaitList
     where wlID = smsno;
  
    if Flag = 1 then
      if (sysdate - to_date(EnterTime, ‘yyyy-mm-dd hh24:mi:ss’)) * 24 * 60 <
         BeLateForMin then
        neworderid := 1; –未迟到 迢回排在第一位
      end if;
    end if;
  
    –print ‘aa’
    –print tmporderId2
    if tmporderId2 > neworderid then
    
      –设置新序号
      –print ‘原序号’+ cast(tmporderId as varchar2(30))+‘>新序号’+cast(neworderid as varchar2(30)) 
      update WaitList set orderid = neworderid where wlID = smsno;
      IF sql%ROWCOUNT > 0 then
      
        ErrMsg := cast(tmporderId2 as varchar2) || ‘>’ ||
                  cast(neworderid as varchar2);
      
      ELSE
      
        ErrMsg := cast(tmporderId2 as varchar2) || ‘!>’ ||
                  cast(neworderid as varchar2);
      END if;
    
      for Order_Cursor in (select WlId, orderid
                             from WaitList
                            where wlID <> smsno) loop
      
        TempwlId   := Order_Cursor.WlId;
        tmporderId := Order_Cursor.orderid;
      
        if (tmporderId < tmporderId2) and (tmporderId >= neworderid) then
        
          update WaitList
             set orderid = tmporderId + 1
           where wlID = TempwlId;
        end if;
      
      End loop;
    
    elsif tmporderId2 < neworderid then
    
      –print ‘原序号’+ cast(tmporderId as varchar2(30))+‘<新序号’+cast(neworderid as varchar2(30)) 
      update WaitList set orderid = neworderid where wlID = smsno;
      IF sql%ROWCOUNT > 0 then
      
        ErrMsg := cast(tmporderId2 as varchar2) || ‘<’ ||
                  cast(neworderid as varchar2);
      
      ELSE
      
        ErrMsg := cast(tmporderId2 as varchar2) || ‘!<’ ||
                  cast(neworderid as varchar2);
      end if;
      for Order_Cursor2 in (select WlId, orderid
                              from WaitList
                             where wlID <> smsno) loop
      
        TempwlId   := Order_Cursor2.WlId;
        tmporderId := Order_Cursor2.orderid;
      
        if (tmporderId > tmporderId2) and (tmporderId <= neworderid) then
        
          update WaitList
             set orderid = tmporderId - 1
           where wlID = TempwlId;
        
        End if;
      end loop;
    else
    
      –print ‘原序号’+ cast(tmporderId as varchar2(30))+‘=新序号’+cast(neworderid as varchar2(30)) 
      ErrMsg := cast(tmporderId2 as varchar2) || ‘=’ ||
                cast(neworderid as varchar2);
    end if;
  
    declare
      isremark2     int;
      newEntertime2 date;
      ReasonName2   varchar2(50);
    begin
      if (tmporderId2 = neworderid) then
      
        select isremark, ConcludeEnterTime - 1 / 24 / 60 / 60, ReasonName
          into isremark2, newEntertime2, ReasonName2
          from WaitList
         where orderid = neworderid;
        update WaitList_mz
           set isremark       = isremark2,
               newentertime   = newEntertime2,
               remark1        = ReasonName,
               CallbackReason = ReasonName2,
               curstatus      = 0,
               issendled      = 0,
               issound        = 0,
               IfTurnEarlier  = 1
         where wlID = smsno;
        O_Error := O_Error + O_Error;
      
      elsif (neworderid = 1) and (tmporderId2 <> neworderid) then
      
        –print neworderid
        select isremark, ConcludeEnterTime - 1 / 24 / 60 / 60, ReasonName
          into isremark2, newEntertime2, ReasonName2
          from WaitList
         where orderid = 2;
        –print newEntertime2
        –print ‘新序号’+cast(neworderid as varchar2(30))+‘;排序时间:’+cast(newEntertime2 as varchar2(30)) 
        update WaitList_mz
           set isremark       = isremark2,
               newentertime   = newEntertime2,
               remark1        = ReasonName,
               CallbackReason = ReasonName2,
               curstatus      = 0,
               issendled      = 0,
               issound        = 0,
               IfTurnEarlier  = 1
         where wlID = smsno;
        update stat_mz set memo = ReasonName where waitid = smsno;
        O_Error := O_Error + O_Error;
      
      elsif (neworderid > 1) and (tmporderId2 <> neworderid) then
      
        select COUNT(orderid) into countOrderId2 from WaitList;
        IF countOrderId2 >= neworderid then
        
          select isremark, ConcludeEnterTime + 1 / 24 / 60 / 60, ReasonName
            into isremark2, newEntertime2, ReasonName2
            from WaitList
           where orderid = neworderid - 1;
        
        ELSE
        
          select isremark, ConcludeEnterTime + 1 / 24 / 60 / 60, ReasonName
            into isremark2, newEntertime2, ReasonName2
            from WaitList
           where orderid = countOrderId2 - 1;
        END if;
        –print ‘新序号’+cast(neworderid as varchar2(30))+‘;排序时间:’+cast(newEntertime2 as varchar2(30)) 
        update WaitList_mz
           set isremark       = isremark2,
               newentertime   = newEntertime2,
               remark1        = ReasonName,
               CallbackReason = ReasonName2,
               curstatus      = 0,
               issendled      = 0,
               issound        = 0,
               IfTurnEarlier  = 1
         where wlID = smsno;
        update stat_mz set memo = ReasonName where waitid = smsno;
        O_Error := O_Error + O_Error;
      
      end if;
    end;
  end;
  /* if  Flag<2 THEN
  
      select  Error INTO  Error,ErrMsg INTO  ErrMsg FROM DUAL;
  end IF;/ –这一段不了解业务含义
  /
  select wlID,isremark,EnterTime=Convert(datetime,EnterTime,121),NewEnterTime,ConcludeEnterTime,qno
  From v_JH_waitlist where CtrllerID=CtrllerID and QueueID=QueueID 
  and worktype=worktype 
  and datediff(d,EnterTime,sysdate)=0 and curstatus=0
  Order by isremark,ConcludeEnterTime,qno
  /

exception
  when others then
    rollback;
    BEGIN
      DECLARE
        o_error_number    int;
        o_error_message   nvarchar2(2048);
        o_error_severity  int;
        o_error_state     int;
        o_error_line      int;
        o_error_procedure nvarchar2(126);
        o_user_name       nvarchar2(128);
        o_host_name       nvarchar2(128);
      begin
      
        o_error_number    := SQLCODE;
        o_error_message   := sqlerrm || ErrMsg;
        o_error_severity  := null; –ERROR_SEVERITY();
        o_error_state     := null; –ERROR_STATE();
        o_error_line      := dbms_utility.format_error_backtrace();
        o_error_procedure := fn_getname();
        o_user_name       := user; –SUSER_SNAME();
        o_host_name       := null; –HOST_NAME();
      /  INSERT into dbo.Mx_ErrorLog
          (ferror_number,
           ferror_message,
           ferror_severity,
           ferror_state,
           ferror_line,
           ferror_procedure,
           fuser_name,
           fhost_name,
           Findate)
        VALUES
          (o_error_number,
           o_error_message,
           o_error_severity,
           o_error_state,
           o_error_line,
           o_error_procedure,
           o_user_name,
           o_host_name,
           sysdate);
        commit;*/
        EXECUTE IMMEDIATE Q‘{ SELECT ‘User: :1,
         Host: :2, Procedure: :3, Error :4, Level :5, 
         State :6, Line :7, Message: :8 ’
          FROM DUAL }’
          INTO o_error_message
          USING o_user_name, o_host_name, o_error_procedure, o_error_number, o_error_severity, o_error_state, o_error_line, o_error_message;
        Raise_application_error(-20001, o_error_message);
      
      end;
    END;
END;
/

只要一个值：

select max(avgs) from (
select sno,avg(grade) as avgs
from stu_course
group by sno) t

保留平均值:

select sno,avg(grade) as avgs,
max(avg(grade)) over() maxs
from stu_course
group by sno

1521不行就1522，
5521有可能被docker禁用或者被主机占用。
另外就是你可以换个docker镜像，我现在用的这个,挺正常的，构建代码也是开源的

wnameless/oracle-xe-11g-r2

select regexp_substr(opstaion,‘\d{11}’) from a

select zzz.
  from zzz
 where decode(to_char(sysdate, ‘q’), ‘1’, ‘4’, ‘2’, ‘1’, ‘3’, ‘2’, ‘4’, ‘3’) =
       to_char(to_date(yf, ‘yyyymm’), ‘q’)
   and decode(to_char(sysdate, ‘q’),
              ‘1’,
              to_char(sysdate, ‘yyyy’) - 1,
              substr(yf, 1, 4)) = substr(yf, 1, 4)

select zzz.,avg(fs) over() avg_fs
  from zzz
 where decode(to_char(sysdate, ‘q’), ‘1’, ‘4’, ‘2’, ‘1’, ‘3’, ‘2’, ‘4’, ‘3’) =
       to_char(to_date(yf, ‘yyyymm’), ‘q’)
   and decode(to_char(sysdate, ‘q’),
              ‘1’,
              to_char(sysdate, ‘yyyy’) - 1,
              substr(yf, 1, 4)) = substr(yf, 1, 4)

因为没这种语法，而且逻辑上也说不过去。
"if not exists" 的意思是 “如果不存在，就…”，这个只能针对create操作，"如果不存在，则创建"，这多么合理。
但像drop和alter，总不能“如果不存在这个数据库就删除这个数据库”或者“如果不存在这个数据库就修改这个数据库”吧？

你这样写sql，执行会报语法错误。
一个标量子查询是作为select后面的一个字段，因此注定只能返回一行一列，如果查了多个列，就会报错

select 关键字段 from 表  group by 关键字段 
having count( case when A字段 is null then 1 else null end )=0

因为CBO觉得你加的这个hint太离谱了，消耗成本过高，因此它自行选择了成本更低的方式。
你可以先尝试一下更新这个表的统计信息再试，如果依旧没有full，说明可能的确不适合用full
另外，不同版本的数据库，CBO算法不完全一样

用coalesce函数

select coalesce(wk1,wk2,wk3,wk4,wk5,wk6,wk7,wk8,wk9,wk10) from 表

这个要看你的数据库是什么，以及版本号是多少。
现在很多数据库都支持with递归查询，不需要写循环,你可以先用 "with 递归 sql"作为关键词搜索一下相关文章，如果不会的话再问，或者看我之前的一些回答

mysql递归如何实现，p_uid对应的uid数量-大数据-CSDN问答

CSDN问答为您找到mysql递归如何实现，p_uid对应的uid数量相关问题答案，如果想了解更多关于mysql递归如何实现，p_uid对应的uid数量 sql 技术问题等相关问答，请访问CSDN问答。



https://ask.csdn.net/questions/7667773?answer=53725612

然后下面这个页面有大量的sql问答，就是数据量太大，加载有点慢，等加载完后可以按单个关键词在页面中搜索相关sql

少了as,没有end loop

CREATE OR REPLACE PROCEDURE “test” as
BEGIN
  FOR list IN (SELECT DISTINCT pmd.ACCOUNT_NUMBER AS ACCOUNT_NUMBER,
                               ppv.MLOC           AS PPVMLOC,
                               ppv.BOM_NUM        AS PPVBOM_NUM,
                               ppv.SERIALNUM      AS PPVSERIALNUM
                 FROM PPS_MBOM_DETAILED_0415 pmd
                 LEFT JOIN (SELECT a.TOP_PLAN_NUM,
                                  a.MLOC,
                                  a.BOM_NUM,
                                  a.SERIALNUM
                             FROM PPS_PLAN_VIN a
                             LEFT JOIN (SELECT TOP_PLAN_NUM,
                                              max(VERSIONS) AS max_VERSIONS
                                         FROM PPS_PLAN_VIN
                                        GROUP BY TOP_PLAN_NUM) b
                               ON a.TOP_PLAN_NUM = b.TOP_PLAN_NUM
                              AND a.VERSIONS = b.max_VERSIONS) ppv
                   ON ppv.TOP_PLAN_NUM = pmd.account_number) loop
  
    insert into PPS_MBOM_INFO_TEST a
    values
      (seq_pps_mbom_info_test.nextval.nextval,
       list.ACCOUNT_NUMBER,
       list.PPVMLOC,
       list.PPVBOM_NUM,
       list.PPVSERIALNUM);
  END loop;
  commit;
END;

主要看你的“数字”是否存在算数计算，如果不存在计算，而且长度还较长，那么存成字符类型是合理的

因为你group by了cno，每个cno就只会取一条，然后其他字段随机取一行。
这个语法在目前的标准sql语法里是不对的

in和out的位置不对

CREATE OR REPLACE PROCEDURE sp_test8( monthe in int,season out  varchar)

另外，oracle不建议使用varchar，而应该使用varchar2

把你操作系统环境变量path里的东西贴出来一下，看看是不是系统本来的一些环境变量被清掉了

把下面这些都加进去

C:\Windows\system32
C:\Windows
C:\Windows\System32\Wbem
C:\Windows\System32\WindowsPowerShell\v1.0<br/>C:\Windows\System32\OpenSSH<br/>%SystemRoot%\system32
%SystemRoot%
%SystemRoot%\System32\Wbem
%SYSTEMROOT%\System32\WindowsPowerShell\v1.0<br/>%SYSTEMROOT%\System32\OpenSSH<br/>

数字没加引号，前面的0会被省略。其实你直接执行一下下面的这条sql就知道区别了

select convert(nvarchar(20),‘012345678’) a,convert(nvarchar(20),012345678) b

你确定你连的是同一个数据库？在oracle官方文档中有说明

NLS_LANG FAQ





https://www.oracle.com/database/technologies/faq-nls-lang.html

SELECT USERENV (‘language’) FROM DUAL; gives the session’s _ but the DATABASE character set not the client, so the value returned is not the client’s complete NLS_LANG setting!

翻译如下

SELECT USERENV (‘language’) FROM DUAL;得到当前会话的 语言_地区 以及 数据库字符集,不是客户端的字符集,所以它返回的值不是完整的客户端NLS_LANG设置!

也就是说，你linux那台机器连接的数据库的字符集是AL32UTF8;你用PLSQLDEV连接的数据库的字符集是ZHS16GBK，连接的是两个不同的数据库。

能通过环境变量保持一致的，只有前面的 语言和地区，而后面的字符集无论怎么改，只要连的是同一个数据库，那么都会保持一致。
详见

【ORACLE】谈一谈Oracle数据库使用的字符集,不仅仅是乱码_DarkAthena的博客-CSDN博客_oracle数据库默认字符集

一、前言先看一个比较有意思的案例上面这个sql,查询了a和b两个字段,均为"张三"两个汉字,并且使用length函数检查,长度均为2。但是,当你看到下面这几个sql的输出结果时,很有可能第一反应是:"这特喵的怎么可能？“其实,你所看到的两个"张三”,的确长得是一模一样,用显微镜去看也不可能看到区别。但为什么a和b不相等呢？这是因为组成他们的成分不一样,这个成分就是 字符集二、什么是字符集？百度百科简单来说,字符（Character）是各种文字和符号的总称，包括各国家文字、标



https://darkathena.blog.csdn.net/article/details/122659532

拼个字符串作为一个字段，这个字段内的内容是 "select * from 用户名.表名"

放大了仔细看，这两玩意不一样的，一个是尖括号，一个是圆括号

create table user
(id char(6) not null primary key,
name char(6) not null,
major char(10) not null);

首先你要确认一下是数据乱码了还是你本地客户端和代码页字符集不匹配。
本地客户端的字符集是在环境变量NLS_LANG中设置的，windows和linux都有这个环境变量，所以就算你是华为的工作环境，也同样是可以设置的.
至于代码页字符集，其实就是你程序的查询窗口定义的字符集，或者是你使用的开发语言定义的字符集。
详细可以参考我这篇文章

【ORACLE】谈一谈Oracle数据库使用的字符集,不仅仅是乱码_DarkAthena的博客-CSDN博客_oracle数据库默认字符集

一、前言先看一个比较有意思的案例上面这个sql,查询了a和b两个字段,均为"张三"两个汉字,并且使用length函数检查,长度均为2。但是,当你看到下面这几个sql的输出结果时,很有可能第一反应是:"这特喵的怎么可能？“其实,你所看到的两个"张三”,的确长得是一模一样,用显微镜去看也不可能看到区别。但为什么a和b不相等呢？这是因为组成他们的成分不一样,这个成分就是 字符集二、什么是字符集？百度百科简单来说,字符（Character）是各种文字和符号的总称，包括各国家文字、标



https://darkathena.blog.csdn.net/article/details/122659532?spm=1001.2014.3001.5502

where (字段1,字段2) in (
(字段1参数1,字段2参数1),
(字段1参数1,字段2参数2),
(字段1参数1,字段2参数3),
(字段1参数2,字段2参数1),
(字段1参数2,字段2参数2),
(字段1参数2,字段2参数3),
)

或者

where (
字段1=字段1参数1 and 字段2 in (字段2参数1,字段2参数2,字段2参数3)
) or (
字段1=字段1参数2 and 字段2 in (字段2参数1,字段2参数2,字段2参数3)
)

 select b.table_name,b.comments,a.created,a.LAST_DDL_TIME
   from dba_objects a, dba_tab_comments b
  where a.object_name = b.table_name
    and a.owner = b.owner
    and a.owner = ‘用户名’
    and b.table_name in (‘表名1’,‘表名2’)

ENUM类型常见于MYSQL数据库中，
oracle数据库里没有enum类型，因此不存在你说的转换。

要把计算机科学理解成一种工具，一种用来解决其他领域中遇到的问题的工具，而不是为了研究计算机科学而去研究计算机科学，不能本末倒置。

把下面的where条件改下

你写的那个存在条件，由于没有和其他表关联，所以只要有一条满足，返回就是true，就相当于没有where条件了，查的是全部记录

在oracle数据库中，任何以select形式查到的字符集，都是客户端字符集，用select是查不到服务端字符集的(网上很多文章都是错的)。
对于oracle数据库而言，查询显示乱码，是由于客户端字符集和代码页字符集不一致导致的，与服务端字符集关系不大。
在你这个例子里，客户端字符集在环境变量中配置，代码页字符集即为cmd窗口的字符集，可以通过输入chcp 936切换成gbk，或者输入chcp 65001切换成utf8,之后再连接数据库操作。
建议你把环境变量NLS_LANG改成

SIMPLIFIED CHINESE_CHINA.AL32UTF8

然后打开cmd，输入chcp 65001回车，再连接数据库执行查询。
另外，如果数据本身就已经是乱码进的数据库，你怎么改设置也还会是乱码，这种情况需要进行对数据进行转码处理了。

更多与oracle字符集的介绍，可以参考我这篇文章

【ORACLE】谈一谈Oracle数据库使用的字符集,不仅仅是乱码_DarkAthena的博客-CSDN博客_oracle数据库默认字符集

一、前言先看一个比较有意思的案例上面这个sql,查询了a和b两个字段,均为"张三"两个汉字,并且使用length函数检查,长度均为2。但是,当你看到下面这几个sql的输出结果时,很有可能第一反应是:"这特喵的怎么可能？“其实,你所看到的两个"张三”,的确长得是一模一样,用显微镜去看也不可能看到区别。但为什么a和b不相等呢？这是因为组成他们的成分不一样,这个成分就是 字符集二、什么是字符集？百度百科简单来说,字符（Character）是各种文字和符号的总称，包括各国家文字、标



https://darkathena.blog.csdn.net/article/details/122659532?spm=1001.2014.3001.5502

SELECT education,gender,AVG(year(now())-year(date_of_birth)) AS 平均年龄 
FROM tbl_employees GROUP BY education,gender

select的非聚合函数字段，都要放到group by 后面

请说明一下你用的是什么数据库，以及数据库版本，还有你这个日期字段的数据类型是什么。
如果是要分别查两个汇总，直接写where条件限定时间，然后sum即可。
如果是要同时查两个汇总，那么where条件里写时间最大的范围，在sum里写case when条件来限定时间。
然后重点就是根据一个指定的日期计算月初和计算年初是分别哪一天了，这关键就看你用什么数据库，因为不同数据库计算日期的函数及方式不一样，而且还要根据字段类型来选择不同的处理方式

把下面where条件中指定的这个日期替换成你的变量即可

create table test_20220424 (a smalldatetime);
insert into test_20220424 values (‘2022-04-24’);
insert into test_20220424 values (‘2022-04-01’);
insert into test_20220424 values (‘2022-01-24’);
insert into test_20220424 values (‘2022-03-24’);

–指定日期的月初至指定日期
select  from test_20220424 where 
a between convert(varchar(8),‘2022-04-24’,120)+‘1’ and ‘2022-04-24’;

–指定日期的年初至指定日期
select  from test_20220424 where 
a between convert(char(4),year(‘2022-04-24’))+‘0101’ and ‘2022-04-24’;

用dateadd函数计算，减一年，就是去年当日

dateAdd(year,-1,‘2022-04-24’)

然后拿这个去年当日，套用上面的方法，可得去年当日的当月

convert(varchar(8),dateAdd(year,-1,‘2022-04-24’),120)+‘1’ 

同理，拿今年的年初 convert(char(4),year(‘2022-04-24’))+‘0101’ 减1年，就能得去年的年初

dateAdd(year,-1,convert(char(4),year(‘2022-04-24’))+‘0101’)

当然也可以用上面计算年初的方式，传入去年当日 dateAdd(year,-1,‘2022-04-24’)

convert(char(4),year(dateAdd(year,-1,‘2022-04-24’)))+‘0101’

日期计算这玩意就是层层套娃，只要知道几个基本的函数，转换加减就行了
至于between and语法不需要我解释了吧？

如果是要得到去重后的结果并且显示每个值有多少条相同的记录，直接用count

select A，count(1)  from 表 group by A

如果是想保留原始记录行数，新增一列显示本行的这个值有多少个相同的值，用开窗函数count

select A，count(1)  over () from 表 

xmltype是一种类型，而不是值，要打开后才能看到里面的数据，或者转换类型来直接显示，比如用to_number转换成数字显示

select to_number(column_value) from xmltable(‘1,2,3’);

另外再给你几种方式

select regexp_substr(‘1,2,3’,  ‘[^,]+’,1, level)
  from dual
connect by level <= regexp_count(‘1,2,3’, ‘[^,]+’)

select * from table(ora_mining_number_nt(1,2,3));

bit表示 一个二进制数字，只能为0或者1，所以不能定义长度，也不能放除0或1或null以外的值。
你如果要用1和2，把类型改成int吧

还需要了解一下A/B/C三个字段的值的分布，比如去重后只有两个值的，或者每个值都不一样的，还有一半的值一样另一半的值都不一样。。。等等不同情况，需要结合这些值的情况，包括你数据的增删改场景，才能综合判断该如何建索引。
有些人会粗暴的直接根据你这3个sql建三个索引，但这是不可取的，因为索引多了会影响写入性能，还占用了大量的存储空间。

提sql题建议把表结构和模拟数据发出来，纯文字描述不一定描述得清楚，而且答题人还要自行去编写create table和insert语句，很浪费时间，这样就几乎没人会理你这种提问方式了。
我猜测，你这是一个表有18个列，想把这18个列做行列转换，变成18个行；第2个就是固定前8列，然后新增一列，新增的这一列来自于第9列到第18列的行列转换。
如果是我猜的这样，那么使用unpivot写法即可

create table test_20220423 (
c1 number,c2 number,c3 number,c4 number,c5 number,
c6 number,c7 number,c8 number,c9 number,c10 number,
c11 number,c12 number,c13 number,c14 number,
c15 number,c16 number,c17 number,c18 number
);
insert into test_20220423 values (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18);
commit;

select * from test_20220423 unpivot 
(val for col in (c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15,c16,c17,c18) );

select * from test_20220423 unpivot 
(val for col in (c9,c10,c11,c12,c13,c14,c15,c16,c17,c18) );

下面是将字符串’1-18周’拆成1-18的这18行的方式

with t as
 (select ‘1-18周’ a from dual)
select regexp_substr(replace(a, ‘周’), ‘[^-]+’, 1, 1) + level-1 b
  from t
connect by regexp_substr(replace(a, ‘周’), ‘[^-]+’, 1, 1) + level-1 <=
           regexp_substr(replace(a, ‘周’), ‘[^-]+’, 1, 2)

建议把背景描述一下，看看是个什么需求，具体问题具体分析，不能一上来就好像必须要进行大表join。
比如如果最终结果需要经过where过滤，且只返回少量数据，那么可以先针对两个表分别过滤，然后再join。
而且如果机器配置好的话，几十万的数据真不算大。

你想一下，join之后，难道就把这几十万都输出到前端展现么？难道前端或者用户不会先指定查询条件？如果有指定查询条件的话，就不再需要对全部的数据去进行join了呀。当你第一个表把数据过滤掉了绝大部分，再去左关联其他表，也就只会去找剩下的这几行。
就算是不输入任何查询条件，分页其实也算是个条件，比如每页十行，第一个表查前十行记录作为子查询，再左连接其他表，得到第一页的数据。
mysql是可以设定内存占用大小的。

不能只看sql的，同一个sql，表的索引建的方式或者索引类型不一样，可能会出现不同的情况，实际还是要看执行计划。
大多数情况下来说，普通的索引都不支持like模糊查找，除非是全文索引。
所以针对你这两个条件，都是既可以走索引也可以不走索引

表不多的话，直接join就行了，但你这要200个表一起的话，join性能就抗不住了，需要分批join。
比如基表和表1join后得到一个临时表，然后临时表再join表2得到一个新的临时表，就这样一直循环下去。
至于代码编写，用拼接字符串的方式来拼接动态sql执行即可。
取字段的话，用Select name from syscolumns Where ID=OBJECT_ID('表名') and name <>'编号' 作为游标循环拼接字符串。

select a.userid,a.item from 表1 a 
where not exists 
(select 1 from 表2 b where 
a.userid=b.userid and a.item=b.item)

字段间要有逗号间隔

CREATE TABLE Student
(Sno CHAR(9) PRIMARY KEY,
Sname CHAR(20),
Ssex CHAR(2),
Sage SMALLINT,
Sdept CHAR(20)
);

能给个报错截图么？
如果你题目中的就是你执行的sql，那么肯定是会报错的，因为你括号不对，输成全角的了。
还有，既然是要算每个系，那肯定应该还要有个group by 系列呀。
另外，你这题目描述也有问题，“插入”肯定是insert，而且插入一定是插入新行，但是你这又要插入旧表，两个结构不一致的数据放在了同一个表里，原题真是这么描述的么？难道不是让你把比值更新到原表的每一行去么？

不确定你机器配置怎么样，如果性能不行，就写过程分批处理；
如果性能比较好，那么直接用row_number对整个数据排个序号，然后 取 round(序号,-2)=序号 的，即为要保留的，同理，round(序号,-2)<>序号 的，即为要删除的。
但是，对于一个大表，要删除大量数据，保留小量数据，更常见的做法是把要保留的数据create table as 一个新表，然后修改表名替换即可，因为delete这个操作开销太大了，应该尽量避免大量的delete

因为你"NOT（employee_id"这个中间的括号是全角的，导致把这一串都当成一个字段了，
not在某些时候是很有用的，楼上说不会带来太大简化，不够恰当

select student_id,
max(case  type when  ‘yu’ then score end) yu, 
max(case  type when  ‘shu’ then score end) shu, 
max(case  type when  ‘ying’ then score end) ying, 
max( time) time from 成绩表
group by student_id

题目里没写字段类型，自己改下

create procedure test_func(i_lzbh number) is
begin
  for rec in (select t.rowid rd from tmp_house t where 楼幢编号 = i_lzbh) loop
    update tmp_house
       set 备注 = case
                  when 面积 <= 80 then
                   ‘小户型’
                  when 面积 <= 140 then
                   ‘中房型’
                  else
                   ‘大户型’
                end
     where rowid=rec.rd;
  end loop;
  insert into tmp_test(户型 ,个数,总面积,平均面积)
    select 备注, count(1), sum(面积), avg(面积)
      from tmp_house where 楼幢编号 = i_lzbh
     group by 备注;
  commit;
end;

因为你这个json是个列表（以"[“开头，以”]“结尾），所以你定位的路径不对，要先取这个列表中的第一个元素，然后再往下找imageUrl。

select JSON_EXTRACT(title_image,‘$[0].imageUrl’) as cc , a.* from housing_investment a;

或者先把”[]"去掉，再用你写的这个来定位

在select 后面加上 top 3即可，比如

SELECT top 3 表1.ID, 表1.字段1
FROM 表1;

纯select的sql是不能实现动态列的，sql必须在查询发出前就已经确定好有哪些列，包括列名和数据类型，这与sql解析器本身的逻辑有关。
就算是其他数据库中的pivot或者unpivot的写法，也都是要指定列（目前真正唯一支持动态列的可能只有oracle18c的多态表函数功能）。
对于一般的数据库，可以通过在存储过程中拼接动态sql字符串来执行，你可以搜一下 “动态sql”去了解一下，这也是在数据库里执行的，没有使用到其他开发语言。

F5执行计划贴一下，然后如果把LISTAGG这个列改成简单的count，时间消耗差异有多大？
另外，你用的oracle版本是多少？如果是在18c及之后，可以把within开始的后面一整段都去掉，即不进行组内排序，能省一点开销

把数据读出来，通过网络传输到客户端内存，再由客户端把数据页面渲染出来，这些总得消耗时间吧

建议你用记事本打开一下这个sql文件看看，这玩意看上去不是纯sql文件，报错信息里还有sqlite的字样

查询是为了输出数据，如果只是为了删除，那么你加where条件直接删除这条数据就行了，没必要再去查询它

为啥子下面执行的显示是没加引号？
理论上是加了单引号就不会报这个错

图能不能截全点？看不出你这是一个表的字段内容还是别的什么东西。
如果是表的话，查看这个表的ddl建表语句就知道它每个字段是什么类型了。
肉眼看字段内容是无法准确识别字段类型的，必须以表结构定义为准

我见过不少数据库了，你这个真碰到我的盲区了，我竟然一时看不出这是啥子数据库。但是根据单词来分析，word应该是一种文本类型 类似于char；second应该是一种时间类型，而且很有可能是以秒为单位。至于asc，就可能要结合一下数据来看了，不确定是指的ascii还是指的排序中的asc，如果是排序中的asc，那么它就有可能是数字类型。
如果你能给一下数据库名称，倒是可以去找找官方文档的说明

CASE WHEN status=5 THEN enddate ELSE null END  as enddate

贴一下你这个表的表结构，不确定你的日期是哪个字段；
或者直接用下面这个试试

insert into student values(‘22030809’,‘里斯’,‘男’,‘28’,‘计算机’,‘软件工程161’,null,null)

在sql标准中，select后面的非聚合函数字段，必须都放到group by后面去。只有老版本的mysql没这个要求，因而会出现查询出来的数据出现随机性。其他数据库以及mysql8.0开始都是严格执行sql标准。
像你上面这个sql，应该加上 group by 订单.订购日期,订单.发货日期

鼠标右键此文件，点属性-安全，添加你的电脑用户名，勾上完全控制的权限，确定，之后就能自由修改了。
或者，在开始菜单中，对着记事本程序鼠标右键，使用管理员身份打开，然后选择文件-打开，下面文件类型改成全部，定位到host文件的目录，打开host文件，也可以自由修改

请检查你的mysql版本号，开窗函数要8.0及之后才支持

SELECT SPID, JG ,RQ FROM 
(select A.*,B.RQ ,
ROW_NUMBER() OVER(PARTITION BY A.DJBH ORDER BY RQ DESC) RN
 from A, B WHERE A.DJBH=B.DJBH) T
WHERE T.RN=1

要安装个java 1.8，并配置好java_home的环境变量

表的别名不能接在from后面。
你第一个sql实际上把B表查了两次。
另外不确定你最后是不是省略了A表和B表的关联条件，这个不关联会导致数据行数翻倍。常见的写法应该长这样

select
(select name from B b
where a.id=b.id) name
from A a

或者

select b.name  name
from A a left join B b 
on a.id=b.id

如果数据都能匹配上的话，还可以这么写

select b.name  name
from A a , B b 
where a.id=b.id

如果要多次使用某个表，可以使用with，例如

with b as (select * from B)
select
(select name from b
where a.id=b.id) name
from A a,b;

不能，两者根本不是一个类型的数据库。
mongodb是文档数据库，mysql是关系型数据库，两者各有所长，
应针对不同的数据本身的特点及数据的应用方式来选择将不同的数据存在不同的数据库中

group by后面不要带别名，select了啥就group by啥（除了聚合函数字段）

select a.stt_psn_type, a.med_pool_type, a.insutype,
nvl(a.grp_type, ‘A’) grp_type, nvl(sum(n), 0) amt
from tp.mdtrt_d a,
tp.setl_d b,
tp.setl_ext_d c
where a.mdtrt_id = b.mdtrt_id
and b.setl_id = c.setl_id
and a.vali_flag = ‘1’
and b.new_setl_id is null
and b.init_setl_id is null
and c.code = ‘dejzyzje’
and nvl(c.n, 0) <> 0
and exists (select ‘X’
from tp.setl_ext_d
where setl_id = c.setl_id
and code = ‘hxjsh-2’
and c in (select year_end_setl_id
from tp.year_end_setl_d
where dfr_id = ‘1’))
group by a.stt_psn_type, a.med_pool_type, a.insutype,
nvl(a.grp_type, ‘A’)

• 方案一，mysql8.0可以用with递归出一个完整的日期列表

  with RECURSIVE  cte as
  (select  date‘2019-01-01’ d
  union all
  select DATE_ADD(d, INTERVAL 1 DAY)
    from cte
   where DATE_ADD(d, INTERVAL 1 DAY) <= date‘2019-12-31’)
  select d  from cte
  

  
  

• 方案二，借用一个带递增列的系统表

  select DATE_ADD(date‘2019-01-01’, INTERVAL help_topic_id DAY)
  from mysql.help_topic where help_topic_id<=180
  

  
  

不同的数据库，时间处理函数不一样，但是思路是一样的，即让时间进行偏移，让两个时间点都落在一天内，就可以进行group by 了。
比如你是想统计 "每天晚上20：00到次日早上8：00"（这里应该为7:59:59,否则要多减1秒才能放到前一天），那么可以把字段减8个小时，条件其实就变成了
“每天12：00：00到23：59：59”，再把日期给格式化成年月日，group by 这个日期就可以愉快的sum了

sqlserver 限定行数的写法为 top

在sqlserver2012后支持 OFFSET 和 FETCH

动态sql肯定是在dba_dependencies查不到的，因为动态sql就是个字符串文本而已，oracle在编译阶段不会对这些字符串进行任何校验，你想怎么拼接就可以怎么拼接，只有在执行到对应的execute immediate 的时候才会对动态sql的合法性进行校验，因此oracle无法提前知晓依赖关系。

declare
  a varchar2(40) := ‘dba’;
  b varchar2(40) := ‘_’;
  c varchar2(40) := ‘views’;
  i number;
begin
  execute immediate 'select count(1)  from ' || a || b || c
    into i;
end;

比如这个例子，整个代码里不包含"dba_views"，但实际上查的又是“dba_views”这个视图，如果把参数c的值换成别的，同样的代码查询的又是不同的视图了

你这个sql逻辑不对，语法也不对。
首先括号就没成对，然后where 后面是不能出现聚合函数来作为条件的，聚合函数条件只能放在having后面。
你这里的where是想把不同的行放到一行来比较，只能先用开窗函数把两行的值拉到一行，再去计算。
建议提供原始表结构及数据样本，并用文字说明你想要实现的逻辑，最好能用表格举例

底层处理是没有"年龄"概念的，你这个操作就是简单的把一个数字加1，然后更新（update）到这个字段上而已。再底层一点，就得扯到二进制上去了。
如果要实现动态的年龄，完全可以改成存个出生日期（或者只存出生年份），然后计算当前年份和出生年份的差即可获得年龄，也不需要每年去更新数据了

第一条sql中的子查询，查出来的是12个不同的值，而不是行记录，然后再从sc表里去找满足这12个值的行记录，可以找到有37行（等同于 in ('11111','2222','3333','4444','5555',…)）。
第二条sql，把行记录用distinct去重后，得到的是12个值，所以count就是12了

使用开窗函数的滑动窗口即可

select t.*,
sum(Qty) over(partition by CPNum order by DocDate) JCSL 
from table1 t

【ORACLE】谈一谈分析函数（窗口函数）的前世今生-那些可能不为人知的事_DarkAthena的博客-CSDN博客

一、前言经常写报表sql的小伙伴，应该都知道"分析函数"这一强大的功能，常见用法比如 取分组TOP-N、滚动求和、取当前行的上（下）N行等等。不过本篇不会再对这些常见基础用法进行介绍，只会说说那些关于"分析函数"可能不被人注意的事。二、最早使用分析函数的数据库有文章里说过，分析函数最早是在ORACLE8.1.6中出现的，我翻了下8.1.6和8.0的文档，发现的确如此（8.1.5版本文档已被移除，暂无法确认）而ORACLE8.1.6是在1999年11月发布的，因此早在二十多年前（此文创作日期为2022



https://darkathena.blog.csdn.net/article/details/123701128?spm=1001.2014.3001.5502

sqlserver2008还不支持开窗函数中用order by,至少要到sqlserver2012.
所以你这个问题只能用循环去解决了

只有在命令行里才能用exec命令来执行存储过程，在sql窗口中一般都是用下面这种方式来执行的

begin
存储过程名称(参数1,参数2);
end;
/

clickehouse支持窗口函数，可以使用lag配合sum来获取变化的位置

大概像下面这样，我这里没数据环境不好测试。

select fanId,min(create_time) create_time from (
select t.*,
sum(lag) over (PARTITION BY fanId ORDER BY create_time) s from 
(select id ,create_time, DS ,fanId,
   case when any(DS) OVER (PARTITION BY fanId ORDER BY create_time  ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING) = DS 
   then 0 else 1 end lag 
from fan) t) t2
group by fanId,s

原理就是上一行和当前行相等时计为0，不等时计为1，然后使用滑动窗口求和，就能在每次数据变化的时候加1，这样就能把数据按顺序切分开了，再按这个字段group by，就可以取每组最大和最小的时间

你的sql文件里有"\b"这个东西，不符合sql语法，无法识别

group by 后面把select的非聚合函数的字段或表达式放进去就行了，你这里是select的case when，那么group by后面也要有同样的case when

select case when age < 25 or age is null
 then “25岁以下” 
when age >= 25 then “25岁及以上”
  end as age_cut, 
   count(*) number
  from user_profile
 group by case when age < 25 or age is null
 then “25岁以下” 
when age >= 25 then “25岁及以上”
  end;

有以下几种可能

1. 它不是视图，而是个表或者是个物化视图
2. 它不在你当前用户下

因为你没写几个表之间的关联条件，导致产生了笛卡尔积，一个表的每一行都可以和另一个表的每一行匹配。正常的表关联应该类似下面这样

select * from a,b where a.字段名=b.字段名;
—或者
select * from a join n on a.字段名=b.字段名;

建议用having替代where条件，减少一层嵌套。然后建议用join替代这个exists条件。因为很明显里面的这个sql才应该是主驱动表，条件都是基于b表的，应该先确定要查哪些cst_id后，再用这些cst_id查a表。而不是针对a表的每一行去查哪些cst_id满足条件

题主没说明是想改表结构还是说在sql语法代码上进行兼容。如果是改表结构，这对之前的程序逻辑会有影响可能会需要大量调整程序逻辑。如果是改sql，只要用函数to_number转换一下这个字段就行了

先单独查xs表，并写条件 xs.专业名='计算机'，看能不能查到记录。如果能查到，再随便取一个学号，单独查xs_kc表，看找不找得到记录。

如果你表里面本就没有对应的数据，是count不出一条新的记录的。此时可以多次查询然后再union all或者分成不同的字段查询再进行行列转换

不同数据库支持的函数是有区别的，least函数在mysql和oracle中是支持的，在sqlserver中不支持

这个建议查看一下执行计划，可能会使用也可能不会使用，这个要看数据库本身的优化。会使用时，说明数据库自动进行了谓词内推

sqlserver不支持limit语法，请使用top语法或者开窗函数row_number

火鸟数据库简单语法可参考这篇文章

FIREBIRD常用SQL - 走看看

一、分页写法小例： select first 10 templateid,code,name from template ; select first 10 skip 10 templateid,co



http://t.zoukankan.com/top5-p-1433010.html

select first 10 templateid,code,name from template ;
select first 10 skip 10 templateid,code,name from template ;
select * from shop rows 1 to 10; –firebird2.0支持这种写法

数据库里建两个表，一个记录批次，每行为一个批次，有主键id作为批次id，然后第二个表记录题目明细，并记录对应的批次id。然后页面上可以显示批次id列表或者可以指定批次id查询题目明细

你这sql和下面这个貌似是等价的

SELECT STOCK_NAME,
       TIME_TO_MARKET(T.STOCK_NAME) TRADE_DAYS,
       COUNT(1) STOCK_COUNT,
       CASE  WHEN TIME_TO_MARKET(T.STOCK_NAME) = T2.STOCK_COUNT THEN
          1  ELSE 0  END TF
  FROM JQDATA.ORDER_ACTIVITIES
 GROUP BY STOCK_NAME
having TIME_TO_MARKET(T.STOCK_NAME) <> COUNT(1)

其实效率点应该先考虑一下这个TIME_TO_MARKET自定义函数,毕竟这玩意要作为条件使用,看能不能把逻辑拆开,放到sql里

直接把所有帖子按顺序拼成一个字符串,再判断和wang的是否相等即可

select user_id from (
select user_id,group_concat(post_id ORDER BY post_id) g ,
max(case when user_id=‘wang’ then group_concat(post_id ORDER BY post_id) end ) over() w
from remark group by user_id) t
where g=w and user_id<>‘wang’

SET GLOBAL sql_mode=(SELECT REPLACE(@@sql_mode,‘ONLY_FULL_GROUP_BY’,‘’)); 

改完后重启数据库。
另外,其实强烈不建议改这个参数,我倒是建议你换一个新版本的navicat,或者用navicat Premium。

你这是sql里的变量没替换掉吧,数据库抛出的语法错误提示你执行的sql长这样

这当然不能执行呀,你得把具体的表名字段名还有where条件放进去

最容易的写法就一个自关联了,注意除数为0的特殊处理

select a.,
       round(decode(b.SALE_MONEY,
                    0,
                    null,
                    (a.SALE_MONEY - b.SALE_MONEY) / b.SALE_MONEY) * 100,
             2) || ‘%’ 环比增长率
  from sql2004 a
  left join sql2004 b
    on trunc(to_date(a.tyear || lpad(a.tmonth, 2, 0), ‘yyyymm’) - 1, ‘mm’) =
       to_date(b.tyear || lpad(b.tmonth, 2, 0), ‘yyyymm’)

select TYEAR,
       TMONTH,
       SALE_MONEY,
       round(decode(l_SALE_MONEY,
                    0,
                    null,
                    (SALE_MONEY - l_SALE_MONEY) / l_SALE_MONEY) * 100,
             2) || ‘%’ 环比增长率
  from (select a.,
               lag(SALE_MONEY) over(order by tyear , tmonth ) l_SALE_MONEY
          from sql2004 a);

如果好巧不巧,刚好关门了一个月而且没插入对应月份的数据,那么也还是可以使用开窗函数,不过要换成range滑动窗口了

select TYEAR,
       TMONTH,
       SALE_MONEY,
       round(decode(l_SALE_MONEY,
                    0,
                    null,
                    (SALE_MONEY - l_SALE_MONEY) / l_SALE_MONEY) * 100,
             2) || ‘%’ 环比增长率
  from (select a.*,
               max(SALE_MONEY) over(order by tyear * 12 + tmonth range between 1 preceding and 1 preceding) l_SALE_MONEY
          from sql2004 a)

在数据完整的情况下,上述3个sql输出结果都是一样的

你这个表上建了个外键,要求在这个表里的cpno必须来自于这个表里的cno,
你当前表里面没有cno为5的,所以插入cpno为5的就会报错

我觉得很奇怪了,搜你这个错能发现一大堆一模一样的,连表名和字段名都一样,甚至连插入的数据都一模一样,你们是不是看了同一本教程

INSERT 语句与 FOREIGN KEY SAME TABLE 约束"FK__Course__Cpno__060DEAE8"冲突。_百度知道





https://zhidao.baidu.com/question/521154474.html

这时间跨度都已经有十年了。。。

可以用translate函数

select translate(‘aaabbddehhiijjaabb’,‘abcdefghij’,‘1234567890’) from dual

第1个参数为原字符串,第2个参数和第3个参数,按字符位置匹配对应的转换关系,比如a转换成1,b转换成2。
但是,很明显,数字只有10个,当然也可以用其他的字符,但那样就无法一眼识别原字符了,
而且你题目中举的例子,如果是 26,那么它是2代表的字母和6代表的字母拼接？还是第26个字母呢？
如果是纯粹的想把字母转换成数字,不考虑歧义问题,可以直接用ascii函数获得这个字符的ascii码

select ascii(‘a’),ascii(‘b’),ascii(‘z’) from dual;

select 的函数只能返回一个字段 ,比如 select Replaceletter(‘jk’) from dual,
如果要返回两个数字,只能把这两个数字拼成一个字符串,比如 ‘10_11’。
你的字符映射规则确定就是A-Z映射到1-26么,而且确定有且只有两个字母？
如果是,可以用下面这种方式,分别截取第一位和第二位,计算ascii码减去96,最后再拼接起来

select to_char(ascii(substr(str, 1, 1)) - 96) || ‘_’ ||
       to_char(ascii(substr(str, 2, 1)) - 96)
  from (select ‘ab’ str from dual)

建议你还是把原始需求描述一下,可能有其他解决方式,你要求的这种转换目前看上去很不合常理。

本来就是要获取两个字段,而且是提取不同行的数据,当然要关联两次,要么join,要么标量子查询

select t.name,a.name,b.name 
from table1 t,table2 a,table2 b
where t.dw1=a.code and t.dw2=b.code

标量子查询的上面那位已经给了。
但是,的确是有办法只关联一次table2的,但是效率也不见得会高

这题要求的是取对应的记录,简单的聚合函数会导致丢失一些列,比如上面的回答就丢了id和type。
如果要求查询的字段完整,应该使用开窗函数

select * from (
select t.*,
row_number() over(partition by t_user_id,t_game_id order by t_create_time desc) rn 
from t_consumption t)
where rn=1

不确定你的空时null还是空字符串,先假设是null

• 第一个

select * from (
select a.,
row_number() over(partition by job_id order by level desc) rn 
from test_20220411_a a) b 
where rn=1 or level is null

select min(id) id,job_id,max(name) name,
concat(max(skills),‘-’,max(level)) `skills-level`,
GROUP_CONCAT(concat(project,‘-’,role)) `project-role`,
group_concat(lessones) lessones,
sum(score) score
from (
select a.,
row_number() over(partition by job_id order by level desc) rn 
from test_20220411_a a) b 
where rn=1 or level is null
group by job_id

如果,实测如果空值是null的话,group_concat并不会造成数据里有多余分隔符,所以如果你的数据是空字符串,那么可以在最内层select的时候,用case when转换成null

这用上一题的答案稍微改一下不就出来了？

SELECT today() AS o,
 concat(formatDateTime(toStartOfWeek(today() + toIntervalDay(3)) - toIntervalDay(3), ‘%m-%d’) ,‘~’,
 formatDateTime(toStartOfWeek(today() + toIntervalDay(3)) + toIntervalDay(3), ‘%m-%d’)) AS b1,
 concat(formatDateTime(toStartOfWeek(today() + toIntervalDay(3)) - toIntervalDay(10), ‘%m-%d’) ,‘~’,
 formatDateTime(toStartOfWeek(today() + toIntervalDay(3)) - toIntervalDay(4), ‘%m-%d’)) AS b2,
 concat(formatDateTime(toStartOfWeek(today() + toIntervalDay(3)) - toIntervalDay(17), ‘%m-%d’) ,‘~’,
 formatDateTime(toStartOfWeek(today() + toIntervalDay(3)) - toIntervalDay(11), ‘%m-%d’)) AS b3,
 concat(formatDateTime(toStartOfWeek(today() + toIntervalDay(3)) - toIntervalDay(24), ‘%m-%d’) ,‘~’,
 formatDateTime(toStartOfWeek(today() + toIntervalDay(3)) - toIntervalDay(18), ‘%m-%d’)) AS b4
;

给你个官方文档地址吧,想要什么函数可以先在官方文档里找一下

Introduction | ClickHouse Documentation

Functions There are at least* two types of functions - regular functions (they are just called “functions”) and aggregat



https://clickhouse.com/docs/en/sql-reference/functions/

exists常见于两处语法位置,

• 一是用于创建对象前的判断,如果对象不存在就执行创建,否则就忽略本条命令执行。如果不使用exists,而对象又已经存在的话,创建就会报错
• 二是用于sql查询中,作为where条件之一使用,意思就是就是exist后面这个括号里的sql,查出来有数据,就满足条件；查出来没数据,就不满足条件。当然,很多情况下,exists后面的这个查询sql是不能单独拎出来查的,因为它的where条件一般会关联到括号前面的表,而这种条件的左右两个字段,比如a=b,就类似于 a in (select b)的执行结果了。当然执行效率两者是有区别的。

你那条exists的sql应该像下面这样,语法才是正确的

SELECT
    y.city_name,
    y.employee_number
FROM
    sddp.month y
    INNER JOIN sddp.report l ON y.`year_month` = ‘202112’ 
    AND l.`year` = ‘2021’ 
    AND y.job_zhuanye = l.job_zhuanye 
    where NOT EXISTS ( SELECT 1 FROM sddp.report_not d 
WHERE d.`year` = ‘2021’ and d.employee_number= y.employee_number) 

create schema test authorization zhang

这一句表示创建一个schema(或者叫一个模式、架构、有时也叫一个库),这个schema的名称定为test,然后授权 zhang 这个用户
由于你当前并不存在 zhang 这个用户,因此创建失败。

如果你要建表,在连接到对应的schema后,直接执行你下面的create table 命令就行了。
建议你多看一些用例,注意看完整,了解每一个命令的意思

你想给哪个用户就可以给哪个用户,前提是该用户在数据库中存在

a[a.index(‘a’):a.index(‘N’)+1]

先确认是否已正确安装CUDA,然后检查path环境变量是否包含对应的路径,
参考这篇文章

nvcc --version: nvcc不是内部或外部命令 - it610.com

首先，有两种可能：首先确定自己是否安装了CUDA,CUDA本身是一个工具包，需要自己下载；如果确定已经安装过CUDA,那可能是没有配置环境变量（安装后发现安装CUDA本身就会更新环境变量，在安装路径中cmd打开nvcc不会报错，但是在其它路径下会报错，这就要考虑是否是环境变量path没有更新）解决方法：在系统变量path中，双击，点击新建：添加两个路径：C:\ProgramFiles\NVIDIA



https://www.it610.com/article/1296857012767891456.htm

你这两个文件是都只有一行记录？还是说文件1只有一行,但文件2有多行？

1. info.inc文件

PLUGIN_b = “202203012102”

PLUGIN_SET = “202203012102”

PLUGIN_a = “202203012102”

2. Pluginset.txt文件

   202204090746
   

   
   
3. bat文件

   @echo off
   Set /P option=<Pluginset.txt
   (for /f “tokens=1,2* delims==:” %%h in (‘findstr /n .* info.inc’) do (
   if “%%i”==“” (echo.) else if “%%j”==“” (echo %%i) else if “%%i”==“PLUGIN_SET " (echo PLUGIN_SET = “%option%”) else echo %%i=%%j))>temp.ini
   move /y temp.ini info.inc
   

   
   
4. bat运行后,info.inc文件变为

如果一行有2个参数,只替换其中一个参数,用下面这个

@echo off
Set /P option=<Pluginset.txt
(for /f “tokens=1,2,3,4* delims==;:” %%h in (‘findstr /n .* info.inc’) do (
if “%%i”==”" (echo.) else if “%%j”==“” (echo %%i) else if “%%i”=="PLUGIN_SET " (echo PLUGIN_SET = “%option%”;%%k=%%l) else echo %%i=%%j))>temp.ini
move /y temp.ini info.inc

执行效果

把你怎么在java里执行的,以及报错信息发出来

报错提示是存在语法错误就肯定是有语法错误,
在java里写sql一般是用的字符串拼接或者绑定变量的方式,很少会把完整的字符串写上去,因此很可能是拼接得有问题,建议你在执行这个sql前,先把sql打印出来,这样就能一眼看出sql哪里拼得有问题了,尤其要注意分钟后面是怎么拼的,否则它不会在这里断开

1. 你这个报错看上去不完整,后面应该还有一截说明了具体的报错原因
2. 如果你能看懂c++的话,查看这个文件的4010行 D:\WORK\codeserver\main\65.30.2003.10000\运行系统\view653\db\DBServer.cpp
   然后分析逻辑,看看sql是怎么写的
3. 找这个软件的售后

因为你班级表和学生表没有关联起来,造成了笛卡尔积,每个学生都分配到了所有班级。加上关联条件就没问题了

select 所属院系,班级名称,学号,姓名,性别
from 班级表,学生表
where 班级表.班级编号=学生表.班级编号 
and  学号 not in (select 学号
from 成绩表)
order by 所属院系,姓名

给你一个简单的例子吧

import numpy
def forecast_speed(hour):
    x = [1,2,3,5,6,7,8,9,10,12,13,14,15,16,18,19,21,22]
    y = [100,90,80,60,60,55,60,65,70,70,75,76,78,79,90,99,99,100]
    mymodel = numpy.poly1d(numpy.polyfit(x, y, 3))
    myline = numpy.linspace(1, 23, 100)
    speed = mymodel(float(hour))
    return {‘speed’:speed}

print(forecast_speed(17))

上面这个就是输入一组x和y的数据,拟合了一个函数模型,然后就能输入x返回对应的y值了
更多的内容可以去了解一下机器学习、拟合模型相关的内容

你说说什么叫做规律？什么叫做原样本的特征？特征不就是规律么？你能把这些特征都量化下来么？如果特征无法量化,那如何判断是符合原样本特征呢？如果特征都量化了,那不就是一个函数模型么？

这个例子可不只是一个缺失值,按照这种方式,你可以选择对应的2次函数或更多次函数(即函数图像为曲线),让机器学习自动帮你把各次项系数算出来.
给你个文档先看看吧

机器学习 - 多项式回归





https://www.w3school.com.cn/python/python_ml_polynomial_regression.asp

你图上提示已处理28,错误1,也就是说明你这个表有29行数据,其中有28行长度是没问题的,有一行的长度是有问题的,这个时候你就应该去看一下是哪一行超长

对于用户’root’@‘localhost’,无密码登录时,权限不足以执行该操作(SQL: select * from blog_user where username = bb)

可以尝试带密码登录

• 硬盘就是个用于存储的硬件,一般情况下并不会绑定操作系统,把硬盘拆了接其他电脑上一样可以读取其中的数据。
• U盘、移动硬盘这些设备内安装的操作系统,启动时并不会认为自己是外部系统,插上去的设备只要有驱动就都能识别出来。
• U盘PE系统一开始就是作为一个维护系统,在本地操作系统挂了的时候,可以通过PE系统来读出本地磁盘的文件,所以这是能读很正常的。
• 如果想要其他操作系统无法无法打开你本地磁盘的文件,你可以先设置个bios密码,没密码连开机都开不了；
• 或者可以对你本地磁盘进行加密处理,比如bitlocker,比如ntfs磁盘加密,但是代价就是,一旦你本地系统坏了进不去了,而且没保留相关密钥,就没人拯救你的本地磁盘上的文件了。

你表里面当前是否存在不满足这个约束的数据？

如果是让这个字段至少要有1个数字,可以使用正则函数

ALTER TABLE USER ADD CHECK(regexp_like(pwd, ‘[0-9]’));

select publisher,avg(price) from 表 group by publisher

这个要看你的区间是等距区间还是自定义灵活区间

• 如果是等距区间,比如按10元递增

  select floor(price/10),avg(price) from 表 group by  floor(price/10);
  

  
  
• 如果是自定义区间

  select 
  case 
  when price <10 then ‘低于10元’
  when price >=10 and price <30  then ‘10~29.9元’
  else ‘30元及以上’
  end ,
  avg(price) from 表 
  group by 
  case 
  when price <10 then ‘低于10元’
  when price >=10 and price <30  then ‘10~29.9元’
  else ‘30元及以上’
  end;
  

  
  

你要评分的平均值,把avg函数后面的字段换成评分就行了
avg(score)

咨询sql题,请说明数据库类型、版本,提供对应的原始数据建表sql及insert数据sql,以及用表格形式说明一下最终需要的数据的格式。
虽然能大概猜到你是什么意思,但不同数据库的写法不一样,而且你说的那种数据,更适合在客户界面进行处理,不适合查询出来直接就是这个结果,因为存在大量的空值,一排序就乱了,找不到明细行对应主表的哪一行。
下面是使用开窗函数lag的一种实现方式,让主表的数据只会在明细的第一行显示,其他行都为空

select 
case when lag(主表.id) over(order by 主表.id) =主表.id then null else 主表.id end,
case when lag(主表.id) over(order by 主表.id) =主表.id then null else 主表.字段2 end,
case when lag(主表.id) over(order by 主表.id) =主表.id then null else 主表.字段3 end,
明细表.字段4
from 主表,明细表 where 主表.id=明细表.主表id

如果是支持开窗函数的数据库,那么可以把

`a`.`nzprs` AS `nzprs`,

改成

  case when lag(`a`.`id`) over(order by `a`.`id`, `b`.`id`)=`a`.`id` then null else  `a`.`nzprs` end AS `nzprs`,

然后sql的最后还要加上order by a.id, b.id,否则无法定位到每个主表id的第一行

新建一个bat文件,把你要运行的bat文件名都写进去,每个文件前面加start,比如

start d:<span class=“hljs-number”>1.bat
start d:\test<span class=“hljs-number”>2.bat
start d:<span class=“hljs-number”>3.bat
exit

然后就只用执行这一个bat文件了。
start是开新窗口执行,新窗口呼出后就会继续往下执行,不会管这个新窗口的执行情况,也就是说可以让这3个bat接近于同时启动。
至于你说的调取多个任务失败,如果是因为windows调度的问题,可以通过这个方法解决,但是如果是你本身部署有问题导致bat执行失败,那就得另外看了

exists ,直接翻译成中文就是"存在",你这个例子里面就是查询如果"存在"数据就执行查询,否则打印一段文字
execute ,直接翻译成中文就是"执行",
这些关键词随便查下词典就能知道意思了,至于更多的用例,建议直接在网上搜

md文件其实就是一个纯文本文件,用任意文本编辑工具都可以打开。
但是如果要解析markdown语法并格式化显示,就需要其他软件了。
如果图片链接都是本地文件,那就得看你本地对应路径下是不是有这些文件了。
如果你图片链接都是互联网链接而非本地文件链接的话,什么软件都不用下载,最简单的方式就是在csdn博客里新建一篇博客,注意使用markdown编辑器而非富文本编辑器,把md文件里面的内容全部复制粘贴到左边,右边就会自动进行格式化了。

datetime后面不要加长度

目前官网已经查不到5.5的文档了,最早的5.7版本文档中对check是这么描述的

The CHECK clause is parsed but ignored by all storage engines.

大概意思就是check语法可以被解析,但是会被忽略。这和你描述的现象一致。
在5.7版本中,是没有 "CONSTRAINT CHECK"语法的,所以更老的5.5估计也没有

CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
    (create_definition,…)
    [table_options]
    [partition_options]

create_definition: {
    col_name column_definition
  | {INDEX | KEY} [index_name] [index_type] (key_part,…)
      [index_option] …
  | {FULLTEXT | SPATIAL} [INDEX | KEY] [index_name] (key_part,…)
      [index_option] …
  | [CONSTRAINT [symbol]] PRIMARY KEY
      [index_type] (key_part,…)
      [index_option] …
  | [CONSTRAINT [symbol]] UNIQUE [INDEX | KEY]
      [index_name] [index_type] (key_part,…)
      [index_option] …
  | [CONSTRAINT [symbol]] FOREIGN KEY
      [index_name] (col_name,…)
      reference_definition
  | CHECK (expr)
}

但8.0版本是有这个语法的

[CONSTRAINT [symbol]] CHECK (expr) [[NOT] ENFORCED]

import json
s = {‘Code’: 0, ‘Mess’: ‘11’, ‘uu’: ‘435’, ‘data’: {‘result’: ‘{“hit”:[{“er”:4,“r_c”:1},{“er”:4,“r_c”:2},{“er”:4,“r_c”:3}]}’}, ‘uu’: ‘43’}
r=json.loads(s[‘data’][‘result’])
print(r[‘hit’])

S.ENUM_CUTLEVEL 这个字段cast一下,转成varchar,估计你这个字段是个int类型,它就把这个加号当成了真正的加法,然后又发现前面这个参数无法转换成int,就报错了。建议把每个字段都cast一下,毕竟你这是在拼字符串

cast(S.ENUM_CUTLEVEL as varchar)

双击这个服务,看下它执行文件的路径。
考虑到你是移动硬盘,每次插入时可能盘符会不一样,导致它无法根据之前的盘符找到文件。

先说下你用的什么数据库吧，这个是可以实现的，但不同数据库关于日期的计算方式不一样

SELECT
    today AS o,
    toStartOfWeek(today + toIntervalDay(3)) - toIntervalDay(3) AS a,
    toStartOfWeek(today + toIntervalDay(3)) + toIntervalDay(3) AS b

原理就是先把要计算的日期加3天,然后toStartOfWeek获取这个日期对应星期的第一天(星期天),最后再减3天得星期四

只能怀疑serial2里存在空格、回车或者不可见字符了，因为既不是NULL也不是空字符串，而且长度还大于0。
这数据库类型是什么？建议找下该数据库是否有查询数据的二进制或十六进制函数，看看这些空白的值到底是个什么东西

CREATE TABLE test_table_20220408  (
  id int UNSIGNED NOT NULL,
    name VARCHAR(10) not null default ‘123456’,
  PRIMARY KEY (id)
);

你的想法应该是tk_money+overdue_money 的结果的字段名为co_money，但却写成了一个函数用法，正确的写法应该是下面这样

select tk_name,tk_money,overdue_money,(tk_money+overdue_money) co_money from ticket where tk_id=463327862570

当然这个括号可以不要

with 后面要加一个RECURSIVE，比如

with RECURSIVE t as (

注意，别的地方不要加这个东西，只要with后面加一个就行了

这个设计中，有一个很重要的场景，就是在发布问卷后，有新员工入职该公司，是否可以看到此份调查问卷。
如果业务要求必须看到，那么这个设计就会相对复杂；如果业务方接受可以看不到，那么这个就相对简单。
即，在问卷发布时，根据参与人员的范围，直接生成"问卷id-用户id-是否已填写"这三列数据，之后用户来检索自己需要的问卷时，就无需关联其他表即可获得自己需要填写的问卷。
至于生成这个清单，是用or还是union，建议都测试一下，但无论这个清单怎么生成，只要在用户查询前生成了，那么就不会影响到用户的查询效率。
如果生成这个清单所消耗的时间在应用端不可忍受，那么可以引入一个异步处理，即增加"发布中"的状态，等后台程序处理完了，再更新状态，这样前端也可以通过手动刷新页面来查看是否发布成功

问卷平均有效期多长？
建议用两个不同的表，一个是当前处于生效及待生效的"问卷-用户"清单，一个是处于失效期的清单，每晚批处理将前一日失效数据转至失效问卷表内，这样可以让经常被查询的这个表处于一个相对稳定的行数。况且如果不把这个列表记录下来，如果要查历史某个问卷的参与度，就无法计算了，因为当前的用户数并不代表历史的用户数。而且字段少的话并不会占用多少存储空间，只是要注意考虑到历史数据清理，建议表上要有日期字段，甚至可以按时间范围来对表进行分区。
至于新员工入职，可以在新员工信息创建的时候，扫一次问卷，看看哪些问卷是需要填的，自动补几行记录到上面说的这个表

两个极致，

1. 粗暴定时全量刷新，逻辑简单，较为准确，但消耗太大；
2. 把逻辑写到用户信息变更这个环节，只要提交了任意一个用户信息变更，就根据这个用户最新的资料，匹配一次问卷，对当前该用户的问卷列表进行刷新，这样可以将开销分散到每一次用户信息变更里。这个功能可以封装成一个单独的接口，传入用户id即可刷新此用户的问卷列表，虽然增加了耦合性，但也不会太高，出现问题可以紧急先停掉，将第一种方案的全量刷新作为一个应急方案或者说数据修复方案，两手准备

你是想问oracle里怎么写还是mysql里怎么写？这两个数据库支持的语法不一样。另外请给出数据库版本。
最好能把create table 和insert数据也给一份，省得回答问题的人都还要自己去造数据模拟测试

oracle里可以使用开窗函数lag获取上一行，并且支持通过加关键词的方法来实现获取上一行不为空的值,在这篇帖子里有类似的场景
https://bbs.csdn.net/topics/605261646

以日历为主表，外关联持仓表，当本行市值为空时，获取上一个不为空的市值到本行，最后按月份求和除以天数就好了

你题目里写错一行数据，坑了我一把。。。

账户 12 进 22 账户 10

应该为

账户 12 出 22 账户 10

with t as (
SELECT ‘账户 1’ 实体A,‘出’ 标志,2 交易金额,‘账户 11’ 实体B UNION ALL
SELECT ‘账户 1’, ‘出’,1,‘账户 12’ UNION ALL
SELECT ‘账户 1’, ‘出’,2,‘账户 12’ UNION ALL
SELECT ‘账户 1’, ‘出’,3,‘账户 12’ UNION ALL
SELECT ‘账户 1’, ‘出’,1,‘账户 2’ UNION ALL
SELECT ‘账户 1’, ‘进’,2,‘账户 2’ UNION ALL
SELECT ‘账户 10’, ‘出’,8,‘账户 6’ UNION ALL
SELECT ‘账户 10’, ‘进’,5,‘账户 11’ UNION ALL
SELECT ‘账户 12’, ‘出’,22,‘账户 10’ UNION ALL
SELECT ‘账户 3’, ‘进’,2,‘账户 2’ UNION ALL
SELECT ‘账户 3’, ‘出’,5,‘账户 7’ UNION ALL
SELECT ‘账户 3’, ‘出’,7,‘账户 7’ UNION ALL
SELECT ‘账户 3’, ‘出’,5,‘账户 7’ UNION ALL
SELECT ‘账户 3’, ‘出’,4,‘账户 9’ UNION ALL
SELECT ‘账户 6’, ‘进’,7,‘账户 4’ UNION ALL
SELECT ‘账户 6’, ‘进’,8,‘账户 10’ UNION ALL
SELECT ‘账户 6’, ‘出’,5,‘账户 10’ UNION ALL
SELECT ‘账户 6’, ‘出’,7,‘账户 11’ UNION ALL
SELECT ‘账户 6’, ‘进’,5,‘账户 7’ UNION ALL
SELECT ‘账户 8’, ‘出’,6,‘账户 4’ UNION ALL
SELECT ‘账户 9’, ‘出’,3,‘账户 8’ ),
tt as (SELECT 
CASE 标志 when ‘出’ then 实体A ELSE 实体B end id1,
CASE 标志 when ‘出’ then 实体B ELSE 实体A end id2,
sum(交易金额) 交易金额 FROM T 
group by 
CASE 标志 when ‘出’ then 实体A ELSE 实体B end,
CASE 标志 when ‘出’ then 实体B ELSE 实体A end),
cte as (
select distinct cast(‘0’ AS  VARCHAR(1000)) id1,id1 id2,cast(id1 as VARCHAR(100)) root_node,cast(id1+‘/’ as VARCHAR(1000)) path, 0 lvl,0 amt from tt where id1=‘账户 1’
union all
select cast(tt.id1 AS  VARCHAR(1000)) ,tt.id2,cte.root_node,cast(cte.path+tt.id2+‘/’  as VARCHAR(1000)) path,lvl+1,amt+交易金额 from tt  join  cte on tt.id1=cte.id2
where  PATH NOT LIKE ‘%’+tt.id2+‘/%’
)
select  root_node,id2,path,amt from cte where id2=‘账户 6’ ;

你那个汇总转账金额不知道是不是指的每2个节点之间的转账都要先汇总，就是tt表里面那个sum

mysql 不支持intersect的语法，建议使用其他方式来实现，比如你这个sql完全可以写成

select sname from Test.student where sdept = ‘信息院’ and sage <= 19

mysql里不能直接用加减法来计算日期，如下

想象一下，4月30号加1天，理论上应该是5月1日，但是sql中如果直接加1，会得出4月31号，而且结果还不是日期类型了。
因此需要使用date_add或者add_date之类函数来对日期进行加减。
另外，不清楚你题目mysql的版本，如果是8.0及以后的版本，更好的方式应该是使用开窗函数，这样就只需要对这个表查一次，无需查两次来自关联

你这个sql是个缝合怪了。。。

• getdate() 是sqlserver数据库中的获取当前时间的年月日时分秒函数，mysql里类似的函数名应该为 now()
• dateadd()是sqlserver中对日期进行增加的函数，但是其中的3个参数的位置和你写的不一样，并且并没有’aa’这种时间度量表达式。而MySQL中类似功能的函数名为ADDDATE()和DATE_ADD(),并且参数和你题目里面的也不一样
• to_char()是oracle数据库中将某种类型转换成字符串的函数，此题中是将一个日期转换成’yyyymm’格式,即4位年份2位月份，比如’202204’