数据库代码暂存
功能：
插入文件 、插入用户、删除操作
其他功能：
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);
