PartiQL 对 SQL 的扩展，可以查询非结构化的数据

2023-05-16

开始

先决条件

下载 PartiQL CLI

运行 PartiQL CLI

窗户

macOS （Mac）和 Unix

命令行教程

介绍

PartiQL 查询与 SQL 兼容

PartiQL 数据模型：许多底层数据存储格式的抽象

了解更多信息

查询嵌套数据

嵌套集合

取消嵌套嵌套集合

了解更多信息

使用取消嵌套嵌套集合JOIN

使用 LEFT JOIN 取消嵌套数据始终保留父信息

用例：检查嵌套集合是否满足条件

用例：聚合嵌套集合的子查询

嵌套元组值和多步骤路径

取消嵌套任意形式的嵌套集合

用例：取消嵌套标量数组

用例：取消嵌套数组的数组

文字

查询异构和无模式数据

缺少属性的元组

访问和处理缺失属性：缺失值

评估缺少的功能和条件

在结果元组中传播缺失

变量的范围可以超过不同类型的数据

按顺序访问数组元素

[]

多步骤路径

查找数组中每个元素的索引

旋转和取消旋转

取消枢轴元组

旋转到元组

用例：旋转子查询

创建嵌套和非 SQL 结果

使用查询创建嵌套结果SELECT VALUE

创建嵌套结果GROUP BY ... GROUP AS

了解有关 PartiQL 的更多信息

开始

PartiQL 提供了一个交互式 shell，允许用户编写和评估 PartiQL 查询。

先决条件

PartiQL 要求在您的计算机上安装 Java 运行时（JVM）。您可以从以下任一位置获取最新版本的 Java 运行时

OpenJDK或适用于Windows的OpenJDK
神谕

按照有关如何设置到 Java 运行时安装路径的说明进行操作。JAVA_HOME

下载 PartiQL CLI

每个版本的 PartiQL 都附带一个存档，其中包含 PartiQL CLI 作为压缩文件。

下载。您可能需要单击才能查看zip和tgz存档。最新的 zip 存档到您的计算机。Assets``partiql-cli
展开（解压缩）计算机上的存档。展开存档将生成以下文件夹结构：

该文件会将 PartiQL 的发布版本附加到存档中，即 .partiql-cli-0.1.0.zip


├── partiql-cli
    ├── bin
    │   ├── partiql
    │   └── partiql.bat
    ├── lib
    │   └── ... 
    ├── README.md
    └── Tutorial
        ├── code
        │   └── ... 
        ├── tutorial.html
        └── tutorial.pdf

其中表示省略的文件/目录。...

根文件夹包含一个文件和 3 个子文件夹partiql-cli``README.md

该文件夹包含适用于 macOS 的启动脚本和 Unix 系统和 Windows 系统。执行这些文件以启动 REPL。bin``partiql``partiql.bat
该文件夹包含运行 PartiQL 所需的所有必需的 Java 库。lib
该文件夹包含教程和表单。子文件夹包含 3 种类型的文件：
```
Tutorial  
```
```
pdf  
```
```
html  
```
```
code  
```
1. 扩展名为的数据文件 .这些文件包含 PartiQL 我们可以查询的数据。.env
2. 扩展名为的 PartiQL 查询文件 .这些文件包含本教程中使用的 PartiQL 查询。.sql
3. 扩展名为的示例查询输出文件 .这些文件包含运行教程查询的示例输出适当的数据。.output
4. 或者，您可以使用在线 CLI 教程。

运行 PartiQL CLI

窗户

运行（双击）。这应该打开一个命令行提示并启动 PartiQL Shell，其中显示：partiql.bat


Welcome to the PartiQL shell!

macOS （Mac）和 Unix

打开终端并导航到该文件夹。partiql-cli
通过键入并按 Enter 启动 REPL，其中显示：./bin/partiql

文件夹名称将以 PartiQL 版本作为后缀，即 .partiql-cli-0.1.0


Welcome to the PartiQL shell!

命令行教程

要更深入地了解 PartiQL，请查看 CLI 教程。

介绍

PartiQL 提供跨多个 SQL 兼容的统一查询访问包含结构化、半结构化和嵌套数据的数据存储。 PartiQL 分离了从基础数据源和数据格式查询。它使用户能够在有或没有的情况下与数据进行交互常规架构。

该实现目前仅支持没有图式。即将推出架构支持。

本教程旨在教SQL用户SQL的PartiQL扩展。这教程主要由“操作方法”示例驱动。

对于对完整细节和正式感兴趣的读者 PartiQL 的规范，我们建议使用 2 层 PartiQL 正式规范：正式规范首先描述 PartiQL 核心，它是一种简短而简洁的函数式编程语言。然后规范通过语法糖层 SQL 兼容性展示了如何将SQL功能转换为语义等效的核心 PartiQL 表达式。这些翻译以句法糖的形式呈现启用 SQL 兼容性。

PartiQL 查询与 SQL 兼容

PartiQL 向后兼容 SQL-92。我们将看到什么兼容性是指当它用于查询在数据格式中找到的数据时和数据存储。

SQL-92

对于初学者，给定表格hr.employees


  Id             name          title
  -------------- ------------- ----------------
  3              Bob Smith     null
  4              Susan Smith   Dev Mgr
  6              Jane Smith    Software Eng 2

以下 SQL 查询


SELECT e.id, 
       e.name AS employeeName, 
       e.title AS title
FROM hr.employees e
WHERE e.title = 'Dev Mgr'

也是一个有效的 PartiQL 查询。正如我们从SQL中知道的那样，当这个查询在表上运行，它将返回结果hr.employees


  Id   employeeName   title
  ---- -------------- ---------
  4    Susan Smith    Dev Mgr

信息

为方便起见，我们在文件夹中提供了该文件。您还将在同一文件夹中找到单独的文件对于教程中的每个查询。tutorial-all-data.env``Tutorial/code/``.env

例如，跑步
./bin/partiql  -e .wiki/assets/code/tutorial-all-data.env  
将在 REPL 中加载本教程中使用的所有数据。这将允许您将教程中的查询复制粘贴到 REPL 中并尝试他们出来了。

PartiQL 数据模型：许多底层数据存储格式的抽象

PartiQL 不仅对 SQL 表进行操作，还对数据进行操作可能具有嵌套、联合类型、不同的属性不同的元组，以及我们在今天的嵌套和/或半结构化格式，如 JSON、Ion、Parquet 等。

为了捕获这种通用性，PartiQL 基于逻辑类型系统： PartiQL 数据模型。每个 PartiQL 实现映射数据格式，像 JSON、Parquet 等一样，放入遵循 PartiQL 的 PartiQL 数据集中数据模型。PartiQL 查询处理 PartiQL 数据集抽象。

例如，该表在 PartiQL 数据中表示建模为此数据集hr.employees


{ 
    'hr': { 
        'employees': <<
            -- a tuple is denoted by { ... } in the PartiQL data model
            { 'id': 3, 'name': 'Bob Smith',   'title': null }, 
            { 'id': 4, 'name': 'Susan Smith', 'title': 'Dev Mgr' },
            { 'id': 6, 'name': 'Jane Smith',  'title': 'Software Eng 2'}
        >>
    }
}

请注意，嵌套在中。分隔符... 表示数据是一个无序集合（也称为 bag），情况就是如此与 SQL 表。也就是说，三个元组之间没有顺序。单行注释以行尾开头，结束于行尾。employees``hr``<<``>>``--

一种非常不同类型的数据源可能会导致相同的 PartiQL 数据。例如，一组包含以下内容的 JSON 文件 JSON 对象


{ 
    "hr" : { 
        "employees": [
            { "id": 3, "name": "Bob Smith",   "title": null },
            { "id": 4, "name": "Susan Smith", "title": "Dev Mgr" },
            { "id": 6, "name": "Jane Smith",  "title": "Software Eng 2"}
        ]
    }
}

可能会被支持 PartiQL 的实现到与表相同的 PartiQL 抽象中。hr.employees

附加到的 JSON 值是一个有序列表。PartiQL 实现可以提供自己的映射，来自流行的数据格式，例如CSV，TSV，JSON，Ion等，到PartiQL数据模型和/或允许客户端以实现自己的映射。employee

备注：你会不断注意到PartiQL的相似性表示法和 JSON 表示法。还要注意细微的差异：在 SQL兼容性的兴趣，PartiQL文字是单引号，而 JSON 文本是双引号的。

备注：您可能从概念上认为反序列化程序输入 JSON 并输出 PartiQL 数据集。但不要假设查询 PartiQL 实现的处理必须实际解析和将底层数据存储的每一比特抽象为 PartiQL。

回到我们的查询


SELECT e.id, 
       e.name AS employeeName, 
       e.title AS title
FROM hr.employees e
WHERE e.title = 'Dev Mgr'

在 PartiQL 中计算查询将生成：


<<
  {
    'id': 4,
    'employeeName': 'Susan Smith',
    'title': 'Dev Mgr'
  }
>>
--- 
OK!

结果保持不变，无论是否 SQL 表或 JSON 文件。所需要的只是一个名称与 PartiQL 抽象之间的关联数据。hr.employees``hr.employees

本着同样的精神，相同的PartiQL抽象可能来自CSV。文件或镶木地板文件，这种格式获得了很大的吸引力，这要归功于存储数据的有效方式。同样，相同的查询使完美的感觉，无论背后的存储格式到底是什么。hr.employees

了解更多信息

PartiQL 数据集看起来非常像 JSON。

有什么区别？事实上，PartiQL 采用了元组/对象和数组 JSON 的表示法。但是，PartiQL 字符串文本表示用单引号。重要的是，PartiQL 的标量类型是那些 SQL，而不仅仅是字符串，数字和布尔值，如JSON。
实现是否需要具有目录？

如果查询引用名称，目录在逻辑上验证名称是否存在。但是，我们还将看到不引用名称的 PartiQL 查询。

查询嵌套数据

SQL-92 仅具有具有包含标量值的元组的表。一把钥匙许多现代格式的特征是嵌套数据。也就是说，属性值本身可以是表（即元组的集合），也可以是标量数组，或数组数组和许多其他组合。让我们仔细看看 PartiQL 的功能（SQL 扩展），这些功能允许我们以使用嵌套数据。

我们还包括标题为“用例”的部分。此类“用例”部分不会引入其他功能。他们只是展示了如何结合一些具有标准SQL功能的新颖PartiQL功能，以便解决大量问题。

嵌套集合

现在让我们将嵌套属性添加到数据集中。projects


{ 
  'hr': { 
      'employeesNest': <<
         { 
          'id': 3, 
          'name': 'Bob Smith', 
          'title': null, 
          'projects': [ { 'name': 'AWS Redshift Spectrum querying' },
                        { 'name': 'AWS Redshift security' },
                        { 'name': 'AWS Aurora security' }
                      ]
          },
          { 
              'id': 4, 
              'name': 'Susan Smith', 
              'title': 'Dev Mgr', 
              'projects': [] 
          },
          { 
              'id': 6, 
              'name': 'Jane Smith', 
              'title': 'Software Eng 2', 
              'projects': [ { 'name': 'AWS Redshift security' } ] 
          }
      >>
    }
}

请注意，的值是一个数组。数组用逗号分隔的数组元素表示。在我们的示例中，数组恰好是一个元组数组。我们将看到数组可能是数组任何东西，而不仅仅是元组数组。'projects'``[ ... ]

取消嵌套嵌套集合

以下查询查找处理包含以下内容的项目的员工的姓名字符串并输出它们以及项目名称。请注意，查询只有一个扩展名超过标准 SQL ---部分。'security'``'security'``e.projects AS p


SELECT e.name AS employeeName, 
       p.name AS projectName
FROM hr.employeesNest AS e, 
     e.projects AS p
WHERE p.name LIKE '%security%'

我们查询的输出是


<<
  {
    'employeeName': 'Bob Smith',
    'projectName': 'AWS Redshift security'
  },
  {
    'employeeName': 'Bob Smith',
    'projectName': 'AWS Aurora security'
  },
  {
    'employeeName': 'Jane Smith',
    'projectName': 'AWS Redshift security'
  }
>>
--- 
OK!

SQL 的扩展是子句项。标准 SQL 会尝试查找以表命名的架构，由于在我们的示例中没有表，因此查询将失败。相反，PartiQL 识别为引用的属性。FROM``e.projects AS p``e``projects``e.projects``e.projects``projects``e

一旦我们允许这个扩展，语义就是类似的SQL。别名（在 PartiQL 中也称为变量）绑定到每个员工，在转。对于每个员工，变量绑定到每个反过来，员工的项目。因此，查询的含义，如 SQL，是e``p

Foreach 员工元组来自 Foreach 项目元组来自 if 输出e``hr.employeesNest``p``e.projects``p.name LIKE '%security%'``e.name AS employeeName, p.name AS projectName

请注意，我们的查询涉及的变量范围超过嵌套集合（在示例中），以及范围超过表（在示例中），就像标准 SQL 别名一样。所有变量，无论它们的范围如何，都可以在任何地方使用我们将在下面的示例中看到的、子句。p``e``FROM``WHERE``SELECT

了解更多信息

我只能取消嵌套元组数组吗？

不，任何东西都可以取消嵌套。例如，标量数组等。
e.projects AS p 是否必须出现在相同的 FROM 子句中这定义了E？

不。例如，请参阅下面的用例涉及子查询。在那里，和在单独的条款。e``p``FROM
如何强制 e.projects 引用嵌套属性项目，即使有一个名为 e 的架构和表项目？``

使用语法。回想一下，在缺少，为了 SQL 兼容性，PartiQL 将首先尝试取消引用目录。@e.projects``@``e.projects
SQL允许我在编写时避免编写显式别名e，说，e.name。我也可以避免在 PartiQL 中写 e 吗？

SQL允许我们避免在模式这些表允许正确的取消引用。PartiQL 也这样做。但是，回想一下，PartiQL 数据集不需要架构。事实上，我们的示例没有假设模式。缺席的情况下在架构中，不能省略别名（变量）。例如如果你只写，没有模式，PartiQL 不能告诉您是指员工姓名还是项目名称。因此，您需要显式写入别名（变量）。name

此规则有一个例外：如果您的查询包含单个项目在其子句中，可以省略别名（变量）。例如，你可以写FROM
```
SELECT name FROM hr.employeesNest  
```
在这种情况下，很明显可能只是员工名称，因此 PartiQL 允许您不提供别名（变量）。name

不过，为清楚起见，我们建议您始终使用别名（变量），这就是本教程的作用。
如果有模式，我可以避免写入别名 p 吗？

不。必须编写以表示迭代项目。p

使用取消嵌套嵌套集合`JOIN`

在本节中，我们只是介绍另一种表达和思考的方式关于取消嵌套集合。

有人可能会认为从某种意义上说，示例在员工和项目之间执行 A。如果它可以帮助您从的角度思考，您可以替换逗号跟。也就是说，以下两个查询是等效的。FROM``JOIN``JOIN``JOIN


+-----------------------------------+-----------------------------------------+
| SELECT e.name AS employeeName,    | SELECT e.name AS employeeName,          |
|        p.name AS projectName      |        p.name AS projectName            |
| FROM hr.employeesNest AS e,       | FROM hr.employeesNest AS e CROSS JOIN   |
|      e.projects AS p              |      e.projects AS p                    |
| WHERE p.name LIKE '%security%'    | WHERE p.name LIKE '%security%'          |
+-----------------------------------+-----------------------------------------+

使用 LEFT JOIN 取消嵌套数据始终保留父信息

假设我们要编写一个查询，该查询以一袋从中元组整个员工和项目信息。我们想要的查询结果是这袋元组带有属性、和：hr.employeesNest``id``employeeName``title``projectName


<<
  {
    'id': 3,
    'employeeName': 'Bob Smith',
    'title': NULL,
    'projectName': 'AWS Redshift Spectrum querying'
  },
  {
    'id': 3,
    'employeeName': 'Bob Smith',
    'title': NULL,
    'projectName': 'AWS Redshift security'
  },
  {
    'id': 3,
    'employeeName': 'Bob Smith',
    'title': NULL,
    'projectName': 'AWS Aurora security'
  },
  {
    'id': 4,
    'employeeName': 'Susan Smith',
    'title': 'Dev Mgr'
  },
  {
    'id': 6,
    'employeeName': 'Jane Smith',
    'title': 'Software Eng 2',
    'projectName': 'AWS Redshift security'
  }
>>
--- 
OK!

请注意，结果中有一个元组，尽管事实上，苏珊没有项目。苏珊的。我们可以通过使用运算符将员工和项目组合在一起来获得此结果，如下所示：'Susan Smith'``projectName``null``LEFT JOIN


SELECT e.id AS id, 
       e.name AS employeeName, 
       e.title AS title, 
       p.name AS projectName
FROM hr.employeesNest AS e LEFT JOIN e.projects AS p ON true

此查询的语义可以认为是


 foreach employee tuple `e` from `hr.employeesNest`
     if the `e.projects` is an empty collection then *// this part is special about LEFT JOINs*
         output `e.id AS id`, `e.name AS employeeName`, `e.title AS title`
         and output a `null AS projectName`
     else *// the following part is identical to plain (inner) JOINs*
         foreach project tuple `p` from `e.projects`
             output `e.id AS id`, `e.name AS employeeName`, `e.title AS title`

用例：检查嵌套集合是否满足条件

以下用例使用了我们所拥有的非嵌套功能已经在新的用例中讨论过。出现的一个教训是，我们可以使用范围超过嵌套数据的变量（SQL 别名），就好像它们是标准 SQL 别名。这种认识给了我们解决的能力仅通过组合非嵌套功能即可获得大量用例具有我们已经从标准SQL中了解的功能。

在我们的第一个用例中，我们想要一个返回参与包含单词的项目的员工。该解决方案采用 SQL 的“（子查询）” 功能，以及取消嵌套：'security'``EXISTS


SELECT e.name AS employeeName
FROM hr.employeesNest AS e
WHERE EXISTS ( SELECT *
               FROM e.projects AS p
               WHERE p.name LIKE '%security%')


<<
  {
    'employeeName': 'Bob Smith'
  },
  {
    'employeeName': 'Jane Smith'
  }
>>
--- 
OK!

在第二个用例中，我们想要一个输出拥有多个安全项目的员工，以及我们知道员工的键（例如，属性保证每个员工都有唯一的价值）。我们可以通过使用和的组合来找到所需的员工。在我们的示例中，假设该属性是雇员的主键。然后我们可以找到具有多个安全项目的员工具有以下查询：GROUP BY``HAVING``id

我们也可以将运算符与子查询的结果一起使用，但是当前实现的问题阻止了我们这样做。>


SELECT e.name AS employeeName
FROM hr.employeesNest e, 
     e.projects AS p
WHERE p.name LIKE '%security%'
GROUP BY e.id, e.name
HAVING COUNT(*) > 1


<<
  {
    'employeeName': 'Bob Smith'
  }
>>
--- 
OK!

用例：聚合嵌套集合的子查询

接下来，让我们找出有多少个查询项目（即其名称包含“查询”一词）每个员工都有。

做出和以前一样的假设，这是员工的关键，我们可以解决查询的问题id


SELECT e.name AS employeeName, 
       COUNT(p.name) AS queryProjectsNum
FROM hr.employeesNest e LEFT JOIN e.projects AS p ON p.name LIKE '%querying%'
GROUP BY e.id, e.name


<<
  {
    'employeeName': 'Bob Smith',
    'queryProjectsNum': 1
  },
  {
    'employeeName': 'Susan Smith',
    'queryProjectsNum': 0
  },
  {
    'employeeName': 'Jane Smith',
    'queryProjectsNum': 0
  }
>>
---
OK!

请注意，此查询的结果包括 Susan Smith 和 Jane Smith，他们没有查询项目。

嵌套元组值和多步骤路径

值也可以是元组 - 在许多中也称为对象和结构模型和格式。例如，以下项目中的项目值元组始终是具有项目名称和项目组织的元组。


{ 
    'hr': { 
        'employeesWithTuples': << 
            { 
                'id': 3, 
                'name': 'Bob Smith', 
                'title': null, 
                'project': { 
                    'name': 'AWS Redshift Spectrum querying', 
                    'org': 'AWS' 
                }
            },
            {
                'id': 6, 
                'name': 'Jane Smith', 
                'title': 'Software Eng 2', 
                'project': { 
                    'name': 'AWS Redshift security', 
                    'org': 'AWS' 
                }
            }
         >>
    }
}

PartiQL 的多步骤路径支持在元组内导航。例如以下查询查找 AWS 项目并输出项目名称和员工姓名。


SELECT e.name AS employeeName, 
       e.project.name AS projectName
FROM hr.employeesWithTuples e
WHERE e.project.org = 'AWS'

结果是


<<
  {
    'employeeName': 'Bob Smith',
    'projectName': 'AWS Redshift Spectrum querying'
  },
  {
    'employeeName': 'Jane Smith',
    'projectName': 'AWS Redshift security'
  }
>>
--- 
OK!

取消嵌套任意形式的嵌套集合

前面的示例显示了嵌套属性，这些属性是数组元组。嵌套属性不一定是元组的集合。它们也可能只是标量数组，数组的数组，或数据的任意组合可以通过组合标量、元组和数组来创建。你不需要学习每种情况都有不同的查询语言功能集。解嵌套我们已经看到的功能就足够了。

用例：取消嵌套标量数组

与每个员工关联的项目列表可能只是项目名称的列表字符串。用普通字符串替换嵌套元组给了我们hr.employeesNest


{ 
    'hr': { 
        'employeesNestScalars': <<
            { 
                'id': 3, 
                'name': 'Bob Smith', 
                'title': null, 
                'projects': [ 
                    'AWS Redshift Spectrum querying',
                    'AWS Redshift security',
                    'AWS Aurora security'
                ]
            },
            { 
                'id': 4, 
                'name': 'Susan Smith', 
                'title': 'Dev Mgr', 
                'projects': []
            },
            { 
                'id': 6, 
                'name': 'Jane Smith', 
                'title': 'Software Eng 2', 
                'projects': [ 'AWS Redshift security' ]
            }
        >>
    } 
}

让我们在修订后的员工数据上重复前面的用例。

以下查询查找从事项目的员工的姓名包含字符串并将它们与名称一起输出的“安全”项目。'security'


SELECT e.name AS employeeName, 
       p AS projectName
FROM hr.employeesNestScalars AS e, 
     e.projects AS p
WHERE p LIKE '%security%'

前面的查询返回


<<
  {
    'employeeName': 'Bob Smith',
    'projectName': 'AWS Redshift security'
  },
  {
    'employeeName': 'Bob Smith',
    'projectName': 'AWS Aurora security'
  },
  {
    'employeeName': 'Jane Smith',
    'projectName': 'AWS Redshift security'
  }
>>
--- 
OK!

变量范围（再次）超过的内容。在这种情况，由于有字符串（与元组相反），因此变量每次绑定到项目名称字符串。因此，这可以将查询视为执行以下代码片段。p``e.projects``e.projects``p


 foreach employee tuple `e` from `hr.employeesNestScalars`
     foreach project `p` from `e.projects`
         if the string `p` matches `'%security%'`
           output `e.name AS employeeName` and the string `p AS projectName`

用例：取消嵌套数组的数组

数组也可以直接包含数组，而不干预元组，如在数据集中。matrices


{ 
    'matrices': <<
        { 
            'id': 3, 
            'matrix': [ 
                [2, 4, 6],
                [1, 3, 5, 7],
                [9, 0]
            ]
        },
        { 
            'id': 4, 
            'matrix': [ 
                [5, 8],
                [ ]
            ]
            
        }
    >>
}

以下查询查找每个偶数并输出偶数以及发现它的元组。id


SELECT t.id AS id, 
       x AS even
FROM matrices AS t, 
     t.matrix AS y,
     y AS x
WHERE x % 2 = 0

前面的查询返回


<<
  {
    'id': 3,
    'even': 2
  },
  {
    'id': 3,
    'even': 4
  },
  {
    'id': 3,
    'even': 6
  },
  {
    'id': 3,
    'even': 0
  },
  {
    'id': 4,
    'even': 8
  }
>>
--- 
OK!

非正式地，可以将查询的评估视为


 foreach tuple `t` from `matrices`
     foreach array `y` from `t.matrix`
         foreach number `x` from `y`
             if `x` is even then
                 output `t.id AS id` and `x AS even`

文字

PartiQL 查询语言的文本对应于 PartiQL 数据模型：

标量，包括遵循 SQL 语法的标量，包括以下适用。例如：null
- 5
- 'foo'
元组，用元组元素表示，由（也称为结构和/或对象多种格式和其他数据模型）{...}``,
- { 'id' : 3, 'arr': [1, 2] }
数组，用数组元素表示[...]``,
- [ 1, 'foo' ]
袋子，用袋子元素表示，由<< ... >>``,
- << 1, 'foo'>>

请注意，本着 PartiQL 数据模型的精神，文本组成自由和任何类型的文字可以出现在任何元组、数组和袋字面，例如，


{ 
    'id': 3, 
    'matrix': [ 
        [2, 4, 6],
        'NA'
    ]
}

查询异构和无模式数据

许多格式不需要描述数据的模式，即无模式数据。在这种情况下，可以有各种数据中的“异质性”：

一个元组可能具有属性，而另一个元组可能没有此属性x
在集合的一个元组中，属性可能是一种类型，例如，字符串，而在同一集合的另一个元组中相同属性可以是不同的类型 - 例如，数组。x``x
集合的元素（无论是包还是数组）可以是异构的（没有相同类型）。例如，第一个元素可能是一个字符串，即第二个可以是整数，第三个可以是数组。
一般来说，任何组合都是可能的，因为我们可以捆绑阵列和袋中的异构元素。

异构性并非无架构所特有的。架构可能允许数据类型的异构性。例如，其中一个配置单元数据类型是联合类型，它允许值属于类型列表。考虑以下架构，其属性可能是字符串或字符串数组projects

配置单元联合类型


CREATE TABLE employeesMixed(
        id: INT,
        name: STRING,
        title: STRING,
        projects: UNIONTYPE<STRING, ARRAY<STRING>>
);

遵循此架构的 PartiQL 元组集合可以是


{ 
    'hr': { 
        'employeesMixed1': <<
            { 
                'id': 3, 
                'name': 'Bob Smith', 
                'title': null, 
                'projects': [ 
                    'AWS Redshift Spectrum querying',
                    'AWS Redshift security',
                    'AWS Aurora security'
                ]
            },
            { 
                'id': 4, 
                'name': 'Susan Smith', 
                'title': 'Dev Mgr', 
                'projects': [] 
            },
            { 
                'id': 6, 
                'name': 'Jane Smith', 
                'title': 'Software Eng 2', 
                'projects': 'AWS Redshift security' 
            }
        >>
    }
}

因此，我们看到数据可能具有异质性---无论是否它们是否由架构描述。PartiQL 解决异构问题数据，我们将在下一个用例和功能中看到介绍。

缺少属性的元组

让我们回到桌子（即元组袋）。 Bob Smith 没有标题，正如 SQL 中的典型情况一样，缺少标题是使用值建模。hr.employees``null


{ 
    'hr': { 
        'employees': <<
            { 'id': 3, 'name': 'Bob Smith',   'title': null }
            { 'id': 4, 'name': 'Susan Smith', 'title': 'Dev Mgr' }
            { 'id': 6, 'name': 'Jane Smith',  'title': 'Software Eng 2'}
        >>
    }
}

如今，许多半结构化格式允许用户表示以两种方式“丢失”信息。

第一种方法是使用 .null
第二种是属性的明显缺失元。

也就是说，我们可以表示鲍勃·史密斯没有头衔的事实只需在元组中没有属性：title``'Bob Smith'


{ 
    'hr': {
        'employeesWithMissing': <<
            { 'id': 3, 'name': 'Bob Smith' }, -- no title in this tuple
            { 'id': 4, 'name': 'Susan Smith', 'title': 'Dev Mgr' },
            { 'id': 6, 'name': 'Jane Smith', 'title': 'Software Eng 2'}
        >>
    }
}

PartiQL 不争论何时使用 s 以及何时使用 “失踪”。无数数据集已经使用两者之一或两者之一。但是，PartiQL 使查询能够区分 null 和缺失值，并且还启用具有 null 和缺失值。事实上，PartiQL 使得传播源代码变得非常容易。数据空作为查询结果空和源数据缺少属性进入结果缺少属性。null

访问和处理缺失属性：缺失值

再次考虑这个PartiQL查询，它恰好也是一个SQL 查询。


SELECT e.id, 
       e.name AS employeeName, 
       e.title AS title
FROM hr.employeesWithMissing AS e
WHERE e.title = 'Dev Mgr'

当查询经过鲍勃·史密斯元组时会发生什么，该元组具有不？title

回答这个问题的第一步是了解别名（变量）绑定到元组时的路径。用更基本的术语来说，什么是表达式的结果？ PartiQL说这是特殊价值。行为与非常相似。e.title``e``{ 'id': 3, 'name': 'Bob Smith' }``{ 'id': 3, 'name': 'Bob Smith' }.title``MISSING``MISSING``null

评估缺少的功能和条件

如果一个函数（包括中缀函数，如）输入一个函数的结果是。在本例中，这意味着该条款将评估当绑定到和时，像在 SQL 中一样，当它不绑定时，子句失败评估为。因此，输出将是=``MISSING``NULL``WHERE``e.title='Dev Mgr'``NULL``e``{ 'id': 3, 'name': 'Bob Smith' }``WHERE``true


<<
  {
    'id': 4,
    'employeeName': 'Susan Smith',
    'title': 'Dev Mgr'
  }
>>
--- 
OK!

在结果元组中传播缺失

如果缺少属性，或者更一般地说，如果缺少属性，会发生什么情况返回表达式出现在？MISSING``SELECT


SELECT e.id, 
       e.name AS employeeName,
       e.title AS outputTitle
FROM hr.employeesWithMissing AS e

查询将为每个员工输出一个元组。当它输出鲍勃·史密斯元组，将评估到然后输出元组将没有属性。e.title``NULL``outputTitle


<<
  {
    'id': 3,
    'employeeName': 'Bob Smith'
  },
  {
    'id': 4,
    'employeeName': 'Susan Smith',
    'outputTitle': 'Dev Mgr'
  },
  {
    'id': 6,
    'employeeName': 'Jane Smith',
    'outputTitle': 'Software Eng 2'
  }
>>
--- 
OK!

同样的处理也会发生，比如说，如果我们有这个将标题转换为大写字母的查询：MISSING


SELECT e.id, 
       e.name AS employeeName, 
       UPPER(e.title) AS outputTitle
FROM hr.employeesWithMissing AS e

同样，将计算为 for ，然后是并且还评估为。因此，结果将是：e.title``MISSING``'Bob Smith'``UPPER(e.title)``UPPER(MISSING)``NULL


<<
  {
    'id': 3,
    'employeeName': 'Bob Smith',
    'outputTitle': NULL
  },
  {
    'id': 4,
    'employeeName': 'Susan Smith',
    'outputTitle': 'DEV MGR'
  },
  {
    'id': 6,
    'employeeName': 'Jane Smith',
    'outputTitle': 'SOFTWARE ENG 2'
  }
>>
--- 
OK!

变量的范围可以超过不同类型的数据

PartiQL 变量（在 SQL 中称为别名）可以绑定到查询计算期间的不同类型。这与 SQL 不同，其中变量始终绑定到元组。它甚至与什么不同发生在用例中：取消嵌套标量数组和在用例：取消嵌套数组数组中发生了什么。

在第一个用例中，PartiQL 变量碰巧总是绑定到一个字符串（给定示例）。在第二个用例中，PartiQL 变量是始终绑定到数组（同样，给定示例）。p``y

要说明绑定到不同类型的变量，请考虑数据集中的以下扭曲。一些数组的元素是纯字符串，有些是元组。即使是员工元组也并不总是具有相同的属性。employeesNest``projects


{ 
    'hr': { 
        'employeesMixed2': <<
            { 
                'id': 3, 
                'name': 'Bob Smith', 
                'title': null, 
                'projects': [ 
                    { 'name': 'AWS Redshift Spectrum querying' },
                    'AWS Redshift security',
                    { 'name': 'AWS Aurora security' }
                ]
            },
            { 
                'id': 4, 
                'name': 'Susan Smith', 
                'title': 'Dev Mgr', 
                'projects': []
            },
            { 
                'id': 6, 
                'name': 'Jane Smith', 
                'projects': [ 'AWS Redshift security'] 
            }
        >>
    }
}

此查询生成员工姓名 -- 员工项目对。hr.employeesMixed2


SELECT e.name AS employeeName,
       CASE WHEN (p IS TUPLE) THEN p.name 
       ELSE p END AS projectName
FROM hr.employeesMixed2 AS e,
     e.projects AS p

请注意子表达式。可以使用运算符以在评估时根据其类型检查值。另请注意，变量绑定到不同的类型。(p IS TUPLE)``IS``p

通常，查询的子句绑定其变量（别名）到数据。变量不需要绑定到具有相同数据类型。每个绑定都馈送到子句，子句评估其表达式。FROM``SELECT

此表显示了子句生成的每个变量的绑定以及子句的相应元组输出。FROM``SELECT


+-----------------------+-----------------------+-----------------------+
| Variable `e`          | Variable `p`          | Result tuple          |
+=======================+=======================+=======================+
| { 'id': 3,            | { 'name': 'AWS        | {                     |
|                       | Redshift Spectrum     |                       |
| 'name': 'Bob Smith',  | querying' }           | 'employeeName': 'Bob  |
|                       |                       | Smith',               |
| 'title': null,        |                       |                       |
|                       |                       | 'projectName': 'AWS   |
| 'projects':  [ {      |                       | Redshift Spectrum     |
| 'name': 'AWS Redshift |                       | querying'             |
| Spectrum querying' }, |                       |                       |
|                       |                       | }                     |
| 'AWS Redshift         |                       |                       |
| security',            |                       |                       |
|                       |                       |                       |
| { 'name': 'AWS Aurora |                       |                       |
| security' }           |                       |                       |
|                       |                       |                       |
|  ]                    |                       |                       |
|                       |                       |                       |
| }                     |                       |                       |
+-----------------------+-----------------------+-----------------------+
| { 'id': 3,            | 'AWS Redshift         | {                     |
|                       | security'             |                       |
| 'name': 'Bob Smith',  |                       | 'employeeName': 'Bob  |
|                       |                       | Smith',               |
| 'title': null,        |                       |                       |
|                       |                       | 'projectName': 'AWS   |
| 'projects':  [ {      |                       | Redshift security'    |
| 'name': 'AWS Redshift |                       |                       |
| Spectrum querying' }, |                       | }                     |
|                       |                       |                       |
| 'AWS Redshift         |                       |                       |
| security',            |                       |                       |
|                       |                       |                       |
| { 'name': 'AWS Aurora |                       |                       |
| security' }           |                       |                       |
|                       |                       |                       |
|  ]                    |                       |                       |
|                       |                       |                       |
| }                     |                       |                       |
+-----------------------+-----------------------+-----------------------+
| { 'id': 3,            | { 'name': 'AWS Aurora | {                     |
|                       | security' }           |                       |
| 'name': 'Bob Smith',  |                       | 'employeeName': 'Bob  |
|                       |                       | Smith',               |
| 'title': null,        |                       |                       |
|                       |                       | 'projectName': 'AWS   |
| 'projects': \[ {      |                       | Aurora security'      |
| 'name': 'AWS Redshift |                       |                       |
| Spectrum querying' }, |                       | }                     |
|                       |                       |                       |
| 'AWS Redshift         |                       |                       |
| security',            |                       |                       |
|                       |                       |                       |
| { 'name': 'AWS Aurora |                       |                       |
| security' }           |                       |                       |
|                       |                       |                       |
| \]                    |                       |                       |
|                       |                       |                       |
| }                     |                       |                       |
+-----------------------+-----------------------+-----------------------+
| { 'id': 6,            |   'AWS Redshift       | {                     |
|                       | security'             |                       |
| 'name': 'Jane Smith', |                       |   'employeeName':     |
|                       |                       | 'Jane Smith',         |
| 'projects': \[ 'AWS   |                       |                       |
| Redshift security' \] |                       |   'projectName': 'AWS |
|                       |                       | Redshift security'    |
| }                     |                       |                       |
|                       |                       | }                     |
+-----------------------+-----------------------+-----------------------+

按顺序访问数组元素

SQL 允许我们使用子句对查询的输出进行排序。但是，SQL 数据模型无法识别输入数据。相比之下，许多新的数据格式具有数组; 数组的元素有一个顺序。我们可能想找到一个数组元素通过其索引或，我们可能想要找到某些位置元素在其数组中。ORDER BY

`<Array> [<number>]`

让我们再次考虑数据集。hr.employeesNest


{ 
  'hr': { 
      'employeesNest': <<
         { 
          'id': 3, 
          'name': 'Bob Smith', 
          'title': null, 
          'projects': [ { 'name': 'AWS Redshift Spectrum querying' },
                        { 'name': 'AWS Redshift security' },
                        { 'name': 'AWS Aurora security' }
                      ]
          },
          { 
              'id': 4, 
              'name': 'Susan Smith', 
              'title': 'Dev Mgr', 
              'projects': [] 
          },
          { 
              'id': 6, 
              'name': 'Jane Smith', 
              'title': 'Software Eng 2', 
              'projects': [ { 'name': 'AWS Redshift security' } ] 
          }
      >>
    }
}

该属性是一个元组数组;也就是说，每个元组有一个与之关联的序数。以下查询返回每个员工姓名，以及员工的第一个项目。projects


SELECT e.name AS employeeName, 
       e.projects[0].name AS firstProjectName
FROM hr.employeesNest AS e

查询返回


<<
  {
    'employeeName': 'Bob Smith',
    'firstProjectName': 'AWS Redshift Spectrum querying'
  },
  {
    'employeeName': 'Susan Smith'
  },
  {
    'employeeName': 'Jane Smith',
    'firstProjectName': 'AWS Redshift security'
  }
>>
--- 
OK!

多步骤路径

从技术上讲，该结构是一种路径步骤。例如，请注意 4 步路径。当绑定到的第一个元组时，路径将结果变为数组[<number>]``e.projects[0].name``e``hr.employeesNest``e.projects


[ 
    { 'name': 'AWS Redshift Spectrum querying' },
    { 'name': 'AWS Redshift security' },
    { 'name': 'AWS Aurora security' }
]

因此，应用步骤（即评估）导致。最后，评估步骤（即评估）线索自。[0]``e.projects``e.projects[0]``{'name': 'AWS Redshift Spectrum querying'}``.name``e.projects[0]``e.projects[0].name``'AWS Redshift Spectrum querying'

查找数组中每个元素的索引

假设每个员工的项目都按优先级顺序排序。以下查询查找每个员工的姓名涉及安全项目、安全项目及其索引数组。projects


SELECT e.name AS employeeName, 
       p.name AS projectName, 
       o AS projectPriority
FROM hr.employeesNest AS e, 
     e.projects AS p AT o
WHERE p.name LIKE '%security%'

请注意新功能：。虽然范围超过元素的数组中，变量被赋给索引数组中的元素。查询返回：AT o``p``e.projects``o


<<
  {
    'employeeName': 'Bob Smith',
    'projectName': 'AWS Redshift security',
    'projectPriority': 1
  },
  {
    'employeeName': 'Bob Smith',
    'projectName': 'AWS Aurora security',
    'projectPriority': 2
  },
  {
    'employeeName': 'Jane Smith',
    'projectName': 'AWS Redshift security',
    'projectPriority': 0
  }
>>
--- 
OK!

旋转和取消旋转

许多查询需要范围并收集属性名称/值元组对或映射的键/值对。

取消枢轴元组

考虑这个数据集，它提供了多个收盘价股票代码。


{ 
    'closingPrices': <<
        { 'date': '4/1/2019', 'amzn': 1900, 'goog': 1120, 'fb': 180 },
        { 'date': '4/2/2019', 'amzn': 1902, 'goog': 1119, 'fb': 183 }
    >>
}

以下查询对股票代码/价格对进行反转。


SELECT c."date" AS "date", 
       sym AS "symbol", 
       price AS price
FROM closingPrices AS c, 
     UNPIVOT c AS price AT sym
WHERE NOT sym = 'date'

请注意在此查询中使用。双引号允许我们消除关键字和标识符的歧义。双引号还可以指定属性查找区分大小写。"``date``"date"

查询返回


<<
  {
    'date': '4/1/2019',
    'symbol': 'amzn',
    'price': 1900
  },
  {
    'date': '4/1/2019',
    'symbol': 'goog',
    'price': 1120
  },
  {
    'date': '4/1/2019',
    'symbol': 'fb',
    'price': 180
  },
  {
    'date': '4/2/2019',
    'symbol': 'amzn',
    'price': 1902
  },
  {
    'date': '4/2/2019',
    'symbol': 'goog',
    'price': 1119
  },
  {
    'date': '4/2/2019',
    'symbol': 'fb',
    'price': 183
  }
>>
--- 
OK!

取消透视元组允许使用属性名称，就好像它们是数据。例如，计算每个的平均价格变得容易符号为


SELECT sym AS "symbol", 
       AVG(price) AS avgPrice
FROM closingPrices c, 
     UNPIVOT c AS price AT sym
WHERE NOT sym = 'date'
GROUP BY sym


<<
  {
    'symbol': 'amzn',
    'avgPrice': 1901
  },
  {
    'symbol': 'fb',
    'avgPrice': 181.5
  },
  {
    'symbol': 'goog',
    'avgPrice': 1119.5
  }
>>
--- 
OK!

旋转到元组

旋转将集合转换为元组。例如，考虑收集


{ 
    'todaysStockPrices': <<
        { 'symbol': 'amzn', 'price': 1900},
        { 'symbol': 'goog', 'price': 1120},
        { 'symbol': 'fb', 'price': 180 }
    >>
}

然后进行以下查询PIVOT


PIVOT sp.price AT sp."symbol"
FROM todaysStockPrices sp

生成元组


{
  'amzn': 1900,
  'goog': 1120,
  'fb': 180
}
--- 
OK!

请注意，该查询看起来像一个查询，只是它有一个 .另请注意，查询不会返回元组集合：而是它从字面上返回一个元组值。PIVOT``SELECT-FROM-WHERE-...``SELECT``PIVOT <value expression> AT <attribute expression>``PIVOT

用例：旋转子查询

（此示例还使用了 PartiQL 的分组功能，创建嵌套结果与分组依据...组为。

让我们概括一下前面的枢轴情况。我们有一个表格股价


{ 
    'stockPrices':<<
        { 'date': '4/1/2019', 'symbol': 'amzn', 'price': 1900},
        { 'date': '4/1/2019', 'symbol': 'goog', 'price': 1120},
        { 'date': '4/1/2019', 'symbol': 'fb',   'price': 180 },
        { 'date': '4/2/2019', 'symbol': 'amzn', 'price': 1902},
        { 'date': '4/2/2019', 'symbol': 'goog', 'price': 1119},
        { 'date': '4/2/2019', 'symbol': 'fb',   'price': 183 }
    >>
}

我们希望将其透视为元组集合，其中每个元组具有日期的所有对，如下所示symbol:price


<<
{ 
    'date': date(4/1/2019), 
    'prices': {'amzn': 1900, 'goog': 1120, 'fb': 180} 
},
{ 
    'date': date(4/2/2019), 
    'prices': {'amzn': 1902, 'goog': 1119, 'fb': 183} 
}
>>

以下查询首先为每个日期创建一个组日期价格。然后，子查询将组枢轴为元组价格。PIVOT


SELECT sp."date" AS "date", 
       (PIVOT dp.sp.price AT dp.sp."symbol" 
        FROM datesPrices as dp ) AS prices
FROM StockPrices AS sp GROUP BY sp."date" GROUP AS datesPrices

例如，从 for 返回的集合是datesPrices``GROUP AS``sp.date = date(4/1/2019)


    'datesPrices': <<
      {
        'sp': {
          'date': '4/1/2019',
          'symbol': 'amzn',
          'price': 1900
        }
      },
      {
        'sp': {
          'date': '4/1/2019',
          'symbol': 'goog',
          'price': 1120
        }
      },
      {
        'sp': {
          'date': '4/1/2019',
          'symbol': 'fb',
          'price': 180
        }
      }
    >>

创建嵌套和非 SQL 结果

PartiQL 允许创建嵌套结果的查询以及查询产生异构结果。

使用查询创建嵌套结果`SELECT VALUE`

让我们再次考虑数据集：hr.employeesNestScalars


{ 
    'hr': { 
        'employeesNestScalars': <<
            { 
                'id': 3, 
                'name': 'Bob Smith', 
                'title': null, 
                'projects': [ 
                    'AWS Redshift Spectrum querying',
                    'AWS Redshift security',
                    'AWS Aurora security'
                ]
            },
            { 
                'id': 4, 
                'name': 'Susan Smith', 
                'title': 'Dev Mgr', 
                'projects': []
            },
            { 
                'id': 6, 
                'name': 'Jane Smith', 
                'title': 'Software Eng 2', 
                'projects': [ 'AWS Redshift security' ]
            }
        >>
    } 
}

以下查询输出的每个元组，除了每个元组而不是所有项目只有安全性员工的项目。这里重要的新功能是 .hr.employeesNestScalars``SELECT VALUE <expression>


SELECT e.id AS id, 
       e.name AS name, 
       e.title AS title,
       ( SELECT VALUE p
         FROM e.projects AS p
         WHERE p LIKE '%security%'
       ) AS securityProjects
FROM hr.employeesNestScalars AS e

结果是


<<
  {
    'id': 3,
    'name': 'Bob Smith',
    'title': NULL,
    'securityProjects': <<
      'AWS Redshift security',
      'AWS Aurora security'
    >>
  },
  {
    'id': 4,
    'name': 'Susan Smith',
    'title': 'Dev Mgr',
    'securityProjects': <<>>
  },
  {
    'id': 6,
    'name': 'Jane Smith',
    'title': 'Software Eng 2',
    'securityProjects': <<
      'AWS Redshift security'
    >>
  }
>>
--- 
OK!

查询（或子查询，如示例）返回计算结果的集合。SELECT VALUE <expression>``<expression>

注意与SQL的区别，它总是产生元组。如果 SQL 显示为子查询，则子查询指定是否应强制子查询的结果进入标量（例如，当），强制进入标量的集合（例如，何时）等。都不是这适用于，它生成一个集合，并且收集不是强制的。SELECT``SELECT``5 = <subquery>``5 IN <subquery>``SELECT VALUE

创建嵌套结果`GROUP BY ... GROUP AS`

在 PartiQL 中创建嵌套结果的另一种模式是通过 SQL 的扩展。这种模式更有效，并且比使用嵌套查询更直观时所需的嵌套不遵循输入的嵌套。（示例在使用 SELECT VALUE 查询创建嵌套结果是其中之一输出中的嵌套遵循输入的嵌套，因此，直观的解决方案不涉及。GROUP AS``GROUP BY``SELECT VALUE``GROUP BY

以下查询输出在中找到的每个安全项目以及员工姓名列表在项目上工作。hr.employeesNestScalars


SELECT p AS projectName,
       ( SELECT VALUE v.e.name 
         FROM perProjectGroup AS v ) AS employees
FROM hr.employeesNestScalars AS e JOIN e.projects AS p ON p LIKE '%security%'
GROUP BY p GROUP AS perProjectGroup

结果是


<<
  {
    'projectName': 'AWS Aurora security',
    'employees': <<
      'Bob Smith'
    >>
  },
  {
    'projectName': 'AWS Redshift security',
    'employees': <<
      'Bob Smith',
      'Jane Smith'
    >>
  }
>>
--- 
OK!

通过使公式化的 SQL 泛化对查询的和子句完全可用的组。与 SQL 的相反，其中 and 子句可以具有聚合函数分组列，但它们无法访问分组列。GROUP AS``GROUP BY``SELECT``HAVING``GROUP BY``SELECT``HAVING

为了更好地理解它的工作原理是最好将 PartiQL 查询视为子句管道，从的，继续和结束。每个子句都是一个输入数据和输出数据的函数。从这个意义上说，这是一个输入的函数的结果和将其结果输出到 .GROUP BY ... GROUP AS``FROM``GROUP BY``SELECT``GROUP BY ... GROUP AS``FROM``SELECT

以下查询（概念上）生成子句的输出。FROM


SELECT e AS e, p AS p
FROM hr.employeesNestScalars AS e JOIN e.projects AS p ON p LIKE '%security%'

我们看到，交付的元组集合包括由该子句输出的员工和项目，即 .这就像SQL的语义。FROM``e``p``FROM``LEFT JOIN``FROM


+-----------------------------------+-----------------------------------+
| Variable `e`                      | Variable `p`                      |
+===================================+===================================+
| { 'id': 3,                        |   'AWS Redshift security'         |
| 'name': 'Bob Smith',              |                                   |
| 'title': null,                    |                                   |
| 'projects':  [ 'AWS Redshift      |                                   |
| Spectrum querying',               |                                   |
| 'AWS Redshift security',          |                                   |
| 'AWS Aurora security'             |                                   |
|  ]                                |                                   |
| }                                 |                                   |
+-----------------------------------+-----------------------------------+
| { 'id': 3,                        |   'AWS Aurora security'           |
| 'name': 'Bob Smith',              |                                   |
| 'title': null,                    |                                   |
| 'projects':  [ 'AWS Redshift      |                                   |
| Spectrum querying',               |                                   |
| 'AWS Redshift security',          |                                   |
| 'AWS Aurora security'             |                                   |
|  ]                                |                                   |
| }                                 |                                   |
+-----------------------------------+-----------------------------------+
| { 'id': 6,                        | 'AWS Redshift security'           |
| 'name': 'Jane Smith',             |                                   |
| 'title': 'Software Eng 2',        |                                   |
| 'projects':  [ 'AWS Redshift      |                                   |
| security'  ]                      |                                   |
| }                                 |                                   |
+-----------------------------------+-----------------------------------+

那么可以认为输出每个分组依据表达式都有一列的表（即，每个安全项目）和最后一列值（概念上）是对应于分组依据表达式的员工/项目/元组的集合。因此输出是表GROUP BY ... GROUP AS ...``p``perProjectGroup``e``p``p``GROUP BY ... GROUP AS ...


+-----------------------------------+-----------------------------------+
| `p`                               | `perProjectGroup`                 |
+===================================+===================================+
| 'AWS Redshift security'           | <<                              |
|                                   | { e: { 'id': 3, 'name': 'Bob      |
|                                   | Smith', ... }, p: 'AWS Redshift   |
|                                   | security' },                      |
|                                   |                                   |
|                                   | { e: { 'id': 6, 'name': 'Jane     |
|                                   | Smith', ... }, p: 'AWS Redshift   |
|                                   | security' }                       |
|                                   | >>                              |
+-----------------------------------+-----------------------------------+
| 'AWS Aurora security'             | <<                              |
|                                   | { e: { 'id': 3, 'name': 'Bob      |
|                                   | Smith', ...}, p: 'AWS Aurora      |
|                                   | security' },                      |
|                                   | >>                              |
+-----------------------------------+-----------------------------------+

最后子句输入上述内容并输出查询结果。SELECT

了解有关 PartiQL 的更多信息

PartiQL 网站包含新闻、更新、文档，以及有关 PartiQL 实现的更多信息。

转自：

Tutorial · partiql/partiql-lang-kotlin Wiki (github.com)https://github.com/partiql/partiql-lang-kotlin/wiki/Tutorial

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)