SQL基础查询和LINQ集成化查询

select

select 语句用于从表中选取数据，是 sql 最基本的操作之一。

通过 select 查询的结果被存储在一个结果表中（称为结果集）。

sql select 语法

只查询某个列的数据：

select [列名称] from [表名称]

查询所有列的数据

select * from [表名称]

sql

查询所有数据

select * from categories

查询一列或多列

select category_id,category_name from categories

查询表达式

            var list = from categories in context.categories
                       select new
                       {
                           categories.categoryid,
                           categories.categoryname
                       };

            var lists = from categories in context.categories
                        select categories;

查询语句

            var list = context.categories.select(categories =>
            new
            {
                categories.categoryid,
                categories.categoryname
            });
            var lists = context.categories.select(categories => categories);

sql select distinct 语句

distinct 可以去除查询结果集中完全相同的项，只有每一个列中每一个数据都相同，才能被认为是“完全相同”。

可在 categories 表中添加相同数据的项进行测试(除主键外相同)。

sql

select distinct category_id,category_name from categories

查询表达式

            var dislist = list.distinct();

            var dislist2 = (from categories in context.categories
                            select new
                            {
                                categories.categoryid,
                                categories.categoryname
                            }).distinct();

查询语句

            var dislist = list.distinct();
            var dislist2 = context.categories.distinct().select(categories =>
              new
              {
                  categories.categoryid,
                  categories.categoryname
              });

where 和 操作符

用于条件筛选。

操作符	描述
=	等于
<>	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于
between	在某个范围内
like	搜索某种模式

注释：在某些版本的 sql 中，操作符 <> 可以写为 !=。

between 和操作符

between ... and 或 between ... or

c# 中可以使用 && 或 ||表示。

sql

select [列名称] from [表名称] where [列] [运算符] [值]

select
	category_id,
	category_name 
from
	categories 
where
	between category_id > 1 
	and category_id < 5

查询表达式

            var list3 = from categories in context.categories
                        where categories.categoryid > 1 && categories.categoryid < 5
                        select categories;

查询语句

            var list3 = context.categories.where(x => x.categoryid > 1 && x.categoryid < 5);

like 和通配符

在 sql 中，可使用以下通配符：

通配符	描述
%	替代一个或多个字符
_	仅替代一个字符
[charlist]	字符列中的任何单一字符
[^charlist]或者[!charlist]	不在字符列中的任何单一字符

sql

select * from categories where  category_name like 'b%'

查询表达式

            var list4 = from categories in context.categories
                        where categories.categoryname.startswith("b")
                        select categories;

不能直接使用 %。

查询语句

            var list4 = context.categories.where(x => x.categoryname.startswith("b"));

linq 只有 startwith 、 endwith 和 contains，没有其它通配符。

而 ef中提供了 ef.functions.like() 来进行通配符操作。

例如：

            var list5 = from categories in context.categories
                        where ef.functions.like(categories.categoryname,"b_")
                        select categories;

            var list5 = context.categories.where(x => ef.functions.like(x.categoryname, "b_"));

更多通配符操作，请自行了解 ef.functions.like()。

order by 排序

sql

select * from categories order by category_id

c#

            var list6 = (from categories in context.categories
                         select categories).orderby(c => c.categoryid);


            var list7 = from categories in context.categories
                        orderby categories.categoryid
                        select categories;

            var list6 = context.categories.orderby(x => x.categoryid).tolist();

            var list7 = context.categories.tolist().orderby(x=>x.categoryid);

top

postgresql 中没有 top，可以使用 offset、limit 代替。

select select_list
    from table_expression
    [ order by ... ]
    [ limit { number | all } ] [ offset number ]

top(5) 的表达

select * from test order by test  limit 5

或者

select * from test offset 0 limit 5

一般与 order by 一起使用

select * from test order by test offset 5 limit 5

limit all 的效果和省略limit子句一样，例如下面的 sql 或获取全部数据。

select * from test limit all   --等价 select * from test

c#代码中，则相应使用 take 、 skip。

            var list = (from c in context.userroles
                        select c).skip(0).take(5);

            var list = context.userroles.skip(0).task(5);

例外：

t-sql 中的 top(1) ，在 postgresql 中，可以表示

select * from test limit 1

而 c# 表示：

            var list00 = (from c in context.userroles
                         select c).first();
            var list01 = (from c in context.userroles
                          select c).firstordefault();
            var list02 = (from c in context.userroles
                          select c).take(1);

            var list10 = context.userroles.first();
            var list11 = context.userroles.firstordefault();
            var list12 = context.userroles.take(1);

可以使用 first() 或 firstordefault() 返回查询结果中的第一条数据，方法体中不加条件，相当于 top(1)。

takewhile 和 skipwhile

takewhile

运行查询，直到某一条件成立才停止获取；即当条件成立时，才会停止。

skipwhile

运行查询，直到某一条件成立才停止跳过；即当条件成立时，才会开始。

in

与 where 一起使用，表示符合条件中的一个。

select * from test where test in ('1','2')

select * from test where test not in ('1','2')

c# 中用 contains 表示

            string[] item = new string[] { "a","b","c"};
            var list = from c in context.userroles
                       where item.contains(c.roleid)
                       select c;

            var list2 = context.userroles.where(x => item.contains(x.roleid));

alias(as)

sql 中，可以给查询的列设置别名，例如

select test as ttttt from test 

c#中，应该无直接如此的操作。

不过，很多操作形式最后生成的 sql 都会出现 as。

exists 和 not exists

sql	c#
in	contains
exists	any
not exists	all

exists

判断子查询中是否有结果集返回，如果有即为 true。

子查询中应当有 where 等条件

select * from test exists （{子查询}）

exists 并不关注 子查询中返回了什么、返回了多少结果集，它只判断有没有结果返回(查询返回的结果集，行数>0)。

例如

select * from test exists （select 1 from test where test == "a"）

c#

使用 .any()

            var list = from s in context.userroles
                       where (from c in context.userroles
                              select c).any()
                       select s;

            var list2 = context.userroles.where(x => context.userroles.any());

any() 中也可以加条件

            var list = from s in context.userroles
                       where (from c in context.userroles
                              select c).any(x => x.roleid != "x")
                       select s;

            var list2 = context.userroles.where(x => context.userroles.any(x => x.roleid != "x"));

not exists

无结果集返回则为，没有返回则为 true。

子查询中应当有 where 等条件判断。

linq 的 拓展方法 all，表示每一个元素是否都符合条件。返回 bool。。

            var list = from s in context.userroles
                       where context.userroles.all(x=>x.roleid=="a")
                       select s;

            var list2 = context.userroles.where(x => context.userroles.all(x => x.roleid == "x"));

in 比 exists 的速度快。

到此这篇关于sql基础查询和linq集成化查询的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持。