精华内容
下载资源
问答
  • select 子句

    2010-04-06 17:04:00
    在查询表达式中,select 子句可以指定将在执行查询时产生的值的类型。该子句的结果将基于前面所有子句的计算结果以及 select 子句本身中的所有表达式。查询表达式必须以 select 子句或 group 子句结束。下面的示例...

    在查询表达式中,select 子句可以指定将在执行查询时产生的值的类型。该子句的结果将基于前面所有子句的计算结果以及 select 子句本身中的所有表达式。查询表达式必须以 select 子句或 group 子句结束。

    下面的示例演示了查询表达式中的简单 select 子句。

    C# “复制”图像复制代码
    class SelectSample1
    {   
        static void Main()
        {           
            //Create the data source
            List<int> Scores = new List<int>() { 97, 92, 81, 60 };
    
            // Create the query.
            IEnumerable<int> queryHighScores =
                from score in Scores
                where score > 80
                select score;
    
            // Execute the query.
            foreach (int i in queryHighScores)
            {
                Console.Write(i + " ");
            }            
        }
    }
    //Output: 97 92 81
    
    

    select 子句产生的序列的类型决定了查询变量 queryHighScores 的类型。在最简单的情况下,select 子句仅指定范围变量。这会使返回的序列包含与数据源具有相同类型的元素。有关更多信息,请参见查询操作中的类型关系 (LINQ)。不过,select 子句还提供了一种功能强大的机制,可用于将源数据转换(或投影)为新类型。有关更多信息,请参见使用 LINQ 进行数据转换。

    示例

    下面的示例演示了 select 子句可能采用的所有不同形式。在每个查询中,请注意 select 子句和查询变量(studentQuery1studentQuery2 等)的类型之间的关系。

    C# “复制”图像复制代码
        class SelectSample2
        {
            // Define some classes
            public class Student
            {
                public string First { get; set; }
                public string Last { get; set; }
                public int ID { get; set; }
                public List<int> Scores;
                public ContactInfo GetContactInfo(SelectSample2 app, int id)
                {
                    ContactInfo cInfo =
                        (from ci in app.contactList
                        where ci.ID == id
                        select ci)
                        .FirstOrDefault();
    
                    return cInfo;
                }
    
                public override string ToString()
                {
                    return First + " " + Last + ":" + ID;
                }
            }
    
            public class ContactInfo
            {
                public int ID { get; set; }
                public string Email { get; set; }
                public string Phone { get; set; }
                public override string ToString() { return Email + "," + Phone; }
            }
    
            public class ScoreInfo
            {
                public double Average { get; set; }
                public int ID { get; set; }
            }
    
            // The primary data source
            List<Student> students = new List<Student>()
            {
                 new Student {First="Svetlana", Last="Omelchenko", ID=111, Scores= new List<int>() {97, 92, 81, 60}},
                 new Student {First="Claire", Last="O'Donnell", ID=112, Scores= new List<int>() {75, 84, 91, 39}},
                 new Student {First="Sven", Last="Mortensen", ID=113, Scores= new List<int>() {88, 94, 65, 91}},
                 new Student {First="Cesar", Last="Garcia", ID=114, Scores= new List<int>() {97, 89, 85, 82}},
            };
    
            // Separate data source for contact info.
            List<ContactInfo> contactList = new List<ContactInfo>()
            {
                new ContactInfo {ID=111, Email="SvetlanO@Contoso.com", Phone="206-555-0108"},
                new ContactInfo {ID=112, Email="ClaireO@Contoso.com", Phone="206-555-0298"},
                new ContactInfo {ID=113, Email="SvenMort@Contoso.com", Phone="206-555-1130"},
                new ContactInfo {ID=114, Email="CesarGar@Contoso.com", Phone="206-555-0521"}
            };
    
    
            static void Main(string[] args)
            {
                SelectSample2 app = new SelectSample2();
    
                // Produce a filtered sequence of unmodified Students.
                IEnumerable<Student> studentQuery1 =
                    from student in app.students
                    where student.ID > 111
                    select student;
    
                Console.WriteLine("Query1: select range_variable");
                foreach (Student s in studentQuery1)
                {
                    Console.WriteLine(s.ToString());
                }
    
                // Produce a filtered sequence of elements that contain
                // only one property of each Student.
                IEnumerable<String> studentQuery2 =
                    from student in app.students
                    where student.ID > 111
                    select student.Last;
    
                Console.WriteLine("/r/n studentQuery2: select range_variable.Property");
                foreach (string s in studentQuery2)
                {
                    Console.WriteLine(s);
                }
    
                // Produce a filtered sequence of objects created by
                // a method call on each Student.
                IEnumerable<ContactInfo> studentQuery3 =
                    from student in app.students
                    where student.ID > 111
                    select student.GetContactInfo(app, student.ID);
    
                Console.WriteLine("/r/n studentQuery3: select range_variable.Method");
                foreach (ContactInfo ci in studentQuery3)
                {
                    Console.WriteLine(ci.ToString());
                }
    
                // Produce a filtered sequence of ints from
                // the internal array inside each Student.
                IEnumerable<int> studentQuery4 =
                    from student in app.students
                    where student.ID > 111
                    select student.Scores[0];
    
                Console.WriteLine("/r/n studentQuery4: select range_variable[index]");
                foreach (int i in studentQuery4)
                {
                    Console.WriteLine("First score = {0}", i);
                }
    
                // Produce a filtered sequence of doubles 
                // that are the result of an expression.
                IEnumerable<double> studentQuery5 =
                    from student in app.students
                    where student.ID > 111
                    select student.Scores[0] * 1.1;
    
                Console.WriteLine("/r/n studentQuery5: select expression");
                foreach (double d in studentQuery5)
                {
                    Console.WriteLine("Adjusted first score = {0}", d);
                }
    
                // Produce a filtered sequence of doubles that are
                // the result of a method call.
                IEnumerable<double> studentQuery6 =
                    from student in app.students
                    where student.ID > 111
                    select student.Scores.Average();
    
                Console.WriteLine("/r/n studentQuery6: select expression2");
                foreach (double d in studentQuery6)
                {
                    Console.WriteLine("Average = {0}", d);
                }
    
                // Produce a filtered sequence of anonymous types
                // that contain only two properties from each Student.
                var studentQuery7 =
                    from student in app.students
                    where student.ID > 111
                    select new { student.First, student.Last };
    
                Console.WriteLine("/r/n studentQuery7: select new anonymous type");
                foreach (var item in studentQuery7)
                {
                    Console.WriteLine("{0}, {1}", item.Last, item.First);
                }
    
                // Produce a filtered sequence of named objects that contain
                // a method return value and a property from each Student.
                // Use named types if you need to pass the query variable 
                // across a method boundary.
                IEnumerable<ScoreInfo> studentQuery8 =
                    from student in app.students
                    where student.ID > 111
                    select new ScoreInfo
                    {
                        Average = student.Scores.Average(),
                        ID = student.ID
                    };
    
                Console.WriteLine("/r/n studentQuery8: select new named type");
                foreach (ScoreInfo si in studentQuery8)
                {
                    Console.WriteLine("ID = {0}, Average = {1}", si.ID, si.Average);
                }
    
                // Produce a filtered sequence of students who appear on a contact list
                // and whose average is greater than 85.
                IEnumerable<ContactInfo> studentQuery9 =
                    from student in app.students
                    where student.Scores.Average() > 85
                    join ci in app.contactList on student.ID equals ci.ID
                    select ci;
    
                Console.WriteLine("/r/n studentQuery9: select result of join clause");
                foreach (ContactInfo ci in studentQuery9)
                {
                    Console.WriteLine("ID = {0}, Email = {1}", ci.ID, ci.Email);
                }
    
                // Keep the console window open in debug mode
                Console.WriteLine("Press any key to exit.");
                Console.ReadKey();
                }
            }
        /* Output
            Query1: select range_variable
            Claire O'Donnell:112
            Sven Mortensen:113
            Cesar Garcia:114
    
            studentQuery2: select range_variable.Property
            O'Donnell
            Mortensen
            Garcia
    
            studentQuery3: select range_variable.Method
            ClaireO@Contoso.com,206-555-0298
            SvenMort@Contoso.com,206-555-1130
            CesarGar@Contoso.com,206-555-0521
    
            studentQuery4: select range_variable[index]
            First score = 75
            First score = 88
            First score = 97
    
            studentQuery5: select expression
            Adjusted first score = 82.5
            Adjusted first score = 96.8
            Adjusted first score = 106.7
    
            studentQuery6: select expression2
            Average = 72.25
            Average = 84.5
            Average = 88.25
    
            studentQuery7: select new anonymous type
            O'Donnell, Claire
            Mortensen, Sven
            Garcia, Cesar
    
            studentQuery8: select new named type
            ID = 112, Average = 72.25
            ID = 113, Average = 84.5
            ID = 114, Average = 88.25
    
            studentQuery9: select result of join clause
            ID = 114, Email = CesarGar@Contoso.com
    */
    
    

    如上一个示例中的 studentQuery8 所示,您有时可能希望所返回序列中的元素仅包含源元素的属性子集。通过使返回的序列尽可能地小一些,可以降低内存需求,并提高查询的执行速度。通过在 select 子句中创建一个匿名类型,并且借助于对象初始值设定项用源元素中的适当属性对该匿名类型进行初始化,可以达到此目的。有关如何执行此操作的示例,请参见对象和集合初始值设定项(C# 编程指南)

    备注

    编译时,select 子句会被转换为对 Select 标准查询运算符的方法调用。

    请参见

    展开全文
  • SELECT 子句的顺序

    2018-07-18 15:58:01
    SELECT 子句的顺序 SELECT FROM  WHERE GROUP BY HAVING ORDER BY LIMIT

    SELECT 子句的顺序

    SELECT

    FROM 

    WHERE

    GROUP BY

    HAVING

    ORDER BY

    LIMIT

    展开全文
  • SQLite中的SELECT子句

    千次阅读 2018-04-10 10:56:01
    SQLite中的SELECT子句目前为止,最常见的SELECT语句由三个子句组成,分别为SELECT、FROM与WHERE。本小节我们首先讲解SELECT子句SELECT子句可以用来定义最终结果表的格式和内容。要显示在最终结果表中的列必须由...

    SQLite中的SELECT子句

    目前为止,最常见的SELECT语句由三个子句组成,分别为SELECT、FROM与WHERE。本小节我们首先讲解SELECT子句。SELECT子句可以用来定义最终结果表的格式和内容。要显示在最终结果表中的列必须由SELECT子句中的select_heading定义,如果是多列,使用“,”分隔。

    【示例3-1】下面将使用查询语句获取Students表中的id列和Name列内容。SQL语句如下:

    SELECT id,Name FROM Students

    运行程序,执行效果如图3.2所示。


    图3.2  运行效果

    注意:图3.3中显示的是Students数据库表中的全部内容。


    图3.3  Students数据库表

    展开全文
  • Hibernate hql select子句

    千次阅读 2017-05-03 18:01:18
    select子句 指定返回的数据类型:Object[]、List、Map、自定义类型和distinct

    参考http://www.imooc.com/learn/410
    select子句

    select子句 指定返回的数据类型
    以Object[],List,Map返回查询结果,没有孰优孰劣,看个人习惯使用Object[]还是List还是Map

    1、以Object[]形式返回查询结果
    参考http://www.imooc.com/video/9392
    select子句中未指定返回数据类型,默认为(对象数组)Object[]

    这里写图片描述

    如果select子句中 只查询一个属性,默认返回的数据类型是(对象)Object
    这里写图片描述

    2、以List形式返回查询结果

    这里写图片描述

    3、以Map形式返回查询结果
    获取值的时候,map中的key值是索引值,是字符串类型
    这里写图片描述

    使用别名获取属性信息,自定义key值

    这里写图片描述

    4、以自定义类型返回查询结果

    第一步:在持久化类中定义构造器,构造器的参数就是要返回的属性信息

    这里写图片描述

    第二步:在select子句中使用这个构造器

    这里写图片描述

    5、distinct关键字
    消除重复元素

    这里写图片描述

    展开全文
  • Oracle:select子句执行过程 通过FROM子句找到需要查询的表 通过WHERE子句进行非分组函数的限制条件的筛选 通过GROUP BY子句进行分组 通过HAVING子句进行分组函数的限制条件的筛选 通过SELECT子句选择显示的列...
  • select 子句主要用于返回在执行查询时所需要的数据,该子句主要基于前面子句... select子句也非常简单,有一点需要注意,如果我们返回的是一个匿名对象,并且在select子句上做了操作,那么,我们应该给操作后的数据...
  • SQLite中的SELECT子句使用表达式在SELECT语句中可以只有SELECT子句不写FROM子句。这些表达式列表将被单次计算,生成一行,然后组成工作表。这对于测试和判断独立表达式很有用。例如,下面的SQL语句在SELECT语句中只...
  • select子句里能支持另一个select语句的实现形式如下(即要配合case when关键字): select case when lock_purpost in(SELECT id from data_dictionary) then (SELECT name from data_dictionary where id=...
  • SQLite中的SELECT子句使用通配符

    千次阅读 2018-04-18 10:08:57
    SQLite中的SELECT子句使用通配符在SELECT子句中支持两个通配符,分别为*和table_name.*。其中,*通配符会将FROM子句中每个源表的所有用户定义的列进行输出。例如,下面的SQL语句将输出Students的所有用户定义的列。...
  • SQLite中的SELECT子句使用别名

    千次阅读 2018-04-17 10:33:56
    SQLite中的SELECT子句使用别名开发者可以使用AS关键字为指定的列名提供一个新的别名,其语法形式如下SELECT column_name AS Alias [,…]例如,下面的SQL语句为Name列设置了一个别名StudentName。SELECT id,Name AS ...
  • select子句顺序

    2018-07-27 14:51:17
    学习mysql的时候,要记住子句是有顺序的,某个子句必须出现在某个子句之前,现在记录下来。
  • 文章来源:MyBatis动态传入WHERE子句表名和SELECT子句列名   要在项目中实现动态传入表名、列名,你需要将***Mapper.XML配置文件做如下修改: 1、添加属性statementType="STATEMENT" 备注:...
  • MYSQL语句之Select子句

    千次阅读 2011-11-09 12:03:42
    Select 子句 from子句:指定查询数据的表 where子句:查询数据的过滤条件 group by子句:对匹配where子句的查询结果进行分组 having子句:对分组后的结果进行条件限制 order by子句:对查询结果结果进行排序,...
  • select子句用于选择指定的属性或直接选择某个实体,当然select选择的属性必须是from后持久化类包含的属性,譬如: select p.name from Person as pselect可以选择任意属性,即不仅可以选择持久化类的直接属性,还...
  • 关于SELECT子句中使用聚合函数

    千次阅读 2011-09-15 10:21:27
    在JPA查询语句中,可以通过SELECT子句返回一个聚合函数,如下所示: SELECT COUNT(app) FROM Bpp bpp, IN(bpp.apps) app 语句将会统计app返回的数量。 若通过SELECT子句返回多个列,并且其中某个列中使用聚合...
  • 执行顺序,先执行FROM 子句,然后执行WHERE 子句,最后执行SELECT 所以Select 子句后的别名,在where条件中不能使用 SELECT 控制显示的列, WHERE控制显示的行 模糊查询: "_"表示任意一位字符 "%"表示任意任意位字符 NOT ...
  • 在LINQ查询表达式中,select子句指定查询结果的类型和表现形式。LINQ查询表达式要么以select子句结束,要么为group子句结束。下面的代码实例就演示了包含最简单select子句的查询操作。该select子句选择元素的本身。...
  • 数据说明: ...select 课程编号,课程编号 from (select C# 课程编号, CNAME 课程编号, count(distinct S# ) 选修的学生数量 from SC left join C on SC.C# = C.C# group by C#,CNAME having count(disti
  • SELECT子句的功能及其顺序

    万次阅读 2018-12-11 23:12:12
    子句 说明 是否必须使用 SELECT 要返回的列或者表达式 是 FROM 从中检索数据的表 仅在从表里选择数据时使用 WHERE 行级查询 否 GROUP BY 分组说明 仅在按组计算聚集时使用 HAVING 组间过滤(用在GROPUP ...
  • 要通过不止一个列进行果过滤,可以使用AND操作符对WHERE子句附加条件,用在WHERE子句中的关键字 OR 操作符 OR操作符与AND操作符正好相反,它告诉DBMS检索匹配任一条件的行,事实上,许多DBMS在ORWHERE 子句的...
  • where: 条件字段必须是“数据表”中存在的字段 having:条件字段必须是...select id, name, price from goods where price&gt;1000 select id, name, price from goods having price &gt;1000 2、只能使用...
  • select子句的默认排序方式

    千次阅读 2007-01-16 09:16:00
    其中比较常用的一种是使用select top 子句顺序得到结果的子集; 在这个过程中需要借助orderby对结果进行排序;当然也可以在表上建立索引后对执行默认排序规则。 但使用默认排序规则在某些情况下可能会出现问题;...
  • MstrSelectSql = "SELECT StuInfo.NO AS 学号,StuInfo.Name AS 姓名,StuInfo.Sex AS 性别,StuInfo.BirDate AS 出生日期,StuInfo.PolType AS 政治面貌,StuScore.English AS 大学英语,StuScore.Computer AS 计算机,...
  • [为了简洁,截去了prod_desc的描述信息]现在我执行:select vend_id, prod_price from products where prod_price >= 10;结果如下: 没有问题,然后我们执行: select vend_id, count(*) as num_prods, prod_price

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 213,729
精华内容 85,491
关键字:

select子句