本文将介绍如何在AWSRedshift数据库中获取过滤器的子字符串和groupby子句的详细情况，。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于Amazon

本文将介绍如何在AWS Redshift数据库中获取过滤器的子字符串和group by子句的详细情况，。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于Amazon Redshift数据库、Bash技巧：使用参数扩展获取变量的子字符串和字符串长度、LINQ基础之From和GroupBy子句、mysql – 如何在GROUP BY子句中放入CASE语句的知识。

• 如何在AWS Redshift数据库中获取过滤器的子字符串和group by子句
• Amazon Redshift数据库
• Bash技巧：使用参数扩展获取变量的子字符串和字符串长度
• LINQ基础之From和GroupBy子句
• mysql – 如何在GROUP BY子句中放入CASE语句

如何在AWS Redshift数据库中获取过滤器的子字符串和group by子句

如何从包含AWS Redshift数据库中的filter和group by子句记录的列中获取子字符串。

我有记录，如表：

Table_Id | Categories         | Value<ID>     | ABC1; ABC1-1; XYZ  | 10<ID>     | ABC1; ABC1-2; XYZ  | 15<ID>     | XYZ                | 5.....

现在，我想根据“ ABC1”或“ ABC1和XYZ”等单个类别过滤记录

查询的预期输出将是：

Table_Id | Categories         | Value<ID>     | ABC1               | 25<ID>     | ABC1-1             | 10<ID>     | ABC1-2             | 15<ID>     | XYZ                | 30.....

因此需要根据各个类别对结果进行分组。

答案1

@ JonScott，@ AlexYes和其他在类似情况下挣扎的朋友。

除了@AlexYes所建议的方法外，我发现了其他更好的方法。

我所做的是，我将结果列扁平化，这会产生单个记录。我可以进一步处理。

询问：

select row_number() over(order by 1) as r1,         to_char(timestamptz ''epoch'' + date_time * interval ''1 second'', ''yyyy-mm-dd'') AS DAY,        split_part(categories, '';'', numbers.n) as catg,        value    from <TABLE>    join numbers    on numbers.n <= regexp_count(category_string, '';'') + 1 <OTHER_CONDITIONS>

解释：

这里有两个有用的函数：首先，split_part函数将一个字符串分割为’;’。分隔符，并返回从拆分字符串指定的第一个，第二个，…，第n个值；第二个是regexp_count，它告诉我们在字符串中找到特定模式的次数。

Amazon Redshift数据库

Amazon Redshift介绍

　　Amazon Redshift是一种可轻松扩展的完全托管型PB级数据仓库，它通过使用列存储技术和并行化多个节点的查询来提供快速的查询性能，使您能够更高效的分析现有数据。使用云端Amazon Redshift服务，您无需管理庞大的服务器集群，分析数据的成本不到传统解决方案的十分之一。

　　Amazon Redshift使用列存储技术改善I/O效率并跨过多个节点平行放置查询，从而提供快速的查询性能。Redshift使用标准的PostgreSQL JDBC和ODBC驱动程序，从而使您能够使用各种常见SQL客户端。数据加载速度与集群大小呈线性关系。

作为AWS的服务之一的Redshift有哪些优势呢？

1、完全托管，快速上手

　　使用Redshift云服务，您可以根据业务需要在几分钟内建立几个到几十个节点的数据仓库集群，立刻开始您的数据分析的任务，也能根据需求随时增加或减少集群资源。Redshift是完全托管平台，承担了大量的集群管理、数据库管理、监控、集群健康检查、备份、升级等工作，让您能专注业务分析，无需花大量时间在服务器管理，安全及数据备份等工作上。
2、为数据仓库而优化的架构

　　Amazon Redshift基于企业级PostgreSQL数据库，有大规模并行处理（MPP）结构，MPP可以通过将数据分布到各个计算节点来解决海量数据的处理难题。在Redshift中，每个集群有一个管理节点和多个计算节点。集群内部使用私有、高速、 低延时的网络连接。每个计算节点都有单独的CPU，内存和附加存储，并且每个计算节点有多个分区，您的数据被分布保存在计算节点的多个分区内，因此每个分区的数据量大大减少，您的查询会在多个分区并行执行，大大的增加了查询的效率。

　　注：MPP是将任务并行的分散到多个服务器和节点上，在每个节点上计算完成后，将各自部分的结果汇总在一起得到最终的结果(与Hadoop相似)，详情点击;https://blog.csdn.net/qq_42189083/article/details/80610092

3、查询优化

　　Redshift提供了针对MPP架构的查询优化引擎，被编译后的SQL分布在多个计算节点的分区内并行执行，并且最大化的利用了列式存储的优势，因此在复杂的多表连接查询的情况下，查询优化器通常能有很大的性能提升。

4、高性能

　　很多用户使用Redshift获得了几十倍甚至上百倍的查询加速，Redshift为您提供非常搞笑的查询性能，除了上面讲的专为数据仓库而优化的架构外，还有以下优势：

　　4.1、列式存储

　　　　很多数据库使用行式存储，此时如果要基于某个列求和，需要加载整张表的数据，而Redshift列式存储只需要加载一列的数据，磁盘的IO以及内存的消耗都显著减少，增加了性能。由于数据仓库中的大部分查询只是扫描整张表中的部分字段，因此Redshift列式存储特别适合数据仓库查询，另外列式存储索引比传统索引能提供5倍以上的压缩效果和10倍以上的性能提升。

　　4.2、数据压缩

　　　　作为一个列式数据仓库，Redshift还支持列数据压缩，数据压缩减少了磁盘占用空间，减少了读写I/O、减少了内存占用空间，并提高了查询的性能。由于Redshift同列的数据类型相同，有些值也相同，因此Redshift的压缩率很高

5、成本低

　　使用Redshift无需昂贵的服务器及管理人员成本，仅按使用量付费，并且可以通过购买预留实例来进一步减少成本，实际成本只有传统数据仓库分析的十分之一。

6、安全

　　创建Redshift集群的时候，可以选择启用加密来保护数据仓库中的数据，启用加密后，所有的数据库、系统表及备份数据都会被加密，保障了数据的安全。连接Redshift的时候，您也可以使用SSL连接，保障网络传输安全。另外AWS也通过身份管理IAM，虚拟网络VPC，防火墙安全组等保护您数据的安全 。
7、负载性能监控

　　Redshift监控让您能了解集群运行的细节，比如您可以随时检查集群节点的CPU、内存、网络、存储的使用状况，了解节点当前负载，确保您使用合适的资源来满足当前的业务需求。Redshift和云监控CloudWatch服务高度集成，CloudWatch能够监测Redshift的各种指标，也可以设置警报，在集群出现故障时第一时间通知您。CloudWatch简单易用，是保障集群健康的重要环节。
8、数据迁移到Redshift

不管您的数据是否在云中，都能轻松的使用Redshift分析现有数据，对于传统的没有使用云的用户，只需要先将数据文件上传到AWS中。AWS提供了多种途径将云中的数据加载到Redshift中，下面介绍几种：

　　8.1、从S3中加载数据

　　传统的用户可以将数据文件通过上传到AWS的云存储S3上。对于敏感数据，可以在上传前加密数据或者使用S3云端加密功能，因此无需担心数据安全。Redshift提供了命令自动将S3中的数据并行加载到Redshift中。

　　8.2、从Dynamo DB中加载数据

　　您也可以将数据加载AWS的NoSQL数据库（Dynamo DB）中，Dynamo DB中的数据可以实时或者批量的导入到Redshift。

　　8.3、从EMR中加载数据

　　EMR是AWS基于hadoop框架的大数据处理服务，通过大数据处理平台加工后的数据，可以使用Redshift命令将HDFS中的数据加载到Redshift中。

　　8.4、通过SSH从远程服务器加载数据

　　Redshift也提供了命令从云中或您数据中心主机上通过SSH连接加载数据。

　　AWS提供了丰富的功能帮助您将数据中心或云中的数据加载到Redshift中，加载完成后您就可以在Redshift中建立模型，分析数据，使用AWS的QuickSight、Elasticsearch Service等服务显示报表，也可以在AWS的Market Place中寻找行业BI工具分析和显示数据。

Bash技巧：使用参数扩展获取变量的子字符串和字符串长度

在 bash 中，通常使用 ${parameter} 表达式来获取 parameter 变量的值，这是一种参数扩展 (parameter expansion)。
Bash 还提供了其他形式的参数扩展，可以对变量值做一些处理，起到操作字符串的效果。例如：

• ${parameter:offset:length} 从 parameter 变量值的第 offset 个字符开始，获取 length 个字符，得到子字符串。
• ${#parameter} 获取 parameter 变量值的字符串长度。

注意：这些表达式都不会修改 parameter 自身的变量值，它们只是基于 parameter 变量值扩展得到新的值。
如果要保存这些值，需要赋值给具体的变量。

查看 man bash 的 Parameter Expansion 小节，就能看到相关说明。具体举例说明如下。

${parameter:offset} 和 ${parameter:offset:length}

查看 man bash 对 ${parameter:offset} 和 ${parameter:offset:length} 的说明如下：

Substring Expansion.
Expands to up to length characters of the value of parameter starting at the character specified by offset.
If parameter is @, an indexed array subscripted by @ or *, or an associative array name, the results differ as described below.

If length is omitted, expands to the substring of the value of parameter starting at the character specified by offset and extending to the end of the value. length and offset are arithmetic expressions.

If offset evaluates to a number less than zero, the value is used as an offset in characters from the end of the value of parameter.

If length evaluates to a number less than zero, it is interpreted as an offset in characters from the end of the value of parameter rather than a number of characters, and the expansion is the characters between offset and that result.

Note that a negative offset must be separated from the colon by at least one space to avoid being confused with the :- expansion.

即，${parameter:offset:length} 表达式从 parameter 变量值的第 offset 个字符开始，一直获取 length 个字符，得到一个子字符串，会包括第 offset 个字符自身。

${parameter:offset} 表达式省略了 length 参数，会从 parameter 变量值的第 offset 个字符开始一直获取到末尾。

这里的 length 和 offset 可以是算术表达式。
字符串的 offset 从 0 开始。

如果 offset 的数值小于 0，那么这个值被用作 parameter 变量值的末尾偏移，从后往前获取字符。
如果 length 数值小于 0，它会被当成 parameter 变量值的末尾偏移，而不是当作总的字符数目，且扩展后的结果是在这两个偏移之间的字符。

注意：一个负数的偏移量必须用至少一个空格和冒号分割开，以避免和 :- 扩展产生混淆。
即，这种情况下的冒号 : 和 负号 - 之间至少要有一个空格，类似于 : - 的形式。

具体举例说明如下：

$ value="This is a test string."
$ echo ${value:5}
is a test string.
$ echo ${value:5:2}
is
$ echo ${value:5: -4}
is a test str
$ echo ${value: -7:3}
str
$ echo ${value: -7: -1}
string

可以看到，${value:5} 获取从 value 变量值的第 5 个字符开始，一直到末尾的全部字符。
注意偏移量是从 0 开始，获取到的子字符串包括第 5 个字符自身。

${value:5:2} 从 value 变量值的第 5 个字符开始，获取包括该字符在内的两个字符，也就是 "is" 字符串。

当所给的 length 参数值为负数时，负号和冒号之间要用空格隔开。
此时 length 参数不表示要获取的字符个数，而是表示对应 parameter 变量值从后往前的偏移，而且这个偏移是从 1 开始。
${value:5: -4} 表示从 value 变量值的第 5 个字符开始，一直获取到倒数第 4 个字符为止，不包括倒数第 4 个字符。

当所给的 offset 参数值为负数时，负号和冒号之间要用空格隔开。
此时 offset 参数对应 parameter 变量值从后往前的偏移，而且这个偏移是从 1 开始。
${value: -7:3} 表示从 value 变量值的倒数第 7 个字符串开始，获取包括该字符在内的三个字符，也就是 "str" 字符串。

${value: -7: -1} 表示从 value 变量值的倒数第 7 个字符串开始，一直获取到倒数第 1 个字符为止。
包括倒数第 7 个字符，不包括倒数第 1 个字符。
具体得到的是 "string" 字符串，不包含最后的点号 .。

${#parameter}

查看 man bash 对 ${#parameter} 的说明如下：

Parameter length. The length in characters of the value of parameter is substituted.
If parameter is * or @, the value substituted is the number of positional parameters.
If parameter is an array name subscripted by * or @, the value substituted is the number of elements in the array.

即，如果 parameter 变量值是字符串，则 ${#parameter} 可以获取到对应字符串的长度。

具体举例说明如下：

$ value="123456"
$ echo ${#value}
6

注意：在 bash 的参数扩展中，数字属于位置参数（positional parameters），可以用数字来引用传入脚本或者函数的参数。
当用在当前表达式时，就表示获取所传参数的字符串长度。
例如 $1 对应传入的第一个参数，那么 ${#1} 对应所传入第一个参数的字符串长度。
具体举例如下：

$ function param_length() { echo ${#1}; }
$ param_length 123456
6

可以看到，param_length 函数使用 ${#1} 获取到所给第一个参数值的长度。

LINQ基础之From和GroupBy子句

FROM子句

一、简单FROM子句

获取数据源：

var queryAllCustomers =
        from cust in Customers
        select cust;

分析：

查询表达式必须以from子句开头
例子中cust是范围变量，范围变量类似于foreach循环中的迭代变量，但在查询表达式中，实际上不发生迭代。执行查询时，范围变量将用作对Customers中的每个后续元素的引用。因为编译器可以推断cust的类型，所以不必显示指定此类型。
Customers是数据源，实现了IEnumerable或IEnumerable(T)或其派生接口的

二、复合FROM子句

查询出成绩有90分以上的学生，得到他们的名字和成绩

//数据源
 IList<Student> students = new List<Student>
{
    new Student{ Name="Kevin", Score=new List<int>{89,93,88,78}},
    new Student{ Name="Jackie",Score=new List<int>{92,87,83,91}},
    new Student{ Name="Helen",Score=new List<int>{53,76,72,62}}
};
            //所有的Linq查询操作都由以下三个不同的操作组成：
            //1.获得数据源
            //2.创建查询
            //3.执行查询

            //使用复合from子句查询命令
            var getStudent =
                    from student in students
                    from score in student.Score
                    where score > 90
                    select new { Name = student.Name, Score = score };

            foreach (var st in getStudent)
            {
                Console.WriteLine("NAME:{0},SCORE:{1}",st.Name,st.Score);
            }

分析：

我们可以看到学生对象中有个Score属性，Score属性本身就是List集合，这时候我们就要用到复合from子句进行查询了。首先遍历学生对象集合中的每个学生对象，然后在用另一个from子句，对每个学生对象中的Score属性进行遍历，筛选出含有90分以上的学生信息进行返回。

GroupBy子句

一、简介

group子句返回一个IGrouping(T Key,T element)对象序列，编译时，group子句被转换成对GroupBy方法的调用。

二、案例

案例一：

根据首字母分组，并打印到控制台

//数据源
string[] fruits = { "apple", "banana", "peach", "orange", "melon", "lemon" };

//分组查询的查询语句
var query = from f in fruits
            group f by f[0];

//执行查询
foreach (var letters in query)
{
    Console.WriteLine("words that start with letter:" + letters.Key);
    foreach (var word in letters)
    {
        Console.WriteLine(word);
    }
}

分析：

首先遍历字符串数组中的每个字符串，然后根据每个字符串的首字母进行分组，返回结果.

案例二：

var query = from f in fruits
             group f by f[0] into g
             where g.Key == ''p'' || g.Key == ''b''
             select g;

分析：

如果您想要对每个组执行附加查询操作，则可以使用into上下文关键字指定一个临时标识符。使用into时，必须继续编写该查询，并最终用一个select语句或另一个group子句结束该查询。

案例三：

string[] strs = { "胡广成", "张国荣", "刘德华", "故国冰封", "万里雪飘", "AAA", "胡翰轩", "张杰" };
            var list5 = strs
                //.Where(a => a.Length == 3)
                .Select(item => item)
                .GroupBy(item => item.Length);//分组   分组依据是字符串的长度
            foreach (var item in list5)
            {
                Console.WriteLine("----------------");
                Console.WriteLine($"分组字段是{item.Key}");  //item.Key是分组依据 显示分组字段
                foreach (var items in item)//内层循环遍历分组项
                {
                    Console.WriteLine(items);
                }
            }

分析：

按照名字的长度进行分组显示。

三、多字段分组示例

GroupBy(x => new { x.a , x.b, x.c }).Select( x=> ( new Class名 { a=x.Key.a , b=x.Key.b , c = x.Key.c } ))

到此这篇关于LINQ使用From和GroupBy子句的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持。

mysql – 如何在GROUP BY子句中放入CASE语句

SELECT
    `Please_identify_which_of_the_following_classroom_hardware_you_c2`,count(`_How_would_you_rate_your_overall_skill_in_using_educational_tec1`) as count,`_How_would_you_rate_your_overall_skill_in_using_educational_tec1`
FROM
    `data_copy_of_Faculty_survey_on_technology_in_the_classroom_Respo`
GROUP BY
    `_How_would_you_rate_your_overall_skill_in_using_educational_tec1`,CASE
        WHEN `Please_identify_which_of_the_following_classroom_hardware_you_c2` LIKE '%Elmo%' THEN 'Elmo'
    END

"sql92 and earlier does not permit queries for which 
the select list,HAVING condition,or ORDER BY list refer 
to nonaggregated columns that are neither named in the GROUP BY 
clause nor are functionally dependent on (uniquely determined by)
GROUP BY columns"

SELECT c2,tec1,COUNT(tec1)
FROM  
    (SELECT
       CASE 
         WHEN `Please_identify_which_of_the_following_classroom_hardware_you_c2` LIKE '%Elmo%' 
           THEN 'Elmo'
         ELSE
         `Please_identify_which_of_the_following_classroom_hardware_you_c2`
       END AS c2,`_How_would_you_rate_your_overall_skill_in_using_educational_tec1`) AS tec1
    FROM 
      `data_copy_of_Faculty_survey_on_technology_in_the_classroom_Respo`) t
GROUP BY c2,tec1

关于如何在AWS Redshift数据库中获取过滤器的子字符串和group by子句的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于Amazon Redshift数据库、Bash技巧：使用参数扩展获取变量的子字符串和字符串长度、LINQ基础之From和GroupBy子句、mysql – 如何在GROUP BY子句中放入CASE语句等相关内容，可以在本站寻找。