domingo, 12 de junio de 2011

NText en Sql Server Ce 4.0

Hoy me han preguntado en el blog como poder grabar un texto de más de 4000 caracteres en una base de datos Sql Server Ce 4.0.

Como me dice el autor del comentario, no tenemos disponible el tipo de datos nvarchar(max), así que la única solución que veo es declarar el campo ntext (que aunque después podría darnos guerra, por lo menos podremos grabar nuestra “super-cadena” de más de 4000 caracteres…)

Pues bien, tengo buenas y malas noticias.

Las malas son que utilizando System.Data.Common (factoría de proveedores) yo no encuentro como hacerlo, es decir, la equivalencia del tipo ntext de CE es System.Data.DbType.String si estamos trabajando con System.Data.Common. Y en este caso, el tamaño máximo de la cadena asignada es 4000. Si intentamos poner una cadena de tamaño superior, no falla pero trunca el valor al grabarlo en la base de datos. De hecho, aquí hay alguien que pregunta por esto mismo, pero como la solución (si es que la hay) está colgada en experts-exchange.com y es de pago, pues me voy a quedar con las ganas y voy a posponer este problema, rezando porque ningún cliente tenga la necesidad de grabar más de 4000 caracteres en las aplicaciones que nos piden en la empresa ;-)

Las buenas noticias son que si utilizamos el proveedor nativo de CE (en vez de la factoría de proveedores) y un SqlCeParameter, sí que podremos grabar más de 4000 caracteres en un campo de tipo ntext.

Por ejemplo, tengo en mi disco un fichero LIBRO.TXT (que literalmente tiene dentro un libro con “chorrocientos mil” caracteres) y no hay problema en guardarlo de este modo…

        Dim cnn As New System.Data.SqlServerCe.SqlCeConnection

        cnn.ConnectionString = "Data Source=|DataDirectory|\MIDB.sdf"

        cnn.Open()

        Dim cmd As New System.Data.SqlServerCe.SqlCeCommand

        cmd.CommandText = "UPDATE Ficheros SET Comentario = @Comentario"

        Dim prm As New System.Data.SqlServerCe.SqlCeParameter

        prm.ParameterName = "@Comentario"

        prm.SqlDbType = Data.SqlDbType.NText

        prm.Value = System.IO.File.ReadAllText("C:\LIBRO.txt")

        cmd.Parameters.Add(prm)

        cmd.Connection = cnn

        cmd.ExecuteNonQuery()

        cmd.Dispose()

        cnn.Dispose()

 

Espero haber contestado con esto a la pregunta del blog, pero en cualquier caso es otro tip a sumar a esa gran decisión de ¿Sql Server CE 4.0 en ASP.NET Sí o No?

Un saludo!.

Enumeraciones binarias

Las enumeraciones son un gran recurso que utilizo casi a diario en mis programas. De hecho, quizás las utilice en exceso, pero una vez me he acostumbrado a trabajar con ellas, lo cierto es que ya no puedo vivir sin ellas.

Un aspecto de las enumeraciones que no es muy utilizado pero que reporta grandes beneficios son las denominadas “enumeraciones binarias”. Por ejemplo, piensa que tenemos una enumeración “Persona” que tiene los siguientes valores: Alto, Bajo, Rubio, Moreno, Delgado, Gordo, Inteligente y Tonto. Todo el mundo sabe cómo asignar un valor sencillo de la enumeración a una variable, por ejemplo:

    Public Enum Persona As Integer

        Alto

        Bajo

        Rubio

        Moreno

        Delgado

        Gordo

        Inteligente

        Tonto

    End Enum

 

    Sub Main()

        Dim manolo As Persona = Persona.Alto

        If manolo = Persona.Alto Then

            Console.WriteLine("Manolo es alto")

        End If

    End Sub

 

Sin embargo ¿Cómo podemos guardar en la misma variable que Manolo, además de Alto también es Rubio y Delgado? Para resolver esto tenemos que utilizan enumeraciones binarias.

Definición

Una enumeración binaria tiene que cumplir las siguientes características:

·         El primer valor de la enumeración tiene que ser 1 (no 0, como es por defecto).

·         El resto de valores de la enumeración tienen que ser la potencia de 2.

·         Tenemos que incluir el adorno Flags.

De este modo, la anterior enumeración quedaría como sigue:

    <Flags()> _

    Public Enum Persona As Integer

        Alto = 1

        Bajo = 2

        Rubio = 4

        Moreno = 8

        Delgado = 32

        Gordo = 64

    End Enum

 

A partir de aquí tenemos que trabajar con operadores lógicos para asignar, consultar o retirar valores de una variable del tipo “Persona”. Los operadores disponibles son:

·         And, conjunción lógica.

·         Or, disyunción lógica.

·         Not, negación lógica.

·         Xor, exclusión lógica.

Agregar valores

Se agregan (suman) valores con el operador Or.

Dim manolo As Persona

manolo = Persona.Alto ' Manolo sólo es Alto (1)

manolo = Persona.Alto Or Persona.Rubio 'Manolo es Alto y Rubio. (5)

manolo = manolo Or Persona.Delgado 'Manolo es además de Alto y Rubio, también Delgado. (37)

 

Si nos fijamos, la primera asignación asigna el valor 1 (Alto) a la variable Manolo.

La segunda asignación asigna el valor 1 (Alto) y el valor 4 (Rubio) a la variable Manolo. De ese modo, Manolo vale 5 (la suma de Alto y Rubio).

Por último, la tercera asignación asigna el valor que ya tuviera Manolo (que podría ser cualquiera pero en nuestro caso es 4 – Alto y Rubio) más el valor 35 (Delgado). Finalmente, Manolo vale 37 (la suma de Alto y Rubio y Delgado).

En lo relativo a la suma de valores, da igual que sumemos varias veces un valor, no por ello Manolo será 2 veces alto!

Retirar valores

Se retiran (restan) valores con el operador Xor.

manolo = Persona.Alto Or Persona.Rubio

manolo = manolo Xor Persona.Rubio 'Manolo ya NO es Rubio (1)

 

Ahora, Manolo ya es no Rubio y su valor es 1, luego es Alto.

Con la resta de valores (Xor) hay que tener mucho cuidado, ya que si intenta restar un valor que actualmente no está asignado, en vez de restar lo que hará es sumar el valor. Por ejemplo:

manolo = Persona.Alto Or Persona.Rubio

manolo = manolo Xor Persona.Rubio 'Manolo ya NO es Rubio (1)

' Manolo no es Moreno, pero intentamos retirar (Xor) el valor Moreno, y en vez de retirarlo lo que hacemos es agregarlo

manolo = manolo Xor Persona.Moreno 'Ahora Manolo es Alto y Moreno (9)

 

Para resolver esto, antes de retirar (restar) un valor hay que asegurarse de que el valor existe realmente. Por ejemplo:

manolo = Persona.Alto Or Persona.Rubio

' Sólo si Manolo es Moreno, le retiramos (restamos) Manolo

If manolo And Persona.Rubio Then 'Comprobar si Manolo es Moreno

manolo = manolo Xor Persona.Moreno

End If

 

Consultar valores

Para consultar valores podemos llevar a cabo las siguientes instrucciones:

manolo = Persona.Bajo Or Persona.Moreno

If manolo = Persona.Bajo Then

Console.WriteLine("Manolo es SÓLO Bajo, nada más")

End If

If manolo And Persona.Bajo Then

Console.WriteLine("Manolo es Bajo")

End If

If manolo = (Persona.Bajo Or Persona.Moreno) Then

Console.WriteLine("Manolo es Bajo y Moreno")

End If

 

Un saludo!.

martes, 7 de junio de 2011

Más experiencias con Sql Server CE 4.0 y ASP.NET

Siguiendo en la línea de los últimos posts, hoy voy a hablar sobre… ¡sorpresa! ¡SQL Server CE 4.0! ;-)

Simplemente son unos tips que me han ocurrido hoy y quería compartirlos.

En SQL Server (la versión de los niños mayores) es perfectamente válida este sentencia:

UPDATE Tabla SET Nombre = Valor FROM Tabla

Sin embargo, en CE la misma consulta nos arroja el siguiente error:

Error al analizar la consulta. [ Token line number = 1,Token line offset = 60,Token in error = FROM ]

Esto quiere decir que a CE no le gusta el FROM, así que la consulta anterior quedaría:

UPDATE Tabla SET Nombre = Valor

Por otro lado y aunque no falla, la sentencia SELECT @@IDENTITY no devuelve ningún valor (al menos a mí no me lo devuelve), así que si quiero saber cual es el último valor de identidad insertado hay que lanzar una consulta como la siguiente:

SELECT autoinc_next - 1 FROM information_schema.columns WHERE table_name = 'MITABLA’ AND autoinc_seed > 0

Ya os iré contando mis venturas y desventuras con CE 4.0 en ASP.NET.

Un saludo!

jueves, 2 de junio de 2011

Ficheros bloqueados de SQL Server CE 4.0 en proyecto ASP.NET

Como sabréis si habéis leído anteriores post de mi blog, estamos inmersos en un proyecto de sitio web ASP.NET con SQL Server Compact Edition 4.0. Después de haber resuelto como desplegar el proyecto en un hosting compartido que no tiene instalado el runtime de SQL Server CE (utilizando también de forma opcional el espacio de nombres System.Data.Common y su factoría de proveedores), ahora nos encontramos con un nuevo problema para el que, con franqueza, no hemos encontrado una solución definitiva.

El problema está es que cuando ejecutamos una página que tiene acceso al fichero .sdf del proyecto (la base de datos de SQL CE), el proceso w3wp.exe (el worker process de ASP.NET) carga el runtime de SQL CE y cuando queremos sobreescribir el directorio \bin de nuevo en el servidor (porque por ejemplo estamos actualizando nuestra aplicación o estamos actualizando la propia versión de SQL CE – cuando llegue el momento y suba de versión, etc.), ciertos ficheros de ese runtime de SQL CE están bloqueados y no permiten la sobreescritura.

Si recordamos, tuvimos que copiar en el directorio \bin de nuestro sitio web todo el contenido de la carpeta C:\Program Files\Microsoft SQL Server Compact Edition\v4.0\Private (excepto el fichero System.Data.SqlServerCe.Entity.dll). Pues bien, cuando queremos volver a subir nuestra aplicación al hosting, obtenemos un “bonito” bloqueo (esto también ocurre cuando copiamos a través de ftp, pero para el ejemplo estoy copiando en un servidor de la oficina utilizando directamente una carpeta compartida).

Si vemos en el servidor que está ocurriendo con el programa Unlocker, podemos ver que el proceso w3wp.exe tiene “pillados” algunos ficheros del runtime de SQL CE.

Para desbloquearlos sólo hemos encontrado las siguientes formas (siempre sin utilizar Unlocker o parecidos que nos parecen un pelín agresivo y además resultan inviable en un entorno de hosting compartido donde no tenemos acceso físico a la máquina):

  • Reiniciar el servicio “Servicio de publicación World Wide Web”.
  • Reciclar el grupo de aplicaciones (AppPool) de nuestra aplicación.

De hecho, el kit de la cuestión es tirar abajo el proceso w3wp.exe, así que en líneas generales, mientras lo consigas cualquier método es válido.

Si estás pensando que modificando el fichero web.config también funcionará… pues va a ser que no. Esto es porque no hay que confundir el AppPool (grupo de aplicaciones), que es quién levanta el proceso w3wp.exe, con el AppDomain (dominio de la aplicación). Si modificas el fichero web.config lo que se reiniciará será el AppDomain (igual que si modificas el fichero global.asax, etc.). Puedes ver más información en el enlace siguiente http://stackoverflow.com/questions/302110/what-causes-an-application-pool-in-iis-to-recycle

Claro está que una solución sería no copiar el directorio \bin completo cada vez que publiquemos, pero con sinceridad quiero despreocuparme de ello y no tener que recordar cada vez que subo que tengo que “excluir” ciertas carpetas y ficheros de mi directorio \bin. De este modo, la única solución digna que hemos encontrado pasa por ser nosotros mismos quienes reiniciemos el grupo de aplicaciones de nuestra aplicación desde el mismo código de nuestra aplicación, y en ese preciso instante (y antes de que nadie pida una página con acceso nuestro fichero .sdf y vuelva a dejar pillado los ficheros), subir rápidamente… La verdad es que no muy científico pero ¡no vemos otra!

Para reiniciar el grupo de aplicaciones desde código, he encontrado los siguientes enlaces. Aún no he probado este método, pero estoy en ello y será “página obligada” en cualquier proyecto ASP.NET con SQL CE 4.0

http://www.codeproject.com/KB/aspnet/AppPoolRecycle.aspx

http://terrapinstation.wordpress.com/2008/06/12/restart-iis-application-pool-from-aspnet-page/

http://www.logue.com.ar/blog/2008/02/find-and-recycle-current-application-pool-programmatically-for-iis-6/

Por otro lado, también tengo que decir (y con profunda amargura) que me estoy encontrado otros problemas con SQL CE 4.0 que me están dejando un mal sabor de boca (ya sé que CE no es SQL Express, pero en mi opinión la gente de Microsoft podía haber hecho algo más por facilitar la vida a los desarrolladores…)

  • No soporta el uso de TransactionScope. Más info aquí. Básicamente CE no soporta transacciones anidadas, y eso y TransactionScope no se llevan bien…
  • No se puede cambiar el nombre de una tabla sino es a través del complemento SQL Server Compact ToolBox.
  • No se puede cambiar el nombre de un campo.
  • No se puede cambiar el orden de los campos.
  • No se puede modificar la identidad (identity) para un campo en una tabla ya creada.
  • No se puede conectar nuestra base de datos con ninguna versión de SSMS (Sql Server Management Studio).
    Cuidado con el complemento SQL Server Compact ToolBox porque sólo tiene un editor de SQL y se perderán los cambios si se genera alguna SQL automáticamente (clic derecho en tabla, por ejemplo). Además de que el editor no está muy logrado en lo relativo a deshacer, seleccionar, etc.

En los próximos días iré contando más experiencias con CE, pero por ahora estoy en ese momento de indecisión, que no sabría si me gusta o no me gusta…

Un saludo!

martes, 24 de mayo de 2011

Resumen de ASP.NET con SQL Server Compact Edition 4.0

Ya estamos preparados para nuestro primer proyecto web con SQL Server CE 4.0.

Si recordáis, en anteriores post hablamos ya sobre CE y sobre como romper el hielo por primera vez con esta base de datos y sobre como desplegar nuestra aplicación en un entorno de hosting compartido sin necesidad de que esté instalado CE en el equipo host.

Ahora que un compañero se ha incorporado al proyecto, ha tenido que preparar su máquina y siendo así, ha sido un momento excepcional para hacer un post resumen de “preparación a CE”. Además, al final del post también haremos un resumen sobre despliegue para que queda todo reflejado en un solo post, tanto instalación como despliegue. Los pasos que hemos seguido han sido los siguientes:

Instalar (si es que aún no lo tenías instalado), Visual Studio 2010 Service Pack 1. Lo puedes descargar desde este enlace o desde WPI (Web Platform Installer).

Instalar SQL Server CE 4.0. De nuevo, podemos elegir entre la descarga directa desde aquí aquí, o instalarlo desde WPI. A mí la verdad es que WPI me da más seguridad porque detecta dependencias entre paquetes y si es necesario las instala también.

clip_image002

Si eres un estudioso y te gusta tener la documentación del producto instalada en tu equipo, también puedes descargar los BOL (Book On Line) de CE desde aquí. Por supuesto, este paso es opcional.

En este momento ya tienes instalado el CE en tu equipo, pero para poder trabajar con CE necesitarás, bien WebMatrix (que fue el primer producto en dar soporte a CE 4.0, pero yo no quiero verlo ni en pintura) o bien instalar Visual Studio 2010 SP1 Tools for SQL Server Compact 4.0, de nuevo desde WPI.

clip_image004

clip_image006

Lo cierto es que, aunque el add-in, add-on, plug-in o como quieras llamarlo, de Visual Studio es suficiente, hay otra herramienta que es must-have y que es SQL Server Compact Toolbox. Está disponible en codeplex  en http://sqlcetoolbox.codeplex.com/ o también desde el administrador de extensiones de Visual Studio. Insisto es que un aplicación muy interesante y que viene a complementar la ya existente en VS.

clip_image008

Por último, si estás utilizando Membership en tu proyecto de ASP.NET, hay que agradecer hasta el infinito y más allá, la aportación de un proveedor de Membership, Role y Profile que se han trabajado en http://sqlcemembership.codeplex.com/.

De hecho, el autor de este proyecto es el mismo que el del add-in SQL Server Compact Toolbox. Su web es http://erikej.blogspot.com/ y es toda una página de referencia sobre CE. También te puedes fijar que en codeplex tiene abiertos más proyectos, todos ellos relativos a CE… y digo yo… ¿Por qué no lo contrata Microsoft? ¿O es que Microsoft le despidió porque sabía demasiado? ;-)

Si hablamos ahora del despliegue, nosotros con ASP.NET 3.5 (creo que con ASP.NET 4.0 serían los mismos pero no puede asegurarlo) y proyecto de sitio web (no he podido hacerlo funcionar en una aplicación web y sigo sin poder hacerlo funcionar) son los siguientes:

Copiar todo el contenido del directorio C:\Program Files\Microsoft SQL Server Compact Edition\v4.0\Private (excepto el fichero System.Data.SqlServerCe.Entity.dll) en el directorio \bin de nuestro sitio web.

De este modo, veremos cómo se agrega a nuestro sitio web una referencia a System.Data.SqlServerCe de tipo BIN.

clip_image010

Cuando publiques, también tendrás que dar permisos de “Modificar” al directorio \App_Data (donde estarán nuestras bases de datos .sdf) y también al directorio \bin (esto es importante y nos ha dado más de un dolor de cabeza!!).

Por último, si estás escribiendo código de acceso a datos independiente de la base de datos subyacente (puedes ver un pequeño tutorial aquí), estarás utilizando System.Data.Common. En este caso tienes que agregar lo siguiente a tu fichero web.config:

  <runtime>

    <assemblyBinding appliesTo="v2.0.50727" xmlns="urn:schemas-microsoft-com:asm.v1">

      <dependentAssembly>

        <assemblyIdentity name="System.Data.SqlServerCe" publicKeyToken="89845dcd8080cc91" culture="neutral"/>

        <bindingRedirect oldVersion="4.0.0.0-4.0.0.1" newVersion="4.0.0.1"/>

      </dependentAssembly>

    </assemblyBinding>

  </runtime>

 

  <system.data>

    <DbProviderFactories>

      <remove invariant="System.Data.SqlServerCe.4.0"/>

      <add name="Microsoft SQL Server Compact Data Provider 4.0" invariant="System.Data.SqlServerCe.4.0" description=".NET Framework Data Provider for Microsoft SQL Server Compact" type="System.Data.SqlServerCe.SqlCeProviderFactory, System.Data.SqlServerCe, Version=4.0.0.1, Culture=neutral, PublicKeyToken=89845dcd8080cc91"/>

    </DbProviderFactories>

  </system.data>

 

Por último y como apunte sencillo, un ejemplo de cadena de conexión contra nuestras bases de datos .sdf sería algo como:

  <connectionStrings>

    <add name="EjemploCE" connectionString="Data Source=|DataDirectory|\Ejemplo.sdf" providerName="System.Data.SqlServerCe.4.0"/>

  </connectionStrings>

 

Seguro que durante el desarrollo de esta aplicación aparecen más cosas dignas de mención, pero por ahora creo que es un buen comienzo para intentar dar el salto a CE para pequeñas y medianas aplicaciones (sobre todo me entusiasma el no tener que depender de SQL Server Express en el hosting compartido).

Un saludo y a programar ASP.NET sobre CE!