WEBVTT

00:00:00.000 --> 00:00:09.223
[音乐]

00:00:13.237 --> 00:00:15.891
大家好，每个人都欢迎到另一个
令人兴奋的数据公开的节目集。

00:00:15.891 --> 00:00:16.920
我是主持人 Scott Klein 和

00:00:16.920 --> 00:00:19.060
返回与我的流行
要求 [笑声] 迈克尔。

00:00:19.060 --> 00:00:19.780
>> [发笑]
>> Michael Rys。

00:00:19.780 --> 00:00:20.370
>> 谢谢，Scott 的信息。

00:00:20.370 --> 00:00:22.000
>> 迈克尔，我们该怎么做？

00:00:22.000 --> 00:00:23.570
>> Hi 专家，是这样

00:00:23.570 --> 00:00:28.380
持续半年后回我
U SQL 说的不是。

00:00:28.380 --> 00:00:31.100
我回以向您提供更新
我们还增加了什么的

00:00:31.100 --> 00:00:31.660
我们已经更改。

00:00:31.660 --> 00:00:34.540
>> 是，并且我们期待
它是因为 U SQL 的流行主题。

00:00:34.540 --> 00:00:36.400
我们开始前，
我们谈一谈它，

00:00:36.400 --> 00:00:38.490
介绍自己快速的
可能并不了解您的人。

00:00:38.490 --> 00:00:39.830
>> 是的我的名字是 Mike Rys

00:00:39.830 --> 00:00:43.170
我是在项目经理
Microsoft 数据大团队。

00:00:43.170 --> 00:00:47.510
我负责 U SQL 和
Azure 数据湖分析。

00:00:47.510 --> 00:00:48.240
>> 超。

00:00:48.240 --> 00:00:50.082
嗯，你这里要谈一谈，

00:00:50.082 --> 00:00:54.294
是因为是，已可能四到
因为我们必须将您在最后的六个月。

00:00:54.294 --> 00:00:54.960
>> 是。

00:00:54.960 --> 00:00:59.070
>> 是什么东西自新
我们希望您的最后一次？

00:00:59.070 --> 00:01:02.790
>> 好，因此我们进行了相当数量的
在添加一些功能的进度

00:01:02.790 --> 00:01:04.163
问过的人。

00:01:04.163 --> 00:01:04.737
>> 是。
>> 和

00:01:04.737 --> 00:01:09.060
我们想到的一些功能
可能值得添加。

00:01:09.060 --> 00:01:11.610
此外添加了一些性能
改进等，并

00:01:11.610 --> 00:01:15.380
我到这里种快速
触摸其中几个。

00:01:15.380 --> 00:01:17.014
>> 所有权利。
>>，向您展示一些代码和

00:01:17.014 --> 00:01:17.910
样本等。

00:01:17.910 --> 00:01:18.750
>> 我总是喜欢看代码。

00:01:18.750 --> 00:01:20.160
好了，让我们单步执行中。

00:01:20.160 --> 00:01:20.890
因此，我们有什么？

00:01:20.890 --> 00:01:25.440
>> 确定，首先在条款
我们有一些新功能。

00:01:25.440 --> 00:01:27.160
我们添加了安全性。

00:01:27.160 --> 00:01:27.690
>> 好。
>> 和

00:01:27.690 --> 00:01:32.178
基本上在文件夹的 ACLing 和
fidle 级别，文件和

00:01:32.178 --> 00:01:34.925
文件夹级，真不好意思。

00:01:34.925 --> 00:01:36.500
>> [发笑]
>> 在商店，和

00:01:36.500 --> 00:01:39.900
此外可以设置
在数据库级别上的权限。

00:01:39.900 --> 00:01:42.210
因此，让我快速显示
您在门户中，，

00:01:42.210 --> 00:01:44.670
这是唯一方式
目前能做的。

00:01:44.670 --> 00:01:45.200
>> 好。
>> 因此

00:01:45.200 --> 00:01:46.955
现在，我们有我们的 Azure 门户和

00:01:46.955 --> 00:01:49.170
我正在打开我
这里的数据湖帐户。

00:01:50.370 --> 00:01:54.530
然后在数据湖帐户
通过使用数据资源管理器

00:01:54.530 --> 00:01:56.340
我可以看到我在本文中的数据库。

00:01:56.340 --> 00:01:59.010
因此，如果速度快，放大

00:01:59.010 --> 00:02:00.910
您在此处看到我的目录
>> 是。

00:02:00.910 --> 00:02:02.930
>> 具有所有这些数据库。

00:02:02.930 --> 00:02:07.030
让我们现在看一下
这里 JSONBlock 数据库。

00:02:07.030 --> 00:02:13.160
而且现在注意到了这里，
没有管理访问属性。

00:02:13.160 --> 00:02:17.510
现在让我到
基本上是授予的权限

00:02:17.510 --> 00:02:21.340
用户可以使用数据库和
与它的事情。

00:02:21.340 --> 00:02:26.690
因此，您在这里看到，在这种情况下，
它是只有我所拥有的访问。

00:02:26.690 --> 00:02:29.975
所以有负责人，这是
创建数据库的人。

00:02:29.975 --> 00:02:30.600
>> 毫米 hm。

00:02:30.600 --> 00:02:33.780
>> 您可以设置权限
在每个组的基础。

00:02:33.780 --> 00:02:35.460
和其他人。

00:02:35.460 --> 00:02:39.244
例如，您可以拥有
一组对的人

00:02:39.244 --> 00:02:41.221
示例中创建的对象。

00:02:41.221 --> 00:02:45.634
如注册程序集，创建
表、 插入数据和自动扫描。

00:02:45.634 --> 00:02:49.460
仅从数据读取
在表格内。

00:02:49.460 --> 00:02:52.737
>>，这与其他 Azure
数据存储区，这样的事情？

00:02:52.737 --> 00:02:53.727
这不会吗

00:02:53.727 --> 00:02:56.170
Azure 的活动目录
>> 是。

00:02:56.170 --> 00:02:56.700
>> 的权限？

00:02:56.700 --> 00:02:59.280
>> 这样的安全原则
是 Azure 活动目录。

00:02:59.280 --> 00:03:02.630
因此它是某些登录或

00:03:02.630 --> 00:03:06.160
它可以使用安全组
这里安全原则。

00:03:06.160 --> 00:03:06.750
>> 好。
>> 和

00:03:06.750 --> 00:03:09.960
权限
数据库是特定的。

00:03:09.960 --> 00:03:14.640
因此读取或写入操作，或
基本上枚举，等等。

00:03:14.640 --> 00:03:16.780
因此这里您看到什么样的
他们所具有的权限。

00:03:16.780 --> 00:03:17.340
>> 好。

00:03:17.340 --> 00:03:18.440
在数据库级别。

00:03:18.440 --> 00:03:19.630
>> 很好，好。

00:03:19.630 --> 00:03:22.210
还有多长时间
已经提供的吗？

00:03:22.210 --> 00:03:28.280
>>，已被用于
关于现在一个月。

00:03:28.280 --> 00:03:29.608
>> 好。
>> 因此，现在的下一步的事情就是我

00:03:29.608 --> 00:03:31.780
要谈一谈吗
性能的改进。

00:03:31.780 --> 00:03:35.660
现在这些性能改进
尚不在产品。

00:03:35.660 --> 00:03:36.360
>> 好。
>> 但

00:03:36.360 --> 00:03:39.315
应按时间可能为
这段视频投入。

00:03:39.315 --> 00:03:41.410
>> [发笑]
>> 或后不久就有但愿。

00:03:41.410 --> 00:03:42.020
>> 希望。

00:03:42.020 --> 00:03:44.118
>> 不像一个月以后。

00:03:44.118 --> 00:03:47.380
并且它是什么，基本上是我们

00:03:47.380 --> 00:03:50.585
有很多人的爱
若要使用我们的文件设置功能。

00:03:50.585 --> 00:03:53.885
基本意思就是文件集功能
提供包含的路径

00:03:53.885 --> 00:03:58.125
要领取的路径中的通配符
路径匹配的所有文件。

00:03:58.125 --> 00:03:59.145
>> 的路径进行匹配。

00:03:59.145 --> 00:04:00.755
>> 但
我们有一些性能问题。

00:04:00.755 --> 00:04:03.055
让我快速显示
您在本文中的示例。

00:04:04.175 --> 00:04:09.620
因此，如果我在这里转
我有 Visual Studio。

00:04:09.620 --> 00:04:11.370
我这里有一个简单的脚本。

00:04:11.370 --> 00:04:14.020
>> 是。
>> 现在，超出此脚本

00:04:14.020 --> 00:04:16.230
一些我们的遥测数据。

00:04:16.230 --> 00:04:16.949
>> 好。
>> 和

00:04:16.949 --> 00:04:19.639
如果您看一下什么
您可以在此处时，

00:04:19.639 --> 00:04:24.770
它基本上有很长的路径
有很多在它的模式的名称。

00:04:24.770 --> 00:04:29.160
因此，它基本上使
在其中我们所看的群集。

00:04:29.160 --> 00:04:30.840
日期、 年、 月、 日期。

00:04:30.840 --> 00:04:31.610
>> 是，并且该名称。

00:04:31.610 --> 00:04:33.350
>> 和文件的名称。

00:04:33.350 --> 00:04:36.929
这里我做只是我和
基本上中提取出的数据

00:04:38.200 --> 00:04:40.950
行，因此
我这里是种相当迟缓。

00:04:40.950 --> 00:04:42.440
>> 是。
>> 和升级显然所有

00:04:42.440 --> 00:04:45.395
这些数据，我们称之为虚拟列，
从该模式。

00:04:45.395 --> 00:04:45.950
>> 的权限。
>> 和

00:04:45.950 --> 00:04:49.270
然后我做一些简单
那里下, 聚合，

00:04:49.270 --> 00:04:50.660
它们输出到一个文件中。

00:04:50.660 --> 00:04:53.170
我还没有到
写出数据。

00:04:53.170 --> 00:04:58.600
现在，我不会运行，但
如果您对现有运行这

00:04:58.600 --> 00:05:02.850
今天，运行的时
您会注意到这里的几种方法。

00:05:02.850 --> 00:05:06.110
让我快速放大以便
您可以看到这里的数字。

00:05:06.110 --> 00:05:13.000
首先，我们有大约 2,150
我们只在运行的文件。

00:05:13.000 --> 00:05:15.010
那里看到
在右手。

00:05:15.010 --> 00:05:16.098
>> 2,150。
>> 告诉我，

00:05:16.098 --> 00:05:18.700
也许到这里该零件放大。

00:05:18.700 --> 00:05:20.310
因此，这基本上就是输入。

00:05:20.310 --> 00:05:23.290
因此，我们的超过 2000 个文件进行的操作。

00:05:23.290 --> 00:05:23.940
>> 好。

00:05:23.940 --> 00:05:27.825
>> 现在遗憾的是，
编译要花十分钟。

00:05:27.825 --> 00:05:28.600
>> [发笑]
>> 时刻。

00:05:28.600 --> 00:05:31.230
并且实际上，
如果达到约 5000 台文件或

00:05:31.230 --> 00:05:33.190
因此我们将您的超时时间。

00:05:33.190 --> 00:05:37.580
因为我们编译时
限制出了 24 分钟。

00:05:37.580 --> 00:05:39.620
>> 好。
>>，然后忽略队列，我

00:05:39.620 --> 00:05:42.850
必须在运行的一些其他东西
当我在此作业的同一时间。

00:05:42.850 --> 00:05:46.411
然后就
在 35 分钟内运行。

00:05:46.411 --> 00:05:46.932
>> 是，woo （）。

00:05:46.932 --> 00:05:50.264
>> 35 和半分钟到或
真正获取您出色完成任务。

00:05:50.264 --> 00:05:50.889
>> 好。

00:05:50.889 --> 00:05:53.178
>> 是，因此不很好。

00:05:53.178 --> 00:05:55.150
>> 超过 2000 文件
似乎很长时间。

00:05:56.240 --> 00:05:57.570
>> 现在我们所做的就是，

00:05:57.570 --> 00:06:02.120
这是现在的作业
在新的位上运行。

00:06:02.120 --> 00:06:02.660
>> 好。

00:06:02.660 --> 00:06:07.890
>>，第一件事
您注意到的是我

00:06:07.890 --> 00:06:11.530
现在已编译时将
下移一个数量级。

00:06:11.530 --> 00:06:12.830
现在是有关一分钟左右。

00:06:12.830 --> 00:06:13.640
>> 一分，是。

00:06:13.640 --> 00:06:17.560
>>，它是最有可能进入
扩展中的好得多

00:06:17.560 --> 00:06:18.707
条款的文件数。

00:06:18.707 --> 00:06:19.508
>> 好。
>> 因此，我们预期的那样

00:06:19.508 --> 00:06:21.780
可一到两个顺序
更多比以前的文件。

00:06:21.780 --> 00:06:23.550
>> 哇。

00:06:23.550 --> 00:06:25.990
>> 和其他注解
您可能是请注意，

00:06:25.990 --> 00:06:30.890
再次忽略队列
运行时不超过十分钟。

00:06:30.890 --> 00:06:35.700
因此这些处理
2000 以及文件很

00:06:35.700 --> 00:06:37.180
更快的现在。

00:06:37.180 --> 00:06:41.010
因为我们还生产
更好地规划

00:06:41.010 --> 00:06:43.510
知道如何处理此类文件。

00:06:43.510 --> 00:06:44.420
>> 好，良好。

00:06:44.420 --> 00:06:47.930
>> 所以这是提示的刚种上

00:06:47.930 --> 00:06:49.825
即将推出的
性能的条款。

00:06:49.825 --> 00:06:50.440
>> 很好。

00:06:50.440 --> 00:06:53.710
>> 另一件我们
改进重复使用的容器。

00:06:53.710 --> 00:06:58.160
所以，在今天当计划作业时，
所有这些说明，您

00:06:58.160 --> 00:07:02.920
有内部作业图
基本上在年轻的容器中运行。

00:07:02.920 --> 00:07:08.550
和每次作业启动时，
建立一个新的容器并且

00:07:08.550 --> 00:07:13.225
采用半秒之间
对可能几秒钟。

00:07:13.225 --> 00:07:13.970
>> 的权限。

00:07:13.970 --> 00:07:17.710
>>，那么我们是什么现在
在下一个版本中，这样做

00:07:17.710 --> 00:07:20.440
是我们要重用
容器在可能的情况。

00:07:20.440 --> 00:07:23.780
因此，基本上不存在
该启动时所有的时间。

00:07:23.780 --> 00:07:26.799
并且，还应提高
相当多的性能。

00:07:27.930 --> 00:07:28.830
>> 的了解。

00:07:28.830 --> 00:07:29.893
>> 因此，现在的功能，

00:07:29.893 --> 00:07:31.441
因为显然我还没有
这里满足已很长时间。

00:07:31.441 --> 00:07:32.469
>> [发笑]
>> 我们有大量的

00:07:32.469 --> 00:07:33.089
[串扰] 功能。

00:07:33.089 --> 00:07:35.760
>> 一个长长的列表。

00:07:35.760 --> 00:07:39.350
>> 也许我转，介绍几种
这些，让我快速转到。

00:07:39.350 --> 00:07:43.000
我们还增加了采样，因此我将
向您介绍一个简单示例。

00:07:43.000 --> 00:07:46.840
但我们也有能力
要不要统一采样和

00:07:46.840 --> 00:07:50.480
在均匀采样
相关的数据集。

00:07:50.480 --> 00:07:54.310
因此，如果您的绘图，您获得
实际上从统计上显著

00:07:54.310 --> 00:07:56.765
样品的两个
联合合作伙伴。

00:07:56.765 --> 00:07:57.610
>> 的权限。

00:07:57.610 --> 00:08:02.270
>> 我们还的能力
要不要对或减少。

00:08:02.270 --> 00:08:05.330
我将向您展示快速的代码中，
如何调用它。

00:08:05.330 --> 00:08:10.190
我有在我 MSDM 上发布博客
博客的实际显示方式

00:08:10.190 --> 00:08:13.090
若要编写变径也。

00:08:13.090 --> 00:08:18.240
我们添加了一些附加
变量声明选项

00:08:18.240 --> 00:08:20.845
我们可以处理
参数化和

00:08:20.845 --> 00:08:23.705
折叠的常数
我将在第二个显示的。

00:08:23.705 --> 00:08:25.563
然后，我们添加了如果然后其他。

00:08:25.563 --> 00:08:28.127
>> 是 [发笑]。

00:08:28.127 --> 00:08:28.985
是的！

00:08:28.985 --> 00:08:30.465
>> 不过，它是只编译时。

00:08:30.465 --> 00:08:31.245
>> 好。
>> 它基本上让

00:08:31.245 --> 00:08:33.355
您可以为
parametrize 您的脚本。

00:08:33.355 --> 00:08:33.930
>> 好。
>> 和

00:08:33.930 --> 00:08:37.815
然后，可以看到是否要执行，
让我们说，

00:08:37.815 --> 00:08:40.933
调试版本中或生产
例如，您的脚本版本。

00:08:40.933 --> 00:08:42.860
>> 好。
仍然很有用也是如此。

00:08:42.860 --> 00:08:47.200
>> 是，您还可以使用
文件已存在，或存在分区

00:08:47.200 --> 00:08:51.550
如果内然后 ELSE 表达式中，
或其他任何布尔值的上下文中。

00:08:51.550 --> 00:08:53.492
>> 好。
>> 对，例如检查

00:08:53.492 --> 00:08:56.323
文件或
分区已存在。

00:08:56.323 --> 00:08:59.490
如果存在，
然后让我们执行的内容。

00:08:59.490 --> 00:09:01.040
如果不能，或
然后执行其他操作。

00:09:01.040 --> 00:09:02.150
>> 的很好。
>> 因此，我们将向您展示，在

00:09:02.150 --> 00:09:02.830
一分钟也。

00:09:02.830 --> 00:09:04.080
>> 好。

00:09:04.080 --> 00:09:06.680
跳过前 n 行，这一直是
针对一段时间，我想询问。

00:09:06.680 --> 00:09:07.920
>> 是的没错，是的和

00:09:07.920 --> 00:09:11.252
我们确实希望，我们
会让出很久以前。

00:09:11.252 --> 00:09:12.245
>> [发笑]
>>，但花了我们，

00:09:12.245 --> 00:09:13.890
遗憾的是，再有点。

00:09:13.890 --> 00:09:14.770
因此，现在没有。

00:09:14.770 --> 00:09:15.607
>> 好。
>> 因此，我们将向您展示，

00:09:15.607 --> 00:09:16.169
以及每分钟。

00:09:16.169 --> 00:09:18.420
>> Woo （)，好了。

00:09:18.420 --> 00:09:20.650
>> 和
使用语句来缩短 C# 名。

00:09:20.650 --> 00:09:23.150
>> 好。
>> 我将向您展示的快速。

00:09:23.150 --> 00:09:26.980
然后再最后但并不容忽视的一点，
我们必须改变表添加和

00:09:26.980 --> 00:09:28.090
删除列。

00:09:28.090 --> 00:09:29.491
>> 好。
>>，使您能够执行

00:09:29.491 --> 00:09:31.490
少量的架构
在表上的发展。

00:09:31.490 --> 00:09:32.560
>> 神奇。
>> 也。

00:09:32.560 --> 00:09:34.950
>> 很好。
>> 我不会但展示。

00:09:34.950 --> 00:09:36.397
>> 的确定。
>> 可以查找该发行版中的

00:09:36.397 --> 00:09:37.598
我们已经有点发布的注释。

00:09:37.598 --> 00:09:41.017
>> 好。
>> 好了，所以让我们回到我的代码

00:09:41.017 --> 00:09:45.633
这里，看看
我有一个第二个脚本。

00:09:45.633 --> 00:09:49.318
现在这个脚本的作用是它
声明一些变量，和

00:09:49.318 --> 00:09:51.275
我将在第二个获得的。

00:09:51.275 --> 00:09:52.862
>> 毫米 hm。

00:09:52.862 --> 00:09:54.800
>> 因为那里
不同的选项和

00:09:54.800 --> 00:09:56.681
我想要快速显示
您做些什么。

00:09:56.681 --> 00:09:59.712
和这里下然后我
有一个 IF 语句。

00:09:59.712 --> 00:10:04.472
如果语句不是这样
实际检查此文件存在

00:10:04.472 --> 00:10:07.617
存储区中时
获取编译脚本。

00:10:07.617 --> 00:10:09.279
>> 是，这是其中一个示例
在幻灯片上，右为？

00:10:09.279 --> 00:10:14.260
>> 是，并且如果它存在，
然后我该做这里的提取。

00:10:14.260 --> 00:10:18.899
现在此类提取操作
在一些汽车的遥测数据。

00:10:18.899 --> 00:10:23.839
因此，数据实际
包含，让我来告诉您，

00:10:23.839 --> 00:10:29.049
速度快，是两个标题行。

00:10:31.040 --> 00:10:34.630
因此，您在这里看到，这就是某些汽车
从行上遥测向下。

00:10:34.630 --> 00:10:39.132
但只是提供了第一行
我录制的一些信息。

00:10:39.132 --> 00:10:43.199
然后第二行给了我和
实际标题行和等等。

00:10:43.199 --> 00:10:45.929
所以很明显我将和
来跳过这两个，因此

00:10:45.929 --> 00:10:47.361
该我提取程序是否有效。

00:10:50.286 --> 00:10:55.948
因此，我使用 skipFirstNRows:2。

00:10:55.948 --> 00:11:00.877
我在做一些计算然后
只是一些分组

00:11:00.877 --> 00:11:05.940
若要查看某些信息，并
然后在我输出的末尾。

00:11:05.940 --> 00:11:07.880
如果该文件不存在，

00:11:07.880 --> 00:11:13.200
我只需创建伪行
它说，找不到文件。

00:11:13.200 --> 00:11:16.334
和我做相同的输出
通过在名称上的欺骗

00:11:16.334 --> 00:11:17.410
列在此处。

00:11:17.410 --> 00:11:19.328
>> [发笑]
>> 因此，我希望能一起工作的。

00:11:19.328 --> 00:11:23.576
好了，因此，如果我现在，执行这
嗯之前执行，

00:11:23.576 --> 00:11:27.930
让我快速地声明，
介绍了这里的声明。

00:11:27.930 --> 00:11:31.700
因此，将声明语句
说外部声明的名称。

00:11:31.700 --> 00:11:36.380
现在这样做，是它使我
若要添加另一个声明语句

00:11:36.380 --> 00:11:41.180
或脚本的参数。

00:11:41.180 --> 00:11:43.424
但是，如果有任何
参数提供，

00:11:43.424 --> 00:11:46.332
然后脚本仍然运行
使用此默认值。

00:11:46.332 --> 00:11:49.692
因此，它不会因为今天如果我
有两个声明语句

00:11:49.692 --> 00:11:52.090
相同的变量，
我们基本上错误。

00:11:52.090 --> 00:11:53.610
在这种情况下，我们基本上是说，

00:11:53.610 --> 00:11:56.790
嗯，实际上这是什么样的
脚本的的默认值。

00:11:56.790 --> 00:11:59.750
如果您想要提供其与
某些参数的机制，为

00:11:59.750 --> 00:12:02.785
示例，Azure 数据工厂
作为参数模型，

00:12:02.785 --> 00:12:04.620
在他们前面
类的语句。

00:12:04.620 --> 00:12:08.355
因此，将会得到我的能力
为此脚本的默认值，

00:12:08.355 --> 00:12:11.595
然后仍 parametrize 它的
通过 ADF 的示例或

00:12:11.595 --> 00:12:13.805
其他提交工具。

00:12:13.805 --> 00:12:17.623
第 5 行
说声明常量。

00:12:17.623 --> 00:12:21.483
它的作用是，它实际上
检查表达式的我

00:12:21.483 --> 00:12:25.430
提供之后无常，可折叠，
为什么重要？

00:12:25.430 --> 00:12:30.200
嗯，可折叠的常数是
我们可以计算在编译

00:12:30.200 --> 00:12:31.220
时间，和

00:12:31.220 --> 00:12:35.300
我们有几个上下文，我们
使您可以在表达式中将。

00:12:35.300 --> 00:12:38.860
请一定要
折叠式，如为常量

00:12:38.860 --> 00:12:41.810
示例从
在提取中的子句。

00:12:41.810 --> 00:12:46.190
或者有特殊优化
它会发生。

00:12:47.790 --> 00:12:51.580
但即使仍执行
如果不是常数可折叠。

00:12:51.580 --> 00:12:54.810
这样，可以使
断言，此表达式

00:12:54.810 --> 00:12:55.830
不变可折叠。

00:12:55.830 --> 00:12:57.028
现在，在这种情况下，

00:12:57.028 --> 00:13:01.617
因为我正在做字符串串联
与在那里的匿名函数。

00:13:01.617 --> 00:13:03.347
>> [发笑]
>> 这一点不会

00:13:03.347 --> 00:13:05.943
可折叠的常量，因此
如果此编译。

00:13:08.872 --> 00:13:13.118
我得到的语法错误
因为我尚未运行不在

00:13:13.118 --> 00:13:14.840
发布下面的运行时。

00:13:14.840 --> 00:13:18.392
所以我本地的工具
没有最多，到目前为止尚未。

00:13:18.392 --> 00:13:22.376
>> [发笑]
>> 它被发现后约六至

00:13:22.376 --> 00:13:29.512
编译器将十秒钟
对此抱怨，让我们看。

00:13:32.613 --> 00:13:34.850
>> 因此，在这点上，
是的就可以了。

00:13:34.850 --> 00:13:37.600
>> 是，因此
让我仔细检查下面的错误。

00:13:38.740 --> 00:13:42.850
如果我放大
您会注意到，它现在说

00:13:42.850 --> 00:13:46.850
表达式不能为
在编译时计算。

00:13:46.850 --> 00:13:47.447
>> 不能被折叠。
和

00:13:47.447 --> 00:13:52.330
就在这里在声明常量
在这种情况下的表达式。

00:13:53.800 --> 00:13:58.458
因此，我可以做什么现在是，
我可以转到背面的课程，

00:13:58.458 --> 00:14:04.490
只是解决该问题，和
解决这个问题用此语句。

00:14:04.490 --> 00:14:08.470
现在，我在这里，有默认值
该文件不存在。

00:14:08.470 --> 00:14:15.587
因此，如果我现在，执行此作业
它将定位并运行和

00:14:15.587 --> 00:14:21.032
创建文件只告诉我
该文件不存在。

00:14:21.032 --> 00:14:27.234
>> 好了，所以
这将花很少一点。

00:14:29.174 --> 00:14:32.710
我们都看什么代码？

00:14:32.710 --> 00:14:33.910
>> 我们要查找这这里。

00:14:33.910 --> 00:14:38.030
>> 好了，这样的区别，
如我所说，第 5 行

00:14:38.030 --> 00:14:42.020
此时不能折叠，因此
是因为它找不到名称？

00:14:42.020 --> 00:14:44.408
>> 没有，因此，常量合并意味着
可计算或

00:14:44.408 --> 00:14:45.019
在编译。

00:14:45.019 --> 00:14:48.533
这样，我们是基本类型
做一些计算

00:14:48.533 --> 00:14:49.890
表达式。

00:14:49.890 --> 00:14:52.018
类似于 C# 的用途，如

00:14:52.018 --> 00:14:54.288
如果您将添加两个常量
用 C# 值。

00:14:54.288 --> 00:14:57.846
>>，所以，在这种情况下显然
该 lambda 表达式不是

00:14:57.846 --> 00:15:01.826
折叠式常数，因为我们
常量的文件夹不是足够聪明

00:15:01.826 --> 00:15:02.819
若要查看它。

00:15:02.819 --> 00:15:06.251
而一个简单的字符串
支持连接则

00:15:06.251 --> 00:15:08.981
实际上所有字符串
操作都是，

00:15:08.981 --> 00:15:11.733
这就是为什么我不得不喜欢这样的
>> 好了，是的

00:15:11.733 --> 00:15:12.559
这是现在可以理解。

00:15:12.559 --> 00:15:15.719
>> 好了，很棒，让我们先
后台，查看该作业的作用。

00:15:17.110 --> 00:15:17.631
因此它现在运行。

00:15:20.490 --> 00:15:22.140
可能已经完成，是。

00:15:23.910 --> 00:15:27.015
所以，现在，
如果我打开我的头文件在这里，

00:15:27.015 --> 00:15:31.592
下载它，您将

00:15:31.592 --> 00:15:36.562
请注意，该得到的
>> 未找到。

00:15:36.562 --> 00:15:37.620
>> 文件找不到。

00:15:38.680 --> 00:15:43.920
如果我走了后，
更改此

00:15:43.920 --> 00:15:48.450
添加此附加的声明

00:15:48.450 --> 00:15:51.640
在外部之前的语句
同一个变量的声明。

00:15:52.770 --> 00:15:54.420
然后我将提交现在也，

00:15:55.450 --> 00:15:57.770
此时的时间
它实际上将起作用。

00:15:57.770 --> 00:16:00.210
>> 我看到。
>> 因此，也许在它运行时，

00:16:00.210 --> 00:16:01.850
让我快速地给出了几
其他的内容。

00:16:04.520 --> 00:16:10.210
因此，我想要的一件事
显示的范围内，PRESORT。

00:16:10.210 --> 00:16:14.540
因此，在本例中这里我
有 U SQL 脚本，

00:16:14.540 --> 00:16:16.780
将某些数据的范围。

00:16:16.780 --> 00:16:22.340
并且我需要什么样的折叠
重叠的范围。

00:16:22.340 --> 00:16:26.940
因此，为了能够执行
我可以编写自定义聚合函数。

00:16:26.940 --> 00:16:31.492
但自定义聚合函数最好
做到这一点的方法是，如果我将它，

00:16:31.492 --> 00:16:34.400
基本上我需要
输入的数据进行排序。

00:16:34.400 --> 00:16:38.594
那么我可以只需看下一步
请参阅我是否需要将其包含的行

00:16:38.594 --> 00:16:42.174
在上一个间隔内或
如果我开始了新的时间间隔。

00:16:42.174 --> 00:16:46.647
因此，对基本上现在和
使我能够创建

00:16:46.647 --> 00:16:49.650
用户定义的有序的聚合。

00:16:49.650 --> 00:16:55.320
因此，这只是一个示例，您
实际上有此我 MSDN 博客上。

00:16:55.320 --> 00:16:59.260
如果您希望也，可用
查看如何代码类似，和

00:16:59.260 --> 00:17:01.270
它是从下载
以及我们备份站点。

00:17:02.400 --> 00:17:05.800
因此，然后第二个
我想要显示的内容

00:17:05.800 --> 00:17:07.799
快速将 USING 语句。

00:17:09.230 --> 00:17:13.230
再次，这是代码我们
可以从我们 GitHub 下载。

00:17:14.670 --> 00:17:19.570
因此，我在此处执行的操作是引用
SQL Server 空间的程序集

00:17:19.570 --> 00:17:22.010
我下载并安装。

00:17:22.010 --> 00:17:24.880
并已预定义和

00:17:24.880 --> 00:17:29.220
在我们运行时预加载时
System.Data 程序集。

00:17:29.220 --> 00:17:31.788
所以现在我，而不是有为
编写 Microsoft SQL 服务器类型。

00:17:31.788 --> 00:17:35.734
>> [发笑]
>> SQL 几何或地理位置，

00:17:35.734 --> 00:17:39.181
我只是使用 USING 语句
若要缩短，并

00:17:39.181 --> 00:17:42.243
然后可以使用的
我 C# 表达式内。

00:17:42.243 --> 00:17:44.380
>> 所以它成为了体验
在此例中的好很多吗？

00:17:44.380 --> 00:17:46.322
>> 是，
类似于使用 C# 中的子句

00:17:46.322 --> 00:17:48.773
只不过它是上层的用例
而不是小写字母。

00:17:48.773 --> 00:17:51.057
>> 很好，是的非常美妙。

00:17:51.057 --> 00:17:56.300
>> 现在，让我们回到我们的工作
它显然现已完成。

00:17:56.300 --> 00:17:59.779
正如您可以看到我们正在编写
会有点更多的数据因此

00:17:59.779 --> 00:18:01.202
如果我下载的文件。

00:18:06.711 --> 00:18:11.142
现在，看到我做的
>> 好了，得到的一些数据？

00:18:11.142 --> 00:18:16.447
>> 五个 laps 通讯，这是持续时间
以毫秒为单位的每个膝的或

00:18:16.447 --> 00:18:19.890
所以，这是最高
我得到的 RPM。

00:18:19.890 --> 00:18:21.666
这也是最高
我有，这样的速度

00:18:21.666 --> 00:18:24.078
千米每小时，在一个点上
不能在每小时英里。

00:18:24.078 --> 00:18:25.125
>> [发笑]。

00:18:25.125 --> 00:18:30.708
所以我了，最快的是象一样
每隔一小时 200 kilometres 和 196。

00:18:30.708 --> 00:18:32.534
但再有可能，

00:18:32.534 --> 00:18:36.660
我必须隐藏其他驱动器
只有像 150 左右的专家。

00:18:36.660 --> 00:18:39.654
>> 好，很好地 200 公里
每隔一小时，仍然大约 100 和-

00:18:39.654 --> 00:18:40.271
>> 25 英里。

00:18:40.271 --> 00:18:41.903
>> 25 英里，好。

00:18:41.903 --> 00:18:43.551
它仍然剪切
沿着已经相当好。

00:18:43.551 --> 00:18:44.287
>>，这是在跑道上。

00:18:44.287 --> 00:18:45.263
>> 好。
[笑声]

00:18:45.263 --> 00:18:46.279
>> 并不是在公共道路。

00:18:46.279 --> 00:18:47.303
>> 这是 405 上。[LAUGHS]

00:18:47.303 --> 00:18:48.575
>> 没有，没有，没有，没有，没有。

00:18:48.575 --> 00:18:50.702
我不宽恕的正常的驱动器。

00:18:50.702 --> 00:18:51.472
>> 很好。

00:18:51.472 --> 00:18:54.991
[笑声]
>> 对，这只是显示您方式

00:18:54.991 --> 00:19:00.010
我们现在可以基本上使用 IF 然后
ELSE 语句并跳过了头。

00:19:00.010 --> 00:19:04.925
因为现在显然已跳过对
这些两个无头

00:19:04.925 --> 00:19:08.756
若要编写自定义提取程序或
说静默等于 true 或

00:19:08.756 --> 00:19:16.240
好，那么回到现在，事情
这里我认为我所示的大部分。

00:19:16.240 --> 00:19:20.130
现在，可支持性的也是
我们将添加新的功能。

00:19:20.130 --> 00:19:21.320
现在，在 Visual Studio 中

00:19:21.320 --> 00:19:24.790
如果您有运行时错误，
有条，则出现在顶部，

00:19:24.790 --> 00:19:29.690
它使您能够下载
失败顶点，和本地对其进行调试。

00:19:29.690 --> 00:19:33.685
因此，如果您有用户代码，让我们说
编写您自己的抽风机，或

00:19:33.685 --> 00:19:35.758
编写您复杂的 C# UDF。

00:19:35.758 --> 00:19:39.881
并且您会遇到一个问题
由于的我不知道，

00:19:39.881 --> 00:19:45.710
内存溢出，无效数字
列的强制转换错误或操作。

00:19:45.710 --> 00:19:48.230
您现在可以下载该顶点和

00:19:48.230 --> 00:19:51.850
看一下本地在本地
在 Visual Studio 调试器。

00:19:51.850 --> 00:19:52.670
>> 和了解应在何处 it-
>>，并对其进行调试并

00:19:52.670 --> 00:19:53.265
看看会发生什么。

00:19:53.265 --> 00:19:54.913
这就是另一个很酷的功能。

00:19:54.913 --> 00:19:55.594
>> 非常好。

00:19:55.594 --> 00:19:59.084
>> 和我希望我们可以邀请一个
Visual Studio，专家的

00:19:59.084 --> 00:20:01.724
团队可以做某些时候的视频。一个

00:20:01.724 --> 00:20:02.220
>>，会非常有趣。

00:20:02.220 --> 00:20:03.620
好了，是的我们将计划执行该操作。

00:20:03.620 --> 00:20:05.692
>> 好，
现在更加严重。

00:20:05.692 --> 00:20:06.910
因此，我们有好消息。

00:20:06.910 --> 00:20:08.470
现在坏消息 [笑声]。

00:20:08.470 --> 00:20:10.523
>> 它是仍然有好消息从长远来看，
但

00:20:10.523 --> 00:20:14.102
这意味着，实际上人的
使用新的 SQL 现在 5 月

00:20:14.102 --> 00:20:15.971
需要去修复他们的脚本。

00:20:15.971 --> 00:20:16.670
>> 好。

00:20:16.670 --> 00:20:19.909
>>，这段时间的
我们的功能开发，

00:20:19.909 --> 00:20:23.146
我们有几项事情
我们注意到需要

00:20:23.146 --> 00:20:26.481
因为提高它
不难理解。

00:20:26.481 --> 00:20:30.732
因为它是使人产生误解，
某种程度上是正确的等等。

00:20:30.732 --> 00:20:35.044
第一个是，人已知道了
与我们分区语法相混淆

00:20:35.044 --> 00:20:37.050
在创建该表的语句。

00:20:37.050 --> 00:20:39.175
因此，我们说的
通过哈希分区和

00:20:39.175 --> 00:20:42.220
然后我们还说
分区的存储桶。

00:20:42.220 --> 00:20:43.845
并且，这仍然不清楚他们如何与相关。

00:20:43.845 --> 00:20:44.676
>> 好。
>> 因此

00:20:44.676 --> 00:20:48.742
我们现在正在进行术语
得更精确。

00:20:48.742 --> 00:20:49.414
>> 好。

00:20:49.414 --> 00:20:51.369
>> 是现在，如果我们说分区，

00:20:51.369 --> 00:20:54.687
分区是事物
它是可寻址的。

00:20:54.687 --> 00:20:59.310
这种被称为
分区的存储桶。

00:20:59.310 --> 00:21:02.818
此外，我们使用的一点
若要调用哈希分区现哈希

00:21:02.818 --> 00:21:06.624
分发或范围分发
这基本上是分布

00:21:06.624 --> 00:21:10.240
表中的数据或
在一个单独的分区。

00:21:10.240 --> 00:21:14.190
这就是现在非常
明确表示在语法中。

00:21:14.190 --> 00:21:17.237
如果您已使用
按分区，请请

00:21:17.237 --> 00:21:19.524
转并更改您的代码
到分发的。

00:21:19.524 --> 00:21:20.400
>> 好。
>> 此外，

00:21:20.400 --> 00:21:25.144
如果您使用分区的存储桶，
然后，转并使用分区，

00:21:25.144 --> 00:21:27.194
相反，通过分发。

00:21:27.194 --> 00:21:30.194
这就是，
真正重要的因为很快，

00:21:30.194 --> 00:21:32.660
我们将关闭旧语法，
对吧？

00:21:32.660 --> 00:21:37.688
现在我们都支持这两者，
但后期的 9 月，由

00:21:37.688 --> 00:21:42.454
早期的 10 月，很有可能，
我们将关闭旧语法。

00:21:42.454 --> 00:21:45.121
然后您将不得不转，
更改您的脚本。

00:21:45.121 --> 00:21:46.442
>> 很好，是的。

00:21:46.442 --> 00:21:49.839
>>，请注意它不影响
任何数据，因此

00:21:49.839 --> 00:21:53.947
您不必转，
重新运行您的脚本，则元数据

00:21:53.947 --> 00:21:56.724
基础数据
是完全相同的。

00:21:56.724 --> 00:21:58.921
它就是语法
正在改变这样

00:21:58.921 --> 00:22:01.523
您不必执行任何操作。

00:22:01.523 --> 00:22:07.061
同样地，我们现在将和
需要使用该官员

00:22:07.061 --> 00:22:11.954
表示
24 小时内，在该文件上设置模式。

00:22:11.954 --> 00:22:18.448
因此我们目前支持这两个
小写字母 h 和大写 h。

00:22:18.448 --> 00:22:23.524
但在 C# 中，小写 h 中
模式语言指的是

00:22:23.524 --> 00:22:25.606
12 小时时钟。

00:22:25.606 --> 00:22:29.282
因此我们将现在基本上
否决小写 h 和

00:22:29.282 --> 00:22:31.268
将要求只大写 h。

00:22:31.268 --> 00:22:34.050
>> 大写 h，好。

00:22:34.050 --> 00:22:39.490
>> 在文件另一事
设置大小，我们有两种方法

00:22:39.490 --> 00:22:43.150
基本上给予肆虐
卡上的名称和

00:22:43.150 --> 00:22:45.654
这是字符串类型的或
以文本或操作。

00:22:45.654 --> 00:22:49.326
一是，列; *。

00:22:49.326 --> 00:22:49.904
>> 是。
>> 和

00:22:49.904 --> 00:22:51.293
另一个是只是列名称。

00:22:51.293 --> 00:22:51.981
>> 好。

00:22:51.981 --> 00:22:53.279
>>，这是令人费解。

00:22:53.279 --> 00:22:55.576
他们稍有
不同的语义，但

00:22:55.576 --> 00:22:58.909
它是非常混乱的人
了解何时使用它。

00:22:58.909 --> 00:23:03.898
因此我们将基本上
删除代号 col *，

00:23:03.898 --> 00:23:08.780
我将语义
一个的它只是对拥有

00:23:08.780 --> 00:23:13.900
列名称是等价于
使用前星的一个。

00:23:13.900 --> 00:23:16.717
请转到和
由于再次更改 [INAUDIBLE]-

00:23:16.717 --> 00:23:19.427
>> [串扰]

00:23:19.427 --> 00:23:22.676
>> 脚本将停止工作时您

00:23:22.676 --> 00:23:24.189
不做的。

00:23:24.189 --> 00:23:25.997
好了，就是这样。

00:23:25.997 --> 00:23:26.580
>> 好，超。

00:23:26.580 --> 00:23:28.741
好的信息，非常好。

00:23:28.741 --> 00:23:30.389
迈克尔，感谢您的光临。

00:23:30.389 --> 00:23:34.115
如果他们有任何疑问，
如果查看器有任何疑问，

00:23:34.115 --> 00:23:37.360
若要获得最佳的方法是什么
保留的提出的问题？

00:23:37.360 --> 00:23:40.872
>> 的最佳方式是如果你
外部，您可以 tweet 在我和

00:23:40.872 --> 00:23:42.458
我应该能够看到它。

00:23:42.458 --> 00:23:43.626
>> 好。

00:23:43.626 --> 00:23:47.462
>> 否则留言，
这里该视频下面。

00:23:47.462 --> 00:23:49.510
>> 在该博客中，是，
是的发表评论。

00:23:49.510 --> 00:23:51.766
>> 或
连接我通过我的博客或操作。

00:23:51.766 --> 00:23:52.734
>> 好了，完美。

00:23:52.734 --> 00:23:54.830
好了，是因为我相信
将会有一些问题，

00:23:54.830 --> 00:23:57.298
尤其是晚
9 月早期 10 月的时限。

00:23:57.298 --> 00:24:00.628
或下只是说，超过 30 天
当人们开始通过迁移。

00:24:00.628 --> 00:24:04.122
所有权利因此
他在自己的 Twitter 帐户，点击

00:24:04.122 --> 00:24:06.773
他的 Twitter 手柄，或者在他的博客上。

00:24:06.773 --> 00:24:08.920
我相信 Mike 会
快乐来解决这个问题。

00:24:08.920 --> 00:24:12.241
每个人，谢谢观看，
然后，我们将看到下一次。

00:24:12.241 --> 00:24:22.241
[音乐]