Cuestión : Cómo detectar si el servidor 2005 o 2008 del SQL está instalado

¿Hola, el

How puede yo detectar si el servidor 2005 o 2008 del SQL está instalado en una computadora dentro de un uso de Delphi? ¿el
Preferably no usando el registry.

I encontró un cierto código en C# que pudo hacer esto??? (véase abajo). class= > " claro " del

> del " codeSnippet " del class= del

class= " lineNumbers " del

class= del

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:

sistema >using notpretty " del class= " del id= " codeSnippet780363 del

 de ///
        /// enumera todos los casos del servidor del SQL en la máquina.
        /// 
        /// 
        bool estático público EnumerateSQLInstances ()
        {
            correctNamespace = GetCorrectWmiNameSpace de la secuencia ();
            si (secuencia. Iguales (correctNamespace, secuencia. Vaciar))
            {
                volver falso;
            }
            encadenar la pregunta = la secuencia. Formato (“seleccionar * de SqlServiceAdvancedProperty donde SQLServiceType = 1 y PropertyName = “instanceID” ");
            getSqlEngine de ManagementObjectSearcher = nuevo ManagementObjectSearcher (correctNamespace, pregunta);
            si (getSqlEngine.Get (). == 0 de la cuenta)
            {
                falso de vuelta;
            }
            Console.WriteLine (“los casos de la base de datos de servidor del SQL descubrieron: ");
            instanceName de la secuencia = secuencia. Vacío;
            serviceName de la secuencia = secuencia. Vacío;
            versión de la secuencia = secuencia. Vacío;
            edición de la secuencia = secuencia. Vacío;
            Console.WriteLine (“versión \ t de la edición \ t del nombre \ t ServiceName \ t del caso”);
            foreach (sqlEngine de ManagementObject en getSqlEngine.Get ())
            {
                serviceName = sqlEngine [“ServiceName”] .ToString ();
                instanceName = GetInstanceNameFromServiceName (serviceName);
                versión = GetWmiPropertyValueForEngineService (serviceName, correctNamespace, “versión”);
                edición = GetWmiPropertyValueForEngineService (serviceName, correctNamespace, “SKUNAME”);
                Console.Write (“{0} \ t”, instanceName);
                Console.Write (“{0} \ t”, serviceName);
                Console.Write (“{0} \ t”, edición);
                Console.WriteLine (“{0} \ t”, versión);
            }
            de vuelta verdad;
        }
         de ///
        El método de /// vuelve el namespace correcto del SQL para utilizar para detectar casos del servidor del SQL.
        /// 
        namespace de /// a utilizar para detectar el servidor instances del SQL
        secuencia estática pública GetCorrectWmiNameSpace ()
        {
            Encadenar el wmiNamespaceToUse = “raíz \ \ \ \ sqlserver de Microsoft”;
            Namespaces de List = nuevo List ();
            intento
            {
                // enumera todos los casos de WMI de
                clase del __namespace WMI de //.
                nsClass de ManagementClass =
                    nuevo ManagementClass (
                    nuevo ManagementScope (wmiNamespaceToUse),
                    nuevo ManagementPath (“__namespace”),
                    falta de información);
                foreach (ManagementObject ns adentro
                    nsClass.GetInstances ())
                {
                    namespaces. Agregar (ns [“nombre”] .ToString ());
                }
            }
            coger (ManagementException e)
            {
                Console.WriteLine (“excepción =” + e.Message);
            }
            si (namespaces. Cuenta > 0)
            {
                si (namespaces. Contiene (“ComputerManagement10”))
                {
                    namespace de //use katmai+
                    wmiNamespaceToUse = wmiNamespaceToUse + “\ \ ComputerManagement10”;
                }
                si (namespaces. Contiene (“ComputerManagement”))
                {
                    namespace de //use yukon
                    wmiNamespaceToUse = wmiNamespaceToUse + “\ \ ComputerManagement”;
                }
                
                {
                    wmiNamespaceToUse = secuencia. Vacío;
                }
            }
            
            {
                wmiNamespaceToUse = secuencia. Vacío;
            }
            wmiNamespaceToUse de vuelta;
        }
         de ///
        el método de /// extrae el nombre del caso del nombre del servicio
        /// 
        name= " serviceName " > del 
        secuencia estática pública GetInstanceNameFromServiceName (serviceName de la secuencia)
        {
            ¡si (! string.IsNullOrEmpty (serviceName))
            {
                si (secuencia. Iguales (serviceName, “MSSQLSERVER”, StringComparison.OrdinalIgnoreCase))
                {
                    serviceName de vuelta;
                }
                
                {
                    serviceName.Substring de vuelta (serviceName.IndexOf (“$") + 1, serviceName.Length - serviceName.IndexOf (“$”) - 1);
                }
            }
            
            {
                secuencia de vuelta. Vacío;
            }
        }
         de ///
        /// vuelve el valor de una propiedad de WMI para un nombre de característica dado para un nombre particular del servicio del servidor del SQL
        /// 
        nombre del servicio del >The del " serviceName " del name= del 
        namespace del wmi del >The del " wmiNamespace " del name= del 
        nombre de característica del >The del " propertyName " del name= del 
        /// 
        secuencia estática pública GetWmiPropertyValueForEngineService (serviceName de la secuencia, wmiNamespace de la secuencia, propertyName de la secuencia)
        {
            propertyValue de la secuencia = secuencia. Vacío;
            encadenar la pregunta = String.Format (“seleccionar * de SqlServiceAdvancedProperty donde SQLServiceType = 1 y PropertyName = “{0}” y ServiceName = “{1}” “, propertyName, serviceName);
            propertySearcher de ManagementObjectSearcher = nuevo ManagementObjectSearcher (wmiNamespace, pregunta);
            foreach (sqlEdition de ManagementObject en propertySearcher.Get ())
            {
                propertyValue = sqlEdition [“PropertyStrValue”] .ToString ();
            }
            propertyValue de vuelta;
        }
    }
}

class= del

Respuesta : Cómo detectar si el servidor 2005 o 2008 del SQL está instalado

Mi fuente acaba de buscar un caso específico del servidor del SQL expreso, he encontrado que un poco rato y modificado el código de enumerar los casos basó un poco en el código de C# que usted fijó en la tapa.

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:



función GetSQLInstances (casos: TStrings): Boleano;
  función GetInstanceNameFromServiceName (const ServiceName: secuencia): secuencia;
  const
    SQLSERVER = “MSSQLSERVER”;
  comenzar
    si ServiceName = '' entonces
      Resultado: = ''
    
    comenzar
      si mayúscula (ServiceName) = SQLSERVER entonces
        Resultado: = ServiceName
      
        Resultado: = copia (ServiceName, posición (“$”, ServiceName) +1, longitud (ServiceName) - posición (“$”, ServiceName));
    extremo;
  extremo;
  función GetWMIPropertyValueForEngineService (const PropertyName, ServiceName, WMINameSpace: secuencia): secuencia;
  var
    SWL: TSWbemLocator;
    SWServ: ISWbemServices;
    SWObjSet: ISWbemObjectSet;
    Enum: IEnumVariant;
    tempObj: OleVariant;
    Valor: Cardinal;    
    SWObj: ISWbemObject;
    SWPropSet: ISWbemPropertySet;
    sQry: secuencia;
  comenzar
    SWL: = TSWbemLocator.Create (nada);
    intento
      intento
        SWServ: = SWL.ConnectServer ('', WMINameSpace, '', '', '', '', 0, nada);
        sQry: = formato ('seleccionar * de SqlServiceAdvancedProperty donde SQLServiceType = 1 y PropertyName = '' %s '' y ServiceName = '' ''' de %s, [PropertyName, ServiceName]);
        SWObjSet: = SWServ.ExecQuery (sQry, “WQL”, wbemFlagReturnImmediately, nada);
        si SWObjSet.Count = 0 entonces
        comenzar
          Resultado: = '';
          Salida;
        extremo;
        //
        Enum: = (_NewEnum de SWObjSet.) como IEnumVariant;
        mientras que (Enum.Next (1, tempObj, valor) = S_OK) hacer
        comenzar
          SWObj: = IUnknown (tempObj) como SWBemObject;
          SWPropSet: = SWObj.Properties_;
          Resultado: = SWPropSet.Item (“PropertyStrValue”, 0). Get_Value;
        extremo;
      excepto
        en E: La excepción hace
        comenzar
          //WriteLn (“error: ” + e.Message);
          Resultado: = '';
        extremo;
      extremo;
    finalmente
      SWL.Disconnect;
      FreeAndNil (SWL);
    extremo;
  extremo;
const
  WMI_NAMESPACES_TO_CHECK: arsenal [0..1] de secuencia = (“ComputerManagement”, “ComputerManagement10”);
var
  GetSqlExpress: TSWbemLocator;
  Servicios: ISWbemServices;
  ObjectSet: ISWbemObjectSet;
  SObject: ISWbemObject;
  propSet: ISWbemPropertySet;
  Enum: IEnumVariant;
  tempObj: OleVariant;
  Valor: Cardinal;
  //
  sQry: secuencia;
  serviceName: secuencia;
  WMIPath: secuencia;
  i: Número entero;
comenzar
  Resultado: = falso;
  Instances.Clear;
  para i: = 0 a 1 hace
  comenzar
    WMIPath: = formato (“raíz \ Microsoft \ SqlServer \ %s”, [WMI_NAMESPACES_TO_CHECK [i]]);
    GetSqlExpress: = TSWbemLocator.Create (nada);
    intento
      intento
        Servicios: = GetSqlExpress.ConnectServer ('', WMIPath, '', '', '', '', 0, nada);
        sQry: = formato ('SELECCIONAR * de SqlServiceAdvancedProperty DONDE SQLServiceType = 1 Y PropertyName = '' ''' del instanceID, [{SQL_INSTANCE}]);
        ObjectSet: = Services.ExecQuery (sQry, “WQL”, wbemFlagReturnImmediately, nada);
        si ObjectSet.Count = 0 entonces
        comenzar
          Continuar;
        extremo;
        //
        Enum: = (_NewEnum de ObjectSet.) como IEnumVariant;
        mientras que (Enum.Next (1, tempObj, valor) = S_OK) hacer
        comenzar
          SObject: = IUnknown (tempObj) como SWBemObject;
          propSet: = SObject.Properties_;
          serviceName: = propSet.Item (“ServiceName”, 0). Get_Value;
          Servicio de //, caso, versión, edición
          Instances.Add (formato (“%s, %s, %s, %s”,
            [serviceName,
              GetInstanceNameFromServiceName (serviceName),
              GetWMIPropertyValueForEngineService (“versión”, serviceName, WMIPath),
              GetWMIPropertyValueForEngineService (“SKUNAME”, serviceName, WMIPath)]));
        extremo;
        Resultado: = verdad;
      excepto
        en E: La excepción hace
        comenzar
          //WriteLn (“error: ” + e.Message);
          Resultado: = falso;
        extremo;
      extremo;
    finalmente
      GetSqlExpress.Disconnect;
      FreeAndNil (GetSqlExpress);
    extremo;
  extremo;
extremo;

Otras soluciones

Cómo fijar un número de líneas en un informe

Cómo fijar extremo del aeropuerto como servidor del DHCP en el LAN con SonicWall

Ediciones del enlace hipertexto

Agregar la fecha a MySQL

Pares de las preguntas de Apple

El DNS reverso no empareja la bandera del smtp

¿Cómo puedo funcionar conmigo PC en modo seguro?

HISTOGRAMA CON EL CP Y EL ANÁLISIS DE CPK

reglas no corrientes de la perspectiva

volver un valor