最佳实践：使用视图可以使用一些工作得以简化，这些工作包括：复杂的连接或者聚合查询、
逆规范化数据或者为列改名以支持即席查询或者报表。当以这种方法来使用视图时，
视图可以保证数据库的一致性。但不要使用视图来支持主要的用户应用程序，也不要用
它来维护系统的安全性。
 
1。使用DDL代码创建视图
 
create view V_YY02        ------创建一个名叫V_YY02的视图
as 
SELECT TOP 100 PERCENT dbo.d_Retail.depotid, dbo.d_Retailsub.styleid,   ----下面是视图的SQL代码
      dbo.d_Retailsub.colorid, dbo.d_Retailsub.sizeid, SUM(dbo.d_Retailsub.nums) 
      AS ‘合计’
FROM dbo.d_Retail INNER JOIN
      dbo.d_Retailsub ON dbo.d_Retail.retailid = dbo.d_Retailsub.retailid
WHERE (LEN(dbo.d_Retail.depotid) = 3)
GROUP BY dbo.d_Retail.depotid, dbo.d_Retailsub.styleid, dbo.d_Retailsub.colorid, 
      dbo.d_Retailsub.sizeid, dbo.d_Retailsub.nums
ORDER BY dbo.d_Retail.depotid       ----也可以使用order by 子句
 
alter view V_YY02  --修改视图
as 
select 语句……
 
2。对于视图的限制
视图不能包含 select into 选项；
视图不能引用临时表（名字中包含#的表）或者表变量，因为这些类型的表生命周期过于短暂了；
视图不能包含compute 或者compute by 列，它只能使用标准的聚合函数和分组功能；
 
3。注意事项
将复杂的聚合查询存储为视图；
使用别名将那些含义不清的列名改为可以理解的列名；
只把用户感兴趣的列含在视图中。
通用的、动态的视图会具有较长的生命周期，也更为实用。应当支持用户可以使用where 子句，如果用户不指定where 子句，视图就应当返回全部的行；
在代码中写上静态的日期值是一种不好的开发方法，应支持用户指定值；
 
4。With Check Option 子句
  限定用户只能存取自己的数据
 
5。视图代码中可以使用ordery by 、top 等子句
 
6。保护视图
 最后有两个选项可以保护视图不受到数据模式变化的影响，并防止好事者存取它们的定义。只需在 create 命令中简单地
      加入这两个选项，就可以将它们应用于所创建的视图。
with schemabinding 将视图绑定到基础基表的架构
with encryption 对视图代码加密
第一步：先创建一个表 test
create table test
(
   nameid nvarchar(50)
)
 
第二步：我们创建一个视图绑定到基础基表的架构
create view Vd_test   --创建一个名叫Vd_test的视图
with schemabinding   ---绑定
as 
SELECT nameid FROM dbo.test  ---在绑定时，引用对象时必须指定它们的所用者（这里为 dbo）,并且不允许使用 select * 来选取全部的例
 
第三步：我们来修改一下表结构
alter table test
alter column nameid nvarchar(100)
 
------------------------------------------------------------------
服务器: 消息 5074，级别 16，状态 3，行 1  ---此时修改表结构时服务器将会报错
对象 'Vd_test' 依赖于 列 'nameid'。
服务器: 消息 4922，级别 16，状态 1，行 1
ALTER TABLE ALTER COLUMN nameid 失败，因为有一个或多个对象访问此列。
 

使用 with encryption 对视图代码加密，它会加密存放在sysComments表中的视图代码
第一步
使用下面的语句，我们可在在系统表中查到上面视图的原代码：
select text from syscomments join sysobjects  --原代码就存放在 text 列中
on sysobjects.id=syscomments.id
where name='Vd_test'     --指定视图名
返回：
  text
---------------------------------------------------------
create view Vd_test 
 with schemabinding       --返回原代码
as   SELECT nameid FROM dbo.test  
 
第二步
下面使用 with encryption 选项重建 Vd_test视图：
alter view Vd_test
with encryption
as 
select nameid from dbo.test
 
第三步
我们重新运行上面的查询语句：
select text from syscomments join sysobjects  --原代码就存放在 text 列中
on sysobjects.id=syscomments.id
where name='Vd_test'     --指定视图名
 
   text
-----------------------------------------------------------------------------------------------------
ࠌ븂吮㐚珎᜙ᣚэ閱߹ԫᤅ勥﬑剄誄堼‸嶷朘簐◐屵᪦ꆮ햵䳨즓……  --返回乱码
 
在企业管理器中查看属性也是看不到原代码的了：
  
 
必须谨慎的使用这个选项，一旦加密了视图的代码，查询分析器的对象浏览器就
不能够为更改视图生成脚本了。
 
7。可更新视图
造成人们对视图不满的一个主要原因是它们通常是不可更新的。事实上，除了用简单的
select 语句创建的视图以处，其他的视图都不能用来更新数据。
下面列出一些不可更新数据的因素：
只能对一个表更新，如果视图包含了连接操作，那引用视图的update语句必须只对其中的一个表进行修改；
视图更新问题可以在网络上去查找........
 
8。视图的性能问题
到目前为止，视图所存在的最大问题就是性能问题。对一个项目来说，与视图相关的开销是否是可以接受。
取决于视图带来的负载和调用视图的频度。如果用户常使用查看和更改数据，建议使用存储过程来取代视图。
 
9。嵌套视图
因为视图是存储的 SQL select 语句，而在 SQL select 语句中又可像引用表一样来引用视图，
这就使一个视图引用其他的视图成为可能。
 
前面我们已建立了一个视图 V_YY02 ，下面来创建一个新的视图来引用它：
create view V_YY03      --创建一个名叫V_YY03的视图
as 
select dbo.V_YY02.styleid,colorid,sizeid from dbo.V_YY02  --引用 V_YY02 视图
join j_style
on V_YY02.styleid=j_style.styleid    --连接条件
where j_style.styleid like 'B8%'     --条件
 
 
 
 

 
 介绍 (Introduction)
 
 
 In this article, we are going to see how to use the CREATE VIEW SQL statement to create a view. This is the first article in a series that will be a programmatical approach of creating, altering and working with views using T-SQL. If you are a beginner and you don’t even know what a view is, don’t worry. We will kick off with a definition, and then move on to some basics like syntax, examples, use cases, etc. 
 
 在本文中，我们将了解如何使用CREATE VIEW SQL语句创建视图。 这是本系列的第一篇文章，它将是使用T-SQL创建，更改和使用视图的编程方法。 如果您是初学者，甚至不知道视图是什么，请不要担心。 我们将从定义开始，然后继续一些基础知识，例如语法，示例，用例等。 
 
 
 A view is simply a virtual table. Think of it as just a query that is stored on SQL Server and when used by a user, it will look and act just like a table but it’s not. It is a view and does not have a definition or structure of a table. Its definition and structure is simply a query that, under the hood, can access many tables or a part of a table. 
 
 
 视图只是一个虚拟表。 可以将其视为仅存储在SQL Server上的查询，并且当用户使用它时，它的外观和作用就像表一样，但事实并非如此。 它是一个视图，没有表的定义或结构。 它的定义和结构只是一个查询，它可以在后台访问许多表或表的一部分。 
 
 
 Views can be used for a few reasons. Some of the main reasons are as follows: 
 
 
 出于某些原因，可以使用视图。 一些主要原因如下： 
 
 
 To simplify database structure to the individuals using it 
 为了简化使用它的个人的数据库结构 
 As a security mechanism to DBAs for allowing users to access data without granting them permissions to directly access the underlying base tables 
 作为DBA的安全机制，允许用户访问数据而无需授予他们直接访问基础基表的权限 
 To provide backward compatibility to applications that are using our database 
 为了向后兼容使用我们数据库的应用程序 
 
 Having said that, those reasons are a topic for designing views which we will not touch in this series. In this article, we are going to go through the CREATE VIEW SQL syntax, see what views are all about, and what we can do with them. 
 
 
 话虽如此，这些原因是设计视图的主题，在本系列中我们将不作讨论。 在本文中，我们将介绍CREATE VIEW SQL语法，查看所有视图的含义以及如何使用它们。 
 
 
 句法 (Syntax)
 
 
CREATE  OR ALTER  VIEW  schema_name.view_name
WITH <view_attribute>
AS select_statement   
[WITH CHECK OPTION]

 
 We all know how complicated syntax can get but this is not the case with views. A view can be created by saying CREATE VIEW followed by a name WITH view attributes: 
 
 
 我们都知道语法会变得多么复杂，但是视图却并非如此。 可以通过说出CREATE VIEW后跟一个具有WITH视图属性的名称来创建视图： 
 
 
ENCRYPTION – Using this attribute prevents the view from being published as part of SQL Server replication 加密 –使用此属性可防止视图作为SQL Server复制的一部分发布 
SCHEMABINDING – Binds the view to the schema of the underlying table. We will use this one in another article when indexing a view SCHEMABINDING –将视图绑定到基础表的架构。 索引视图时，我们将在另一篇文章中使用它 
VIEW_METADATA – Causes SQL Server to return to the DB-Library, ODBC, and OLE DB APIs the metadata information about the view VIEW_METADATA –使SQL Server返回DB-Library，ODBC和OLE DB API有关视图的元数据信息 
 
 After the AS, it goes the actual SELECT statement that defines the query. This is usually the bulk of a query AKA the DML statement that is going to make the view and its results. 
 
 
 在AS之后，它将进入定义查询的实际SELECT语句。 这通常是查询（即要生成视图及其结果的DML语句）的大部分。 
 
 
 The WITH CHECK OPTION is very useful when inserting data through a view. When a row is modified through a view, this option gives us control over inserted data into the table that follows the WHERE clause in the view’s definition. More about this in the upcoming article. 
 
 
 通过视图插入数据时，WITH CHECK OPTION非常有用。 通过视图修改行时，此选项使我们可以控制插入到表中的数据，该数据紧随视图定义中的WHERE子句。 在即将到来的文章中对此有更多的了解。 
 
 
 CREATE VIEW SQL语句 (CREATE VIEW SQL statement)
 
 
 Without further ado, let’s fire up SQL Server Management Studio and start working on views. Before we use the CREATE VIEW SQL statement, let’s create a new database from Object Explorer called SQLShackDB, and then create a few tables in it by running the script from below: 
 
 
 事不宜迟，让我们启动SQL Server Management Studio并开始处理视图。 在使用CREATE VIEW SQL语句之前，让我们从Object Explorer创建一个名为SQLShackDB 的新数据库 ，然后通过从下面运行该脚本在其中创建一些表： 
 
 
CREATE TABLE Employees
(EmployeeID    INT NOT NULL, 
 FirstName     NVARCHAR(50) NOT NULL, 
 MiddleName    NVARCHAR(50) NULL, 
 LastName      NVARCHAR(75) NOT NULL, 
 Title         NVARCHAR(100) NULL, 
 HireDate      DATETIME NOT NULL, 
 VacationHours SMALLINT NOT NULL, 
 Salary        DECIMAL(19, 4) NOT NULL
);
GO
CREATE TABLE Products
(ProductID INT NOT NULL, 
 Name      NVARCHAR(255) NOT NULL, 
 Price     DECIMAL(19, 4) NOT NULL
);
GO
CREATE TABLE Sales
(SalesID    UNIQUEIDENTIFIER NOT NULL, 
 ProductID  INT NOT NULL, 
 EmployeeID INT NOT NULL, 
 Quantity   SMALLINT NOT NULL, 
 SaleDate   DATETIME NOT NULL
);
GO

 
 
 

  
 
 
 
 Now, that we have our sample database with tables in it, we can create a view called vEmployeesWithSales using the script from below as an example: 
 
 
 现在，我们有了包含表的示例数据库，我们可以使用下面的脚本作为示例，创建一个名为vEmployeesWithSales的视图： 
 
 
USE SQLShackDB;
GO
CREATE VIEW vEmployeesWithSales
AS
     SELECT DISTINCT 
            Employees.*
     FROM Employees
          JOIN Sales ON Employees.EmployeeID = Sales.EmployeeID;
GO

 
 This is a simple view with a simple SELECT statement that returns a list of employees that have a sale. As a matter of fact, you can always test the query before creating the view by executing only the SELECT part of the CREATE VIEW SQL statement and it’s a good idea to see if the query will return something. Make sure that you are connected to the appropriate database first, then mark the SELECT part of the code, and hit Execute: 
 
 
 这是带有简单SELECT语句的简单视图，该语句返回具有销售记录的雇员的列表。 实际上，您始终可以通过仅执行CREATE VIEW SQL语句的SELECT部分​​来在创建视图之前测试查询，这是个好主意，看看查询是否会返回某些内容。 确保首先连接到适当的数据库，然后标记代码的SELECT部分​​，然后单击Execute ： 
 
 
 
 

  
 
 
 
 The query returns no result because we don’t actually have any data in our new tables, but you can see the list of columns that returned. The next thing we can do is insert some data into tables. To do this, use the following script: 
 
 该查询未返回任何结果，因为新表中实际上没有任何数据，但是您可以看到返回的列的列表。 我们可以做的下一件事是将一些数据插入表中。 为此，请使用以下脚本： 
 
 
USE SQLShackDB;
GO
    
INSERT INTO Employees SELECT 1, 'Ken', NULL, 'Sánchez', 'Sales Representative', '1/1/2016', 2080, 45000;
INSERT INTO Employees SELECT 2, 'Janice', NULL, 'Galvin', 'Sales Representative', '12/11/2016', 2080, 45000;
    
INSERT INTO Products SELECT 1, 'Long-Sleeve Logo Jersey, S', 12.99;
INSERT INTO Products SELECT 2, 'Long-Sleeve Logo Jersey, M', 14.99;
INSERT INTO Products SELECT 3, 'Long-Sleeve Logo Jersey, L', 16.99;
INSERT INTO Products SELECT 4, 'Long-Sleeve Logo Jersey, XL', 18.99;
    
INSERT INTO Sales SELECT NEWID(), 1, 1, 4, '04/15/2016';
INSERT INTO Sales SELECT NEWID(), 2, 1, 1, '02/01/2016';
INSERT INTO Sales SELECT NEWID(), 3, 1, 2, '03/12/2016';
INSERT INTO Sales SELECT NEWID(), 2, 2, 2, '03/18/2016';
INSERT INTO Sales SELECT NEWID(), 3, 2, 1, '04/16/2016';
INSERT INTO Sales SELECT NEWID(), 4, 2, 2, '04/23/2016';

 
 Just to make sure that data is inserted into our tables successfully, re-execute the SELECT part of the CREATE VIEW SQL statement and it should return the following: 
 
 
 为了确保将数据成功插入到我们的表中，请重新执行CREATE VIEW SQL语句的SELECT部分​​，它应该返回以下内容： 
 
 
 
 

  
 
 
 
 Note that we are using the DISTINCT with SELECT to prevent the retrieval of duplicate records because both employees have multiple records. 
 
 
 请注意，由于两个雇员都有多个记录，因此我们将DISTINCT与SELECT一起使用以防止检索重复记录。 
 
 
 Let’s get back to our view and see how it looks in our database. If we head over to Object Explorer and expand the Views folder under our demo database, we will find our view that looks exactly like a table because it has columns in it: 
 
 
 让我们回到视图，看看它在数据库中的外观。 如果我们转到对象资源管理器并展开我们的演示数据库下的“ 视图”文件夹，我们会发现我们的视图看上去完全像一个表，因为其中包含列： 
 
 
 
 

  
 
 
 
 These are all columns that this view will return. Let’s see what happens if we treat this view as a table. Write a SELECT statement but instead of saying select everything from and then the name of a table, we will simply say from a view: 
 
 
 这些都是该视图将返回的所有列。 让我们看看如果将此视图视为表格会发生什么。 编写SELECT语句，而不是说先从中选择所有内容，然后再选择表名，我们将仅从视图中说出： 
 
 
SELECT * FROM vEmployeesWithSales

 
 
 

  
 
 
 
 As can be seen from the figure above, the result is exactly the same as when querying data using actual tables. 
 
 
 从上图可以看出，结果与使用实际表查询数据时完全相同。 
 
 
 Like any other object in SQL Server, views have properties too. In Object Explorer, right-click any view of which you want to view the properties and select Properties: 
 
 
 像SQL Server中的任何其他对象一样，视图也具有属性。 在对象资源管理器中 ，右键单击要查看其属性的任何视图，然后选择“ 属性” ： 
 
 
 
 

  
 
 
 
 Notice that here you can see the actual options that the view was created with to understand how its data is derived from the actual tables: 
 
 
 注意，在这里您可以看到创建视图的实际选项，以了解其数据是如何从实际表中派生的： 
 
 
ANSI NULLs – It indicates if the object was created with the ANSI NULLs option ANSI NULL –指示是否使用ANSI NULLs选项创建对象 
Encrypted – Specifies whether the view is encrypted 已加密 –指定视图是否已加密 
Quoted identifier – Shows if the object was created with the quoted identifier option 带引号的标识符 –显示是否使用带引号的标识符选项创建对象 
Schema bound – Designates whether the view is schema-bound 架构绑定 –指定视图是否绑定架构 
 
For detailed information about view’s definition and properties, see Get Information About a View 
 有关视图的定义和属性的详细信息，请参阅 获取 有关视图的 信息。  
 
 结论 (Conclusion)
 
 
 In this article, the goal was only to get familiar with the CREATE VIEW SQL statement syntax and creating a basic view. Moving on to a bit more complex stuff like creating a view with aggregates in it will be the focus in the next article. In other words, we are going to use the DLM language (Data Manipulation Language) and write some more advance SELECT queries. 
 
 
 在本文中，目标只是熟悉CREATE VIEW SQL语句语法并创建基本视图。 下一篇文章将重点介绍更复杂的内容，例如创建带有聚合的视图。 换句话说，我们将使用DLM语言（数据操作语言）并编写一些更高级的SELECT查询。 
 
 
 I hope this article on CREATE VIEW SQL statement has been informative for you and I thank you for reading it. Stay tuned for the next one… 
 
 
 我希望有关CREATE VIEW SQL语句的这篇文章对您有所帮助，也感谢您阅读本文。 请继续关注下一个… 
 
 
 目录 (Table of contents)
 
 
CREATE VIEW SQL: Creating views in SQL Server
CREATE VIEW SQL: Modifying views in SQL Server
CREATE VIEW SQL: Inserting data through views in SQL Server
CREATE VIEW SQL: Working with indexed views in SQL Server
 
 
 创建视图SQL：在SQL Server中创建视图 
 创建视图SQL：在SQL Server中修改视图 
 CREATE VIEW SQL：通过SQL Server中的视图插入数据 
 CREATE VIEW SQL：在SQL Server中使用索引视图 
 
 

  
翻译自: https://www.sqlshack.com/create-view-sql-creating-views-in-sql-server/
 

视图的好处，可以主要分为四点：   

 
  

 
    

 
  第一点：   

 
  使用视图，可以定制用户数据，聚焦特定的数据。   

 
    

 
  解释：   

 
  在实际过程中，公司有不同角色的工作人员，我们以销售公司为例的话，   

 
  采购人员，可以需要一些与其有关的数据，而与他无关的数据，对他没   

 
  有任何意义，我们可以根据这一实际情况，专门为采购人员创建一个视   

 
  图，以后他在查询数据时，只需select   *   from   view_caigou   就可以啦。   

 
    

 
  第二点：使用视图，可以简化数据操作。   

 
    

 
  解释：我们在使用查询时，在很多时候我们要使用聚合函数，同时还要   

 
  显示其它字段的信息，可能还会需要关联到其它表，这时写的语句可能   

 
  会很长，如果这个动作频繁发生的话，我们可以创建视图，这以后，我   

 
  们只需要select   *   from   view1就可以啦～，是不是很方便呀～   

 
    

 
  第三点：使用视图，基表中的数据就有了一定的安全性   

 
    

 
  因为视图是虚拟的，物理上是不存在的，只是存储了数据的集合，我们可以   

 
  将基表中重要的字段信息，可以不通过视图给用户，视图是动态的数据的集   

 
  合，数据是随着基表的更新而更新。同时，用户对视图，不可以随意的更改   

 
  和删除，可以保证数据的安全性。   

 
    

 
  第四点：可以合并分离的数据，创建分区视图   

 
    

 
  随着社会的发展，公司的业务量的不断的扩大，一个大公司，下属都设有很   

 
  多的分公司，为了管理方便，我们需要统一表的结构，定期查看各公司业务   

 
  情况，而分别看各个公司的数据很不方便，没有很好的可比性，如果将这些   

 
  数据合并为一个表格里，就方便多啦，这时我们就可以使用union关键字，   

 
  将各分公司的数据合并为一个视图。   

 
    

 
  以上，就是我认为视图的作用，实际上很多公司都使用视图来查询数据的。
 

 
 

 
 
 
CREATE [OR REPLACE] [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}]
 
    VIEW view_name [(column_list)]
 
    AS select_statement
 
    [WITH [CASCADED | LOCAL] CHECK OPTION]
 
 
 该语句能创建新的视图，如果给定了OR REPLACE子句，该语句还能替换已有的视图。select_statement是一种SELECT语句，它给出了视图的定义。该语句可从基表或其他视图进行选择。
 
 该语句要求具有针对视图的CREATE VIEW权限，以及针对由SELECT语句选择的每一列上的某些权限。对于在SELECT语句中其他地方使用的列，必须具有SELECT权限。如果还有OR REPLACE子句，必须在视图上具有DROP权限。
 
 视图属于数据库。在默认情况下，将在当前数据库创建新视图。要想在给定数据库中明确创建视图，创建时，应将名称指定为db_name.view_name。
 
mysql> CREATE VIEW test.v AS SELECT * FROM t;
 
 表和视图共享数据库中相同的名称空间，因此，数据库不能包含具有相同名称的表和视图。
 
 视图必须具有唯一的列名，不得有重复，就像基表那样。默认情况下，由SELECT语句检索的列名将用作视图列名。要想为视图列定义明确的名称，可使用可选的column_list子句，列出由逗号隔开的ID。column_list中的名称数目必须等于SELECT语句检索的列数。
 
 SELECT语句检索的列可以是对表列的简单引用。也可以是使用函数、常量值、操作符等的表达式。
 
 对于SELECT语句中不合格的表或视图，将根据默认的数据库进行解释。通过用恰当的数据库名称限定表或视图名，视图能够引用表或其他数据库中的视图。
 
 能够使用多种SELECT语句创建视图。视图能够引用基表或其他视图。它能使用联合、UNION和子查询。SELECT甚至不需引用任何表。在下面的示例中，定义了从另一表选择两列的视图，并给出了根据这些列计算的表达式：
 
mysql> CREATE TABLE t (qty INT, price INT);
 
mysql> INSERT INTO t VALUES(3, 50);
 
mysql> CREATE VIEW v AS SELECT qty, price, qty*price AS value FROM t;
 
mysql> SELECT * FROM v;
 
+------+-------+-------+
 
| qty  | price | value |
 
+------+-------+-------+
 
|    3 |    50 |   150 |
 
+------+-------+-------+
 
 视图定义服从下述限制：
 
 ·         SELECT语句不能包含FROM子句中的子查询。
 
 ·         SELECT语句不能引用系统或用户变量。
 
 ·         SELECT语句不能引用预处理语句参数。
 
 ·         在存储子程序内，定义不能引用子程序参数或局部变量。
 
 ·         在定义中引用的表或视图必须存在。但是，创建了视图后，能够舍弃定义引用的表或视图。要想检查视图定义是否存在这类问题，可使用CHECK TABLE语句。
 
 ·         在定义中不能引用TEMPORARY表，不能创建TEMPORARY视图。
 
 ·         在视图定义中命名的表必须已存在。
 
 ·         不能将触发程序与视图关联在一起。
 
 在视图定义中允许使用ORDER BY，但是，如果从特定视图进行了选择，而该视图使用了具有自己ORDER BY的语句，它将被忽略。
 
 对于定义中的其他选项或子句，它们将被增加到引用视图的语句的选项或子句中，但效果未定义。例如，如果在视图定义中包含LIMIT子句，而且从特定视图进行了选择，而该视图使用了具有自己LIMIT子句的语句，那么对使用哪个LIMIT未作定义。相同的原理也适用于其他选项，如跟在SELECT关键字后的ALL、DISTINCT或SQL_SMALL_RESULT，并适用于其他子句，如INTO、FOR UPDATE、LOCK IN SHARE MODE、以及PROCEDURE。
 
 如果创建了视图，并通过更改系统变量更改了查询处理环境，会影响从视图获得的结果：
 
mysql> CREATE VIEW v AS SELECT CHARSET(CHAR(65)), COLLATION(CHAR(65));
 
Query OK, 0 rows affected (0.00 sec)
 
 
 
mysql> SET NAMES 'latin1';
 
Query OK, 0 rows affected (0.00 sec)
 
 
 
mysql> SELECT * FROM v;
 
+-------------------+---------------------+
 
| CHARSET(CHAR(65)) | COLLATION(CHAR(65)) |
 
+-------------------+---------------------+
 
| latin1            | latin1_swedish_ci   |
 
+-------------------+---------------------+
 
1 row in set (0.00 sec)
 
 
 
mysql> SET NAMES 'utf8';
 
Query OK, 0 rows affected (0.00 sec)
 
 
 
mysql> SELECT * FROM v;
 
+-------------------+---------------------+
 
| CHARSET(CHAR(65)) | COLLATION(CHAR(65)) |
 
+-------------------+---------------------+
 
| utf8              | utf8_general_ci     |
 
+-------------------+---------------------+
 
1 row in set (0.00 sec)
 
 可选的ALGORITHM子句是对标准SQL的MySQL扩展。ALGORITHM可取三个值：MERGE、TEMPTABLE或UNDEFINED。如果没有ALGORITHM子句，默认算法是UNDEFINED（未定义的）。算法会影响MySQL处理视图的方式。
 
 对于MERGE，会将引用视图的语句的文本与视图定义合并起来，使得视图定义的某一部分取代语句的对应部分。
 
 对于TEMPTABLE，视图的结果将被置于临时表中，然后使用它执行语句。
 
 对于UNDEFINED，MySQL将选择所要使用的算法。如果可能，它倾向于MERGE而不是TEMPTABLE，这是因为MERGE通常更有效，而且如果使用了临时表，视图是不可更新的。
 
 明确选择TEMPTABLE的1个原因在于，创建临时表之后、并在完成语句处理之前，能够释放基表上的锁定。与MERGE算法相比，锁定释放的速度更快，这样，使用视图的其他客户端不会被屏蔽过长时间。
 
 视图算法可以是UNDEFINED，有三种方式：
 
 ·         在CREATE VIEW语句中没有ALGORITHM子句。
 
 ·         CREATE VIEW语句有1个显式ALGORITHM = UNDEFINED子句。
 
 ·         为仅能用临时表处理的视图指定ALGORITHM = MERGE。在这种情况下，MySQL将生成告警，并将算法设置为UNDEFINED。
 
 正如前面所介绍的那样，通过将视图定义中的对应部分合并到引用视图的语句中，对MERGE进行处理。在下面的示例中，简要介绍了MERGE的工作方式。在该示例中，假定有1个具有下述定义的视图v_merge：
 
CREATE ALGORITHM = MERGE VIEW v_merge (vc1, vc2) AS
 
SELECT c1, c2 FROM t WHERE c3 > 100;
 
 示例1：假定发出了下述语句：
 
SELECT * FROM v_merge;
 
 MySQL以下述方式处理语句：
 
 ·         v_merge成为t
 
 ·         *成为vc1、vc2，与c1、c2对应
 
 ·         增加视图WHERE子句
 
 所产生的将执行的语句为：
 
SELECT c1, c2 FROM t WHERE c3 > 100;
 
 示例2：假定发出了下述语句：
 
SELECT * FROM v_merge WHERE vc1 < 100;
 
 该语句的处理方式与前面介绍的类似，但vc1 < 100变为c1 < 100，并使用AND连接词将视图的WHERE子句添加到语句的WHERE子句中（增加了圆括号以确保以正确的优先顺序执行子句部分）。所得的将要执行的语句变为：
 
SELECT c1, c2 FROM t WHERE (c3 > 100) AND (c1 < 100);
 
 事实上，将要执行的语句是具有下述形式的WHERE子句：
 
WHERE (select WHERE) AND (view WHERE)
 
 MERGE算法要求视图中的行和基表中的行具有一对一的关系。如果不具有该关系。必须使用临时表取而代之。如果视图包含下述结构中的任何一种，将失去一对一的关系：
 
 ·         聚合函数（SUM(), MIN(), MAX(), COUNT()等）。
 
 ·         DISTINCT
 
 ·         GROUP BY
 
 ·         HAVING
 
 ·         UNION或UNION ALL
 
 ·         仅引用文字值（在该情况下，没有基本表）。
 
 某些视图是可更新的。也就是说，可以在诸如UPDATE、DELETE或INSERT等语句中使用它们，以更新基表的内容。对于可更新的视图，在视图中的行和基表中的行之间必须具有一对一的关系。还有一些特定的其他结构，这类结构会使得视图不可更新。更具体地讲，如果视图包含下述结构中的任何一种，那么它就是不可更新的：
 
 ·         聚合函数（SUM(), MIN(), MAX(), COUNT()等）。
 
 ·         DISTINCT
 
 ·         GROUP BY
 
 ·         HAVING
 
 ·         UNION或UNION ALL
 
 ·         位于选择列表中的子查询
 
 ·         Join
 
 ·         FROM子句中的不可更新视图
 
 ·         WHERE子句中的子查询，引用FROM子句中的表。
 
 ·         仅引用文字值（在该情况下，没有要更新的基本表）。
 
 ·         ALGORITHM = TEMPTABLE（使用临时表总会使视图成为不可更新的）。
 
 关于可插入性（可用INSERT语句更新），如果它也满足关于视图列的下述额外要求，可更新的视图也是可插入的：
 
 ·         不得有重复的视图列名称。
 
 ·         视图必须包含没有默认值的基表中的所有列。
 
 ·         视图列必须是简单的列引用而不是导出列。导出列不是简单的列引用，而是从表达式导出的。下面给出了一些导出列示例：
 
·                3.14159
 
·                col1 + 3
 
·                UPPER(col2)
 
·                col3 / col4
 
·                (subquery)
 
 混合了简单列引用和导出列的视图是不可插入的，但是，如果仅更新非导出列，视图是可更新的。考虑下述视图：
 
CREATE VIEW v AS SELECT col1, 1 AS col2 FROM t;
 
 该视图是不可插入的，这是因为col2是从表达式导出的。但是，如果更新时不更新col2，它是可更新的。这类更新是允许的：
 
UPDATE v SET col1 = 0;
 
 下述更新是不允许的，原因在于，它试图更新导出列：
 
UPDATE v SET col2 = 0;
 
 在某些情况下，能够更新多表视图，假定它能使用MERGE算法进行处理。为此，视图必须使用内部联合（而不是外部联合或UNION）。此外，仅能更新视图定义中的单个表，因此，SET子句必须仅命名视图中某一表的列。即使从理论上讲也是可更新的，不允许使用UNION ALL的视图，这是因为，在实施中将使用临时表来处理它们。
 
 对于多表可更新视图，如果是将其插入单个表中，INSERT能够工作。不支持DELETE。
 
 对于可更新视图，可给定WITH CHECK OPTION子句来防止插入或更新行，除非作用在行上的select_statement中的WHERE子句为“真”。
 
 在关于可更新视图的WITH CHECK OPTION子句中，当视图是根据另一个视图定义的时，LOCAL和CASCADED关键字决定了检查测试的范围。LOCAL关键字对CHECK OPTION进行了限制，使其仅作用在定义的视图上，CASCADED会对将进行评估的基表进行检查。如果未给定任一关键字，默认值为CASCADED。请考虑下述表和视图集合的定义：
 
mysql> CREATE TABLE t1 (a INT);
 
mysql> CREATE VIEW v1 AS SELECT * FROM t1 WHERE a < 2
 
    -> WITH CHECK OPTION;
 
mysql> CREATE VIEW v2 AS SELECT * FROM v1 WHERE a > 0
 
    -> WITH LOCAL CHECK OPTION;
 
mysql> CREATE VIEW v3 AS SELECT * FROM v1 WHERE a > 0
 
    -> WITH CASCADED CHECK OPTION;
 
 这里，视图v2和v3是根据另一视图v1定义的。v2具有LOCAL检查选项，因此，仅会针对v2检查对插入项进行测试。v3具有CASCADED检查选项，因此，不仅会针对它自己的检查对插入项进行测试，也会针对基本视图的检查对插入项进行测试。在下面的语句中，介绍了这些差异：
 
ql> INSERT INTO v2 VALUES (2);
 
Query OK, 1 row affected (0.00 sec)
 
mysql> INSERT INTO v3 VALUES (2);
 
ERROR 1369 (HY000): CHECK OPTION failed 'test.v3'  
 

视图定义
 
视图是一个虚拟的表，是一个表中的数据经过某种筛选后的显示方式，视图由一个预定义的查询select语句组成。
 
使用SSMS数据库管理工具创建视图
 
1、连接数据库，选择数据库，展开数据库-》右键视图-》选择新建视图。
 
 
2、在添加表弹出框-》选择要创建视图的表、视图、函数、或者同义词等-》点击添加-》添加完成后选择关闭。
 
 
3、在关系图窗格中-》选择表与表之间关联的数据列-》选择列的其他排序或筛选条件。
 
 
4、点击保存或者ctrl+s-》刷新视图-》查看结果。
 
 
5、使用视图。
 
 
使用T-SQL脚本创建视图
 
语法：
 
--声明数据库引用
 use 数据库名;
 go
 
--判断视图是否存在，如果存在则删除
 if exists(select * from sys.views where name=视图名称)
 drop view 视图名称;
 go
 
--创建视图
 create
 view
 
--视图所属架构的名称。
 --[schema_name][.]
 
--视图名称。 视图名称必须符合有关标识符的规则。 可以选择是否指定视图所有者名称。
 [dbo][.]视图名称
 
--视图中的列使用的名称。 仅在下列情况下需要列名：列是从算术表达式、函数或常量派生的；两个或更多的列可能会具有相同的名称（通常是由于联接的原因）；视图中的某个列的指定名称不同于其派生来源列的名称。 还可以在 SELECT 语句中分配列名。
 --如果未指定 column，则视图列将获得与 SELECT 语句中的列相同的名称。
 --[column]
 
[with]
 
--适用范围： SQL Server 2008 到 SQL Server 2017 和 Azure SQL Database。
 --对 sys.syscomments 表中包含 CREATE VIEW 语句文本的项进行加密。 使用 WITH ENCRYPTION 可防止在 SQL Server 复制过程中发布视图。
 [encryption][,]
 
--将视图绑定到基础表的架构。 如果指定了 SCHEMABINDING，则不能按照将影响视图定义的方式修改基表或表。 必须首先修改或删除视图定义本身，才能删除将要修改的表的依赖关系。
 --使用 SCHEMABINDING 时，select_statement 必须包含所引用的表、视图或用户定义函数的两部分名称 (schema.object)。 所有被引用对象都必须在同一个数据库内。
 --不能删除参与了使用 SCHEMABINDING 子句创建的视图的视图或表，除非该视图已被删除或更改而不再具有架构绑定。 否则， 数据库引擎将引发错误。 
 --另外，如果对参与具有架构绑定的视图的表执行 ALTER TABLE 语句，而这些语句又会影响视图定义，则这些语句将会失败。
 [schemabinding][,]
 
--指定为引用视图的查询请求浏览模式的元数据时， SQL Server 实例将向 DB-Library、ODBC 和 OLE DB API 返回有关视图的元数据信息，而不返回基表的元数据信息。 
 --浏览模式元数据是 SQL Server 实例向这些客户端 API 返回的附加元数据。 如果使用此元数据，客户端 API 将可以实现可更新客户端游标。 浏览模式的元数据包含结果集中的列所属的基表的相关信息。
 --对于使用 VIEW_METADATA 创建的视图，浏览模式的元数据在描述结果集内视图中的列时，将返回视图名，而不返回基表名。
 --当使用 WITH VIEW_METADATA 创建视图时，如果该视图具有 INSTEAD OF INSERT 或 INSTEAD OF UPDATE 触发器，则视图的所有列（timestamp 列除外）都可更新。 有关可更新视图的详细信息，请参阅“备注”。
 [view_metadata]
 
--指定视图要执行的操作。
 as
 select_statement
 go
 
示例：
 
--声明数据库引用
 use testss;
 go
 
--判断视图是否存在，如果存在则删除
 if exists(select * from sys.views where name='view1')
 drop view view1;
 go
 
--创建视图
 create
 view
 
--视图所属架构的名称。
 --[schema_name][.]
 
--视图名称。 视图名称必须符合有关标识符的规则。 可以选择是否指定视图所有者名称。
 dbo.view1
 
--视图中的列使用的名称。 仅在下列情况下需要列名：列是从算术表达式、函数或常量派生的；两个或更多的列可能会具有相同的名称（通常是由于联接的原因）；视图中的某个列的指定名称不同于其派生来源列的名称。 还可以在 SELECT 语句中分配列名。
 --如果未指定 column，则视图列将获得与 SELECT 语句中的列相同的名称。
 --column
 
--with
 
--适用范围： SQL Server 2008 到 SQL Server 2017 和 Azure SQL Database。
 --对 sys.syscomments 表中包含 CREATE VIEW 语句文本的项进行加密。 使用 WITH ENCRYPTION 可防止在 SQL Server 复制过程中发布视图。
 --encryption,
 
--将视图绑定到基础表的架构。 如果指定了 SCHEMABINDING，则不能按照将影响视图定义的方式修改基表或表。 必须首先修改或删除视图定义本身，才能删除将要修改的表的依赖关系。
 --使用 SCHEMABINDING 时，select_statement 必须包含所引用的表、视图或用户定义函数的两部分名称 (schema.object)。 所有被引用对象都必须在同一个数据库内。
 --不能删除参与了使用 SCHEMABINDING 子句创建的视图的视图或表，除非该视图已被删除或更改而不再具有架构绑定。 否则， 数据库引擎将引发错误。 
 --另外，如果对参与具有架构绑定的视图的表执行 ALTER TABLE 语句，而这些语句又会影响视图定义，则这些语句将会失败。
 --schemabinding,
 
--指定为引用视图的查询请求浏览模式的元数据时， SQL Server 实例将向 DB-Library、ODBC 和 OLE DB API 返回有关视图的元数据信息，而不返回基表的元数据信息。 
 --浏览模式元数据是 SQL Server 实例向这些客户端 API 返回的附加元数据。 如果使用此元数据，客户端 API 将可以实现可更新客户端游标。 浏览模式的元数据包含结果集中的列所属的基表的相关信息。
 --对于使用 VIEW_METADATA 创建的视图，浏览模式的元数据在描述结果集内视图中的列时，将返回视图名，而不返回基表名。
 --当使用 WITH VIEW_METADATA 创建视图时，如果该视图具有 INSTEAD OF INSERT 或 INSTEAD OF UPDATE 触发器，则视图的所有列（timestamp 列除外）都可更新。 有关可更新视图的详细信息，请参阅“备注”。
 --view_metadata
 
--指定视图要执行的操作。
 as
 select top(10000) a.id,a.age,a.height,a.name,b.id as classid from dbo.test1 as a
 inner join dbo.test3 as b on a.classid=b.id
 where a.classid<=100 
 order by a.id
 --要求对该视图执行的所有数据修改语句都必须符合 select_statement 中所设置的条件。 通过视图修改行时，WITH CHECK OPTION 可确保提交修改后，仍可通过视图看到数据。
 --with check option;
 go
 
示例结果：