Existe uma maneira de validar XML usando variável como esquema?

Eu não acho que isso seja possível usando o T-SQL, no entanto, você pode conseguir o que precisa usando o assembly C# e .NET CLR.

Passos

1. Crie um novo projeto de biblioteca de classes C# no Visual Studio.
2. Escreva um public staticmétodo que fará o trabalho para você.
3. Adicione o assembly CLR ao Microsoft SQL Server.
4. Crie uma função escalar que chamará seu método.
5. Chame seu método do T-SQL, como qualquer outro comando.

Método estático público para validar um documento XML em um XSD

using System;
using System.IO;
using System.Xml;
using System.Xml.Xsl;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
using System.Xml.Schema;

namespace SqlHelperClr
{
    public static class Xml
    {
        [SqlFunction]
        public static SqlString XmlValidate(SqlXml InputXml, SqlXml ValidationXsd)
        {
            if (InputXml.IsNull)
                throw new ArgumentNullException("InputXml", "InputXml is NULL.");
            if (ValidationXsd.IsNull)
                throw new ArgumentNullException("ValidationXsd", "ValidationXsd is NULL.");

            using (XmlReader xmlSchemaReader = ValidationXsd.CreateReader())
            {
                XmlReaderSettings settings = new XmlReaderSettings();

                settings.Schemas.Add("http://schemanamespace.example.com/", xmlSchemaReader);
                settings.ValidationType = ValidationType.Schema;

                using (XmlReader xmlReader = XmlReader.Create(InputXml.CreateReader(), settings))
                {
                    XmlDocument doc = new XmlDocument();
                    doc.Load(xmlReader);

                    ValidationEventArgs capturedEventArgs = null;

                    // Declare anonymous validation event handler to save the validation event arguments to a 'captured variable'
                    ValidationEventHandler eventHandler = new ValidationEventHandler(
                        (obj, e) =>
                        {
                            capturedEventArgs = e;
                        });

                    try
                    {
                        doc.Validate(eventHandler);
                    }
                    catch (Exception ex)
                    {
                        return String.Format("ERROR; Severity {0}: {1}", capturedEventArgs.Severity.ToString(), capturedEventArgs.Message);
                    }

                    return "OK";
                }
            }
        }
    }
}

Adicionar assembly CLR ao Microsoft SQL Server

Crie o assembly e copie o arquivo DLL de saída para um local acessível pela instância do SQL Server. Em seguida, execute este comando para registrar um assembly CLR em um banco de dados:

USE [Mydatabase]
CREATE ASSEMBLY [SqlHelperClr]
FROM 'C:\SqlAssemblies\SqlHelperClr.dll'
WITH PERMISSION_SET = UNSAFE;

Crie uma função escalar que chamará XmlValidate

USE [Mydatabase]
CREATE FUNCTION dbo.fn_ValidateXsd (@InputXml XML, @ValidationXsd XML)
RETURNS NVARCHAR(1000)
AS EXTERNAL NAME [SqlHelperClr].[SqlHelperClr.Xml].[XmlValidate];
-- [AssemblyName].[NamespaceNames.StaticClassName].[MethodName]

Use fn_ValidateXsd

DECLARE @XmlDoc Xml = '<Root><NodeA>Blah</NodeA></Root>'
DECLARE @XmlSchema Xml = '' -- Schema goes here

DECLARE @Validation_Message NVARCHAR(1000)
SET @Validation_Message = dbo.fn_ValidateXsd(@XmlDoc, @XmlSchema)

Eu recomendo começar com o código na função que você já tem para fazer isso a partir de uma Xml Schema Collection, conforme mostrado nesta pergunta:

Erro SQL 2012 CLR: "A transação de contexto que estava ativa antes de inserir ..."?

Você pode criar uma segunda função que é quase a mesma, mas usa o próprio XSD em vez do nome da coleção de esquemas e, em seguida, pode apenas fazer a validação da mesma maneira, mas sem precisar obtê-la do banco de dados. E, como esta função está fazendo qualquer acesso a dados para obter o XSD, ela pode ser marcada como IsDeterministic=trueo que permitirá que ela participe de planos paralelos (ou, dizendo de outra forma, impedirá que a função force um plano serial).

[SqlFunction(IsDeterministic=true)]
public static SqlBoolean ValidateXmlFromXsd(SqlXml Xsd, SqlString ValueString)
{
    XmlDocument asset1 = new XmlDocument();
    XmlSchema schema1 = new XmlSchema();
    System.Text.StringBuilder o = new System.Text.StringBuilder();

    try
    {
         if (Xsd.IsNull)
         {
              try
              {
              asset1.LoadXml(ValueString.Value);
              asset1 = null;
              return new SqlBoolean(true);
              }
              catch (Exception ex)
              {
              return new SqlBoolean(false);
              }
         }
         else
         {
              using (XmlReader xmlReader = Xsd.CreateReader())
              {
                   schema1 = XmlSchema.Read(xmlReader, ValidateSchema);
              }

              asset1.Schemas.Add(schema1);

              XDocument oDoc = new XDocument();
              oDoc = XDocument.Parse(ValueString.Value);
              oDoc.Descendants().Where(e => string.IsNullOrEmpty(e.Value)).Remove();

              asset1.LoadXml(oDoc.FirstNode.ToString());
              oDoc = null;

              asset1.Validate((o, e) =>
              {
                   if (e.Severity == XmlSeverityType.Error)
                   {
                        o.AppendLine("Error: " + e.Message);
                   }
              });

              if (asset1.SchemaInfo.Validity == XmlSchemaValidity.Valid)
              {
                   asset1 = null;
                   return new SqlBoolean(true);
              }
              else
              {
                   asset1 = null;
                   return new SqlBoolean(false);
              }
         }
    }
    catch (Exception ex)
    {
         return new SqlBoolean(false);
    }
    finally
    {
         schema1 = null;
         asset1 = null;
         o = null;
    }
}

Desta forma, você tem uma abordagem consistente para a avaliação, é apenas a fonte do XSD que é diferente. E tanto esta função quanto a função em sua outra pergunta (link acima) podem estar no mesmo SAFEAssembly. Não vejo razão para usar um UNSAFEAssembly para fazer isso.