Get default value of stored procedure parameter

感情迁移 提交于 2019-12-04 14:02:37

It looks that Microsoft has neglected this topic and there is no trivial way to find parameters default values and even if a default value is present or not on a specific parameter:

As we all know, T-SQL stored procedure parameter defaults are not stored in sys.parameters, all_parameters, and system_parameters. They are also not exposed through sp_sproc_columns, sys.columns, or sp_procedure_params_rowset.

Feedback from Microsoft:

As posted by Tibor Karaszi, BOL document that "SQL Server only maintains default values for CLR objects in this catalog view; therefore, this column has a value of 0 for Transact-SQL objects. To view the default value of a parameter in a Transact-SQL object, query the definition column of the sys.sql_modules catalog view, or use the OBJECT_DEFINITION system function."

We dont store even the bit that indicating parameter is of default value in Yukon.

I have tested the first code snippet in this answer and it seems to work for your simple example:

SELECT  
      data3.name
    , [default_value] = REVERSE(RTRIM(SUBSTRING(
          data3.rtoken
        , CASE 
            WHEN CHARINDEX(N',', data3.rtoken) > 0 
                THEN CHARINDEX(N',', data3.rtoken) + 1
            WHEN CHARINDEX(N')', data3.rtoken) > 0 
                THEN CHARINDEX(N')', data3.rtoken) + 1
            ELSE 1 
          END
        , LEN(data3.rtoken)
      )))
FROM (
    SELECT  
          data2.name
        , rtoken = REVERSE(
            SUBSTRING(ptoken
                    , CHARINDEX('=', ptoken, 1) + 1
                    , LEN(data2.ptoken))
                )
    FROM (
        SELECT  
              data.name
            , ptoken = SUBSTRING(
                  data.tokens
                , token_pos + name_length + 1
                , ISNULL(ABS(next_token_pos - token_pos - name_length - 1), LEN(data.tokens))
            )
        FROM (
            SELECT  
                  sm3.tokens
                , p.name
                , name_length = LEN(p.name)
                , token_pos = CHARINDEX(p.name, sm3.tokens)
                , next_token_pos = CHARINDEX(p2.name, sm3.tokens)
            FROM (
                SELECT 
                      sm2.[object_id]
                    , sm2.[type]
                    , tokens = REVERSE(SUBSTRING(sm2.tokens, ISNULL(CHARINDEX('SA', sm2.tokens) + 2, 0), LEN(sm2.tokens))) 
                FROM (
                    SELECT 
                          sm.[object_id]
                        , o.[type]
                        , tokens = REVERSE(SUBSTRING(
                                      sm.[definition]
                                    , CHARINDEX(o.name, sm.[definition]) + LEN(o.name) + 1
                                    , ABS(CHARINDEX(N'AS', sm.[definition]))
                                 )  
                        ) 
                    FROM sys.sql_modules sm WITH (NOLOCK)
                    JOIN sys.objects o WITH (NOLOCK) ON sm.[object_id] = o.[object_id]
                    JOIN sys.schemas s WITH (NOLOCK) ON o.[schema_id] = s.[schema_id] 
                    WHERE o.[type] = 'P '
                        AND s.name + '.' + o.name = 'dbo.Sample1'
                ) sm2
                WHERE sm2.tokens LIKE '%=%'
            ) sm3
            JOIN sys.parameters p WITH (NOLOCK) ON sm3.[object_id] = p.[object_id]
            OUTER APPLY (
                SELECT p2.name
                FROM sys.parameters p2 WITH (NOLOCK) 
                WHERE p2.is_output = 0
                    AND sm3.[object_id] = p2.[object_id] 
                    AND p.parameter_id + 1 = p2.parameter_id
            ) p2
            WHERE p.is_output = 0
        ) data
    ) data2
    WHERE data2.ptoken LIKE '%=%'
) data3

However, it is really ugly for a task that one expects to be easily queryable from system views.

I agree default stored procedure parameter values should be exposed via a SQL Server catalog view.

The T-SQL parsing method may work in many cases but is fragile. Consider using the TransactSQL ScriptDOM. Below is an example using a mix of PowerShell and C#. Not saying this will be perfect for all cases but it seems to process all the parameters I've thrown at it thusfar.

I used the Microsoft.SqlServer.TransactSql.ScriptDom.dll assembly from my SSMS install in this example but it can be downloaded from the NuGet Gallery.

try
{
    Add-type -LiteralPath @("C:\Program Files (x86)\Microsoft SQL Server\140\Tools\Binn\ManagementStudio\Extensions\Application\Microsoft.SqlServer.TransactSql.ScriptDom.dll");
    Add-type `
        -ReferencedAssemblies @("C:\Program Files (x86)\Microsoft SQL Server\140\Tools\Binn\ManagementStudio\Extensions\Application\Microsoft.SqlServer.TransactSql.ScriptDom.dll") `
        -TypeDefinition @"
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.SqlServer.TransactSql.ScriptDom;
using System.IO;
public static class ProcParser
{

    public static List<StoredProcedureParameter> GetStoredProcedureParameters(string storedProcedureDefinition)
    {

        StringReader reader = new StringReader(storedProcedureDefinition);
        var parser = new TSql140Parser(true);

        IList<ParseError> errors;
        TSqlFragment sqlFragment = parser.Parse(reader, out errors);

        if (errors.Count > 0)
        {
            throw new Exception(`"Error parsing stored procedure definition`");
        }

        SQLVisitor sqlVisitor = new SQLVisitor();
        sqlFragment.Accept(sqlVisitor);

        return sqlVisitor.StoredProcedureParameters;

    }

}

internal class SQLVisitor : TSqlFragmentVisitor
{

    public List<StoredProcedureParameter> StoredProcedureParameters = new List<StoredProcedureParameter>();

    public override void ExplicitVisit(ProcedureParameter node)
    {

        var p = StoredProcedureParameter.CreateProcedureParameter(node);
        StoredProcedureParameters.Add(p);

    }

}

public class StoredProcedureParameter
{
    public string ParameterName;
    public string ParameterType;
    public string ParameterDirection = null;
    public string DefaultParameterValue = null;

    public static StoredProcedureParameter CreateProcedureParameter(ProcedureParameter node)
    {
        var param = new StoredProcedureParameter();

        //parameter name
        param.ParameterName = node.VariableName.Value;

        //data type
        switch (((ParameterizedDataTypeReference)node.DataType).Parameters.Count)
        {
            case 0:
                if (node.DataType.Name.Identifiers.Count == 1)
                {
                    param.ParameterType = node.DataType.Name.Identifiers[0].Value;
                }
                else
                {
                    //schema-qualified type name
                    param.ParameterType = node.DataType.Name.Identifiers[0].Value + `".`" + node.DataType.Name.Identifiers[1].Value;
                }
                break;
            case 1:
                param.ParameterType = node.DataType.Name.Identifiers[0].Value + "(" + ((ParameterizedDataTypeReference)node.DataType).Parameters[0].Value + ")";
                break;
            case 2:
                param.ParameterType = node.DataType.Name.Identifiers[0].Value + "(" + ((ParameterizedDataTypeReference)node.DataType).Parameters[0].Value + "," + ((ParameterizedDataTypeReference)node.DataType).Parameters[1].Value + ")";
                break;
        }

        //default value
        if (node.Value != null)
        {
            param.DefaultParameterValue = node.ScriptTokenStream[node.LastTokenIndex].Text;
        }

        //direction
        if (node.Modifier == ParameterModifier.Output)
        {
            param.ParameterDirection = `"OUTPUT`";
        }
        else if (node.Modifier == ParameterModifier.ReadOnly)
        {
            param.ParameterDirection = `"READONLY`";
        }
        else
        {
            param.ParameterDirection = `"INPUT`";
        }

        return param;

    }

    public override string ToString()
    {

        var sb = new StringBuilder();
        sb.Append(ParameterName);
        sb.Append(`" `");
        sb.Append(ParameterType);
        if (DefaultParameterValue != null)
        {
            sb.Append(`" `");
            sb.Append(DefaultParameterValue);
        }
        sb.Append(`" `");
        sb.Append(ParameterDirection);
        return sb.ToString();

    }

}
"@

}
catch [System.Reflection.ReflectionTypeLoadException]
{
  Write-Host "Message: $($_.Exception.Message)"
  Write-Host "StackTrace: $($_.Exception.StackTrace)"
  Write-Host "LoaderExceptions: $($_.Exception.LoaderExceptions)"
  throw;
}

Function Get-ProcText($connectionString, $procName)
{
    $connection = New-Object System.Data.SqlClient.SqlConnection($connectionString);
    $connection.Open();
    $command = New-Object System.Data.SqlClient.SqlCommand("SELECT definition FROM sys.sql_modules WHERE object_id = OBJECT_ID(@ProcName);", $connection);
    $procNameParameter = $command.Parameters.Add((New-Object System.Data.SqlClient.SqlParameter("@ProcName", [System.Data.SqlDbType]::NVarChar, 261)));
    $procNameParameter.Value = $procName;
    $procText = $command.ExecuteScalar();
    $connection.Close();
    return $procText;
}

############
### main ###
############
try {

    # get proc text definition from database
    $procText = Get-ProcText `
        -connectionString "Data Source=.;Initial Catalog=tempdb;Integrated Security=SSPI" `
        -procName "dbo.testproc";

    # parse parameters from proc text
    $procParameters = [ProcParser]::GetStoredProcedureParameters($procText);

    # display parameter values
    foreach($procParameter in $procParameters)
    {
        Write-Host "ParameterName=$($procParameter.ParameterName)";
        Write-Host "`tParameterType=$($procParameter.ParameterType)";
        Write-Host "`tDefaultParameterValue=$($procParameter.DefaultParameterValue)";
        Write-Host "`tParameterDirection=$($procParameter.ParameterDirection)";
    }

}
catch {
    throw;
}
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!