数据库代码暂存

功能：

插入文件 、插入用户、删除操作

其他功能：

1、检索操作应该应该由代码的sql操作进行，这时由user表中的bro_index来指向开始目录，并且要找file表的类型

2、分享操作由前端返回分享密码，分享操作由文件进行检索 

注意：

1、fileid在添加文件的时候必须指明id是多少，因为无法通过自增让其自动生成，否则在生成后找不到这个id 

2、插入用户时，用户表会指向开始文件

#插入用户
insert into user VALUES("admin1","admin1");

#插入文件
#插入文件的存储过程 
#本过程是没有重复文件时使用的 即此存储过程会生成一个fileid 不用输入
#当需要分享的时候 再进行添加分享
#1.判断userid是否存在，2.根据parent找其节点插入
#0代表的是没有此用户 1代表的是父节点为空
delimiter $
CREATE PROCEDURE insert_file(
in username varchar(30), in filename varchar(30),in in_parent varchar(100),
in brother varchar(100),out insert_result
)
BEGIN
  set @a=null;
  set @b=null;
  SELECT user_id into @a from user where userid=username;
  if(@a=NULL) THEN
           set insert_result=0; end if;
  SELECT userid into @b from user_file where userid=in_parent;
  if(@b=NULL) THEN
           set insert_result=1; end if;
#寻找是这个父节点但是brother为空的
   set @a=null;
   SELECT userid  into @a from user_file where user_file.parent=in_parent;
  if(@a=NULL) THEN #说明父节点没有子节点，则直接接到父节点下面
          
    insert into file(fileid,filesize,filetype,filelocate,usersize) VALUES(




//新建

drop PROCEDURE storetest;
delimiter $
create  PROCEDURE storetest(
in username varchar(30),inout lea int)

leave_lable:BEGIN 
  declare insert_result int default 10;
  set @a=null;
  set @b=null;

  SELECT userid into @a from user where userid=username;
/*如果找不到用户名则不再插入*/
    if @a is null THEN set insert_result=0; set lea=100;LEAVE leave_lable; end if;
  
  SELECT insert_result;
END $

delimiter;
set @lea=10;
call storetest("admin5",@lea);
SELECT @lea;
delimiter ;


//最新能运行
/*0代表的是没有此用户
 1代表的是父节点为空
drop PROCEDURE storetest;*/
delimiter $
drop PROCEDURE storetest;
create  PROCEDURE storetest(
in in_userid varchar(30),
in in_fileid int,in in_filesize int, in in_filetype varchar (30),in in_filelocate varchar (200),
in in_parent int
)

leave_lable:BEGIN 
  declare insert_result int default 10;
  set @a=null;
  set @b=null;
  set @c=null;
  /*1.判断该用户是否存在*/
  SELECT userid into @a from user where userid=in_userid;
  if @a is null THEN set insert_result=0; LEAVE leave_lable; end if;

  /*2.插入文件file表*/
  select fileid into @b from file where fileid=in_fileid;
  CASE
  /*该文件不存在，则插入*/
  when @b is null then  insert into file (fileid,filesize,filetype,filelocate,usersize)
              VALUES(in_fileid,in_filesize,in_filetype,in_filelocate,1) ;
  else  /*该文件已经存在，则更新usersize的值*/
       update file set usersize=usersize+1 where fileid=in_fileid;
  end case;

 /*3.将文件的id加入到user_file中*/
  SELECT parent into @c from user_file where userid=in_userid and parent=in_parent;
    /*3.1提供的父节点不存在，则退出下面过程，由于上面是存文件过程，和下面无关，所以可以直接返回insert_result的结果*/
 
  if @c is null THEN set insert_result=1;SELECT insert_result; LEAVE leave_lable; end if;



  SELECT insert_result;
  SELECT @c;
END $

delimiter;
set @lea=10;
call storetest("admin",
               9,1024,"pdf","/name2",
              1);
SELECT @lea;
delimiter ;



//插入文件过程  下面还有一个
in_bro_index其实是父节点  bro_index是唯一主键  他在Navicat中设置的是自动增加，不需要给值 
/*
失败情况：
0代表的是没有此用户 1代表的是父节点为空  4代表有该用户在该目录有重复文件
成功情况：
 2代表总文件中无类似文件  21代表无类似文件无兄弟节点插入  22代表无类似文件有兄弟节点插入
 3代表总文件中有类似文件  31代表有类似文件无兄弟节点插入  32代表有类似文件有兄弟节点插入
 
drop PROCEDURE storetest;*/
delimiter $
drop PROCEDURE storetest;
create  PROCEDURE storetest(
in in_userid varchar(30),
in in_fileid int,in in_filesize int, in in_filetype varchar (30),in in_filelocate varchar (200),
in in_bro_index int ,in in_filename varchar(100),
out insert_result int,out out_now_index int
)

leave_lable:BEGIN 
  set @a=null;
  set @b=null;
  set @c=null; set @c_userid=null;set @c_fileid=null;
  

  /*1.判断该用户是否存在*/
  SELECT userid into @a from user where userid=in_userid;
  if @a is null THEN set insert_result=0; LEAVE leave_lable; end if;

 
 /*2.插入文件file表*/
  select fileid into @b from file where fileid=in_fileid;
  CASE
  /*该文件不存在，则插入*/
  when @b is null then  insert into file (fileid,filesize,filetype,filelocate,usersize)
              VALUES(in_fileid,in_filesize,in_filetype,in_filelocate,0);
              set insert_result=2;
  else  /*该文件已经存在，则更新usersize的值*/     
          set insert_result=3;
  end case;

 


/*3.将文件的id加入到user_file中*/
  SELECT bro_index into @c from user_file where userid=in_userid and bro_index=in_bro_index;
    /*3.1提供的父节点不存在，则退出下面过程，由于上面是存文件过程，和下面无关，所以可以直接返回insert_result的结果*/
    if @c is null THEN set insert_result=1;LEAVE leave_lable; end if;
    
    /*父节点的孩子节点的重复检测，检测插入时是否有相同名字相同类型的文件*/
    SELECT bro_index into @c_duplicate from user_file where userid=in_userid and parent=in_bro_index and fileid=in_fileid and filename=in_filename;
      /*不为空则有重复文件 退出*/ 
      if @c_duplicate is not null then set insert_result=4;LEAVE leave_lable; end if;
    
    /*3.2父节点存在，那么寻找父节点的最右孩子节点  c是最右边的孩子的bro_index*/
    SELECT bro_index into @c from user_file where userid=in_userid and parent=in_bro_index and brother=null;
  CASE   /*3.2.1不存在最右节点，那么自己便是第一个孩子 直接插入，brother置为null*/
  when @c is null then 
       insert into user_file (userid,fileid,filename,share,sharepass,parent,brother)
        VALUES(in_userid,in_fileid,in_filename,null,null,in_bro_index,null);
          set insert_result=insert_result*10+1;
        SELECT bro_index into out_now_index from user_file where userid=in_userid and fileid=in_fileid;
      
    
/*3.2.2 如果最右孩子节点存在 那么在最右孩子节点插入自己 并且插入自己的brother直接置为null*/
  ELSE 
         
      /*冗余的一步*/
  insert into user_file (userid,fileid,filename,share,sharepass,parent,brother)
        VALUES(in_userid,in_fileid,in_filename,null,null,in_bro_index,null);
/*找到新插入的唯一主键  @c_bro_index是新插入的bro_index*/
SELECT bro_index into out_now_index from user_file where userid=in_userid and fileid=in_fileid;
/*将最右孩子节点指向新插入的唯一主键*/
       update user_file set brother= out_now_index where bro_index=@c;
	   
	   
	   
	   
	   
	   5
	   
        set insert_result=insert_result*10+2;
        
  end case;



 /*4 到此说明已经插入成功，将引用这个文件的数量加一*/
 update file set usersize=usersize+1 where fileid=in_fileid;


  SELECT insert_result;
  SELECT @c;
END $

delimiter;
set @insert_result=-1;
set @out_now_index=-1;
/*create  PROCEDURE storetest(
in in_userid varchar(30),
in in_fileid int,in in_filesize int, in in_filetype varchar (30),in in_filelocate varchar (200),
in in_bro_index int ,in in_filename varchar(100)
)  in_bro_index就是父节点
*/
/*插入第一个节点*/
call storetest("admin",
               6,1024,"exe","/xin",
              6,"m",
              @insert_result,@out_now_index);
SELECT @insert_result;
SELECT @out_now_index;
/*插入第二个节点*/

call storetest("admin1",
               6,1024,"exe","/xin",
              9,"m1",
              @insert_result,@out_now_index);
SELECT @insert_result;
SELECT @out_now_index;










------------------------------------------------------------------------------------

//插入用户过程  
leave_lable1离开标志
/*
判断userid是否存在 存在则进行返回
1.插入file里面一个文件   这里在执行成功sql后应该新建一个目录/a/user/要添加的userid
 1.1fileid自动增加 filesize设置为0 filetype设置为list，filelocate设置为/a/user/要添加的userid usersize设置为1

 1.2根据filelocate找到fileid
2.插入user_file里一条记录
  2.1 userid为新添加的userid，fileid为上面查找到的fileid，filename为userid，parent为-1,bro_index为自增，不用添加
  
  2.2根据userid找到新添加记录的bro_index
3.插入user
  3.1 插入用户和密码添加上面找到的bro_index
  
  
插入成功以后插入user_file里记录 

参数列表
 0:代表用户已经存在
 1:代表插入成功

*/

/*
drop PROCEDURE storeusertest;
*/

delimiter $
drop PROCEDURE storeusertest;
create PROCEDURE storeusertest(
in in_userid varchar(100),in in_pass varchar(100),
out insert_result int
)

leave_lable:BEGIN 
  set @a=null;
  set @b=null;
  set @c=null; set @c_userid=null;set @c_fileid=null;
   /*判断userid是否存在 存在则进行返回*/
   SELECT userid into @a from user where userid=in_userid;
   if @a  is  not null THEN set insert_result=0; LEAVE leave_lable; end if;

 /*1.插入file里面一个文件   这里在执行成功sql后应该新建一个目录/a/user/要添加的userid*/

/* 1.1fileid自动增加 filesize设置为1 
filetype设置为list，filelocate设置为/a/user/要添加的userid usersize设置为1*/
 insert into file (filesize,filetype,filelocate,usersize)
              VALUES(0,"0",CONCAT("/a/user/",in_userid),1);
/* 1.2根据filelocate找到fileid 存储到@b*/
 SELECT fileid into @b from file where filelocate=CONCAT("/a/user/",in_userid) and filetype="0";

 /*2.插入user_file里一条记录
  2.1 userid为新添加的userid，fileid为上面查找到的fileid，filename为userid，parent为-1,bro_index为自增，不用添加
 */
insert into user_file (userid,fileid,filename,parent)
                VALUES(in_userid,@b,in_userid,-1);

  /*2.2根据userid找到新添加记录的bro_index*/
SELECT bro_index into @c from user_file where userid=in_userid;

/*
3.插入user
  3.1 插入用户和密码添加上面找到的bro_index
*/
insert into user (userid,pass,bro_index) VALUES (in_userid,in_pass,@c);
SET insert_result=1;

END $

delimiter;
set @insert_result=-1;
call storeusertest("admin10","admin10",
                   @insert_result);
SELECT @insert_result;





------------------------------------------------------------------------------------------
//插入文件
/*
失败情况：
0代表的是没有此用户 1代表的是父节点为空  4代表有该用户在该目录有重复文件
成功情况：
 2代表总文件中无类似文件  21代表无类似文件无兄弟节点插入  22代表无类似文件有兄弟节点插入
 3代表总文件中有类似文件  31代表有类似文件无兄弟节点插入  32代表有类似文件有兄弟节点插入
 
drop PROCEDURE storetest;*/
delimiter $
drop PROCEDURE storetest;
create  PROCEDURE storetest(
in in_userid varchar(30),
in in_fileid int,in in_filesize int, in in_filetype varchar (30),in in_filelocate varchar (200),
in in_bro_index int ,in in_filename varchar(100),
out insert_result int,out out_now_index int
)

leave_lable:BEGIN 
  set @a=null;
  set @b=null;
  set @c=null; set @c_userid=null;set @c_fileid=null;
  

  /*1.判断该用户是否存在*/
  SELECT userid into @a from user where userid=in_userid;
  if @a is null THEN set insert_result=0; LEAVE leave_lable; end if;

 
 /*2.插入文件file表*/
  select fileid into @b from file where fileid=in_fileid;
  CASE
  /*该文件不存在，则插入*/
  when @b is null then  insert into file (fileid,filesize,filetype,filelocate,usersize)
              VALUES(in_fileid,in_filesize,in_filetype,in_filelocate,0);
              set insert_result=2;
  else  /*该文件已经存在，则更新usersize的值*/     
          set insert_result=3;
  end case;

 
/*
搜索父亲节点的孩子节点  父亲节点 in_bro_index   孩子节点 son注入    @c 是父节点的第一个孩子节点 

孩子节点存在 
   插入当前节点  
        将自己的兄弟节点指向那个孩子节点 
   获得新插入的当前节点                     当前孩子节点out_now_index 
   将父亲节点指向当前节点
孩子节点不存在
   插入当前节点 
   获得新插入的节点
   将父亲节点指向当前节点

*/

/*3.将文件的id加入到user_file中*/

  SELECT bro_index into @c from user_file where userid=in_userid and bro_index=in_bro_index;
    /*3.1提供的父节点不存在，则退出下面过程，由于上面是存文件过程，和下面无关，所以可以直接返回insert_result的结果*/
    if @c is null THEN set insert_result=1;LEAVE leave_lable; end if;
    
    /*父节点的孩子节点的重复检测，检测插入时是否有相同名字相同类型的文件*/
    SELECT bro_index into @c_duplicate from user_file where userid=in_userid and parent=in_bro_index and fileid=in_fileid and filename=in_filename;
      /*不为空则有重复文件 退出*/ 
      if @c_duplicate is not null then set insert_result=4;LEAVE leave_lable; end if;
    
    /*3.2父节点存在，那么寻找父节点的最右孩子节点  c是最右边的孩子的bro_index*/

    select son into @c from user_file where userid=in_userid and bro_index=in_bro_index;
  #  SELECT bro_index into @c from user_file where userid=in_userid and parent=in_bro_index and brother=null;
  CASE   /*3.2.1不存在最右节点，那么自己便是第一个孩子 直接插入，brother置为null*/
  when @c is null then 
       insert into user_file (userid,fileid,filename,share,sharepass,parent,brother)
          VALUES(in_userid,in_fileid,in_filename,null,null,in_bro_index,null);
           set insert_result=insert_result*10+1;
        SELECT bro_index into out_now_index from user_file where userid=in_userid and fileid=in_fileid;
        update user_file set son=out_now_index where userid=in_userid and bro_index=in_bro_index;
      
    
/*3.2.2 如果最右孩子节点存在 那么在最右孩子节点插入自己 并且插入自己的brother直接置为null*/
  ELSE 
         
      /*冗余的一步*/
  insert into user_file (userid,fileid,filename,share,sharepass,parent,brother)
        VALUES(in_userid,in_fileid,in_filename,null,null,in_bro_index,@c);
/*找到新插入的唯一主键  @c_bro_index是新插入的bro_index*/
SELECT bro_index into out_now_index from user_file where userid=in_userid and fileid=in_fileid;
/*将最右孩子节点指向新插入的唯一主键*/
       update user_file set son= out_now_index where userid=in_userid and bro_index=in_bro_index;
	   
	   
	   
	   
	   
	   
	   
        set insert_result=insert_result*10+2;
        
  end case;



 /*4 到此说明已经插入成功，将引用这个文件的数量加一*/
 update file set usersize=usersize+1 where fileid=in_fileid;


  SELECT insert_result;
  SELECT @c;
END $

delimiter;
set @insert_result=-1;
set @out_now_index=-1;
/*create  PROCEDURE storetest(
in in_userid varchar(30),
in in_fileid int,in in_filesize int, in in_filetype varchar (30),in in_filelocate varchar (200),
in in_bro_index int ,in in_filename varchar(100)
)  in_bro_index就是父节点
*/
/*插入第一个节点*/
call storetest("admin",
               100,1024,"exe","/xin",
              4,"m",
              @insert_result,@out_now_index);
SELECT @insert_result;
SELECT @out_now_index;
/*插入第二个节点*/

call storetest("admin1",
               101,1024,"exe","/xin",
              1,"m1",
              @insert_result,@out_now_index);
SELECT @insert_result;
SELECT @out_now_index;



fileid在添加文件的时候必须指明id是多少，因为无法通过自增让其自动生成，否则在生成后找不到这个id 

---------------------------------------------------------------------------------------------------------



//删除操作



删除前先进行降低共享数量 对于共享数量，可以在某个时刻进行统一检索扫描删除

1、首先获取某个树
2、获取树的每个节点对应的fileid
3、将file对应的fileid的共享数量减一
4、进行删除

5、某个时刻进行统一检索删除

详细操作：
   输入bro_index和userid
   
   1、根据bro_index和userid获取树的节点bro_index 放入到 del_tree
   2、将上述的二和三步合到一起
     从虚表del_tree找出其对应的filedid生成虚表del_userfile
	 将数量减一
   3、从user_file进行删除树
   
   
/*
传入bro_index会将这个bro_index也会删除
insert_result=1表示插入成功 
insert_result=0表示没有此条记录（一般为bro_index输入出错）
drop PROCEDURE delfiletest;
*/
delimiter $
drop PROCEDURE delfiletest;
create PROCEDURE delfiletest(
in in_bro_index int,in in_userid varchar(100),
out insert_result int,out del_tree varchar(100)
)

leave_lable:BEGIN 

  DECLARE sTemp CHAR(200); 
  DECLARE sTempChd CHAR(200);
  declare tem_fileid char(200);
  set tem_fileid=null;
  set  sTemp = null;
  set @a=null;
  SET sTempChd =cast(in_bro_index as char);
  
    SELECT fileid into @a from user_file where userid=in_userid and userid=in_bro_index;
  if @a is null THEN set insert_result=0; LEAVE leave_lable; end if;

 /*1、根据bro_index和userid获取树的节点bro_index 生成虚表 del_tree*/
  WHILE sTempChd is not null DO
   /*刚开始因为为null所以不会执行 */
    SET sTemp = concat(sTemp,',',sTempChd); 
     if sTemp is  null then set sTemp=sTempChd; end if;
    SELECT group_concat(bro_index) INTO sTempChd FROM user_file 
       where FIND_IN_SET(parent,sTempChd)>0 and userid=in_userid;
  END WHILE;
   set del_tree=sTemp; /*赋值到del_tree里面*/

/*将树的各个节点信息的fileid放入到tem_fileid*/
select group_concat(fileid) into tem_fileid from user_file where FIND_IN_SET(bro_index,del_tree);
select tem_fileid;

/*从file更新使用人数*/
update file set usersize=usersize-1 where fileid in 
(select fileid from (select fileid from file where find_in_set(fileid,tem_fileid) ) as b);

/*从用户表中删除要删除的内容*/
DELETE from user_file where bro_index in
(select bro_index from (select bro_index from user_file where find_in_set(bro_index,del_tree) ) as c);

set @insert_result=1;


END $

delimiter;
set @insert_result=-1;
set @del_tree=null;
call delfiletest(30,"admin",
               @insert_result,@del_tree);
SELECT @insert_result;




//检索内容
检索过程不再进入存储过程 到时候自己调用
找到file里面的文件类型 可以到时候写一个过程




//分享操作
由前端返回分享密码
分享操作由文件进行检索 

新改的插入的 有md5验证的

/*

因为要指明fileid，因此就不用再重新写了

首先sql先根据md5搜索fileid
   如果有相同，先执行存储过程，那么fileid将会指明这行新插入的数据，执行完存储过程后，利用fileid将这条数据删除
   如果不相同，也先执行存储过程，根据fileid找到这条数据，将md5插入进去

最后需要说明的是 
in_bro_index是父亲节点 我曹，当时咋写的
 最后的时候需要返回最终生成的fileid   重复文件检测也将返回值  qt应该对重复文件检测进行检测


insert_result=0 无此用户
insert_result=10 父节点不存在
insert_result=4   有重复文件




失败情况：
0代表的是没有此用户 1代表的是父节点为空  4代表有该用户在该目录有重复文件
成功情况：
 2代表总文件中无类似文件  21代表无类似文件无兄弟节点插入  22代表无类似文件有兄弟节点插入
 3代表总文件中有类似文件  31代表有类似文件无兄弟节点插入  32代表有类似文件有兄弟节点插入
 
drop PROCEDURE storetest;*/
delimiter $
drop PROCEDURE insertListStoredProcedure;
create  PROCEDURE insertListStoredProcedure(
in in_userid varchar(30),
in in_fileid int,
in in_bro_index int ,in in_filename varchar(100),
out insert_result varchar(2000),out out_now_index int,out out_now_filename varchar(200)
)

leave_lable:BEGIN 
  set @a=null;
  set @b=null;
  set @c=null; set @c_userid=null;set @c_fileid=null;
  

  /*1.判断该用户是否存在*/
  SELECT userid into @a from user where userid=in_userid;
  if @a is null THEN set insert_result=0; LEAVE leave_lable; end if;


/*插入文件*/
 insert into file (fileid,filesize,filetype,filelocate,usersize)
              VALUES(in_fileid,0,"list","/file",0);
              set insert_result=2;


 
/*
搜索父亲节点的孩子节点  父亲节点 in_bro_index   孩子节点 son注入    @c 是父节点的第一个孩子节点 

孩子节点存在 
   插入当前节点  
        将自己的兄弟节点指向那个孩子节点 
   获得新插入的当前节点                     当前孩子节点out_now_index 
   将父亲节点指向当前节点
孩子节点不存在
   插入当前节点 
   获得新插入的节点
   将父亲节点指向当前节点

*/

/*3.将文件的id加入到user_file中*/

  SELECT bro_index into @c from user_file where userid=in_userid and bro_index=in_bro_index;
    /*3.1提供的父节点不存在，则退出下面过程，由于上面是存文件过程，和下面无关，所以可以直接返回insert_result的结果*/
    if @c is null THEN set insert_result=10;   LEAVE leave_lable; end if;
    
    /*父节点的孩子节点的重复检测，检测插入时是否有相同名字相同类型的文件*/
    SELECT filename into @c_duplicate from user_file where userid=in_userid and parent=in_bro_index and fileid=in_fileid and filename=in_filename;
   SELECT COUNT(fileid) into @fujia from user_file where userid=in_userid and parent=in_bro_index and fileid=in_fileid;
    set @fujia=@fujia+1;  
/*不为空则有重复文件 退出*/ 
      if @c_duplicate is not null then set insert_result=4;set in_filename=    CONCAT(@c_duplicate,@fujia); end if;
  
      set out_now_filename=in_filename;
    
    /*3.2父节点存在，那么寻找父节点的最右孩子节点  c是最右边的孩子的bro_index*/

    select son into @c from user_file where userid=in_userid and bro_index=in_bro_index;
  #  SELECT bro_index into @c from user_file where userid=in_userid and parent=in_bro_index and brother=null;
  CASE   /*3.2.1不存在最右节点，那么自己便是第一个孩子 直接插入，brother置为null*/
  when @c is null then 
       insert into user_file (userid,fileid,filename,share,sharepass,parent,brother)
          VALUES(in_userid,in_fileid,in_filename,null,null,in_bro_index,null);
           set insert_result=insert_result*10+1;
        SELECT bro_index into out_now_index from user_file where userid=in_userid and fileid=in_fileid;
        update user_file set son=out_now_index where userid=in_userid and bro_index=in_bro_index;
      
    
/*3.2.2 如果最右孩子节点存在 那么在最右孩子节点插入自己 并且插入自己的brother直接置为null*/
  ELSE 
         
      /*冗余的一步*/
  insert into user_file (userid,fileid,filename,share,sharepass,parent,brother)
        VALUES(in_userid,in_fileid,in_filename,null,null,in_bro_index,@c);
/*找到新插入的唯一主键  @c_bro_index是新插入的bro_index*/
SELECT bro_index into out_now_index from user_file where userid=in_userid and fileid=in_fileid and filename=in_filename;
/*将最右孩子节点指向新插入的唯一主键*/
       update user_file set son= out_now_index where userid=in_userid and bro_index=in_bro_index;
	   
	   
	   
	   
	   
	   
	   
       
        
  end case;



 /*4 到此说明已经插入成功，将引用这个文件的数量加一*/
 update file set usersize=usersize+1 where fileid=in_fileid;

  select in_fileid;
  SELECT insert_result;
  
  SELECT @c;


   set insert_result= CONCAT(out_now_index,"#",out_now_filename);
END $

delimiter;




/*插入第一个节点
in in_userid varchar(30),
in in_fileid int,
in in_bro_index int ,in in_filename varchar(100),
out insert_result int,out out_now_index int,out out_now_filename varchar(200)
*/

set @insert_result="";
set @out_now_index=-1;
set @out_now_filename="caozuo";
set @out_now_fileid=100;
call insertListStoredProcedure("admin",
               44557745,
              4,"caozuo6",
              @insert_result,@out_now_index,@out_now_filename);
SELECT @insert_result;
SELECT @out_now_index;
SELECT @out_now_filename;

插入文件夹

/*

因为要指明fileid，因此就不用再重新写了

首先sql先根据md5搜索fileid
   如果有相同，先执行存储过程，那么fileid将会指明这行新插入的数据，执行完存储过程后，利用fileid将这条数据删除
   如果不相同，也先执行存储过程，根据fileid找到这条数据，将md5插入进去

最后需要说明的是 
in_bro_index是父亲节点 我曹，当时咋写的
 最后的时候需要返回最终生成的fileid   重复文件检测也将返回值  qt应该对重复文件检测进行检测


insert_result=0 无此用户
insert_result=10 父节点不存在
insert_result=4   有重复文件




失败情况：
0代表的是没有此用户 1代表的是父节点为空  4代表有该用户在该目录有重复文件
成功情况：
 2代表总文件中无类似文件  21代表无类似文件无兄弟节点插入  22代表无类似文件有兄弟节点插入
 3代表总文件中有类似文件  31代表有类似文件无兄弟节点插入  32代表有类似文件有兄弟节点插入
 
drop PROCEDURE storetest;*/
delimiter $
drop PROCEDURE insertListStoredProcedure;
create  PROCEDURE insertListStoredProcedure(
in in_userid varchar(30),
in in_fileid int,
in in_bro_index int ,in in_filename varchar(100),
out insert_result int,out out_now_index int,out out_now_filename varchar(200)
)

leave_lable:BEGIN 
  set @a=null;
  set @b=null;
  set @c=null; set @c_userid=null;set @c_fileid=null;
  

  /*1.判断该用户是否存在*/
  SELECT userid into @a from user where userid=in_userid;
  if @a is null THEN set insert_result=0; LEAVE leave_lable; end if;


/*插入文件*/
 insert into file (fileid,filesize,filetype,filelocate,usersize)
              VALUES(in_fileid,0,"list","/file",0);
              set insert_result=2;


 
/*
搜索父亲节点的孩子节点  父亲节点 in_bro_index   孩子节点 son注入    @c 是父节点的第一个孩子节点 

孩子节点存在 
   插入当前节点  
        将自己的兄弟节点指向那个孩子节点 
   获得新插入的当前节点                     当前孩子节点out_now_index 
   将父亲节点指向当前节点
孩子节点不存在
   插入当前节点 
   获得新插入的节点
   将父亲节点指向当前节点

*/

/*3.将文件的id加入到user_file中*/

  SELECT bro_index into @c from user_file where userid=in_userid and bro_index=in_bro_index;
    /*3.1提供的父节点不存在，则退出下面过程，由于上面是存文件过程，和下面无关，所以可以直接返回insert_result的结果*/
    if @c is null THEN set insert_result=10;   LEAVE leave_lable; end if;
    
    /*父节点的孩子节点的重复检测，检测插入时是否有相同名字相同类型的文件*/
    SELECT filename into @c_duplicate from user_file where userid=in_userid and parent=in_bro_index and fileid=in_fileid and filename=in_filename;
   SELECT COUNT(fileid) into @fujia from user_file where userid=in_userid and parent=in_bro_index and fileid=in_fileid;
    set @fujia=@fujia+1;  
/*不为空则有重复文件 退出*/ 
      if @c_duplicate is not null then set insert_result=4;set in_filename=    CONCAT(@c_duplicate,@fujia); end if;
  
      set out_now_filename=in_filename;
    
    /*3.2父节点存在，那么寻找父节点的最右孩子节点  c是最右边的孩子的bro_index*/

    select son into @c from user_file where userid=in_userid and bro_index=in_bro_index;
  #  SELECT bro_index into @c from user_file where userid=in_userid and parent=in_bro_index and brother=null;
  CASE   /*3.2.1不存在最右节点，那么自己便是第一个孩子 直接插入，brother置为null*/
  when @c is null then 
       insert into user_file (userid,fileid,filename,share,sharepass,parent,brother)
          VALUES(in_userid,in_fileid,in_filename,null,null,in_bro_index,null);
           set insert_result=insert_result*10+1;
        SELECT bro_index into out_now_index from user_file where userid=in_userid and fileid=in_fileid;
        update user_file set son=out_now_index where userid=in_userid and bro_index=in_bro_index;
      
    
/*3.2.2 如果最右孩子节点存在 那么在最右孩子节点插入自己 并且插入自己的brother直接置为null*/
  ELSE 
         
      /*冗余的一步*/
  insert into user_file (userid,fileid,filename,share,sharepass,parent,brother)
        VALUES(in_userid,in_fileid,in_filename,null,null,in_bro_index,@c);
/*找到新插入的唯一主键  @c_bro_index是新插入的bro_index*/
SELECT bro_index into out_now_index from user_file where userid=in_userid and fileid=in_fileid and filename=in_filename;
/*将最右孩子节点指向新插入的唯一主键*/
       update user_file set son= out_now_index where userid=in_userid and bro_index=in_bro_index;
	   
	   
	   
	   
	   
	   
	   
       
        
  end case;



 /*4 到此说明已经插入成功，将引用这个文件的数量加一*/
 update file set usersize=usersize+1 where fileid=in_fileid;

  select in_fileid;
  SELECT insert_result;
  SELECT @c;
END $

delimiter;




/*插入第一个节点
in in_userid varchar(30),
in in_fileid int,
in in_bro_index int ,in in_filename varchar(100),
out insert_result int,out out_now_index int,out out_now_filename varchar(200)
*/

set @insert_result=-1;
set @out_now_index=-1;
set @out_now_filename="caozuo";
set @out_now_fileid=100;
call insertListStoredProcedure("admin",
               4455745,
              4,"caozuo6",
              @insert_result,@out_now_index,@out_now_filename);
SELECT @insert_result;
SELECT @out_now_index;
SELECT @out_now_filename;

最新两个

 插入文件夹

/*

因为要指明fileid，因此就不用再重新写了

首先sql先根据md5搜索fileid
   如果有相同，先执行存储过程，那么fileid将会指明这行新插入的数据，执行完存储过程后，利用fileid将这条数据删除
   如果不相同，也先执行存储过程，根据fileid找到这条数据，将md5插入进去

最后需要说明的是 
in_bro_index是父亲节点 我曹，当时咋写的
 最后的时候需要返回最终生成的fileid   重复文件检测也将返回值  qt应该对重复文件检测进行检测


insert_result=0 无此用户
insert_result=10 父节点不存在
insert_result=4   有重复文件




失败情况：
0代表的是没有此用户 1代表的是父节点为空  4代表有该用户在该目录有重复文件
成功情况：
 2代表总文件中无类似文件  21代表无类似文件无兄弟节点插入  22代表无类似文件有兄弟节点插入
 3代表总文件中有类似文件  31代表有类似文件无兄弟节点插入  32代表有类似文件有兄弟节点插入
 
drop PROCEDURE storetest;*/
delimiter $
drop PROCEDURE if EXISTS insertListStoredProcedure;
create  PROCEDURE insertListStoredProcedure(
in in_userid varchar(30),
in in_fileid int,
in in_bro_index int ,in in_filename varchar(100),
out result varchar(2000),
out insert_result varchar(2000),out out_now_index int,out out_now_filename varchar(200)
)

leave_lable:BEGIN 
  set @a=null;
  set @b=null;
  set @c=null; set @c_userid=null;set @c_fileid=null;
  

  /*1.判断该用户是否存在*/
  SELECT userid into @a from user where userid=in_userid;
  if @a is null THEN set insert_result=0; LEAVE leave_lable; end if;


/*插入文件*/
 insert into file (filesize,filetype,filelocate,usersize)
              VALUES(0,"list","/file",0);
             
   SELECT LAST_INSERT_ID() into in_fileid;
    set insert_result=2;

 
/*
搜索父亲节点的孩子节点  父亲节点 in_bro_index   孩子节点 son注入    @c 是父节点的第一个孩子节点 

孩子节点存在 
   插入当前节点  
        将自己的兄弟节点指向那个孩子节点 
   获得新插入的当前节点                     当前孩子节点out_now_index 
   将父亲节点指向当前节点
孩子节点不存在
   插入当前节点 
   获得新插入的节点
   将父亲节点指向当前节点

*/

/*3.将文件的id加入到user_file中*/

  SELECT bro_index into @c from user_file where userid=in_userid and bro_index=in_bro_index;
    /*3.1提供的父节点不存在，则退出下面过程，由于上面是存文件过程，和下面无关，所以可以直接返回insert_result的结果*/
    if @c is null THEN set insert_result=10;   LEAVE leave_lable; end if;
    
    /*父节点的孩子节点的重复检测，检测插入时是否有相同名字相同类型的文件*/
    SELECT filename into @c_duplicate from user_file where userid=in_userid and parent=in_bro_index and filename=in_filename;
   SELECT COUNT(fileid) into @fujia from user_file where userid=in_userid and parent=in_bro_index;
    set @fujia=@fujia+1;  
/*不为空则有重复文件 退出*/ 
      if @c_duplicate is not null then set insert_result=4;set in_filename=    CONCAT(@c_duplicate,@fujia); end if;
  
      set out_now_filename=in_filename;
    
    /*3.2父节点存在，那么寻找父节点的最右孩子节点  c是最右边的孩子的bro_index*/

    select son into @c from user_file where userid=in_userid and bro_index=in_bro_index;
  #  SELECT bro_index into @c from user_file where userid=in_userid and parent=in_bro_index and brother=null;
  CASE   /*3.2.1不存在最右节点，那么自己便是第一个孩子 直接插入，brother置为null*/
  when @c is null then 
       insert into user_file (userid,fileid,filename,share,sharepass,parent,brother)
          VALUES(in_userid,in_fileid,in_filename,null,null,in_bro_index,null);
           set insert_result=insert_result*10+1;
        SELECT bro_index into out_now_index from user_file where userid=in_userid and fileid=in_fileid;
        update user_file set son=out_now_index where userid=in_userid and bro_index=in_bro_index;
      
    
/*3.2.2 如果最右孩子节点存在 那么在最右孩子节点插入自己 并且插入自己的brother直接置为null*/
  ELSE 
         
      /*冗余的一步*/
  insert into user_file (userid,fileid,filename,share,sharepass,parent,brother)
        VALUES(in_userid,in_fileid,in_filename,null,null,in_bro_index,@c);
/*找到新插入的唯一主键  @c_bro_index是新插入的bro_index*/
SELECT bro_index into out_now_index from user_file where userid=in_userid and fileid=in_fileid and filename=in_filename;
/*将最右孩子节点指向新插入的唯一主键*/
       update user_file set son= out_now_index where userid=in_userid and bro_index=in_bro_index;
	   
	   
	   
	   
	   
	   
	   
       
        
  end case;



 /*4 到此说明已经插入成功，将引用这个文件的数量加一*/
 update file set usersize=usersize+1 where fileid=in_fileid;




   set result= CONCAT(out_now_index,"#",out_now_filename,"#",in_fileid);
END $

delimiter;




/*插入第一个节点
in in_userid varchar(30),
in in_fileid int,
in in_bro_index int ,in in_filename varchar(100),
out insert_result int,out out_now_index int,out out_now_filename varchar(200)
*/

set @insert_result="";
set @out_now_index=-1;
set @out_now_filename="caozuo";
set @out_now_fileid=100;
call insertListStoredProcedure("admin",
               44557745,
              642,"aaaa",
								@result,
              @insert_result,@out_now_index,@out_now_filename);
SELECT @result;

插入文件

/*

因为要指明fileid，因此就不用再重新写了

首先sql先根据md5搜索fileid
   如果有相同，先执行存储过程，那么fileid将会指明这行新插入的数据，执行完存储过程后，利用fileid将这条数据删除
   如果不相同，也先执行存储过程，根据fileid找到这条数据，将md5插入进去

最后需要说明的是 
in_bro_index是父亲节点 我曹，当时咋写的
 最后的时候需要返回最终生成的fileid   重复文件检测也将返回值  qt应该对重复文件检测进行检测




失败情况：
0代表的是没有此用户 1代表的是父节点为空  4代表有该用户在该目录有重复文件
成功情况：
 2代表总文件中无类似文件  21代表无类似文件无兄弟节点插入  22代表无类似文件有兄弟节点插入
 3代表总文件中有类似文件  31代表有类似文件无兄弟节点插入  32代表有类似文件有兄弟节点插入
 
drop PROCEDURE storetest;*/
delimiter $
drop PROCEDURE insertFileStoredProcedure;
create  PROCEDURE insertFileStoredProcedure(
in in_userid varchar(30),
in in_fileid int,in in_filesize int, in in_filetype varchar (30),in in_filelocate varchar (200),
in in_bro_index int ,in in_filename varchar(100),in in_filehash varchar(200),
out result varchar(2000),
out insert_result int,out out_now_index int,out out_now_filename varchar(200),out out_now_fileid int
)

leave_lable:BEGIN 
  set @a=null;
  set @b=null;
  set @c=null; set @c_userid=null;set @c_fileid=null;
  

  /*1.判断该用户是否存在*/
  SELECT userid into @a from user where userid=in_userid;
  if @a is null THEN set insert_result=0; LEAVE leave_lable; end if;

 
 /*2.插入文件file表*/
  select fileid into @b from file where filehash=in_filehash;
  CASE
  /*该文件不存在，则插入*/
  when @b is null then  insert into file (filesize,filetype,filelocate,usersize,filehash)
              VALUES(in_filesize,in_filetype,"/file",0,in_filehash);
              set insert_result=2;
      /*检查最后插入的自动增加的fileid 然后设置@checkfileid表示已经修改了 也就是需要上传文件*/
							SELECT LAST_INSERT_ID() into in_fileid;
							set @checkfileid=1;
  else  /*该文件已经存在，则更新usersize的值  设置没有修改 则不需要上传文件*/     
           set insert_result=3; set in_fileid=@b; set @checkfileid=2;
  end case;

set out_now_fileid=in_fileid;


 
/*
搜索父亲节点的孩子节点  父亲节点 in_bro_index   孩子节点 son注入    @c 是父节点的第一个孩子节点 

孩子节点存在 
   插入当前节点  
        将自己的兄弟节点指向那个孩子节点 
   获得新插入的当前节点                     当前孩子节点out_now_index 
   将父亲节点指向当前节点
孩子节点不存在
   插入当前节点 
   获得新插入的节点
   将父亲节点指向当前节点

*/

/*3.将文件的id加入到user_file中*/

  SELECT bro_index into @c from user_file where userid=in_userid and bro_index=in_bro_index;
    /*3.1提供的父节点不存在，则退出下面过程，由于上面是存文件过程，和下面无关，所以可以直接返回insert_result的结果*/
    if @c is null THEN set insert_result=1;   LEAVE leave_lable; end if;
    
    /*父节点的孩子节点的重复检测，检测插入时是否有相同名字相同类型的文件*/
    SELECT filename into @c_duplicate from user_file where userid=in_userid and parent=in_bro_index and filename=in_filename;
     SELECT SUBSTRING_INDEX(@c_duplicate,'.',1) into @wenfilename;
		 SELECT SUBSTRING_INDEX(@c_duplicate,'.',-1) into @wenfiletype;
     
   SELECT COUNT(bro_index) into @fujia from user_file where userid=in_userid and parent=in_bro_index and filename LIKE CONCAT(@wenfilename,'%',@wenfiletype);
    set @fujia=@fujia+1;  
/*不为空则有重复文件 退出*/ 
      if @c_duplicate is not null then set insert_result=4;set in_filename=    CONCAT(@wenfilename,@fujia,'.',@wenfiletype); end if;
  
      set out_now_filename=in_filename;
    
    /*3.2父节点存在，那么寻找父节点的最右孩子节点  c是最右边的孩子的bro_index*/

    select son into @c from user_file where userid=in_userid and bro_index=in_bro_index;
  #  SELECT bro_index into @c from user_file where userid=in_userid and parent=in_bro_index and brother=null;
  CASE   /*3.2.1不存在最右节点，那么自己便是第一个孩子 直接插入，brother置为null*/
  when @c is null then 
       insert into user_file (userid,fileid,filename,share,sharepass,parent,brother)
          VALUES(in_userid,in_fileid,in_filename,null,null,in_bro_index,null);
           set insert_result=insert_result*10+1;
        SELECT bro_index into out_now_index from user_file 
						where userid=in_userid and fileid=in_fileid and parent=in_bro_index and filename=in_filename;
        update user_file set son=out_now_index where userid=in_userid and bro_index=in_bro_index;
      
    
/*3.2.2 如果最右孩子节点存在 那么在最右孩子节点插入自己 并且插入自己的brother直接置为null*/
  ELSE 
         
      /*冗余的一步*/
  insert into user_file (userid,fileid,filename,share,sharepass,parent,brother)
        VALUES(in_userid,in_fileid,in_filename,null,null,in_bro_index,@c);
/*找到新插入的唯一主键  @c_bro_index是新插入的bro_index*/
SELECT bro_index into out_now_index from user_file where userid=in_userid and fileid=in_fileid and filename=in_filename and parent=in_bro_index;
/*将最右孩子节点指向新插入的唯一主键*/
       update user_file set son= out_now_index where userid=in_userid and bro_index=in_bro_index;
	   
	   
	   
	   
	   
	   
	   
        set insert_result=insert_result*10+2;
        
  end case;



 /*4 到此说明已经插入成功，将引用这个文件的数量加一*/
 update file set usersize=usersize+1 where fileid=out_now_fileid;

#注意@a和a的区别 这里容易出错 
 set result= CONCAT(out_now_index,"#",out_now_fileid,"#",out_now_filename,"#",@checkfileid,"#",in_filetype);

  # set @resultall=CONCAT(@insert_result,"#",@out_now_index,"#",@out_now_filename,"#",@out_now_fileid);

END $

delimiter;




/*插入第一个节点
create  PROCEDURE storetest(
in in_userid varchar(30),
in in_fileid int,in in_filesize int, in in_filetype varchar (30),in in_filelocate varchar (200),
in in_bro_index int ,in in_filename varchar(100),in in_filehash varchar(200),
out insert_result int,out out_now_index int,out out_now_filename varchar(200),out out_now_fileid int
)
*/

set @insert_result=-1;
set @out_now_index=-1;
set @out_now_filename="caozuo";
set @out_now_fileid=100;
set @resultall="caozuo";
call insertFileStoredProcedure
('admin',-1564001353,50,'txt','D:/Key.txt','840','Key.txt','e2658d7da595d927710475f97cd08a53',
@resultall,@insert_result,@out_now_index,@out_now_filename,@out_now_fileid);
SELECT @insert_result;
SELECT @out_now_index;
SELECT @out_now_filename;
SELECT @out_now_fileid;
SELECT @resultall;

找子节点操作

#select group_concat(bro_index) as ids from user_file where find_in_set(parent, '407');
DROP FUNCTION IF EXISTS `getChildLst`;
DELIMITER //

CREATE FUNCTION `getChildLst`(rootId INT)
RETURNS varchar(1000) READS SQL DATA
BEGIN
  DECLARE sTemp VARCHAR(1000); 
  DECLARE sTempChd VARCHAR(1000);
  SET sTemp = '$';
  SET sTempChd =cast(rootId as CHAR);
  WHILE sTempChd is not null DO
    SET sTemp = concat(sTemp,',',sTempChd);   
    SELECT group_concat(bro_index) INTO sTempChd FROM user_file where FIND_IN_SET(parent,sTempChd)>0;
  END WHILE;
  RETURN sTemp;

END  //
DELIMITER ;
#SELECT getChildLst(407);
SELECT fileid,filename FROM user_file WHERE FIND_IN_SET(bro_index,getChildLst(407));

分享目录

目录的bro_index 留着哪里的bro_index 用户名 返回结果

返回0是失败，返回1是成功

在第二个游标里面会出现bug，这里用的brother代替的bro_index 推测是这个下划线出错

drop PROCEDURE IF EXISTS shareprocedure;
delimiter $
create  PROCEDURE shareprocedure(
in rootId int,in allrootid int,useridroot VARCHAR(200)
,out insert_result varchar(20)
)
# rootId是分享的根节点   allrootid是加到某目录下bro_index

BEGIN 
  DECLARE sTemp VARCHAR(1000); 
  DECLARE sTempChd VARCHAR(1000);
  declare row_fileid int;
  declare row_bro_index int;
declare row_bro_index2 int; #游标2使用这个
	declare nowbroindex int;
	declare row_nowbro_index int;
	DECLARE row_nowbrother int;
DECLARE row_parent int;
DECLARE row_brother int;
DECLARE row_son int;
  declare row_filename VARCHAR(1000);
	declare i int default 0;
	declare in_bro_index int;
	DECLARE tmpson int;
	declare youbiao cursor for select fileid,bro_index,filename from tmp_table;
  declare youbiao2 cursor for select parent,brother,bro_index,son,nowbrother from tmp_table;
  set insert_result=0;

  SET sTemp = '$';
  SET sTempChd =cast(rootId as CHAR);
  WHILE sTempChd is not null DO
    SET sTemp = concat(sTemp,',',sTempChd);   
    SELECT group_concat(bro_index) INTO sTempChd FROM user_file where FIND_IN_SET(parent,sTempChd)>0;
  END WHILE;
#SELECT * FROM user_file WHERE FIND_IN_SET(bro_index,sTemp)>0;

drop table if exists tmp_table;

CREATE temporary table tmp_table SELECT fileid,filename,parent,brother,bro_index,son 
																				FROM user_file WHERE FIND_IN_SET(bro_index,sTemp)>0;
#添加几列
alter table tmp_table add (nowparent int,nowbrother int,nowbroindex int,now_son int);
select count(*) into @rowcount from tmp_table;
set @line=0;
#第一次循环 用于插入得到插入的bro_index 并将新插入的bro_index存储到临时表中
set i=0;
open youbiao;
repeat
set i:=i+1;
fetch youbiao into row_fileid,row_bro_index,row_filename;

 insert into user_file(userid,fileid,filename)
              VALUES(useridroot,row_fileid,row_filename);
             
   SELECT LAST_INSERT_ID() into in_bro_index;
    update tmp_table set nowbroindex=in_bro_index where bro_index=row_bro_index;
#有毒，下面用nowbrother代替nowbroindex
    update tmp_table set nowbrother=in_bro_index where bro_index=row_bro_index;


until i>=@rowcount end repeat;
close youbiao;

#第二次循环  由于未知错误，现在用nowbrother代替nowbroindex
#declare youbiao2 cursor for select parent,brother,bro_index,son,nowbrother from tmp_table;
set i=0;
open youbiao2;
repeat
set i:=i+1;
set row_parent=NULL;set row_bro_index2=NULL; set row_brother=NULL; set row_son=NULL;set row_nowbrother=NULL;
fetch youbiao2 into row_parent,row_brother,row_bro_index2,row_son,row_nowbrother;
if row_bro_index2 = rootId THEN #顶节点
 #查找自己父亲的儿子，将父亲的儿子换成自己，把自己的兄弟改成父亲的儿子
select son into tmpson from user_file where bro_index=allrootid;


update user_file set son=row_nowbrother where bro_index=allrootid;#将父亲的儿子换成自己
update user_file set brother=tmpson where bro_index=row_nowbrother;#更新自己的兄弟
update user_file set parent=allrootid where bro_index=row_nowbrother;#更新自己的爹
update user_file set son=(select nowbrother from tmp_table where bro_index=row_son)  where bro_index=row_nowbrother;


end IF;
#其他情况 
if row_bro_index2 <> rootId THEN
#临时表不能一次打开多次，分开进行
 update user_file set parent=(select nowbrother from tmp_table where bro_index=row_parent) where bro_index=row_nowbrother;
 update user_file set brother=(select nowbrother from tmp_table where bro_index=row_brother)  where bro_index=row_nowbrother;
 update user_file set son=(select nowbrother from tmp_table where bro_index=row_son)  where bro_index=row_nowbrother;


#update tmp_table set nowbrother=in_bro_index where bro_index=row_bro_index;

end if;

until i>=@rowcount end repeat;
close youbiao2;


set insert_result=1;#到这里说明一切顺利


#首先有一个总的节点  father 
#先插入user_file表 filename fileid  得到bro_index 
#插入到nowbro_index 
#插完以后，再来一次循环
# 将father加入到孩子节点数组里面，
 #看是否存在孩子节点，存在说明他是一个父节点，拿将其加入到孩子节点数组里面
#前几层的方法
#将






 #father是第一层  看father是否存在孩子节点  有那么将其
 






END $
delimiter;

call shareprocedure(411,431,"test",@return);