一条sql语句顺序查询出父类的所有子类如下图：用的是sql Server 2008

Posted 2023-04-30

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了一条sql语句顺序查询出父类的所有子类如下图：用的是sql Server 2008相关的知识，希望对你有一定的参考价值。

id name parentId
1 帮助 0
2 新闻 0
3 简介 1
4 新手上路 1
5 通知 2
6 公告 2
7 找回密码 4
8 激活账号 4
。。。。。
要求查询出来时，结果为：
1 帮助 0
3 简介 1
4 联系方式 1
7 找回密码 4
8 激活账号 4
2 新闻 0
5 通知 2
6 公告 2

SQL 2005及以上可以使用CTE实现递归。

with tmp (ID,Name,ParentID,Level,HierarchyCode)
as(
select ID,Name,ParentID,1,convert(varchar,convert(varchar,ParentID)+'->'+convert(varchar,ID))
from 表名 where ParentId=0 --已知根节点是0
UNION ALL
select a.ID,a.Name,a.ParentID,Level+1,convert(varchar,HierarchyCode+'->'+convert(varchar,a.ID))
from 表名 a inner join tmp b on a.ParentID=b.ID
)
select * from tmp order by HierarchyCode

结果如下：

参考技术A 一条sql肯定实现不了的参考技术B 没看出你两个有什么区别...第二个又是以什么排序的?麻烦问题描述清楚一点
需求一清楚了就好回答了

JavaSE复习_7 异常

△子父类涉及的异常问题:

1.子类在覆盖方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类,且只能抛出异常的子集

2.如果父类抛出了多个异常，子类只能抛出父类异常的子集，如果父类的方法没有抛出异常，那么子类重写方法时一定不能抛,只能捕捉

△throw和throws:

1.throw声明在方法内部，抛出的是异常的对象。

2.throws生命在方法上，抛出的是异常类

△编译异常和运行时异常:编译异常必须对其进行处理,而运行时异常不需处理.编译时的异常称为已检查异常，运行时的异常称为未检查异常。

△JDK1.7新增异常的特性:catch(Exception | NullpointerException e):捕获异常,这里注意,参数名只有一个,另外中间只能用"|"不能用"||".并且两个异常不能互相是继承关系。

△多catch语句，父类异常一定要放在最下面。

在一个异常体系捕捉后，catch语句块里面抛出另外一个异常是相当实用的做法。称为异常的转换。

△finally就算碰到return也会继续执行

△finally只用于发生异常且未捕捉到的时候，执行关闭资源的动作，其他情况下，其语句等同于正常的语句，按照正常的顺序执行。

△finally的返回值会将try语句的返回值覆盖

public static int f(int n){
               try{
                      int r =n *n ;
                      return r ;
              }
               finally{
                      if(n ==2)
                            return 6;
              }
       }

该语句当n=2时，返回6。

△try finally语句中，finally语句中如果关闭抛出了异常，那么后抛出的异常将会把刚抛出的异常给覆盖

class XyyException extends Exception{
        public XyyException(String s ){
               super(s );
       }
}
class HlhException extends Exception{
        public HlhException(String s ){
               super(s );
       }
}
public class Demo {

        public static void main(String[] args) throws XyyException, HlhException {
               f();
       }

        public static void f() throws XyyException, HlhException {
               int x =2;
               try{
                      x= x*2;
                      throw new XyyException("try");
              }
               finally{
                      if(x ==4){
                            throw new HlhException("finally");
                     }
              }
       }

}

异常为:

Exception in thread "main" string.Demo.HlhException: finally
       at string.Demo.Demo.f( Demo.java:26)
       at string.Demo.Demo.main( Demo.java:15)

解决这种方法的步骤为：采用带资源的try语句，在try()括号里实现了AutoCloseable接口的类都可以在调用try后关闭资源，（此时try语句里的资源关闭发生的异常将会被抑制，不会被抛出）。

△关于异常finally对于返回值的覆盖，有以下几点细节：

　　finally语句在return执行后返回前执行。对于基本类型，return可以确定的是进入finally前的返回值。对于引用数据类型，return可以确定的是返回的对象内容。用两个示例加以说明：

public static int f(){
            int x=10;
       try{
        System.out.println(12/0);
        return x;
       } catch(Exception e) {
        x=20;
        return x;
       }
       finally {
        x=30;
        if(x==30)
              return x;
       }
}

　　这个代码finally会将return30,因为finally中的return会将catch中的return覆盖,而如果没有return x,则该方法返回20,因为x仅仅赋值,但是返回的此时已经确定好了值.即在finally语句在return执行后返回前执行。

import java.util.*;

public class FinallyTest6
{
    public static void main(String[] args) {
        System.out.println(getMap().get("KEY").toString());
    }

    public static Map<String, String> getMap() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("KEY", "INIT");

        try {
            map.put("KEY", "TRY");
            return map;
        }
        catch (Exception e) {
            map.put("KEY", "CATCH");
        }
        finally {
            map.put("KEY", "FINALLY");
            map = null;
        }

        return map;
    }
}

　　这个代码运行结果是finally。因为在try中即返回了引用所指向的对象（即确定的是对象），随后对对象的操作都会改变返回值，但是在finally代码块的最后一句将引用指向空，对于对象不构成任何影响，原对象返回。

△断言机制：assert关键字

格式为:assert 条件；

或assert 条件:表达式;(表达式部分的唯一目的是产生一个消息字符串。）

当assert的条件为false的时候，将会抛出一个有关键字构成的AssertionError异常。

利用java -ea打开assert，即可进入断言机制模式，默认情况下为关闭。

△记录日志

Logger logger=Logger.getLogger("Demo"); //获得一个记录器，其名为Demo

logger.setLevel(Level.ALL) //获得记录器的等级

然后利用；logger.entering() logger.exiting记录进入方法，离开方法。（需要手动记录)

处理器：可以利用FileHandler将日志输出到文件。

FileHandler fh=new FileHandler( "MyLogger.txt");

fh.setLevel(Level. FINE);

logger .addHandler(fh); //将处理器添加到日志记录器中，可以添加多个

但是这样输出的文件将会是XML格式，不方便阅读因此需要定义格式化器，然后将其添加到处理器

示例:

package io.project.one;
import java.util.logging.FileHandler;
import java.util.logging.Formatter;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

public class Demo2 {
        public static void main(String[] args) {
              Logger logger=Logger. getLogger("io.project.one.Demo2");
               logger.setLevel(Level. FINE);
               try {
                     FileHandler fh= new FileHandler("MyLogger.txt" );
                      fh.setLevel(Level. FINE);
                      fh.setFormatter( new MyFormatter());
                      logger.addHandler( fh);

                      logger.fine( "进入main函数" );
                      int x =2;
                      int y =3;
                      add(x,y);
                      logger.exiting( "io.project.one.Demo2", "main" );
              } catch (Exception e ) {
                      e.printStackTrace();
              }
       }

        public static void add(int x, int y) {
              Logger logger=Logger. getLogger("io.project.one.Demo2");
               logger.fine( "io.project.one.Demo2");
              System. out.println("x+y" );
               logger.fine( "io.project.one.Demo2");
       }

}
class MyFormatter extends Formatter{

        @Override
        public String format(LogRecord record ) {
               return "类别：" +record .getLevel()+"....信息:"+ record.getMessage();
       }
}