精华内容
下载资源
问答
  • 解决的方案sql索引的建立的问题


    解决的方案


    sql索引的建立的问题








    展开全文
  • T-SQL动态查询(4)——动态SQL

    万次阅读 2015-12-09 09:38:17
    接上文:T-SQL动态查询(3)——静态SQL 前言: 前面说了很多关于动态查询的内容,本文将介绍使用动态SQL解决动态查询的...动态SQL尤其自己的优缺点,是否使用需要进行评估分析:动态SQL优点:动态SQL提供了强大的扩


    接上文:T-SQL动态查询(3)——静态SQL

     

    前言:


    前面说了很多关于动态查询的内容,本文将介绍使用动态SQL解决动态查询的一些方法。

     

    为什么使用动态SQL:


    在很多项目中,动态SQL被广泛使用甚至滥用,很多时候,动态SQL又确实是解决很多需求的首选方法。但是如果不合理地使用,会导致性能问题及无法维护。动态SQL尤其自己的优缺点,是否使用需要进行评估分析:

    本文出处:http://blog.csdn.net/dba_huangzj/article/details/50202371

    动态SQL优点:

    • 动态SQL提供了强大的扩展功能,能够应付复杂的需求,即使在需求增加时也能应对,并且不会因为需求的增加而导致代码的线性增长。
    • 执行计划可以缓存查询字符串,意味着大部分查询条件可以重用执行计划缓存而不会导致不必要的重编译。

    动态SQL缺点:

    • 不合理的编码会导致代码的维护陷入困境。
    • 动态SQL是用于应对较高级的问题,对于简单问题,会变得大材小用。
    •  动态SQL的测试显然比其他代码困难,特别是对最终执行的语句的获取,同时容易因为编码的不规范导致语法错误。
    • 相对于前面的OPTION(RECOMPILE),动态SQL需要加入对权限控制的考虑。
    • 动态SQL的计划缓存并不总是你想象的那样,有时候因为输入的参数值而导致不同的计划生成。

    静态SQL其实可以应对大部分的日常需求,但是随着需求的增加,静态SQL会变得越来越复杂,同时可能带来过多的重编译,此时应该考虑动态SQL。

     

    动态SQL简介:


    概述:


    在SQL Server中,动态SQL可以由三种方式实现:

    1. T-SQL存储过程
    2. CLR存储过程
    3. 客户端语句

    本文着重介绍T-SQL中的存储过程。针对用户的输入,有两种方式进行处理:

    • 把参数通过字符串拼接实现,如:' AND col = ' + convert(varchar, @value)'
    • 使用sp_executesql进行参数化查询,可以把上面的参数变成:' AND col = @value'

    基于很多理由,在日常使用中,推荐使用第二种方法也就是sp_executesql。但是需要提醒的是上面提到的三种实现动态SQL的方式没有本质上的好和坏,只有根据实际情况而定才是最有效的。本文将使用静态SQL篇中的需求作为演示,即针对不同的查询条件、不同的排序甚至不同的汇总需求演示。

     本文出处:http://blog.csdn.net/dba_huangzj/article/details/50202371

    权限:


    对于存储过程中使用静态SQL,权限问题并无大碍。只要存储过程的调用者和表的拥有者是相同的,由于所有权链(ownership chaining,https://msdn.microsoft.com/zh-cn/library/ms188676.aspx),可以无障碍地执行存储过程。但是动态SQL中不存在所有权链,即使把它们放在存储过程中也一样,因为动态SQL有自己的权限范围。

    如果在客户端程序或CLR存储过程中创建动态SQL,还需要额外授予用户具有查询中涉及到的表、视图、自定义函数上的SELECT权限。根据客户端程序和CLR存储过程的不同,权限链可能会非常混乱和失控。但是可以使用下面两种方式来应付:

    1. 创建一个证书,对存储过程使用这个证书进行签名。然后使用证书创建一个用户,并由于用户所需的SELECT权限。
    2. 在存储过程中添加EXECUTE AS ‘用户’。然后授予SELECT权限。

     

    动态SQL的参数化查询形式:


    本部分使用第一篇中提到的模版进行改造演示,为了能清晰地描述,使用博客自带的行号来标号:

    USE [AdventureWorks2008R2]																		
    GO                                                                                              
    CREATE PROCEDURE [dbo].[sp_Get_orders]                                                          
         @salesorderid    int           = NULL,                                                     
         @fromdate        datetime      = NULL,                                                     
         @todate          datetime      = NULL,                                                     
         @minprice        money         = NULL,                                                     
         @maxprice        money         = NULL,                                                     
         @custid          int           = NULL,                                                     
         @custname        nvarchar(40)  = NULL,                                                     
         @prodid          int           = NULL,                                                     
         @prodname        nvarchar(40)  = NULL,                                                     
         @employeestr     varchar(MAX)  = NULL,                                                     
         @employeetbl     intlist_tbltypeREADONLY,                                                  
         @debug           bit           =0                                                          
    AS                                                                                              
                                                                                                    
        DECLARE @sql        nvarchar(MAX),                                                          
               @paramlist  nvarchar(4000),                                                          
               @nl         char(2) = char(13) + char(10)                                            
                                                                                                    
        SELECT @sql='                                                                               
           SELECT o.SalesOrderID, o.OrderDate, od.UnitPrice,od.OrderQty,                            
                 c.CustomerID, per.FirstName as CustomerName,p.ProductID,                           
                 p.Name as ProductName, per.BusinessEntityID as EmpolyeeID                          
           FROM  Sales.SalesOrderHeader o                                                           
           INNER JOIN   Sales.SalesOrderDetail od ON o.SalesOrderID= od.SalesOrderID                
           INNER JOIN   Sales.Customer c ON o.CustomerID =c.CustomerID                              
           INNER JOIN   Person.Person per onc.PersonID=per.BusinessEntityID                         
           INNER JOIN   Production.Product p ON p.ProductID =od.ProductID                           
           WHERE 1=1'+@nl                                                                           
                                                                                                    
        IF @salesorderidIS NOT NULL                                                                 
           SELECT @sql+= ' AND o.SalesOrderID=@SalesOrderID'+                                       
                         ' ANDod.SalesOrderID=@SalesOrderID'+@nl                                    
                                                                                                    
        IF @fromdateIS NOT NULL                                                                     
           SELECT @sql+= ' AND o.OrderDate >= @fromdate'+@nl                                        
                                                                                                    
        IF @todateIS NOT NULL                                                                       
           SELECT @sql+= ' AND o.OrderDate <= @todate'+@nl                                          
                                                                                                    
        IF @minpriceIS NOT NULL                                                                     
           SELECT @sql += 'AND od.UnitPrice >= @minprice' + @nl                                     
                                                                                                    
        IF @maxpriceIS NOT NULL                                                                     
           SELECT @sql += 'AND od.UnitPrice <= @maxprice' + @nl                                     
                                                                                                    
        IF @custidIS NOT NULL                                                                       
           SELECT @sql += 'AND o.CustomerID = @custid' +                                            
                        ' AND c.CustomerID = @custid' +@nl                                          
                                                                                                    
        IF @custnameIS NOT NULL                                                                     
            SELECT@sql += ' AND per.FirstName LIKE @custname + ''%''' + @nl                         
                                                                                                    
        IF @prodidIS NOT NULL                                                                       
           SELECT@sql += ' AND od.ProductID = @prodid' +                                            
                        ' AND p.ProductID = @prodid' +@nl                                           
                                                                                                    
        IF @prodnameIS NOT NULL                                                                     
           SELECT@sql += ' AND p.Name LIKE @prodname + ''%''' + @nl                                 
                                                                                                    
        IF @employeestrIS NOT NULL                                                                  
           SELECT@sql += ' AND per.BusinessEntityID IN' +                                           
                        ' (SELECT number FROM dbo.intlist_to_tbl(@employeestr))'+ @nl               
                                                                                                    
        IF EXISTS(SELECT * FROM @employeetbl)                                                       
           SELECT@sql += ' AND per.BusinessEntityID IN (SELECT val FROM @employeetbl)'+ @nl         
                                                                                                    
        SELECT @sql+= ' ORDER BYo.SalesOrderID' + @nl                                               
                                                                                                    
        IF @debug= 1                                                                                
           PRINT @sql                                                                               
                                                                                                    
        SELECT @paramlist=  '@salesorderid    int,                                                  
                          @fromdate   datetime,                                                     
                          @todate     datetime,                                                     
                          @minprice   money,                                                        
                          @maxprice   money,                                                        
                          @custid     nchar(5),                                                     
                          @custname   nvarchar(40),                                                 
                          @prodid     int,                                                          
                          @prodname   nvarchar(40),                                                 
                          @employeestr varchar(MAX),                                                
                          @employeetbl intlist_tbltype READONLY'                                    
                                                                                                    
        EXEC sp_executesql@sql, @paramlist,@salesorderid, @fromdate, @todate, @minprice,            
                       @maxprice,  @custid, @custname,@prodid, @prodname, @employeestr, @employeetbl


     

    代码分析:


    在上面代码中的第18行,定义了一个变量@sql,用于存储查询字符串。由于sp_executesql要求参数必须为NVARCHAR,所以这里使用NVARCHAR(MAX),以便足够存放所有最终字符串。

    在第20行,使用了一个变量@nl,通过赋值char(13)+char(10)实现Windows上的换行符功能。虽然它是变量,但是在存储过程中实际上是一个常量。

    在第22 到31行,包含了动态SQL的核心部分,并存放在@sql变量中。通过后续的参数拼接实现整个动态SQL查询。注意代码中均使用了两部命名(即架构名.表名),因为由于性能原因,SQL Server在编译和优化时需要精确定位对象,如果表A存在dbo.A和Sales.A这两个架构名,那么SQL Server需要花时间去判断究竟使用的是哪个表,这会带来不小的开销,注意,即使只有几十毫秒,但是对于一个频繁被执行的存储过程或语句,整体性能会被明显拉低,所以不管基于性能还是编程规范的考虑,都应该带上架构名,当然如果你的系统只有dbo这个默认架构,不带也行,但是建议还是要规范化编程提高可读性和可维护性。这里再插一句,在本人优化的代码中,经常看到很多语句中,表名使用了别名,但是在ON、WHERE中又没有带上别名前缀,咋一看上去很难知道字段来自于哪个表,要一个一个相关表去检查,花了不该花的时间,为了维护代码的人,你们就行行好吧。

    在第31行是一句“WHERE 1=1”,类似编程语言中的占位符,使WHERE语句即使单独存在也不会报错,下面会介绍为什么也要加上@nl。

    在第33行开始,针对所有单值查询参数进行检查,如果参数不为NULL,则添加到最终的SQL字符串的对应列中。从这里开始就要注意对单引号、双引号的使用,同时留意在每次拼接后面都加上了@nl。

    在第67 行,对@employeestr参数进行处理,处理方式和上一篇静态SQL一样。其他剩余部分相对简单,不做过多解释。

    在第72行,添加了一个参数@debug,默认为0,当用户调用传入1时,输出SQL字符串,这在调试和检查错误时非常有用,因为动态SQL往往很难直接从代码中看出最终语句,如果在开发过程没有注意引号、空格、类型转换等问题时,都会在后续调用过程中报错。通过@debug参数,可以在未执行语句(即还不至于报错停止之前)就把需要执行的语句打印出来,注意顺序很重要,如果在执行报错后你再想打印就不一定能打印出来了。

    对于几乎每行后面都添加的@nl,当然是有意图的,如果不加换行符,代码可能会变成单行很长的字符串,print出来不直观。甚至看起来很痛苦,虽然现在有格式化工具,但是不是每次都破解成功,对单串字符串的美化还是比较浪费时间的。

    最后,通过sp_executesql执行SQL字符串,这是一个系统存储过程,需要提供两个固定参数,第一个是SQL字符串,第二个是参数列。这些参数必须是nvarchar类型。在这个例子中,调用语句在存储过程内部。你也可以在外部调用存储过程。但是需要记住的是动态SQL不能得知任何调用参数。

    注意存储过程最后的参数列@paramlist,是静态的,也就是参数集是固定的,即使有些参数并不是每次都会使用到。

     

    测试:

    可以使用下面语句对存储过程进行测试:

    EXEC [sp_Get_orders]@salesorderid = 70467
    EXEC [sp_Get_orders]@custid  = 30097
    EXEC [sp_Get_orders]@prodid  = 936
    EXEC [sp_Get_orders]@prodid  = 936, @custname = 'Carol'
    EXEC [sp_Get_orders]@fromdate = '2007-11-01 00:00:00.000', @todate = '2008-04-18 00:00:00.000'
    EXEC [sp_Get_orders]@employeestr = '20124,759,1865', @custid = 29688
     
    DECLARE @tbl intlist_tbltype
    INSERT @tbl(val) VALUES(20124),(759),(1865)
    EXEC [sp_Get_orders]@employeetbl = @tbl, @custid = 29688
    对于这类情况,需要对所有参数进行测试,最好是能知道实际使用中哪些参数的使用频率最高。
    本文出处:http://blog.csdn.net/dba_huangzj/article/details/50202371

    动态SQL的编译和缓存:


    每当用户以相同查询参数集进行调用这个存储过程时,执行计划会被重用。如果调用上一章的存储过程sp_get_orders_1时,如:

    EXEC sp_get_orders_1@salesorderid = 70467
    EXEC sp_get_orders_1@salesorderid = 70468
    EXEC sp_get_orders_1@salesorderid = 70469

    由于OPTION(RECOMPILE),所以不缓存任何执行计划并且每次都重编译。但是对于本文中的存储过程:

    EXEC [sp_Get_orders]@salesorderid = 70467
    EXEC [sp_Get_orders]@salesorderid = 70468
    EXEC [sp_Get_orders]@salesorderid = 70469

    只会针对第一次调用进行编译并缓存执行计划,后续两次调用将使用第一的执行计划进行直接运行。但是当调用的参数变化时,如:

    EXEC [sp_Get_orders]@salesorderid = 70467,@prodid  = 870

    会发生新的编译并产生新的缓存条目,但原有的用于查询SalesOrderID的执行计划不受影响。

     

    特殊的查询条件:


    在上一篇静态SQL中,已经展示了如何用静态SQL实现某些特殊的查询条件,本部分将演示用动态SQL来完成这些工作,前面提到过,静态SQL针对简单的查询条件,足以应付自如,但是当需求数量和复杂度逐步增加时,静态SQL将变得不可控。此时就需要考虑动态SQL。

     

    数据分布不均的情况:


    在很多系统中,常见的一类情况是,订单表上有一个状态列Status,里面有4个值:N(新订单)、P(处理中)、E(异常订单)、C(已处理订单),同时几乎99%的数据都是为C。

    这种情况下可以使用对该列中C值的过滤索引/筛选索引(filterindex)来过滤不必要的数据或需要经常查询的数据。但是如果在动态SQL中这样写:

    IF @status IS NOT NULL
      SELECT @sql += ' AND o.Status = @status'

    由于动态SQL的执行计划是针对所有情况进行优化的,所以这种写法是不会专门针对过滤索引起效,需要额外制定一些操作逻辑来“指示”优化器使用这个过滤索引,如:

    IF @status IS NOT NULL
       SELECT @sql += ' AND o.Status = @status' +
                      CASE WHEN @status <> 'C' 
                           THEN ' AND o.Status <> ''C'''
                           ELSE ''
                      END
    这种情况是针对单值参数,如果@status为多值,即用户需要筛选某些类型的数据,则需要按这种方式添加更多的处理逻辑。

    自定义排序:

    在动态SQL中,很常见的应用常见是使用自定义的排序规则,通过用户前端输入的排序条件进行结果集排序,比如:

    @sql += ' ORDER BY ' + @sortcol

    这种写法可以满足多列排序。比如’SalesOrderID, OrderTime Desc’。虽然对于满足功能来说,已经足够了,但是由于客户端不知道查询本身,可能导致传入的参数不属于相关的表或其他因素导致报错,特别是ORDER BY在T-SQL的逻辑处理中属于接近最后部分,SELECT语句可能把原始列进行重命名、运算等,导致前端无法得知SELECT的最终列名。另外即使是使用了正确的名字,但是在后续可能因为表结构的变更、列名变更等因素又带来报错。这种情况其实很难避免,不过多考虑一下问题可能就没有那么严重,比如可以用下面的方式来预处理:

    SELECT @sql += ' ORDER BY ' + 
                   CASE @sortcol WHEN 'OrderID'      THEN 'o.OrderID'
                                 WHEN 'EmplyoeeID'   THEN 'o.EmployeeID'
                                 WHEN 'ProductID'    THEN 'od.ProductID'
                                 WHEN 'CustomerName' THEN 'c.CompanyName'
                                 WHEN 'ProductName'  THEN 'p.ProductName'
                                 ELSE 'o.OrderID'
                   END + CASE @isdesc WHEN 0 THEN ' ASC' ELSE ' DESC' END

    备用表:


    在上一章备用表中,提到了关于不同参数访问不同表的情况,这种情况在动态SQL中实现也不难,可以把FROM部分改写成:

    ROM dbo.' + CASE @ishistoric
                      WHEN 0 THEN 'Orders'
                      WHEN 1 THEN 'HistoricOrders'
                 END + ' o
    JOIN dbo.' + CASE @ishistoric
                      WHEN 0 THEN '[Order Details]'
                      WHEN 1 THEN 'HistoricOrderDetails'
                 END + ' od

    但是为了避免SQL注入的风险,不建议通过前端程序传入表名,而是传入某些标识参数然后在存储过程内部进行表名选择。

     本文出处:http://blog.csdn.net/dba_huangzj/article/details/50202371

     

    缓存问题:


    参数化动态SQL的其中一个优势是可以通过计划重用而减少编译次数。但是缓存并不总是好的,比如在上一章基础技能部分提到的:

    1. exec sp_Get_orders_1@fromdate='20050701',@todate ='20050701'  
    2. exec sp_Get_orders_1@fromdate='20050101',@todate ='20051231'  

    虽然参数集相同,但是当值不同的时候,如果这些不同的值的数据分布严重不均匀,会导致执行计划无法高效支持所有查询。这种情况在动态SQL和静态SQL中都比较常见,下面来介绍一下处理方法:

    OPTION(RECOMPILE):

    对,你又见到它了。在上面提到的特定情况下,如果查询条件是@fromdate和@todate,添加OPTION(RECOMPILE):

    IF (@fromdate IS NOT NULL OR @todate IS NOT NULL)
       SELECT @sql += ' OPTION(RECOMPILE)' + @nl

    通常来说,当你发现查询条件上有合适的索引,并且选择度非常依赖于实际值的输入,那么可以添加OPTION(RECOMPILE),以便你总能通过编译得到关于当前统计信息的最佳执行计划。但是显然这种方式会添加一部分不必要的编译,比如两次执行的值完全一样时,依旧还会编译。

     

    索引提示和其他提示:

    有时候可以尝试使用“提示,hints”,可以通过CASE WHEN 判断需要传入什么参数,并且对这些参数额外指定需要走的索引。但是正如前面提到过的,提示要慎用,特别是索引提示,除非你确保索引名永不变更:

    FROM   dbo.Orders o ' + CASE WHEN @custid IS NOT NULL AND
                                      (@fromdate IS NOT NULL OR
                                      @todate IS NOT NULL) 
                                 THEN 'WITH (INDEX = CustomerID) '
                                 ELSE ''
                             END


    另外一种提示是使用OPTIMIZE FOR。如果你希望执行计划总是使用占用最多的情况来编译,比如前面提到的status类型中的C,那么可以添加:

    IF @status IS NOT NULL
       @sql += ' OPTION (OPTIMIZE FOR (@status = ''C''))'

    如果你不想优化器通过嗅探参数来产生执行计划,可以使用:

    IF @fromdate IS NOT NULL AND @todate IS NOT NULL
       @sql += ' OPTION (OPTIMIZE FOR (@fromdate UNKNOWN, @todate UNKNOWN))'

    这样优化器就不会使用标准假设,即10%左右来编译查询。

     本文出处:http://blog.csdn.net/dba_huangzj/article/details/50202371

     

    总结:


    动态SQL很强大,但是如果读者归纳能力比较强的话,可以看到,动态SQL的问题主要是在不能很好地利用计划缓存或使用的是不合适的执行计划,导致性能问题。

    对于这类情况,有很多方法可以使用,而且如果可以,不妨考虑非数据库层面的其他技术。但是我们的目的还是一个:保证执行计划针对任何参数,最起码绝大部分参数都是最佳的,并且能够尽可能重用。

    最后,需要提醒的是,任何技术、技巧,都应该在尽可能贴近实际环境的测试环境中做充分的测试,以便得到你希望的结果。

     本文出处:http://blog.csdn.net/dba_huangzj/article/details/50202371

     

    展开全文
  • 主要介绍了sqlserver、Mysql、Oracle三种数据库的优缺点总结,需要的朋友可以参考下
  • 初识SqlServer

    千次阅读 2020-01-20 13:09:57
    文章目录一、SqlServer服务安装二、SqlServer连接三、总结 SQL Server是由Microsoft开发和推广的关系数据库管理系统(DBMS),它最初是由Microsoft、Sybase和Ashton-Tate三家公司共同开发的,并于1988年推出了第一...

    SQL Server是由Microsoft开发和推广的关系数据库管理系统(DBMS),它最初是由Microsoft、Sybase和Ashton-Tate三家公司共同开发的,并于1988年推出了第一个OS/2版本。Microsoft SQL Server近年来不断更新版本,1996年,Microsoft 推出了SQL Server 6.5版本;1998年,SQL Server 7.0版本和用户见面;SQL Server 2000是Microsoft公司于2000年推出,目前最新版本是2019年份推出的SQL SERVER 2019。
    ——摘录自百度百科。
    总而言之,这是微软主导开发的一种结构化数据库,由于笔者接触MySQL比较多,在与第三方做数据交互的时候需要用到SqlServer服务,于是在接触SqlServer的过程中记录一些流程和常见错误解决方案,方便日后的查阅。

    一、SqlServer服务安装

    由于SqlServer是微软开发的一款数据库服务,所以使用Windows服务器还是Linux服务器都可以。
    笔者使用的是阿里云CentOS 7版本的Linux服务器作为系统环境,在此介绍用yum命令快速安装SqlServer的过程,一共分为以下四个步骤。

    1. 设置SqlServer安装镜像
    curl https://packages.microsoft.com/config/rhel/7/mssql-server-2017.repo > /etc/yum.repos.d/mssql-server.repo
    
    1. 执行安装命令
    yum install -y mssql-server
    
    1. 进行相关配置
    sudo /opt/mssql/bin/mssql-conf setup
    

    执行以上命令进入配置界面:
    1
    以上8个数字对应8种不同的版本,前三个数字对应的版本均表示免费版本。这里我们选择2表示开发版本,是免费无生产许可的。
    pwd
    随后输入两遍密码配置登录许可密码。
    success
    出现"Setup has completed successfully. SQL Server is now starting"即表示安装成功。

    最后执行source命令使得配置生效。

    1. 配置安全组对外访问端口
      由于笔者使用的是云服务器,所以直接在云服务器控制台的安全组中配置SqlServer的默认端口开放即可,需要注意的是SqlServer的默认端口与MySQL的不同,是1433端口。
      开放端口

    二、SqlServer连接

    安装完之后就可以用远程连接工具进行连接,用Navicat就能连接,不过还是推荐使用官方软件SQL Server Management Studio (SSMS)进行连接。
    或者直接在命令行中进行连接,不过需要使用sqlcmd的依赖。
    接下来介绍三种连接方式:

    1. 首先介绍使用SQL Server Management Studio工具,简称SSMS进行远程连接
      访问SSMS官网,Download SQL Server Management Studio (SSMS),直接点击Download进行下载相关版本的SqlServer连接管理工具即可。
      SqlServer
      安装完之后,首次打开的界面是这样的:
      界面
      我们需要更改Server type为Database Engine,随后在Server name处输入服务器ip地址,Authentication处选择SQL Server Authentication,Login与Password分别输入用户名和密码,其中需要注意的是SqlServer默认的用户名为sa,最后点击connect即可进行连接。
      connect success
      这就是连接成功后的界面效果。

    2. 使用Navicat远程连接SqlServer
      SqlServer
      选择SQL Server的连接
      pwd
      输入相关信息进行连接,这个时候会出现一个意外的错误:
      error
      这是因为Navicat没有安装相关SqlServer的驱动,这个时候我们找到Navicat的安装目录,找到sqlncli_x64.msi,点击双击进行安装。
      install
      安装完毕
      安装完毕之后再进行SqlServer的连接,就能够连接成功了。

    3. 直接在Linux命令行下进行连接
      首先需要使用sqlcmd的依赖,按照以下命令顺序依次执行安装sqlcmd依赖包。

    curl https://packages.microsoft.com/config/rhel/7/prod.repo > /etc/yum.repos.d/msprod.repo
    
    yum install mssql-tools unixODBC-devel
    
    vim /etc/profile.d/mssqltools.sh
    

    编辑配置文件,将**export PATH=$PATH:/opt/mssql-tools/bin/**写入到文件中
    sqlcmd

    source /etc/profile.d/mssqltools.sh
    

    执行source命令使得配置生效,至此,sqlcmd的依赖下载完毕。
    检验sqlcmd是否下载成功,执行sqlcmd命令

    sqlcmd
    

    success
    返回以上命令帮助即表示安装成功,接下来我们使用sqlcmd进行连接SqlServer。
    执行以下命令,表示使用默认sa账号进行登录,并输入正确的密码后即可进入SqlServer。

    sqlcmd -S localhost -U sa
    

    我们执行简单的一条SQL命令,查询所有的库名,在输入SQL命令之后回车,在第二行要记得输入go并回车才能执行命令:

    SELECT name FROM sys.databases
    
    go
    

    查询结果

    三、总结

    虽然SqlServer与MySQL的差别还是存在,但是通过查询相关资料最终还是顺利安装好了SqlServer环境。MySQL与SqlServer同样作为数据库,各自都有共同点和优缺点,由于使用MySQL的时间比较长,对于SqlServer的了解还不够深,后续若有时间将会继续研究相关SqlServer的特性并作分享。

    参考资料:

    展开全文
  • SQL存储过程的优缺点

    千次阅读 2018-07-28 17:17:22
    存储过程是由一些SQL语句和控制语句组成的被封装起来的过程,它驻留在数据库中,可以被客户应用程序调用,用户通过指定存储过程的名字并给定参数(如果该存储过程带有参数)来调用执行它,也可以从另一个过程或...

    概要:

    存储过程是由一些SQL语句和控制语句组成的被封装起来的过程,它驻留在数据库中,可以被客户应用程序调用,用户通过指定存储过程的名字并给定参数(如果该存储过程带有参数)来调用执行它,也可以从另一个过程或触发器调用。
    存储过程是可编程的函数,在数据库中创建并保存,可以由SQL语句和控制结构组成。当想要在不同的应用程序或平台上执行相同的函数,或者封装特定功能时,存储过程是非常有用的。数据库中的存储过程可以看做是对编程中面向对象方法的模拟,它允许控制数据的访问方式。
    根据返回值类型的不同,我们可以将存储过程分为三类:返回记录集的存储过程,返回数值的存储过程(也可以称为标量存储过程),以及行为存储过程。顾名思义,返回记录集的存储过程的执行结果是一个记录集,典型的例子是从数据库中检索出符合某一个或几个条件的记录;返回数值的存储过程执行完以后返回一个值,例如在数据库中执行一个有返回值的函数或命令;最后,行为存储过程仅仅是用来实现数据库的某个功能,而没有返回值,例如在数据库中的更新和删除操作。


    例子:

    大型数据库一般都支持存储过程,合理的利用存储过程也可以提高系统性能。如你有一个业务需要将A表的数据做一些加工然后更新到B表中,但是又不可能一条SQL完成,这时你需要如下3步操作:
    a:将A表数据全部取出到客户端;
    b:计算出要更新的数据;
    c:将计算结果更新到B表。
    如果采用存储过程你可以将整个业务逻辑封装在存储过程里,然后在客户端直接调用存储过程处理,这样可以减少网络交互的成本。


    优点:

    1. 减少网络通信量。针对同一个数据库对象的操作(如查询、修改),如果这一操作所涉及的Transaction-SQL语句被组织进存储过程,那么当在客户计算机上调用该存储过程时,网络中传送的只是该调用语句,从而大大减少网络流量并降低了网络负载。
    2. 较快的执行速度:如果某一操作包含大量的Transaction-SQL代码或分别被多次执行,那么存储过程要比批处理的执行速度快很多。因为存储过程是预编译的。在首次运行一个存储过程时查询,优化器对其进行分析优化,并且给出最终被存储在系统表中的执行计划。而批处理的Transaction-SQL语句在每次运行时都要进行编译和优化,速度相对要慢一些。
    3. 标准组件式编程:存储过程被创建后,可以在程序中被多次调用,而不必重新编写该存储过程的SQL语句。而且数据库专业人员可以随时对存储过程进行修改,对应用程序源代码毫无影响。
    4. 作为一种安全机制来充分利用:使用存储过程使您能够增强对执行计划的重复使用,通过对执行某一存储过程的权限进行限制,能够实现对相应的数据的访问权限的限制,避免了非授权用户对数据的访问,保证了数据的安全。
    5. 布式工作:应用程序和数据库的编码工作可以分别独立进行,而不会相互压制。
    6. 可维护性高:更新存储过程通常比更改、测试以及重新部署程序集需要较少的时间和精力。

    缺点:

    1. 不可移植性,每种数据库的内部编程语法都不太相同,当你的系统需要兼容多种数据库时最好不要用存储过程。
    2. 学习成本高,DBA一般都擅长写存储过程,但并不是每个程序员都能写好存储过程,除非你的团队有较多的开发人员熟悉写存储过程,否则后期系统维护会产生问题。
    3. 业务逻辑多处存在,采用存储过程后也就意味着你的系统有一些业务逻辑不是在应用程序里处理,这种架构会增加一些系统维护和调试成本。
    4. 存储过程和常用应用程序语言不一样,它支持的函数及语法有可能不能满足需求,有些逻辑就只能通过应用程序处理。
    5. 如果存储过程中有复杂运算的话,会增加一些数据库服务端的处理成本,对于集中式数据库可能会导致系统可扩展性问题。
    6. 为了提高性能,数据库会把存储过程代码编译成中间运行代码(类似于java的class文件),所以更像静态语言。当存储过程引用的对像(表、视图等等)结构改变后,存储过程需要重新编译才能生效,在高并发应用场景,一般都是在线变更结构的,所以在变更的瞬间要同时编译存储过程,这可能会导致数据库瞬间压力上升引起故障(Oracle数据库就存在这样的问题)。

    总结:

    普通业务逻辑尽量不要使用存储过程,定时性的ETL任务或报表统计函数可以根据团队资源情况采用存储过程处理。存储过程可以快速解决问题,但是移植性、维护性、扩展性不好,它有时会约束软件的架构,约速程序员的思维,在系统没有性能问题时不建议用存储过程。如果你要完成的功能只是一次或有限次的工作,如数据订正、数据迁移等等,存储过程也可以拿上用场。
    如果你的系统很小,并且有50%的开发人员熟练掌握PL/SQL,人员结构稳定,那存储过程可以减少很多代码量,并且性能不错。当系统变复杂了,开发人员多了,存储过程的弊端就会呈现。


    参考:

    [1] https://blog.csdn.net/yzsind/article/details/6059209
    [2] https://blog.csdn.net/stevendbaguo/article/details/28587419
    [3] https://blog.csdn.net/jackmacro/article/details/5688687
    [4] https://www.cnblogs.com/mark-chan/p/5384139.html

    展开全文
  • 总结:SQL的优缺点及与NoSQL对比

    千次阅读 2020-10-12 09:34:45
    SQL在这里指的是关系型数据库,NoSQL指元组存储?
  • mybatis中mapper文件中的动态sql语句

    千次阅读 2017-09-21 21:24:25
    有时候在检索时,用户提供的数据不一样多,我们很难使用静态的sql语句进行判别,所以这个时候需要使用动态sql语句 这里主要针对Mapper.xml文件中的sql语句,笔者在下面所有的例子中只提供了Mapper.xml文件中的动态...
  • MySQL、SqlServer、Oracle 三种数据库的优缺点总结 一、MySQL 二、SqlServer 三、Oracle 一、MySQL 优点: 体积小、速度快、总体拥有成本低,开源; 支持多种操作系统; 是开源数据库,提供的接口支持多种语言连接...
  • 存储过程中执行动态Sql语句

    万次阅读 2018-08-26 18:50:28
    存储过程中执行动态Sql语句  MSSQL为我们提供了两种动态执行SQL语句的命令,分别是EXEC和sp_executesql;通常,sp_executesql则更具有优势,它提供了输入输出接口,而EXEC没有。还有一个最大的好处就是利用sp_...
  • MySQL数据库面试题(2020最新版)

    万次阅读 多人点赞 2020-03-10 17:20:40
    文章目录数据库基础知识为什么要使用数据库什么是SQL?什么是MySQL?数据库三大范式是什么mysql有关权限的表都有哪几个MySQL的binlog有有几种录入格式?分别有什么区别?数据类型mysql有哪些数据类型引擎MySQL存储...
  • MS_SQL_Server的同步镜像集群优缺点对比,数据库冗余的方案考虑。
  • SQL Server的优点与缺点

    万次阅读 2018-03-06 09:28:03
    第三,当对表中的数据进行增加、删除和修改的时候,索引也要动态的维护,这样就降低了数据的维护速度。 索 引是建立在数据库表中的某些列的上面。因此,在创建索引的时候,应该仔细考虑在哪些列上可以创建索引,在...
  • SQL Server存储过程中执行动态SQL语句

    千次阅读 2015-07-31 16:20:48
    一、简介 在Sql Server中执行动态sql语句有两种方法:exec和exec sp_executesql。 优缺点: 1、exec sp_executesql提供输入、输出接口,可以在sql语句中进行参数占位;exec则不可以。 2、exec sp_executesql能够...
  • 背景:根据业务需要,每个月生成一张根据年份和月份的表,然后当前的数据存到当前月份的表。...String sqlSave = "insert into " + tabName + " (id,serializeObj,methodName,createTi...
  • 来看看我们这个项目中是如何对mybatis动态生成sql进行改进的吧 spring boot在配置了MapperScan之后会自动扫描相关的包,并对有@Mapper标记的类进行注册 @Configuration @EnableAutoConfiguration @...
  • 使用SQL Server视图的优缺点

    千次阅读 2019-02-07 17:27:27
    SQL Server视图我们经常会用的到,下面就为您介绍使用SQL Server视图的优缺点,希望可以对您SQL Server视图有更多的了解。 在程序设计的时候必须先了解视图的优缺点,这样可以扬长避短,SQL Server视图具有如下的...
  • Linq To Sql的优缺点

    千次阅读 2013-11-15 09:43:46
    Linq to Sql是Microsoft开发的针对解决data!=object问题的新技术。在笔者的一系列的文章中,对它已经做了大量的介绍。现在,笔者将从经验的角度,谈谈它的优劣。  1、Linq To Sql的优点  在Linq To Sql推出之前,...
  • 简单谈谈MySQL、SqlServer、Oracle的优缺点 一、MySQL 优点: 支持多种操作系统; 体积小、速度快、总体拥有成本低,开源; 是开源数据库,提供的接口支持多种语言连接操作 ; MySQL的核心程序采用完全的多线程...
  • T-SQL动态查询(1)——简介

    万次阅读 2015-11-19 16:27:58
    起因: 由于最近工作需要及过去一直的疑问,所以决定着手研究一下动态SQL。由于离开一线开发有点年头了,很多技巧性的东西没有过多研究,作为DBA和《SQL Server性能优化与管理的艺术》一书的独立作者,更多的是关注...
  • 踩坑 今天在写一个项目的Mapper配置文件,运行时报了一个SQL语法异常。如下图: ! 咋眼看是不好排查的,但是通过报错信息可以定位到Mapper文件,经过仔细查看之后...SQL动态拼接 概述 Mybatis为了让程序员专注CR...
  • SQL与nosql区别以及优缺点

    千次阅读 2020-03-19 12:09:25
    SQL SQL是关系型数据库,采用关系模型来组织数据结构的数据库(二维表)。 关系型数据库最典型的数据结构是表,由二维表及其之间的联系所组成的一个数据组织 常见的有: le、DB2、SQLServer、Mysql、SQLite都是关系型...
  • SQL,NoSQL优缺点总结

    千次阅读 2021-01-10 18:28:47
    SQL优点: 保持数据一致性(最大优势) 由于以标准化为前提,数据更新的开销很小 可以进行 Join 等复杂查询 SQL不足: 大量数据的写入处理 为有数据更新的表做索引或表结构(schema)变更 字段不固定时应用 对简单...
  • MSSQL存储过程中执行动态Sql语句

    千次阅读 2017-03-16 16:29:30
    MSSQL为我们提供了两种动态执行SQL语句的命令,分别是EXEC和sp_executesql;通常,sp_executesql则更具有优势,它提供了输入输出接口,而EXEC没有。还有一个最大的好处就是利用sp_executesql,能够重用执行计划,这就...
  • SQL 、 NoSQL 和 NewSQL 的优缺点比较

    千次阅读 2018-12-17 14:44:16
    SQL作为主要的数据存储方式已经超过40年,并且经历了至少两个指数扩张期:20世纪90年代Web应用程序崛起之后,以及在过去十年中由于移动设备爆炸引起的扩张。 因此,越来越小的公司开始发现使用数据库的好处,而像...
  • SQL 与 JAVA 实现逻辑的优缺点

    千次阅读 2019-01-02 10:02:39
    第二就是维护这些 SQL 也是一件很难受的事情,因为你完全不知道这个 SQL 背后的数据流转是怎样的,你只能根据自己的猜测去查看 SQL 中的 bug,Java 应用好歹还能 debug 一下还有打点看看数据不是?如果逻辑写在 Java...
  • SQL语句动态传入表名

    千次阅读 2020-05-02 20:10:20
    在ssm框架中,由于sql语句是动态编译的,所以会在传入的字符串加入“ ‘’ ”,而表名是不允许有的,起初我想用trim去除,发现不管用,后来发现有statementType函数,一共有三种属性我就不一一列举了。 直接解决办法...
  • pl/sql: 优点:1.提高应用程序的运行性能;2.模块化的设计思想(分页...缺点:1.移植性不好; 5 /如果存储过程名已经被占用,两种方式:1.修改存储过程名;2添加关键字 or replace :表示如果有yao_prol,就替换。...
  • SQL与ORM的优缺点

    万次阅读 2018-05-18 11:28:39
    因为比如Phalcon的SQL形式写法也可以防注入』方便动态构造语句,对于不同的表的相同操作采用多态实现更优雅一定程度方便重构数据层『比如改表名,字段名等』设置钩子函数缺点不太容易处理复杂查询语句性能较直接用...
  • 由于SQL Server的特殊性,目前市面上没有成熟开源的SQL Server/MongoDB同步软件,可行方案需要采用软件编写的方式才能实现该功能。通过调研,总结3种可行方法。依据采用的原理不同分为如下方法:依据时间戳更新数据...
  • PL/SQL --> 动态SQL调用包中函数或过程

    千次阅读 2013-09-17 17:28:40
    动态SQL主要是用于针对不同的条件或查询任务来生成不同的SQL语句。最常用的方法是直接使用EXECUTE IMMEDIATE来执行动态SQL语句字符串或字符串变量。但是对于系统自定义的包或用户自定的包其下的函数或过程,不能等同...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 208,367
精华内容 83,346
关键字:

动态sql的缺点