Utilidades de Sql Server con ADO.NET – Cambiar el nombre de archivos lógicos de una base de datos

Hola ¿Qué tal?…


Continuando con las utilidades de SQL Server con ADO.NET  toca el turno a una nueva funcionalidad que puede ser de gran ayuda al momento de cambiar de nombre a una base de datos de SQL Server.


Esta funcionalidad podrá ser utilizada con bases de datos de SQL Server 2000 y 2005, aunque en ocasiones tendré que especificar si es posible en versiones anteriores a SQL Server 2005 ya que estaré publicando estas utilidades principalmente para funcionar en SQL Server 2005.


Cambiar el Nombre de Archivos Lógicos de una Base de Datos con T-SQL


Aquí modificaremos los nombres lógicos de los archivos para que quede en congruencia con el nuevo nombre de la base de datos. Así pues, utilizaremos nuevamente la instrucción ALTER DATABASE para esta tarea, quedando de esta manera:

ALTER DATABASE NewAdventureWorks
      MODIFY FILE(
            NAME = ‘AdventureWorks_Data’,
            NEWNAME = ‘NewAdventureWorks_Data’)
GO
ALTER DATABASE NewAdventureWorks
      MODIFY FILE(
            NAME = ‘AdventureWorks_Log’,
            NEWNAME = ‘NewAdventureWorks_Log’)
GO



Como comentaba anteriormente, será necesario utilizar la instrucción GO del analizador de consultas de SQL Server para separa la ejecución de las instrucciones ALTER DATABASE. Bien, con esto hemos cambiado el nombre de archivos lógicos de la base de datos. Aun cuando hemos podido cambiar el nombre de la base de datos y el nombre de los archivos lógicos de la base de datos, aún queda un problema qué resolver, y este es, cambiar el nombre de los archivos físicos de la aplicación. Aquí es donde está el problema, ya que podremos cambiar el nombre lógico del archivo y el nombre a la base de datos, pero , hay un problema… el nombre físico de los archivos no podrá cambiarse debido a la dependencia de los archivos con el servidor de base de datos. La mejor manera podría ser, primeramente, separa los archivos de la base de datos y eliminar la historia de la base de datos, luego, renombrar los archivos físicos al nombre que deseamos, hay que hacerlo con ambos archivos, el Data (mdf) y el Log (ldf), una vez renombrados procederemos a adjuntarlos nuevamente, se adjuntará con el nombre de la base de datos anterior, así que, solo restará hacer lo que hemos aprendido una vez adjuntados los archivos con el nuevo nombre.


Cambiar el Nombre de Archivos Lógicos de una Base de Datos con ADO.NET


Para cambiar el nombre de los archivos lógicos, utilizaremos lo que vimos con anterioridad en esta publicación en la parte de cambiar nombre de archivos lógicos con T-SQL, bien, el método resultante será como el mostrado en el siguiente ejemplo:


VB.NET

Public Sub ChangeLogicalFileName( _
        ByVal DBName As String, _
        ByVal CurrentName As String, _
        ByVal NewName As String)
    ‘Se declara el SqlCommand para ejecutar
    ‘la instrucción
    Dim cmd As SqlCommand = New SqlCommand()
    ‘Se declara un string para armar el
    ‘CommandText para el SqlCommand
    Dim strSql As String
    ‘Se arma la instrucción Alter Table en
    ‘la cadena declarada
    strSql = String.Format( _
        “ALTER DATABASE {0} “ & _
        “MODIFY FILE(NAME = ‘{1}’, NEWNAME = ‘{2}’)”, _
        DBName, CurrentName, NewName)
    ‘Se asigna el CommandText del
    ‘SqlCommand con la cadena strSql
    cmd.CommandText = strSql
    ‘Se asigna la conexión a utilizar
    cmd.Connection = cnn
    ‘Se intetará ejecutar la instrucción
    Try
        ‘Se abre la conexión
        cnn.Open()
        ‘Se ejecut la instrucción
        cmd.ExecuteNonQuery()
    Catch ex As SqlException
        ‘Se captura el mensaje de error
        mMessages = ex.Message
    Finally
        ‘Al final se cierra la conexión
        cnn.Close()
    End Try
End
Sub



C#

public void ChangeLogicalFileName(
        string DBName,
        string CurrentName,
        string NewName)
{
    //Se declara el SqlCommand para ejecutar
    //la instrucción
    SqlCommand cmd = new SqlCommand();
    //Se declara un string para armar el
    //CommandText para el SqlCommand
    string strSql;
    //Se arma la instrucción Alter Table en
    //la cadena declarada
    strSql = String.Format(
        “ALTER DATABASE {0} “ +
        “MODIFY FILE(NAME = ‘{1}’, NEWNAME = ‘{2}’)”,
        DBName, CurrentName, NewName);
    //Se asigna el CommandText del
    //SqlCommand con la cadena strSql
    cmd.CommandText = strSql;
    //Se asigna la conexión a utilizar
    cmd.Connection = cnn;
    //Se intetará ejecutar la instrucción
    try
    {
        //Se abre la conexión
        cnn.Open();
        //Se ejecut la instrucción
        cmd.ExecuteNonQuery();
    }
    catch (SqlException ex)
    {
        //Se captura el mensaje de error
        messages = ex.Message;
    }
    finally
    {
        //Al final se cierra la conexión
        cnn.Close();
    }
}



Con este método tenemos ahora la habilidad de cambiar el nombre de los archivos lógicos de la base de datos. Con esto tendremos suficientes herramientas para automatizar el proceso para cambiar el nombre de una base de datos completamente, con esto quiero decir que cambiaremos todo por completo, desde el nombre de archivos, el nombre de la base y el nombre lógico de los archivos, teniendo completamente cambiados los nombres.


Conclusiones


Como hemos visto hasta ahora, realizar la transformación de T-SQL a ADO.NET ha sido completamente sencillo ya que solo hemos tenido que asignar las instrucciones T-SQL al CommandText de nuestra variable de SqlCommand, seguido solo asignamos la conexión, abrimos la conexión y ejecutamos el SqlCommand. Las demás utilidades que estaré publicando, se hacen de la misma manera.


Recuerden que este método está pensado en el diseño original de la clase SqlUtilities que creamos en la primera publicación de la serie el cual está aquí:


http://msmvps.com/blogs/otelis/archive/2007/06/19/utilidades-de-sql-server-con-ado-net-regenerar-campos-identity.aspx


He decidido publicar segmentos más cortos para  mejor asimilación, este es el primer segmento de la serie que terminará en el método que automatiza el cambio de nombre de una base de datos por completo, así que estén pendientes.


Espero que haya sido de utilidad, nos vemos en el próximo post.


Saludos…


Octavio Telis

Utilidades de Sql Server con ADO.NET – Separar y adjuntar una base de datos

Hola ¿Qué tal?…


Continuando con las utilidades de SQL Server con ADO.NET  toca el turno a una nueva funcionalidad que puede ser de gran ayuda al momento de cambiar de nombre a una base de datos de SQL Server.


Esta funcionalidad podrá ser utilizada con bases de datos de SQL Server 2000 y 2005, aunque en ocasiones tendré que especificar si es posible en versiones anteriores a SQL Server 2005 ya que estaré publicando estas utilidades principalmente para funcionar en SQL Server 2005.


Separar y Adjuntar los Archivos de una Base de Datos de SQL Server con T-SQL


Separar una base de datos del servidor es útil en contadas ocasiones, casi siempre es mejor realizar respaldos de las bases de datos, sin embargo hay escenarios en los que la recuperación de bases de datos no es tarea fácil, y esto es porque en un respaldo se guarda la ruta original del archivo ya que está pensada la restauración para ser ejecutada en el mismo servidor donde se realizó el respaldo. En ocasiones cuando se necesita mover una base de datos de un servidor a otro la mejor manera es separando la base de datos, de esta manera los archivos quedan libres y se pueden adjuntar en un nuevo servidor sin mucho problema, el único detalle es que los trabajos programados no se van con la base de datos, ni aún con los respaldos, dado que los trabajos son registrados en las bases de datos de sistema.


Para la tarea de cambiar el nombre de la base de datos nos será útil la capacidad de SQL Server de separar los archivos del servidor, de esta manera, podremos cambiar el nombre del archivo para volverlo a adjuntar, una vez adjuntados será útil realizar el procedimiento que he descrito con anterioridad en este artículo.


Veamos la manera de realizar la separación de la base de datos del servidor utilizando T-SQL:

–Ejecutado de manera directa
EXEC sp_detach_db AdventureWorks–Ejecutad con asiganción explícita
–del parámetro @dbname
EXEC sp_detach_db @dbname=AdventureWorks

Se utiliza el procedimiento almacenado de sistema sp_detach_db, cuyos parámetros son tres, sin embargo es suficiente con el parámetro de base de datos ya que el segundo parámetro es para indicar si se omite la instrucción UPDATE STATISTICS sobre todas las tablas de la base de datos. UPDATE STATISTICS se ejecuta de manera predeterminada sobre todas las tablas de la base de datos antes de separarla si se omite este valor, lo cual es bueno pues deja a la base de datos lista para adjuntarse en otro servidor.


Cuando se separan los archivos de una base de datos estos quedan en el directorio de datos del servidor, este directorio de archivos de bases de datos comúnmente está en:

 %programfiles%\Microsoft SQL Server\MSSQL.1\MSSQL\Data


Esto es para instancias de SQL Server 2005, aunque puede variar según la instancia del servidor donde se esté trabajando, la instancia se identifica por la carpeta MSSQL y el sufijo .n donde n es el número de la instancia.


Continuando con el tema de renombrar la base de datos, separamos la base de datos en cuestión y procederemos a cambiar el nombre de los archivos en congruencia con el nuevo nombre de la base de datos, esto es, que si el archivo se llama AdventureWorks_Data.mdf y el nuevo nombre de la base de datos será NewAdventureWorks, pues la congruencia sería renombrar el archivo a NewAdventureWorks_Data.mdf, de manera similar será con el archivo Log (ldf); así entonces, una vez cambiado el nombre de los archivos procedemos a adjuntaros. En versiones anteriores a SQL Server 2005 se utilizaba el procedimiento almacenado de sistema sp_attach_db, sin embargo, en SQL Server 2005 se utiliza la instrucción CREATE DATABASE para adjuntar una base de datos. En el siguiente ejemplo se muestra cómo adjuntar la base de datos que hemos modificado:


Create Database NewAdventureWorks
on
(FILENAME=‘C:\Archivos de programa\
                    Microsoft SQL Server\
                    MSSQL.1\MSSQL\Data\NewAdventureWorks_Data.mdf’
),
(
FILENAME=‘C:\Archivos de programa\
                    Microsoft SQL Server\
                    MSSQL.1\MSSQL\Data\NewAdventureWorks_Log.ldf’
)
For ATTACH


NOTA: la ruta del archivo debe quedar en una sola línea, sin espacios ni saltos de línea, aunque en el ejemplo se muestra con saltos de línea a causa de las limitaciones del ancho de esta publicación, ya que de otra manera causaría un error.


Al cambiar el nombre directamente de los archives nos da la oportunidad de definir el nuevo nombre de la base de datos al adjuntarlos nuevamente, lo único que quedará pendiente será cambiar los nombre de los archivos lógicos, con lo que estará completamente cambiado el nombre de la base de datos. Y digo cambiar completamente el nombre ya que el cambiar el nombre de la base de datos desde el SQL Server Management Studio no aplica los cambios en los archivos lógicos y físicos.


Separar y Adjuntar los Archivos de una Base de Datos de SQL Server con ADO.NET


Ahora nos enfocaremos a escribir los métodos necesarios para separar y adjuntar una base de datos de Sql Server, pero utilizando ADO.NET, para lo cual utilizaremos lo que vimos con T-SQL.


Primeramente crearemos el método que separa la base de datos. El siguiente ejemplo muestra cómo queda este método:


VB.NET

Public Sub DetachDataBase(ByVal DBName As String)
    ‘Declaramos el SqlCommand que se usará
    ‘para ejecutar el procedimiento almacenado
    Dim cmd As SqlCommand = _
        New SqlCommand(“sp_detach_db”)
    ‘Se establece el tipo de Command que se
    ‘usará, para este caso StoredProcedure
    cmd.CommandType = CommandType.StoredProcedure
    ‘Se agrega el parámetro @dbname que se
    ‘utiliza para identificar la base de datos
    ‘a separar
    cmd.Parameters.Add(“@dbname”, _
        SqlDbType.NVarChar, 128).Value = DBName
    ‘Se asigna la conexión al command
    cmd.Connection = cnn
    Try
        ‘se abre la conexión
        cnn.Open()
        ‘se ejecuta el command
        cmd.ExecuteNonQuery()
    Catch ex As SqlException
        ‘se capturan los mensajes de error
        mMessages = ex.Message
    Finally
        ‘se cierra la conexión al terminar
        cnn.Close()
    End Try
End
Sub



C#

public void DetachDataBase(string DBName)
{
    //Declaramos el SqlCommand que se usará
    //para ejecutar el procedimiento almacenado
    SqlCommand cmd =
        new SqlCommand(“sp_detach_db”);
    //Se establece el tipo de Command que se
    //usará, para este caso StoredProcedure
    cmd.CommandType = CommandType.StoredProcedure;
    //Se agrega el parámetro @dbname que se
    //utiliza para identificar la base de datos
    //a separar
    cmd.Parameters.Add(“@dbname”,
        SqlDbType.NVarChar, 128).Value = DBName;
    //Se asigna la conexión al command
    cmd.Connection = cnn;
    try
    {
        //se abre la conexión
        cnn.Open();
        //se ejecuta el command
        cmd.ExecuteNonQuery();
    }
    catch (SqlException ex)
    {
        //se capturan los mensajes de error
        messages = ex.Message;
    }
    finally
    {
        //se cierra la conexión al terminar
        cnn.Close();
    }
}



Aquí tenemos ya nuestro método para separa la base de datos, habrá que hacer algunas observaciones adicionales, como por ejemplo, el parámetro @dbname que utilizamos en T-SQL para pasar el nombre de la base de datos en el procedimiento almacenado sp_detach_db es del tipo sysname en T-SQL, este tipo es un tipo definido por el usuario en Sql Server, por lo que no podremos utilizarlo directamente, sin embargo tiene una equivalencia con NVarchar(128), por lo que utilizaremos este tipo y longitud en nuestro parámetro, lo cual es equivalente funcionalmente.


Ahora veremos cómo podremos adjuntar los archivos nuevamente. Este método será crucial para el objetivo principal que es cambiar el nombre a la base de datos y es que será el que realmente cambie el nombre de la base de datos ya que al adjuntar los archivos, debemos especificar un nombre en la base de datos, con lo que estaremos definiendo el nombre que nos interesa.


El siguiente ejemplo muestra el método que realizará la tarea de adjuntar la base de datos al servidor:

VB.NET

Public Sub AttachDataBase(ByVal DBName As String, _
        ByVal Files As List(Of String))
    ‘Se declara el SqlCommand que ejecutará la
    ‘instrucción
    Dim cmd As SqlCommand = New SqlCommand()
    ‘Se declara un string donde se construirá
    ‘la cadena de la instrucción
    Dim strSql As String
    ‘Se contruye la primera parte de la instrucción
    strSql = String.Format(“Create Database {0} on “, DBName)
    ‘Se agreagan las rutas de archivos que usará
    ‘la instrucción CREATE DATABASE
    For Each str As String In Files
        strSql &= String.Format(“(FILENAME='{0}’),”, str)
    Next
    ‘Se remueve la útlima coma de la cadena
    strSql = strSql.Remove(strSql.Length – 1)
    ‘Se completa la instrucción
    strSql &= ” FOR ATTACH”
    ‘Se asigna la instrucción al SqlCommand
    cmd.CommandText = strSql
    ‘Se asigna la conexión al SqlCommand
    cmd.Connection = cnn
    ‘Se intenta ejecutar el SqlCommand
    Try
        ‘Se abre la conexión
        cnn.Open()
        ‘Se ejecuta la instrucción
        cmd.ExecuteNonQuery()
    Catch ex As SqlException
        ‘Se capturan los mensajes de error
        mMessages = ex.Message
    Finally
        ‘Se cierra la conexión
        cnn.Close()
    End Try
End
Sub



C#

public void AttachDataBase(String DBName,
    List<string> Files)
{
    //Se declara el SqlCommand que ejecutará la
    //instrucción
    SqlCommand cmd = new SqlCommand();
    //Se declara un string donde se construirá
    //la cadena de la instrucción
    String strSql;
    //Se contruye la primera parte de la instrucción
    strSql = String.Format(“Create Database {0} on “, DBName);
    //Se agreagan las rutas de archivos que usará
    //la instrucción CREATE DATABASE
    foreach (String str in Files)
    {
        strSql += String.Format(“(FILENAME='{0}’),”, str);
    }
    //Se remueve la útlima coma de la cadena
    strSql = strSql.Remove(strSql.Length - 1);
    //Se completa la instrucción
    strSql += ” FOR ATTACH”;
    //Se asigna la instrucción al SqlCommand
    cmd.CommandText = strSql;
    //Se asigna la conexión al SqlCommand
    cmd.Connection = cnn;
    //Se intenta ejecutar el SqlCommand
    try
    {
        //Se abre la conexión
        cnn.Open();
        //Se ejecuta la instrucción
        cmd.ExecuteNonQuery();
    }
    catch (SqlException ex)
    {
        //Se capturan los mensajes de error
        messages = ex.Message;
    }
    finally
    {
        //Se cierra la conexión
        cnn.Close();
    }
}



Con esto tendremos listo el método para adjuntar la base de datos. Nótese que he usado un parámetro de lista genérica para pasar la ruta de los archivos que se usaran para adjuntar la base de datos. Si no se agrega el archivo Log, SQL Server intentará crear uno nuevo.


Conclusiones


Como hemos visto hasta ahora, realizar la transformación de T-SQL a ADO.NET ha sido completamente sencillo ya que solo hemos tenido que asignar las instrucciones T-SQL al CommandText de nuestra variable de SqlCommand, seguido solo asignamos la conexión, abrimos la conexión y ejecutamos el SqlCommand. Las demás utilidades que estaré publicando, se hacen de la misma manera.


Recuerden que este método está pensado en el diseño original de la clase SqlUtilities que creamos en la primera publicación de la serie el cual está aquí:


http://msmvps.com/blogs/otelis/archive/2007/06/19/utilidades-de-sql-server-con-ado-net-regenerar-campos-identity.aspx


He decidido publicar segmentos más cortos para  mejor asimilación, este es el primer segmento de la serie que terminará en el método que automatiza el cambio de nombre de una base de datos por completo, así que estén pendientes.


Espero que haya sido de utilidad, nos vemos en el próximo post.


Saludos…


Octavio Telis

Utilidades de Sql Server con ADO.NET – Obtener información de archivos de una base de datos

Hola ¿Qué tal?…


Continuando con las utilidades de SQL Server con ADO.NET  toca el turno a una nueva funcionalidad que puede ser de gran ayuda al momento de cambiar de nombre a una base de datos de SQL Server.


Esta funcionalidad podrá ser utilizada con bases de datos de SQL Server 2005, aunque en ocasiones tendré que especificar si es posible en versiones anteriores a SQL Server 2005 ya que estaré publicando estas utilidades principalmente para funcionar en SQL Server 2005.


Consultar Información de Archivos de una Base de Datos con T-SQL


Una vez realizada la instrucción de la sección anterior, ejecutemos una consulta a las vistas de sistema para verificar el nombre lógico de los archivos de la base de datos. Comúnmente estos archivos llevan el mismo nombre de la base de datos, veamos cómo se hace esta consulta a las vistas de sistema, que en este caso será a la vista sys.database_files, esta vista nos da información acerca de los archivos de la base de datos en contexto, esto se refiere a que como es una vista de sistema, tomará la base de datos que está en el contexto de la conexión para obtener la información de los archivos. Para ver la información completa de los archivos de una base de datos, se utiliza una instrucción como la siguiente:

Use AdventureWorks
Select * From sys.database_files


Esta consulta devolverá toda la información de los archivos, tomaremos una consulta simple, o bien, compacta para consultar los archivos:

Use AdventureWorks
Select Name From sys.database_files


Estos ejemplos nos sirven para consultar los nombres de archivo, sin embargo, en una secuencia de cambio de nombre, habrá que considerar que el nombre de la base de datos ha cambiado, para lo cual la secuencia podría quedar como sigue:

ALTER DATABASE AdventureWorks MODIFY NAME = NewAdventureWorks
GO
Use NewAdventureWorks
Select Name From sys.database_files


Dado que es necesario ejecutar la instrucción ALTER DATABASE de manera independiente, deberemos utilizar la instrucción GO del analizador de consultas para que separe la ejecución de la instrucción ALTER DATABASE de la ejecución de la consulta, quedando como dos ejecuciones independientes.


Consultar Información de Archivos de una Base de Datos con ADO.NET


Realizaremos una consulta a las vistas de sistema y llenaremos un DataTable con la información para tenerla disponible. Esto nos será útil en el proceso que cambiará los nombres de los archivos de la base de datos.


Para la creación de este método utilizaré los campos file_id, type, type_desc, name y physical_name, que son los que nos dan información suficiente sobre los archivos y el tipo al que pertenecen. En el siguiente ejemplo se muestra cómo quedará el código para realizar la consulta:


VB.NET

Public Function GetDataBaseFileInfo() As DataTable
    ‘Declaramos el DataAdapter que usaremos para
    ‘llenar el DataTable
    Dim da As SqlDataAdapter
    ‘Declaramos el DataTable que se usará
    ‘para devolver el resultado
    Dim dt As DataTable = New DataTable()
    ‘Declaramos el SqlCommand que se usará
    ‘para ejecutar la consulta
    Dim cmd As SqlCommand = _
        New SqlCommand(“Select file_id,type, “ & _
                        “type_desc,name,physical_name “ & _
                        “From sys.database_files”)
    ‘Asignamos la conexión al SqlCommand
    ‘construido en la variable cmd
    cmd.Connection = cnn
    ‘Construimos el DataAdapter en la variable
    ‘da utiizando la variable cmd como parámetro
    ‘del constructor
    da = New SqlDataAdapter(cmd)
    ‘Intentaremos llenar la tabla
    Try
        ‘Se ejecuta el método fill que
        ‘llenará la tabla
        da.Fill(dt)
    Catch ex As SqlException
        ‘Capturamos los mensajes de error
        mMessages = ex.Message
    End Try
    ‘Devolvemos la variable dt previamente
    ‘construida
    Return dt
End Function


C#

public DataTable GetDataBaseFileInfo()
{
    //Declaramos el DataAdapter que usaremos para
    //llenar el DataTable
    SqlDataAdapter da;
    //Declaramos el DataTable que se usará
    //para devolver el resultado
    DataTable dt = new DataTable();
    //Declaramos el SqlCommand que se usará
    //para ejecutar la consulta
    SqlCommand cmd = new SqlCommand(“Select file_id,type,” +
        “type_desc,name,physical_name From sys.database_files”);
    //Asignamos la conexión al SqlCommand
    //construido en la variable cmd
    cmd.Connection = cnn;
    //Construimos el DataAdapter en la variable
    //da utiizando la variable cmd como parámetro
    //del constructor
    da = new SqlDataAdapter(cmd);
    //Intentaremos llenar la tabla
    try
    {
        //Se ejecuta el método fill que
        //llenará la tabla
        da.Fill(dt);
    }
    catch (SqlException ex)
    {
        //Capturamos los mensajes de error
        messages = ex.Message;
    }
    //Devolvemos la variable dt previamente
    //construida
    return dt;
}


De esta manera devolvemos de manera conveniente los resultados de la consulta en un DataTable para utilizarlo posteriormente. Cabe mencionar que no se muestra el momento en que se abre la conexión ni tampoco cuando se cierra, y esto es debido a que el método Fill del SqlDataAdapter se encargará de abrir y cerrar la conexión. Otra observación que hay que tener en cuenta es que la consulta se realizará bajo el contexto de la base de datos de la información del ConnectionString del objeto cnn.

Conclusiones

Como hemos visto hasta ahora, realizar la transformación de T-SQL a ADO.NET ha sido completamente sencillo ya que solo hemos tenido que asignar las instrucciones T-SQL al CommandText de nuestra variable de SqlCommand, seguido solo asignamos la conexión, abrimos la conexión y ejecutamos el SqlCommand. Las demás utilidades que estaré publicando, se hacen de la misma manera.


Recuerden que este método está pensado en el diseño original de la clase SqlUtilities que creamos en la primera publicación de la serie el cual está aquí:


http://msmvps.com/blogs/otelis/archive/2007/06/19/utilidades-de-sql-server-con-ado-net-regenerar-campos-identity.aspx


He decidido publicar segmentos más cortos para  mejor asimilación, este es el primer segmento de la serie que terminará en el método que automatiza el cambio de nombre de una base de datos por completo, así que estén pendientes.


Espero que haya sido de utilidad, nos vemos en el próximo post.


Saludos…

Octavio Telis

PodCast Comunidad SharePoint México y PodCast The Sharp Code

Hola ¿Qué tal?


Quiero compartir con ustedes algunos PodCasts Amigos, recién se inicia y sería bueno seguirles la pista.


PodCast Comunidad SharePoint Mexico


El primero, el de la comunidad SharePoint México, de hecho no hablaré mucho de esta comunidad pues el Episodio 1 de su PodCast se encarga de eso.


Este primer episodio lo presenta Roberto Cabañas (www.sharepointmex.com)  para dar entrada a Luis DuSolier (http://sharepointmx.mvps.org/blogs/ldusolier), quien se encarga de describir la comunidad. Escúchenlo y no los pierdan de vista.


Los linkes…


Comunidad SharePoint México:


http://sharepoint.com.mx/


El PodCast:


http://sharepoint.com.mx/PodCasts/Forms/AllItems.aspx


http://sharepoint.com.mx/PodCasts/PrimerPodCastComunidadSharePoint.mp3


 


PodCast The Sharp Code


Pues, Juan José Karam se atreve y nos presenta lo que es su primer episodio del PodCast de The Sharp Code, dedicado al tema de Silverlight y sus detalles, no se lo pierdan, está muy interesante. Por cierto, no dejen de ver los screencast que ha preparado.

Los linkes…

Blog The Sharp Code:

http://www.thesharpcode.com/

El PodCast:

http://thesharpcode.com/?p=53

http://www.podtrac.com/pts/redirect.mp3/thesharpcode.com/Podcasts/TheSharpCodePodcastSilverlight.mp3


Bueno, pronto estaré publicando el episodio 9 del PodCast AS-IS, así que tampoco se lo pierdan, por el momento, les dejo estos para que tengan variedad de la buena. Que lo disfruten y nos vemos.


Saludos…


Octavio Telis

Disney tiene algo que explicar

Hola ¿qué tal?


Pues… no lo puedo creer, y es que no acostumbro referenciar mucho sobre noticias en otros blogs, sin embargo esto está un poco sospechoso por parte de Disney… o de la gente que trabaja ahí.


Recientemente estaba leyendo un post sobre un troyano ligado a los servidores de Disney y relacionado con Pornografia.


Los detalles los pueden ver en el post directamente en:


http://msmvps.com/blogs/hostsnews/archive/2007/06/29/disney-has-some-explaining-to-do.aspx


Saludos…


Octavio Telis

¿A dónde se fue ".NET A New Try" por dos días?

Hola ¿Qué tal?

Se habrán preguntado a dónde se fue mi blog (y el blog de muchos otros hospedados en este servidor) durante el 27 de Junio de 2007 a las 8:00 y el 28 de Junio de 2007 a las 18:00…

Bueno, creerán que fuimos víctimas de un ataque por algún hacker, o que falló Windows Server o que SQL Server se murió… bueno, no fue así, afortunadamente. El motivo por el cual estuvimos sin servicio fue a causa de una falla de hardware, sin embargo, dejaré que sea nuestro administrador del dominio quién lo explique.

La nota completa esta aquí:

http://msmvps.com/blogs/yoda/archive/2007/06/29/so-you-were-probably-wondering-where-i-was-for-the-last-day.aspx

Afortunadamente, el equipo de MVPs que lleva el sitio, ha logrado recuperar todo, o al menos en mi blog está todo, lo único que se perdió… fueron las estadísticas.

Por otra parte… el que ya me preocupó es el sitio de MSDN Live (http://msdnlive.net ), pues el día de hoy ha estado mostrando un mensaje de error, ya tiene varias horas así, tal vez mañana se restablezca y ojalá sea por tareas de mantenimiento que ha estado así.

Bueno… no crean que se han librado de mi, por aquí seguiré atiborrando mi blog de artículos extensos de diversos temas… y son extensos tratando de no dejar la menor duda.

Saludos…

Octavio Telis

 


 

Resumen de la Reunión de la Comunidad.NET del DF del 27 de Junio del 2007

Hola ¿Qué tal?…


Pues eso, que les voy a platicar de lo que fue la reunión de la comunidad el pasado 27 de Junio.


Pues todo comenzó a la hora indicada, con buena audiencia, en primer turno pasó Raúl Guerrero a hablarnos de WCF (Windows Communication Foundation) a manera de introducción mostró los conceptos básicos de la construcción de aplicaciones que implementan WCF en la comunicación entre servicios, servicios web y entre otras aplicaciones.


Después de esto, Juan Karam nos habló de .NET Remoting, a manera de introducción mostró los conceptos básicos de la ejecución de componentes de manera remota, mostrando las diferentes configuraciones que existen en el uso de esta tecnología, misma que ahora se verá enriquecida con WCF.


Para terminar, venía el turno a mi, que en lugar de dar una presentación con diapositivas, preferí hacer un charla más informal en la cafetería del lugar, esto fue con la intensión de crear interés en los asistentes a las nuevas tecnologías que ha lanzado últimamente Microsoft, en esta charla hablamos de Microsoft Surface, Microsoft Silverlight, Microsoft Multipoint y tocamos temas en los que el objetivo era poner a pensar a los participantes en nuevas maneras de hacer las cosas, en particular fue el tema de la interfaz de usuario, donde ahora con Microsoft MultiPoint en CTP nos provoca a los desarrolladores a pensar en un nuevo nicho de mercado orientado a Microsoft Surface.


El evento fue interesante, la última charla básicamente es una introducción a lo que veremos en la próxima sesión.


Todo terminó muy bien, y ya estamos planeando la próxima reunión.


Saludos…


Octavio Telis

PodCast AS-IS Episodio No. 8: Arquitectura 2 – Componentes de Negocio

Hola ¿Qué tal?…


Es momento de pasar al siguiente tema de arquitectura de aplicaciones .NET, es el turno en esta ocasión de la capa de Negocio, o bien, componentes de negocio, workflows y servicios.


En es podcast cubro aspectos diversos de las consideraciones de diseño de componentes de negocio.


Les dejo el link del podcast:


http://feeds.feedburner.com/~r/WebcastAs-is/~5/128048225/Episodio08_26062007.mp3


Y el link del Feed, para que se suscriban:


http://feeds.feedburner.com/WebcastAs-is


Además, La liga al documento que recomiendo en el podcast es la siguiente:


http://msdn2.microsoft.com/en-us/library/ms954595.aspx


http://www.microsoft.com/downloads/details.aspx?familyid=a08e4a09-7ae3-4942-b466-cc778a3bab34&displaylang=en


Espero que les sea de utilidad, y no duden en dejar sus comentarios y observaciones al respecto, estaré atento a lo que digan para mejorar este espacio.


Saludos…


Octavio Telis


Nota: El tema utilizado en este podcast y en los demás es Japan del disco Gravity de Kenny G, pueden adquirir sus discos desde www.kennyg.com


 

Para empezar a utilizar Microsoft Workflow Foundation con Visual Studio 2005

Hola ¿Qué tal?…


En esta ocasión vamos a ver que necesitamos para empezar a utilizar Windows Workflow Foundation.


Primeramente debes instalar algunas cosas adicionales de Visual Studio para poder programar Workflows.


Instalación de Workflow Foundation


Instalar el service pack 1 de Visual Studio 2005, bueno esto es un requerimiento de actualización más que un requerimiento para que funcione WF, y siempre será necesario tener actualizado el sistema antes de iniciar con otras instalaciones, así que, primero instalaremos el Service Pack 1 de Visual Studio 2005.


-Las ligas y la manera de instalarlo están documentados en una publicación anterior:


http://msmvps.com/blogs/otelis/archive/2007/04/11/instalando-service-pack-1-en-visual-studio-2005.aspx


Una vez que se instala el Service Pack 1 de VS2005, procedemos a instalar el .NET Framework 3.0 Redist, este es solo el motor de ejecución necesario para que se ejecuten los Workflows que programamos. La liga de descarga es la siguiente:


http://www.microsoft.com/downloads/details.aspx?FamilyId=10CC340B-F857-4A14-83F5-25634C3BF043&displaylang=en


Opcionalmente, pueden instalar el SDK de Windows Vista y .NET Framework 3.0, en lo personal no he tenido problemas si no lo instalo, sin embargo, toda la documentación del .NET Framework 3.0 está en ese SDK. La liga de la descarga es la siguiente


http://www.microsoft.com/downloads/details.aspx?FamilyId=C2B1E300-F358-4523-B479-F53D234CDCCF&displaylang=en


Una vez instalado el .NET Framework 3.0, procederemos a instalar las extensiones de Workflow Foundation para Visual Studio 2005 que puedes conseguir aquí:


http://www.microsoft.com/downloads/details.aspx?FamilyId=5D61409E-1FA3-48CF-8023-E8F38E709BA6&displaylang=en


Y una vez hecho este proceso tendremos disponibles las plantillas para proyectos basados en Workflow Fountation y tendremos también la infraestructura para ejecutarlos.


Proyectos de Workflow Foundation para WSS 3.0 y MOSS 2007


Primeramente deberemos instalar WSS 3.0, este componente de Windows solo funciona en Windows Server 2003. La liga de descarga es la siguiente:


http://www.microsoft.com/downloads/details.aspx?familyid=d51730b5-48fc-4ca2-b454-8dc2caf93951&displaylang=en


Para poder tener disponibles los proyectos de Workflow Foundation para WSS debemos realizar el proceso de instalación de todo lo anterior y después instalar las extensiones de Windows Sharepoint Services 3.0 Tools para Visual Studio 2005. Estas extensiones instalan las plantillas de proyecto para usarlas en la creación de sitios basados en WSS 3.0 y entre estas plantillas se encontraran las de Workflows para WSS. La liga de descarga es la siguiente:


http://www.microsoft.com/downloads/details.aspx?familyid=19F21E5E-B715-4F0C-B959-8C6DCBDC1057&displaylang=en


Para poder ejecutar estos proyectos será necesario tener instalado WSS en el sistema operativo, WSS solo puede instalarse en Windows Server 2003, por lo qué será necesario contar con este sistema operativo si se quieren ejecutar y depurar proyectos de WSS.


Para tener disponible los proyectos de Workflow Foundation para MOSS 2007, será necesario instalar el producto, esto es, instalar Microsoft Office Sharepoint Server 2007, eso requiere de Windows Server 2003, una vez instalado el producto se tendrán instaladas las plantillas para proyectos de WF sobre MOSS 2007. Descarga MOSS 2007 de evaluación aquí:


http://www.microsoft.com/downloads/details.aspx?familyid=2e6e5a9c-ebf6-4f7f-8467-f4de6bd6b831&displaylang=es


Bien, con esto tendremos todo listo para empezar a utilizar Workflow Foundation en nuestras aplicaciones.


Espero sea de utilidad.


Saludos…


Octavio Telis

Utilidades de Sql Server con ADO.NET – Diagnosticar y Reparar Tablas

Hola ¿Qué tal?…

Continuando con la serie de utilidades de Sql Server con ADO.NET, llega a escena una herramienta que nos proporcionará diagnósticos y reparaciones de nuestras tablas, utilizando el mismo DBCC (Database Command Console) de T-SQL, realizaremos un método en la clase que creamos en la publicación anterior llamada SqlUtilities.

Reparar y Diagnosticar las Tablas de una Base de Datos de SQL Server con T-SQL

Para el diagnóstico y reparación de las tablas de nuestra base de datos utilizaremos la instrucción DBCC CHECKTABLE, en la publicación anterior checamos los campos identity de una tabla, con la instrucción DBCC CHECKIDENT, el cual repara la congruencia de la semilla que da los números automáticamente a los campos Identity y además permite regenerar el contador en caso necesario. En esta ocasión nos vamos un poco más arriba y veremos cómo reparar y diagnosticar nuestras tablas, además de que generaremos un archivo de reporte de los resultados obtenidos. En este caso DBCC CHECKTABLE comprobará la integridad de todas las páginas y estructuras de las que se constituye una tabla o una vista indizada.

Primeramente veremos la instrucción de T-SQL, cómo se usa y los parámetros que ocupa. En el siguiente ejemplo muestro los usos de CHECKTABLE utilizando T-SQL.

– Resume el diagnóstico de la tabla
DBCC CHECKTABLE (‘Production.Product’)

– Intenta reparar la tabla con el riesgo de perder datos
DBCC CHECKTABLE (‘Production.Product’,REPAIR_ALLOW_DATA_LOSS)

– Repara la tabla sin el riesgo de perder datos
DBCC CHECKTABLE (‘Production.Product’,REPAIR_REBUILD)

La primera instrucción devuelve un mensaje como el siguiene:

DBCC results for ‘Production.Product’.
There are 504 rows in 13 pages for object “Production.Product”.
DBCC execution completed.
If DBCC printed error messages, contact your system administrator.

Es importante mencionar que las últimas dos instrucciones solo se pueden realizar con la base de datos en modo de usuario único (single user mode). Esto implica que habrá que tener cuidado del uso de estas instrucciones, ya que solo deben utilizarse cuando se sospecha que la tabla tiene fallas en su estructura.  Siempre será mejor restaurar la base de datos en caso de que el diagnóstico devuelva errores en la tabla, el uso de las opciones de reparación es solo en caso de que no se cuente con un respaldo, así que si las reparaciones se aplican correctamente, será recomendable realizar un respaldo de la base de datos inmediatamente después de quedar reparada la tabla. Esta utilería pretende ser para diagnóstico más que para usarla como reparación, sin embargo ampliaremos la funcionalidad para tener herramientas que nos sirvan en casos extremos.

Diagnosticar y Reparar una Tabla de una Base de Datos de SQL Server con ADO.NET

Una vez identificado el uso de las instrucciones de DBCC CHECKTABLE en T-SQL, podremos realizar los métodos para la ejecución de estas instrucciones.

Será muy simple la manera de programar el método de diagnóstico ya que es análogo a lo que hicimos en la primera publicación de esta serie. Veamos cómo queda:

VB.NET

Public Sub CheckTable(ByVal Table As String)
    ‘Se declaran la variables a utilizar
    Dim cmd As SqlCommand = New SqlCommand(“DBCC CHECKTABLE (@Table)”)

    ‘Se agregan el parámetro @Table para identificar la tabla
    cmd.Parameters.Add(“@Table”, _
            SqlDbType.VarChar, 150).Value = Table
    ‘Se asigna la conexión al command
    cmd.Connection = cnn
    ‘Se intentará la ejecución del código
    Try
        ‘Se abre la conexión
        cnn.Open()
        ‘Se ejecuta la instrucción
        cmd.ExecuteNonQuery()
    Catch ex As Exception
        ‘Se capturan los mensajes de error
        mMessages = ex.Message
    Finally
        ‘se cierra la conexión
        cnn.Close()
    End Try
End
Sub

C#

public void CheckTable(string Table)
{
    //Se declaran la variables a utilizar
    SqlCommand cmd =
        new SqlCommand(“DBCC CHECKTABLE (@Table)”);

    //Se agregan el parámetro @Table para identificar la tabla
    cmd.Parameters.Add(“@Table”,
        SqlDbType.VarChar, 150).Value = Table;
    //Se asigna la conexión al command
    cmd.Connection = cnn;

    //Se intentará la ejecución del código
    try
    {
        //Se abre la conexión
        cnn.Open();
        //Se ejecuta la instrucción
        cmd.ExecuteNonQuery();
    }
    catch (SqlException ex)
    {
        //Se capturan los mensajes de error
        messages = ex.Message;
    }
    finally
    {
        //se cierra la conexión
        cnn.Close();
    }
}

El otro método, el cual servirá para realizar la reparación dependerá primeramente de un enumerador que definiremos fuera de la clase SqlUtilities. Este enumerador servirá para enumerar  las opciones de reparación con las que se contará. Así pues, definamos el enumerador, el cual se muestra en el siguiente ejemplo:

VB.NET

Public Enum RepairOption
    REPAIR_ALLOW_DATA_LOSS
    REPAIR_REBUILD
End Enum

C#

public enum RepairOption
{
    REPAIR_ALLOW_DATA_LOSS,
    REPAIR_REBUILD
}

Este enumerador lo utilizaremos en la definición del método de reparación. Este método será una sobrecarga del que se expone más arriba. La definición será prácticamente la misma, solo tendrá un parámetro adicional del tipo RepairOption que es el enumerador que hemos definido. Este enumerador lo utilizaremos en una siguiente publicación.

En el siguiente ejemplo se muestra cómo queda el método de reparación:

VB.NET

Public Sub CheckTable(ByVal Table As String, _
                      ByVal RepairOption As RepairOption)
    ‘Se declaran la variables a utilizar
    Dim cmd As SqlCommand = _
        New SqlCommand(“DBCC CHECKTABLE (@Table , “ & _
                        RepairOption.ToString() & “)”)
    ‘Se agregan el parámetro @Table para identificar la tabla
    cmd.Parameters.Add(“@Table”, _
            SqlDbType.VarChar, 150).Value = Table
    ‘Se asigna la conexión al command
    cmd.Connection = cnn
    ‘Se intentará la ejecución del código
    Try
        ‘Se abre la conexión
        cnn.Open()
        ‘Se ejecuta la instrucción
        cmd.ExecuteNonQuery()
    Catch ex As Exception
        ‘Se capturan los mensajes de error
        mMessages = ex.Message
    Finally
        ‘se cierra la conexión
        cnn.Close()
    End Try
End
Sub

C#

public void CheckTable(string Table, RepairOption RepairOption)
{
    //Se declaran la variables a utilizar
    SqlCommand cmd =
        new SqlCommand(“DBCC CHECKTABLE (@Table, “ +
                        RepairOption.ToString() + “)”);
    //Se agregan el parámetro @Table para identificar la tabla
    cmd.Parameters.Add(“@Table”,
        SqlDbType.VarChar, 150).Value = Table;
    //Se asigna la conexión al command
    cmd.Connection = cnn;
    //Se intentará la ejecución del código
    try
    {
        //Se abre la conexión
        cnn.Open();
        //Se ejecuta la instrucción
        cmd.ExecuteNonQuery();
    }
    catch (SqlException ex)
    {
        //Se capturan los mensajes de error
        messages = ex.Message;
    }
    finally
    {
        //se cierra la conexión
        cnn.Close();
    }
}

Aquí debemos tener en cuenta dos aspectos, el primero es un “trucazo” para utilizar el parámetro RepairOption sin usar un switch (Select Case en VB.NET) y usar directamente el valor del enumerador en la cadena de consulta, por eso es necesario declarar el enumerador con sus miembros textualmente idénticos a los que se utilizan en T-SQL al pasar los parámetros de reparación. Se usa la variable del tipo RepairOption y se invoca el método ToString() con el que se obtiene el nombre del identificador del valor del enumerador. El segundo aspecto es que no podrémos utilizar este método directamente sin antes haber cambiado la opción de acceso de la base de datos a Single_User, lo cual motiva la siguiente publicación.

Utilización del Método

Bien, aquí están los ejemplos de dos posibles usos:

VB.NET

Uso para diagnóstico:

‘Declaramos nuestra variable del tipo SqlUtilties
Dim sqlUtil As SqlUtilities = _
    New SqlUtilities(“(LOCAL)”, “AdventureWorks”, “”, “”)

‘Ejecutamos el método de diagnóstico       
sqlUtil.CheckTable(“Production.Product”)

‘Mostramos el resultado obtenido
MessageBox.Show(sqlUtil.Messages, “Resultados”, MessageBoxButtons.OK)

Uso para reparación:

‘Declaramos nuestra variable del tipo SqlUtilties
Dim sqlUtil As SqlUtilities = _
    New SqlUtilities(“(LOCAL)”, “AdventureWorks”, “”, “”)

‘Para reparar necesitamos cambiar la opción
‘de la base de datos a Sigle User
sqlUtil.ChangeDbUserAccessOption(DBUserAccessOption.SINGLE_USER)

If sqlUtil.GetCurrentDbUserAccessOption().Trim() = “SINGLE_USER” Then
    ‘Ejecutamos el método de Reparación
    sqlUtil.CheckTable(“Production.Product”, _
                        RepairOption.REPAIR_REBUILD)
Else
    MessageBox.Show(“La base de datos debe estar en Single User”, _
                    “Resultados”, MessageBoxButtons.OK)
End If

‘Mostramos el resultado obtenido
MessageBox.Show(sqlUtil.Messages, “Resultados”, MessageBoxButtons.OK)
‘Regresamos la opción de la base de datos
‘MULTI_USER

C#

Uso para diagnóstico:

//Declaramos nuestra variable del tipo SqlUtilties
SqlUtilities sqlUtil =
    new SqlUtilities(“(LOCAL)”, “VentasWeb”, “”, “”);
//Ejecutamos el método de diagnóstico
sqlUtil.CheckTable(“Production.Product”);
//Mostramos el resultado obtenido
MessageBox.Show(sqlUtil.Messages);

Uso para reparación:

//Declaramos nuestra variable del tipo SqlUtilties
SqlUtilities sqlUtil =
    new SqlUtilities(“(LOCAL)”, “AdventureWorks”, “”, “”);
//Para reparar necesitamos cambiar la opción
//de la base de datos a Sigle User
sqlUtil.ChangeDbUserAccessOption(DBUserAccessOption.SINGLE_USER);
if (sqlUtil.GetCurrentDbUserAccessOption().Trim() == “SINGLE_USER”)
{
    //Ejecutamos el método de Reparación       
    sqlUtil.CheckTable(“Production.Product”,
                        RepairOption.REPAIR_REBUILD);
}
else
{
    MessageBox.Show(“La base de datos debe estar en Single User”,
                    “Resultados”, MessageBoxButtons.OK);
}
//Mostramos el resultado obtenido
MessageBox.Show(sqlUtil.Messages);

Conclusiones

Hemos visto varias cosas nuevas aquí, y algunas contradicciones. Sobre las contradicciones quiero comentarles que puede verse contradictorio en algunas líneas de código el uso de concatenación de instrucciones cuando en la publicación en la que hablo de parámetros sugiero sobre todo el uso de parámetros en lugar de la concatenación. Bueno, en el caso de Alter Table fue necesario ya que no se puede utilizar un parámetro para indicar el nombre de la base de datos, también utilicé la concatenación para indicar los parámetros de algunas instrucciones DBCC, bien, cómo es que esto es válido a pesar de todo. Primeramente, la inyección de SQL no es posible en este medio ya que el nombre de la base de datos se toma de las propiedades de la conexión, si el nombre viene más la conexión hacia la base de datos no es posible, por otra parte, los parámetros se toman de los nombres de miembros de un enumerador fijo, por esta razón podemos decir que la concatenación es segura.

Por otra parte es claro que esta utilidad es muy delicada, debemos tener en cuenta que antes que reparar una tabla, debemos tomar el diagnóstico, y si marca errores, siempre será mejor restaurar un respaldo de la base de datos que intentar corregir la tabla.

Referencias de la Publicación

Esta publicación forma parte de la Serie 2 de la colección Utilidades de SQL Server con ADO.NET

Indice de publicaciones que conforman la Serie II:

Serie II Parte I: Diagnosticar y Reparar Tablas de una Base de Datos (http://msmvps.com/blogs/otelis/archive/2007/06/22/utilidades-de-sql-server-con-ado-net-diagnosticar-y-reparar-tablas.aspx)

Serie II Parte II: Cambiar la opción de acceso de una base de datos (http://msmvps.com/blogs/otelis/archive/2007/07/02/utilidades-de-sql-server-con-ado-net-cambiar-la-opci-243-n-de-acceso-de-una-base-de-datos.aspx)

Serie II Parte III: Consultar la opción de acceso de una base de datos (http://msmvps.com/blogs/otelis/archive/2007/07/02/utilidades-de-sql-server-con-ado-net-consultar-la-opci-243-n-de-acceso-de-una-base-de-datos.aspx)

Referencias Adicionales

Con esto terminamos nuestro recorrido por esta utilidad, si tienes alguna duda o comentario no dudes en dejarme tus comentarios. Las referencias de este tema las pongo a continuación:

DBCC CHECKTABLE
http://msdn2.microsoft.com/en-us/library/ms174338.aspx

ALTER TABLE
http://msdn2.microsoft.com/en-us/library/ms190273.aspx

sys.databases
http://msdn2.microsoft.com/en-us/library/ms178534.aspx

La Clase SqlUtilities
http://msmvps.com/blogs/otelis/archive/2007/06/19/utilidades-de-sql-server-con-ado-net-regenerar-campos-identity.aspx

Bien, pues espero que sea de utilidad.

Saludos…

Octavio Telis