vb程序,访问SQL数据库的一个表，能够增加和删除记录_百度知道
vb程序,访问SQL数据库的一个表，能够增加和删除记录
在VB里面编程,实现访问SQL数据库的一个表，能够增加和删除记录,有哪位高手帮忙解决下,小弟感激不尽~~
提问者采纳
首先在FORM_LOAD方法里面调用打开连接的方法Opencon
Private Sub Form_Load()
OpenConEnd Sub然后再来定义怎么连接到数据库，用下面的代码：Public Function OpenCon() As Boolean
Dim mag As String
'定义一个消息框
On Error GoTo strerrmag
'发生错误程序跳转到消息框
Set conn = New Connection
'创建一个连接
conn.Open &Provider=SQLOLEDB.1;Persist Security Info=FUser ID= 数据库用户名;_
password=数据库登陆密码;Initial Catalog=数据库名;Data Source=服务器名&
OpenCon = True
addFlag = True
Exit Functionstrerrmag:
mag = &Data can't connect&
Call MsgBox(mag, vbOKOnly, &Error:Data connect&)
'定义消息框
addFlag = False
Exit FunctionEnd Function现在你已经创建好了到数据库的连接了接下来是怎么对数据库进行添加查询和删除了先来看添加，创建一个方法 save 来执行在数据库里添加记录的任务Private Sub Save()
'定义一个叫SAVE的方法
Set rs = New Recordset
'创建一个叫rs的连接字段
rs.Open &select * from 表名 &, conn, adOpenKeyset, adLockPessimistic
'打开连接
'调用VB里面的AddNew方法进行插入记录
r(0) = ''
'对数据库里的表里的字段进行赋值,括号里的数字对应表里字段的排序,''里面是要插入的内容,
r(1) = ''
'可以是文本框的内容(Text1.text),也可以是标签的内容(Label1.Caption),
r(2) = ''
'具体的自己看看相关的VB教程里控件的属性的定义
r(3) = ''
'调用Update方法,更新表里的记录
'插入完了记得关闭这个连接哦End Sub对应的,查找基本一样,只是赋值语句倒过来,把数据库里的字段的值赋给窗体里的控件Private Sub selectmsg()
'创建一个查找的方法selectmsg
Set rs = New Recordset
'创建一个叫rs的连接字段
rs.Open &select * from aaf_empapp where &条件&, conn, adOpenKeyset, adLockPessimistic
'打开连接
''=r(0)
'给窗体里的对应的控件赋值
''=r(1)
''=r(2)
''=r(3)
'关闭连接End Sub最后是删除记录,这个可以用上面的方法,先创建连接,再通过SQL语句来控制操作,但是我们也可以用VB自带的函数来执行Private Sub delete()
'创建一个删除记录的方法
conn.Execute &delete from aaf_empapp where &条件&End Sub
这样几个语句就可以对我们选顶的记录进行删除了当然,光这些还不够,我们还需要在需要的地方调用我们定义的方法才能执行想要的操作比如在窗体里放置了三个分别叫叫 Command1 , Command2 , Command3 的按钮,需要点击它以后执行插入,查找,删除的功能,那么就在Command_Click的事件中来调用实现定义好的方法.Private Sub Command1_Click()
SaveEnd Sub
Private Sub Command2_Click()
selectmsgEnd Sub Private Sub Command3_Click()
deleteEnd Sub加入这些代码以后,我们在窗体里点击对应的按钮就可以执行对应的操作了最后提醒一下,别忘了在 Form_Unload 方法里面关闭数据库连接,释放连接占有的服务器资源Private Sub Form_Unload(Cancel As Integer)
conn.CloseEnd Sub好了,基本的操作方法就是这样,当然你可以去查找一下VB6.0的MSDN,连接数据库的方法有很多种,里面有很详细的说明的
提问者评价
谢谢你讲的这么详细，我回去试试的
参考资料：
VB6.0里的MSDN
其他类似问题
按默认排序
其他1条回答
Public Function qsy(ByVal sql As String, mycn As ADODB.Connection) As ADODB.Recordset
Dim myrs As New ADODB.Recordset
.CursorLocation = adUseClient
.CursorType = adOpenForwardOnly
.LockType = adLockOptimistic
.ActiveConnection = mycn
myrs.Open sql
Set qsy = myrsEnd FunctionPublic Sub odb()
strcn = &Provider=Microsoft.Jet.OLEDB.4.0;Data Source=& & App.Path & &\数据库名;Persist Security Info=False&
If cn.State = adStateOpen Then
Set cn = Nothing
cn.Open strcnEnd Sub'增加insert into 表名 values'删除delete from 表名 where '修改update 表名 set '查询select * from 表名
sql数据库的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁第四章、SQL Server数据库查询大全（单表查询、多表连接查询、嵌套查询、关联子查询、拼sql字符串的查询、交叉查询）
时间： 18:42:03
<span style="font-family:宋体; color:#.1、查询的类型
declare @value
set @value
select& 'age:'
as age,2008 years,@value
--这种查询时跟表没有关系的
select &'age:'
as age,2008 years,@value
as va from student
--这种查询涉及到表，表有多少行就查询出多少行，但是没有涉及到表的列
select 'age:' age,Sage
,2008 years ,@value
as va from Student
--这种是外面的列与表中的列的综合
<span style="font-family:宋体; color:#.2、单表查询
4.2.1、列名的别名和表名的别名
select Sno, Sname
,2008-Sage
from student
--2008-Sage可运算，但无列名
select Sno xuehao, Sname
as xingming,2008-Sage shengri
from student&
--给列名取别名既可以加as也可以不加
select Sno,Sname,2008-Sage
as shengri from student
order by shengri--where shengri & 1983
--shengri字段即属性的别名是不能用来作为判断条件使用的,但是可以排序
--原列名既可以作为判断条件，也可以排序；列名的别名只能用作排序，不能用作判断条件
select Sno,lower(Sdept) sd
from student--lower(Sdept)
，但无列名
select 'age:' age,Sage
,2008 years from Student
select ss.Sno, Sname
,2008-Sage
from student as ss
where ss.Sno='95001'
select ss.Sno, Sname
,2008-Sage age
from student ss where ss.Sno='95001'
select ss.Sno, Sname
,2008-Sage
from student as ss
order by ss.Sno
--select ss.Sno as n, Sname ,2008-Sage from student as ss where ss.n='95001'
这个SQL 语句是错误的.
--select ss.Sno as n, Sname ,2008-Sage from student as ss order by ss.n
--这种排序是错误的.
--表名也可以有别名，给表名取别名既可以加as也可以不加；用表名或者表明的别名来引用列名，既可以排序也可以作为判断条件；用表名或者表明的别名来引用列名的别名，既不可以排序也不可以作为判断条件
4.2.2、消除重复行distinct
select distinct Sno
--消除取&#20540;重复的行，关键字是distinct，默认缺损&#20540;是ALL，这个是针对某一行而不是某一个字段，也就是说各行之间的各个字段完全相同才算是重复的，而不是只有某一个字段相同就算重复了
4.2.3、比较运算符、not运算符
select Sname
from Student where sdept
select Sname
,Sage from Student
where Sage&=20
select distinct Sno
from SC where
not grade & 60
--比较运算符：& &= & &= = != && !& !&
--not运算符：是针对某一个逻辑表达式（bool表达式）的，是对逻辑表达式取反的，而不是针对一个符号，比如grade not& 60，所以运算符NOT可以与比较运算符同用，对条件求非，比如not
grade & 60
4.2.4、确定取&#20540;范围between...and...
select Sname,Sage
from student where sage
not between 22
--确定取&#20540;范围：between...and...，not between...and...
--注意：between&
A& and& B& 这个相当于&=&
A& and&= B,& 顺序不能错！不会对A,B的大小进行检查
4.2.5、确定集合:in、not in
select Sname,Sage,sdept
from student where sdept
in ('CS','ma')
--确定集合:in,not in , in可以用= OR =
等等来替代，not in
可以用！= and ！=
--注意：加了括号的
4.2.6、模糊查询like
from student where sno
from student where sno
like '95001'
from student where sname
like '刘%'
from student where sname
like '刘_'
from student where sno
like '9500_'
from student where sname
like '_呈%'
from student where sname
FROM COURSE
from course where cname
like 'DB\_M'
escape '\'
from course where cname
like 'MA\%S'
escape '\'
from course where cname
like 'MA%K__'
--字符匹配[not]like % _ escape
--当like后面的字符串没有包含通配符的时候，like就是=
--& %：通配符，代表任意长度的字符串包括0.
代表一个字符.默认每一个字符（数&#20540;，字母，汉字）采用ascii进行编码的.但是
管用什么方式进行编码，_代表的是一个字符，而不是一个字节.
--escape 定义某一个字符，这个字符后面紧跟的通配符是不起通配作用的，当like比较的时候会忽略字符串中的escape
定义某一个字符，而把其后的通配符当成一个普通的字符。
4.2.9、涉及空&#20540;null的查询
from student where sname
from student where ssex
from student where sname
--涉及空&#20540;的查询：is not null
--当是空&#20540;的时候只能用IS来判断，其他的都不可以.
--null表示什么都没有，而''表示的是长度为零的字符串
--null与任何类型的&#20540;进行算术运算的结果都为null
4.2.10、多重条件查询and、or
from student where sdept
= 'cs' and sage
--多重条件查询and&
--and 表示的是并且，而or表示的是或者
--and 的优先级比or高，但是（）可以改变优先级别
4.2.11、对查询结果进行排序
from SC where cno
order by grade desc
from SC order by sno,grade
--排序order by asc/desc
--asc 是升序，是默认的缺损&#20540;，desc是降序的
--order by a，b，c，d
像这种按照多个字段进行的排序，先按照第一个字段排序，再按照第二个字段排序，以此类推，但是第二个字段的排序是在第一个的基础上进行的，它不会去打乱第一个排序的，第一个排序其实就已经分成组了，第二个排序是在第一个排序的各个小组里面进行的排序.
4.2.12、集函数（count、avg、sum、max、min）
from student
count(*)from student
count(all sno) num
from student
count(distinct sno) num
from student
--select count(distinct *)from student--为什么*的时候不能加distinct？
--select count(all *)from student--为什么*的时候不能加all？
avg(distinct sage)
from student--必须是数字，非null&#20540;的加和除以非null&#20540;的个数
sum(distinct sage)
from student--必须是数字，非null&#20540;的加和
max(distinct sno)
from student--只要是可以比较大小的就可以，如果该列全是null，那么结果也是null
min(distinct sno)
from student--只要是可以比较大小的就可以，如果该列全是null，那么结果也是null
--对于这些集函数,dinstinct表示消除了重复的行，而默认缺损为all
4.2.13、分组查询group by
select cno
from sc group by cno
—-分组之后，一组中只取一个&#20540;，而不会取出多个重复的&#20540;，哪怕没有distinct也是这样的，所以如果要加其他的列，这些列在一组中要保证只有一个&#20540;。所以每一组只会有一行。
select cno,sno
from sc group
by cno,sno--分组是不会排序的
select cno,sno
from sc group
by cno,sno order
select cno,count(sno)
from sc group
select sno,count(cno) cnoNum
from sc group
count(distinct cno)&=3
select cno,count(sno)
from sc where cno&1
group by cno,sno&
count(sno)&0
order by cno
--注意上面这个sql语句的顺序,执行的顺序是先分组，然后查询计算，然后在查询
--的结果中判断where和having条件，最后去排序.
--分组与不分组的区别是：不分组的时候，（如果是多表的话，先要去连接）先查询，
--然后在查询结果中按照where子句的条件来筛选。而分组的时候，
--（如果是多表的话，先要去连接）是先分组，然后再执行查询，然后在查询结果中
--按照where子句和having子句的条件来筛选。Having后面的集函数是对每一最小组(按照group
by后面的所有列进行的分组，是所有列而非某一列分组)的那些行进行运算的。另外，having后面也可以对某列进行非集函数的条件判断，这种判断也是针对每一最小组的那些行。
select top 10 a.sno,count(distinct
cno) cno_num
from student
as a,sc as b
where a.sno
and a.sno =
group by a.sno
count(distinct cno)
order by a.sno
查询的执行步骤：先连接，然后按照条件去分组，然后按照组查询，先查询第一组（第一行），然后用where子句和having子句的条件来筛选，满足条件就保留，否则就舍去，然后查询第二行......，最后在查询出的结果中排序，然后在排好序的结果中去求top
1、分组是按照某个列来进行分组的，最后在该列中列&#20540;相同的就是一组了，group by a,b,c先按照a进行分组，在按照a分好的每一组里面，再按照b进行分组，即保留了最开始的组，然后在按照b分好的组里面再按照c进行分组，以此类推......
2、分组是不会排序的,排序和分组是两个独立的过程，排序是在分组查询之后，在最终的满足各种条件的查询结果里面来排序.
3、如果在分组的时候要查询某些字段，那么一定要保证在最小组中的该字段是绝对唯一的，因为每一个最小组最后只会有一行记录，有时候，用户知道是绝对的唯一的，但是计算机不知道，所以在这种情况下必要的时候可以再按照该字段进行一次分组，或者使用集函数.在使用集函数进行运算的时候，是对对最小的组进行计算.
4、没有分组的时候判断条件用where，分组之后对于某一组的集函数结果的判断条件是having，一般用于集函数count，分组后对于某一个字段的判断还是用where
<span style="font-family:宋体; color:#.3、多表连接查询
4.3.1、连接查询概述&&&&&&&&&&&&&&&&&
在关系数据库的查询中，单表查询是有很大的局限性的，因为多数情况下各个表之间都是有关联的，所以绝大多数情况下都要多表连接查询：
无条件连接
非等&#20540;连接
有条件连接自然连接
等&#20540;连接左外连接
、无条件连接
无条件连接其实就是广义笛卡尔乘积，即一个表（行）中的每一行都与另外表（行）中的每一行联合，最终构成了一个行的一个表。
、有条件连接
有条件连接顾名思义就是两个表之间的连接是有条件的，其中一个表的某一个字段与另外一个表中的某一个字段以某一种条件联系起来，连接的过程就是先扫面表的第一行，去与表二中的每一行对比，满足条件的就选择出来，然后拿表一中的第二行去做相同的操作，一直到最后完成。很显然，这个连接后的表其实是广义笛卡尔乘积的子集。这种条件如果是不相等的话，那么就是非等&#20540;连接，反之就是等&#20540;连接。非等&#20540;连接用的比较少，主要是等&#20540;连接。
、等&#20540;连接
当一个表的某一个字段与另外一个表中的某一个字段的联系条件是相等的时候，那么这种连接就是等&#20540;连接。在等&#20540;连接中，如果消除了重复的列，那么这样的等&#20540;连接就是自然连接。在自然连接中，满足条件的才会被选出来成为新的行，不满足条件的是不会被选择出来的。其实自然连接就是内连接。
在两个表之间，如果某一张表的行与另外一张表对应的时候，出现了根据条件去筛选另外一张表的全部行，而前一张表仍有未对应的行，那么这些行是不会成为新表中的行的，但是如果想把这些没有对应的行显示出来，就要用到外连接了。如果表一和表二连接，在表一中存在没有连接的行，表二中全部用来补充，缺损的就是，所以此时称为左外连接，反之则是右外连接。
左外连接：就是以左边的行为主，左边的全部都要显示出来，右边与之对应的要显示出来，没有与之对应的就补。至于右边是否对应完了，不用考虑。
右外连接：就是以右边的行为主，右边的行要全部显示出来，左边与之对应的显示出来，没有对应的补。至于左边是否对应完了，不用考虑。
4.3.2、连接查询的列名
对于查询时候的字段名字，某个字段如果在两个表中都是唯一的，没有重复的，那么就直接用字段名字，当然，如果用表名列名更稳妥，但是建议只用字段名；对于那些在两个表中有相同的字段的，那么一定要用表名列名，此时的列名一般就是按照例名来编号，这样显然不好，一般要用别名比较好，那么这样处理后在应用程序中引用的时候就非常方便，也不会出错了。
注意：只要使用了别名，显示出来的就是别名，而且应用程序中也是要通过这个别名来引用才不会出错的。使用函数的时候一般也要用到别名。
4.3.3、两张表以上的连接查询
对于两张表以上的内连接或者外连接，可以认为先让前面两张表连接起来，构成一个记录集，然后让把这个记录集当成新的表与后面的表相连接。
4.3.4、连接查询实例
、内连接查询实例
方法一：用号内连接
use zwj_study
from student
from course
select student.*
,sc.*,sc.Grade
from student,sc
where student.sno
--表名.*表示的是选择了这个表中的所有列，所有列名都用了表名.列名
select student.*
from student,sc,course
where student.sno
and sc.cno = course.cno
--不管最终查询的列是否在某个表中，但是只要这个查询的条件中涉及到了这张表，那么就一定要在from中添加进来这张表
方法二：用内连接
select student.*,sc.*
from student inner
join sc on student.sno
select student.*,sc.*
student inner
join sc on student.sno
inner join course
= course.cno
--以上是内连接的第二种写法.这个连接的过程是前面两张表先连接好了，然后再来连接第三张表。连接的条件已经在from里面了．当然还可以用where来添加新的条件
--select student.* ,sc.* from student inner join sc
--where& student.sno = sc.sno
--select student.*,sc.*,course.* from student inner join sc inner join course
--where& student.sno = sc.sno o = o
--以上的这两种写法是完全错误的，不能个这样写.
、外连接查询实例
select student.*
FROM&& Student
left outer JOIN SC
ON Student.Sno
Where ……
select student.*
FROM&& Student
right outer JOIN SC
ON Student.Sno
select student.*
,sc.*,course.*
FROM&& Student
left outer JOIN SC
ON Student.Sno
&&&&&& right
outer join course
on SC.cno = course.cno
--连接的条件已经在from里面了．当然还可以用where来添加新的条件．
--select student.* ,sc.*
--FROM&& Student left outer JOIN SC where Student.Sno = SC.Sno
--select student.* ,sc.*,course.*
--FROM&& Student left outer JOIN SC
--&&&&&& right outer join course
--where& Student.Sno = SC.Sno o = o
--以上这两种方式是错误的
、内外混合连接查询实例
select student.*
,sc.*,course.*
FROM&& Student
left outer JOIN SC
ON Student.Sno
&&&&&& inner
join course on SC.cno
= course.cno
<span style="font-family:宋体; color:#.4、嵌套查询
在关系数据库的查询中，单表查询是有很大的局限性的，因为多数情况下各个表之间都是有关联的，所以绝大多数情况下都要多表连接查询，多表连接查询只有一个，但是有时候也用嵌套查询来代替连接查询，使得查询之间的层次关系更加清晰。所谓嵌套查询，就是在一个查询语句中出现了多个表达式。
4.4.1、子查询作为主查询的条件
、带谓词的子查询
select s1.*,s2.*
from student as s1,student
where& s1.sdept
= s2.sdept
and s1.sname =
--与刘呈同系（单表连接）
select s1.*
from student as s1,student
where& s1.sdept
= s2.sdept
and s2.sname =
--与刘呈同系（单表连接）
from student
where sdept
in (select sdept
from student where sname
= '刘呈')--与刘呈同系
from student
where sdept
in (select sdept
from student where sname
(select sname
from student where sno
= '95002')
select student.sno,sname
from student,sc,course
where student.sno
and sc.cno = course.cno
&and cname
= '信息系统'--选修了信息系统
select sno,sname
from student
(select sno
(select cno
from course
where cname
= '信息系统')
)--选修了信息系统
select sno,sname
from student
(select sno
(select cno
from course
where cname
= '信息系统'
= '女'--选修了信息系统,而且性别为女
1、嵌套查询中的IN,表示某一个字段在某一个集合里面，集合中可能有多个也可能只有一个&#20540;，但是只会有一个字段
2、任何一个子查询都是select块，一定要加上（），否则就会报错.
3、任何一个子查询都不能用order by
来排序，只能对最终的查询结果进行排序
4、子查询的结果只是作为父查询的某一个条件而已，还可以用AND,OR等追加更多的条件
、带比较运算符的子查询
from student
where sdept
= (select sdept
from student where sname
--当确定了一个子查询的结果是单&#20540;的时候，父查询的查询条件就可以使用比较运算符，子查
询必须在比较运算符的后面，而不能是前面
exists(select sdept
from student where sage
from student
if exists(select
* from student
where sage &30)
from student
--exists，not exists只能针对一个select语句，它返回的是一个逻辑&#20540;：true或者false，它主要应用于if语句的判断的，特别是在插入某张表之前来判断某条记录是否存在的，它还可以作为where判断条件
小结：以上的子查询作为主查询的判断条件，有些时候，子查询与主查询时关联的，有时候是不关联的。
4.4.2、子查询作为主查询的列
、表达式作为主查询的列
select sno,cno,grade,
= (select sno
from student where sname
= 'james')
then 'james'
else 'others'
--上面这个查询是一个不相关子查询，即子查询与父查询之间没有关联，执行的步骤是先查询第一行的sno，cno，grade，case语句，然后查询第二行的sno，cno，grade，case，第三行......
--case是一个表达式，它会返回单&#20540;
select sno,cno,grade,
= (select sno
from student where sno
then 'one'
else 'others'
--上面这个查询是一个相关子查询，即子查询与父查询之间有关联，执行的步骤是先查询第一行的sno，cno，grade，case语句，然后查询第二行的sno，cno，grade，case，第三行......
--case是一个表达式，它会返回单&#20540;
、查询表达式作为主查询的列
select sno,cno,grade,
(select sname
from student where sno
= sc.sno )
as name from sc
--当子查询的结果只有一行一列的时候，还可以直接将子查询作为主查询的列，作为主查询的列
--子查询与父查询相关联
小结：以上两种查询的列都出现了特殊的列，而不是一个普通的列，这个特殊列就是一个表达式，这个表达式永远都只会返回一行一列，即返回单&#20540;。每查询一行都会执行一次特殊列表达式，得到一个列出来。子查询与主查询可能是关联的，也可能是非关联的。
4.4.3、子查询作为主查询的from对象
select a.sno,sname, grade
student a ,(select sno,cno,grade
from sc ) b
where a.sno
count(*) from
(select clsbdh,count(*)
as su& from z_hgzzz
group by clsbdh
having count(*)
--在from中使用子查询，子查询的结果就是一个新的表，一定要给新表加一个别名，否则会出错。这种在from中使用子查询，是把子查询作为from的对象了，这种子查询与主查询是永远不会有关联的，否则就不要把子查询作为主查询的from对象了。
<span style="font-family:宋体; color:#. 5、关联子查询
子查询的查询条件不依赖于父查询时，我们称之为不相关子查询，反之，则成为相关子查询。相关子查询只会发生在嵌套查询中，但是在嵌套查询中的一种情况下是不会发生相关子查询的，这就是子查询作为主查询的对象的时候。
下面以子查询作为主查询的条件来讲解关联子查询，关联子查询的执行过程如下，每一个子查询被外部查询的每一行执行一次：
执行过程：先查询第一行，然后执行的判断，如果满足条件，那么这一行就选择出来，否则就舍去。在这一行中，子查询中的就是父查询中这一行的的&#20540;，然后查询第二行、第三行
执行过程：先查询第一行，然后执行的判断，如果满足条件，那么这一行就选择出来，否则就舍去。在这一行中，子查询中的就是父查询中这一行的的&#20540;，然后查询第二行、第三行
执行过程：先查询第一行，然后执行的判断，如果子查询查出来确实存在，那么就会返回，那么这一行就选择出来，否则就舍去。在这一行中，子查询中的就是父查询中这一行的的&#20540;，然后查询第二行、第三行
执行过程：先查询第一行，然后执行的判断，如果子查询查出来确实不存在，那么就会返回，那么这一行就选择出来，否则就舍去。在这一行中，子查询中的就是父查询中这一行的的&#20540;，然后查询第二行、第三行
<span style="font-family:宋体; color:#. 6、拼sql字符串的查询
在存储过程中，有些时候，要动态的查询一些列，动态的变换条件，那么就要拼语句：
&&& declare @sqlSelect
as varchar(5000)
&&& set @sqlSelect
= 'select 1,1,1,null from #zwj1'
拼完之后，可以用命令去执行，但是执行结果是一个记录集，哪怕只有一个&#20540;也是记录集，执行的结果只能用一种方式取得，即定义一个与查询结果相同的表，然后将结果插入到表中，该表可以是临时表也可以不是，这个表一定要之前就定义好，列固定：
insert into zwj
exec(@sqlSelect)
以下的用法都是错误的：
from exec('select 1,1,1,null from #zwj1')
into #v from
exec('select 1,1,1,null from #zwj1')
declare @k
exec('select count(*) from #zwj1')
update zwj
set s = exec('select count(*) from #zwj1')
<span style="font-family:宋体; color:#. 7、交叉查询
在存储过程中，有时候想把记录集的行变成列查询出来，那么就要用到交叉查询，下面举例说明交叉查询：
例一：使用表达式来实现交叉查询：
每个行列转换，都要经过三个逻辑处理阶段，扩展阶段是新增多个列，这样将导致新增了一些行；分组阶段将按照未转换的列分组；聚合阶段将对每个组进行处理，从而实现行的减少得到最终的结果。
以下是一张记录表，这一列只有四个&#20540;，、、、，现在要把这一列分成、、、四列的形式显示出来：
那么就要交叉查询：
select dmcode,klcode,phaseType,
case when phaseType='phase1'
then phasevalue else 0
end phase1 ,
case when phaseType='phase2'
then phasevalue else 0
end phase2 ,
case when phaseType='phase3'
then phasevalue else 0
end phase3,
case when phaseType='phase4'
then phasevalue else 0
end phase4
from PhaseInfo
查询结果如下：
对以上查询结果再进行一次转换：
select dmcode,klcode,
sum(phase1) phase1,sum(phase2)
sum(phase3) phase3,sum(phase4)
select dmcode,klcode,phaseType,
case when phaseType='phase1'
then phasevalue else 0
end phase1 ,
case when phaseType='phase2'
then phasevalue else 0
end phase2 ,
case when phaseType='phase3'
then phasevalue else 0
end phase3,
case when phaseType='phase4'
then phasevalue else 0
end phase4
from PhaseInfo
group by dmcode,klcode
order by dmcode,klcode
查询结果如下：
未找到任何相关信息！
$T.total > 0 && $T.page <= $T.pageNum}
{#foreach $T.data as r}
{$T.r.formt_tm}{#if $T.r.nickname}{#else}匿名{#/if}
{$T.r.content}
{#if $T.page > 1 && $T.pageNum > 1)
$T.s_num > 2}
{#for index = $T.s_num to $T.e_num}
$T.pageNum > $T.pageNavSize+ 2 && $T.s_num != $T.pageNum - $T.pageNavSize}
{#if $T.pageNum > 1}
{#if $T.pageNum != $T.page && $T.pageNum > 1}
<a href="javascript:void(0);" page="{$T.page 下一页
您的回应...
还没有相关话题!
也许你感兴趣
(C)2012 本站提供的内容来源于广大网络用户，我们不保证内容的正确性。如果转载了您的内容，希望删除的请联系我们！