Error en la instancia de SQL Server 2008

17. November 2010 19:07 by Oscar.SS in Desarrollo Empresarial  //  Tags:   //   Comments (5)

Resulta que en un portátil tenía instalado Visual Studio 2010, al instalar SQL Server 2008 me encuentro con que cada vez que SQL Server Management Studio intenta conectar con el motor de base de datos me genera el siguiente error:

 

TITLE: Microsoft SQL Server Management Studio

The type initializer for 'Microsoft.SqlServer.Management.Dmf.PolicyStore' threw an exception. (Microsoft.SqlServer.Dmf)

ADDITIONAL INFORMATION:

Could not load file or assembly 'Microsoft.SqlServer.Diagnostics.STrace, Version=10.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91' or one of its dependencies. El sistema no puede encontrar el archivo especificado. (Microsoft.SqlServer.Dmf) 

 

 

O en la versión totalmente inglesa (tiene gracia que solo cambien una frase):

 

TITLE: Microsoft SQL Server Management Studio

The type initializer for 'Microsoft.SqlServer.Management.Dmf.PolicyStore' threw an exception. (Microsoft.SqlServer.Dmf)

ADDITIONAL INFORMATION:

Could not load file or assembly 'Microsoft.SqlServer.Diagnostics.STrace, Version=10.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91' or one of its dependencies. The system cannot find the file specified. (Microsoft.SqlServer.Dmf)

 

Después de probar distintas soluciones, como por ejemplo (y cito por orden):

1- Instalar SQL Server SP1

2- Reinstalar o Reparar Visual Studio 2010

3- Buscar sin éxito la dichosa DLL, en otra máquina que no daba problemas con SQL Server 2008, para copiarla en la misma ubicación (si la hubiera encontrado).

 

Nada de esto ha funcionado. La solución ha sido desinstalar por completo Visual Studio 2010 y luego volverlo ha instalar. Luego he reiniciado el equipo y todo perfecto.

En fin, lo he comentado aquí por si alguno de vosotros tiene el mismo problema y se puede ahorrar tiempo.

Dar prioridad a un PostBack Asíncrono específico (2ª parte)

6. November 2010 13:34 by Oscar.SS in Desarrollo Web  //  Tags:   //   Comments (2)

Respondiendo a la última pregunta del post anterior continuamos ahora con una pequeña "ñapa" o "remiendo" que se me ocurrió para dar solución a este tema.

El problema es el siguiente. Tenemos por ejemplo un Gridview como el siguiente.

 

 

Y queremos como en el post anterior, que antes de eliminar un registro, se pida una confirmación al usuario, y claro está, que no pida la confirmación cuando intenta editar y actualizar una fila. La pega es que no sirve el código del post anterior porque el método y propiedad get_postBackElement().id nos devuelve el id del Gridview pero no de la celda donde está el comando eliminar que ha pulsado el usuario.

¿Y porqué una solución no muy ortodoxa?. Por que simplemente no he encontrado nada en las propiedades de los parámetros sender y args del evento initializeRequest() que nos permita salvar esta cuestión. Si vosotros conocéis una solución más elegante estaré encantado de conocerla. A mí se me ha ocurrido un pequeño atajo.

Antes de empezar recordar que este Gridview está dentro de un UpdatePanel y que queremos dar la opción al usuario de confirmar si desea eliminar una fila concreta. Bien, veamos como se renderiza en el cliente el código fuente de la celda donde está el comando eliminar.

 

 

Como vemos, cada celda eliminar se renderiza con una etiqueta <td> que contiene otra etiqueta <a> que es donde se ejecuta la llamada al método __doPostBack('GridView1','Delete$2'). Es decir, la llamada a este método provoca el postback asíncrono o llamada AJAX.

¿Y si ponemos "a pelo" en la etiqueta <td> un onclick para llamar a una función cliente propia y desde aquí controlar la ejecución de la llamada AJAX?. Entonces en el evento RowDataBound del Gridview escribimos el siguiente código.

 

    protected void GridView1_RowDataBound(object sender, GridViewRowEventArgs e)
    {
        
//Comprobamos que sea una fila de datos y no una header, footer, etc
        
if (e.Row.RowType == DataControlRowType.DataRow)
        {
            e.Row.Cells[
6].Attributes.Add("onclick""javascript:confirmarEliminar();");
        
}
    }

 

Veamos ahora como se renderiza en el cliente la celda eliminar.

 

 

Como podemos comprobar, ahora ahora tenemos en el <td> una llamada a una función JavaScript personal que se ejecutará antes de llamar al método __doPostBack().

Ahora solo falta implementar esta función personal que contendrá el siguiente código en el que se controla si el usuario ha cancelado la eliminación y en función de esto nosotros cancelamos cualquier llamada al servidor.

 

      <script type="text/javascript" language="javascript">
          
function confirmarEliminar() {

              
var valorConfirm = confirm("¿Está seguro que desea eliminar este registro?");

              
//Si el usuario cancela la eliminación cancelamos la llamada asincrona al servidor.
              
if (!valorConfirm) {
                  
                  
//Intercetamos la llamada automatica de AJAX ASP.NET al servidor.
                  
Sys.WebForms.PageRequestManager.getInstance().add_initializeRequest(cancelarLlamadaAsincrona);

                  function 
cancelarLlamadaAsincrona(sender, args) { args.set_cancel(true)}
              }
          }
      </script> 

Dar prioridad a un PostBack Asíncrono específico (1ª parte)

20. October 2010 22:00 by Oscar.SS in Desarrollo Web  //  Tags:   //   Comments (0)
Le recomiendo al lector que antes de empezar a leer este artículo dedique unos minutos a este otro artículo. En él se explican algunos conceptos que serán necesarios para comprender lo que ahora veremos.
 
Cuando estamos trabajando bajo el esquema del UpdatePanel podemos tener la necesidad de diferenciar que control u objeto provocó la solicitud asíncrona. Para entenderlo con facilidad veamos un ejemplo.
 
Supongamos que tenemos la siguiente interfaz de usuario.
 
 
 
 
La funcionalidad que queremos implementar es que tanto al guardar la dirección del usuario, como al borrar la dirección del campo de texto, se produzca con AJAX. Además, antes de borrar queremos pedir una confirmación al usuario.
 
Introducimos el campo de texto dentro del UpdatePanel y obtenemos el siguiente código.
 
        <asp:UpdatePanel ID="UpdatePanel1" runat="server">
            
<ContentTemplate>
                
<asp:Label ID="lbDireccion" runat="server" Text="Dirección:   "></asp:Label>
                
<asp:TextBox ID="tbDireccion" runat="server" Width="260px"></asp:TextBox>
            
</ContentTemplate>
            
<Triggers>
                
<asp:AsyncPostBackTrigger ControlID="btBorrar" EventName="Click" />
                <
asp:AsyncPostBackTrigger ControlID="btGuardar" EventName="Click" />
            </
Triggers>
        
</asp:UpdatePanel>
 
Ahora viene lo bueno. ¿Como diferenciamos que control provocó la llamada asíncrona?. ¿Como decimos que un botón deba tener una confirmación antes de llamar asincronamente al servidor y el otro botón no?.
 
    <script type="text/javascript" language="javascript">
        
        
//Intercetamos la llamada automatica de AJAX ASP.NET al servidor para pedir una confirmacion antes de eliminar.
        
Sys.WebForms.PageRequestManager.getInstance().add_initializeRequest(confirmarEliminar);

        function 
confirmarEliminar(sender, args) {

            
//Capturamos el boton que inicializa la llamada AJAX.
            
var idPostBack args.get_postBackElement().id;

            if 
(idPostBack == "btBorrar") {
                
var valorConfirm = confirm("¿Está seguro que desea borrar esta dirección.?");

                
//Si el usuario ha cancelado detenemos la llamada al servidor.
                
if (!valorConfirm) {
                    args.set_cancel(
true);
                
}
            }
        }
    </script>
 
En primer lugar debemos interceptar la llamada asíncrona justo antes de que comience. Para ello utilizamos el evento initializeRequest del ciclo de vida cliente. A continuación obtenemos el id del control que provoco la llamada con el método y propiedad get_postBackElement().id. Y en función de la elección del usuario cancelamos la llamada al servidor con el método set_cancel().
 
 

Transformación del Modelo E/R al Modelo Relacional

12. October 2010 20:57 by Oscar.SS in Desarrollo Empresarial  //  Tags:   //   Comments (3)

En el diseño de base de datos lo más difícil y sujeto a la interpretación del desarrollador es construir un buen modelo entidad-relación que represente fielmente el problema. Sin embargo, la transformación de este al modelo relacional es casi mecánico y se basa en unas pocas reglas que ahora veremos.

 

Transformación de entidades débiles

Todas la entidades del modelo E/R  se convierten en tablas en el modelo relacional. Las entidades débiles también se transforman en tablas pero su clave primaria se compone de la unión de esta con la clave de la entidad fuerte a la que pertenece.

 

 

Transformación de las relaciones (1:1)

 

- Mismo Identificador  

Si las dos identidades tienen el mismo identificador se transforman en única tabla que contendrá este identificador como clave primaria y los atributos de ambas entidades.

 

  

- Diferente Identificador  

Cuando tienen diferente identificador cada entidad se convierte en una tabla con su identificador como clave primaria y como clave ajena el identificador de la otra entidad.

 

 

- Cardinalidad Mínima Cero 

Si alguna de las entidades participa con cardinalidad mínima igual a cero se añade una tabla intermedia cuyo identificador se forma por las claves primarias de las otras dos tablas y se le añaden los atributos de la relación cuando los haya.

 

 

 

Transformación de relaciones (1:N)

 

- Cardinalidad Mínima Uno

Si en la relación la entidad que participa con cardinalidad máxima igual a uno, lo hace también con cardinalidad mínima igual a uno, cada entidad se transforma en una tabla con su respectiva clave primaria. La tabla, que participa con caridnalidad N,  tendrá como clave ajena la clave primaria de la otra tabla, así como los atributos de la relación.

 

 

 

Cardinalidad Mínima Cero

En este caso cada entidad se transforma en una tabla con su respectiva clave primaria. Se añade otra tabla que representa la relación, cuya clave primaria será la clave primaria de la tabla con cardinalidad N. Y tendrá como clave ajena la clave primaria de la tabla con cardinalidad uno.

 

 

  

 

Transformación de las relaciones (N:N)

Cada entidad se transforma en una tabla con su respectiva clave primaria. Se añade una tabla para la relación con los atributos de esta y como clave primaria la composición de las claves de las otras entidades.

 

 

 

 

Transformación de las relaciones N-arias

En este tipo de relaciones intervienen 3 o N entidades.

 

 

Al transformarlo al modelo relacional podemos separar cada una de las relaciones y tratarlas por separado.

 

 

De este modo, podemos aplicar las relaciones (1:1), (1:N) o (N:N) según los casos como hemos visto anteriormente. En el ejemplo que nos ocupa tendríamos las siguientes tres tablas. 

 

 

 

 

Transformación de relaciones reflexivas

 

 

En este tipo de relaciones hay que suponer que se trata de una relación binaria normal en la que las dos entidades son iguales. A partir de aquí, aplicar las reglas de las relaciones (1:1) o (N:N).

 

 

 

Consultas SQL sobre multiples tablas

11. September 2010 01:21 by Oscar.SS in Desarrollo Empresarial  //  Tags:   //   Comments (6)

Continuando con el artículo anterior, veremos en este las consultas SELECT combinado columnas de distintas tablas. Este tipo de consultas nos permiten explotar nuestro almacén de negocio de forma más efectiva al relacionar datos de distintas tablas. 

 

--------------------------------------------------------------------------------------------------------------------
--CONSULTAS DE VARIAS TABLAS (Producto cartesiano de filas)--
--------------------------------------------------------------------------------------------------------------------

-- Si no se hacen coincidir los valores de las columnas relacionadas se obtiene gran duplicidad de filas. Tantas como
-- el producto cartesiano de las filas de las tablas a las que se hace referencia. Ejemplo:

select from dbo.Products, dbo.Orders

--------------------------------------------------------------------------------------------------------------------
--UTILIZAR ALIAS EN UNA TABLA--
--------------------------------------------------------------------------------------------------------------------

-- Cuando se relacionan varias tablas es normal que una misma columna forme parte de varias tablas. Para evitar 
-- errores de nombres duplicados podemos hacer dos cosas. Una es utilizar la sintaxis de nombre completo:
-- NombreTabla.NombreColumna.

select from dbo.Products, dbo.Categories
where dbo.Products.CategoryID dbo.Categories.CategoryID

-- La otra forma es dar un alias a cada tabla. Ejemplo:

select from dbo.Products P, dbo.Categories C
where P.CategoryID C.CategoryID

--------------------------------------------------------------------------------------------------------------------
--INSTRUCCIÓN JOIN ON(Coincidencia INTERNAS de columnas)--
--------------------------------------------------------------------------------------------------------------------

--NOTA: La instrucción INNER JOIN  es exactamente lo mismo que JOIN, dado que es el valor predeterminado.

--TEORÍA--

-- La instrucción JOIN nos permite combinar varias tablas haciendo coincidir los valores de las columas que nos 
-- interesen. Es decir, si tenemos dos tablas A y B que contienen una (o varias) columnas con el mismo nombre,
-- podemos relacionar ambas tablas por la columna del mismo nombre.

-- Por cada registro de la columna en la tabla A que también esté en la columna de la tabla B, obtendremos un
-- una relación. Lo que quiere decir que se produce un producto cartesiano de cada valor de la columna de la tabla A,
-- por todos los valores coincidentes de la columna en la tabla B.


--VOLVIENDO A LA BASE DE DATOS NORTHWIND--

-- 1. Por ejemplo, la tabla empleados nos facilita bastante información de los mismos. La más significativa es el
-- número de empleado, el nombre y la ciudad donde vive. Sin embargo, no nos dice nada de las ventas efectuadas por
-- cada empleado.

-- Si miramos la tabla de ventas veremos que además del número de ventas, tenemos información del empleado que
-- realizo estas ventas. Por lo tanto, por medio de la columna EmployeeID presente en las dos tablas podemos
-- relacionar los empleados con el número de venta. Ejemplo:

select OrderID, LastName, FirstName, City
from dbo.Orders O join dbo.Employees E
on  O.EmployeeID E.EmployeeID
order by OrderID

-- De este modo podemos concluir que la columna que pertenece a una tabla A y otra B sirve de nexo para relacionar
-- los datos de otras columnas de la tabla A que no estan incluidos en la tabla B y viceversa.

--2. Otro caso es la tabla de productos que nos da mucha información sobre los mismos pero apenas nos dice nada de 
-- la categoría a la que pertenece cada producto. Mostremos una tabla productos personal que muestre la información
-- más interesante de los productos, más el nombre de la categoría y una descripción de esta.

select ProductID, ProductName, C.CategoryID, CategoryName, Description, UnitPrice, UnitsInStock
from dbo.Products P join dbo.Categories C
on P.CategoryID C.CategoryID

--3. COMBINACIÓN DE TRES TABLAS. Si nos fijamos en las tablas de empleados y de clientes nos damos cuenta que no hay
-- forma de relacionar que empleado atendió (o vendió) a que cliente. Podemos hacerlo a través de la tabla de ventas
-- que tiene los números de empleados y de clientes. 

select E.EmployeeID, LastName, FirstName, OrderID, C.CustomerID, CompanyName, ContactName
from dbo.Orders O 
join dbo.Employees E on O.EmployeeID E.EmployeeID 
join dbo.Customers C on O.CustomerID C.CustomerID
order by EmployeeID

--4. Puede darse el caso en que solo interese esta información para los clientes de España.

select E.EmployeeID, LastName, FirstName, OrderID, C.CustomerID, CompanyName, ContactName
from dbo.Orders O 
join dbo.Employees E on O.EmployeeID E.EmployeeID 
join dbo.Customers C on O.CustomerID C.CustomerID
where C.Country 'Spain'
order by EmployeeID

--5. La instrucción JOIN también podemos utilizarla para sustituir a las subconsultas. La forma de hacerlo es dando
-- dos alias diferentes a una misma tabla. Ejemplo:
--    (Mostrar los empleados que son mayores que el empleado 5 (1955-03-04) ).

-- Técnica de subconsultas.
select EmployeeID, LastName, FirstName, BirthDate from dbo.Employees
where BirthDate > (select BirthDate from dbo.Employees
                    
where EmployeeID 5)

-- Instrucción JOIN.
select E1.EmployeeID, E1.LastName, E1.FirstName, E1.BirthDate from dbo.Employees E1 join dbo.Employees E2
on E1.BirthDate > E2.BirthDate
where E2.EmployeeID 5

--------------------------------------------------------------------------------------------------------------------
--INSTRUCCIÓN OUTER JOIN (Coincidencias EXTERNAS de columnas)--
--------------------------------------------------------------------------------------------------------------------

-- Puede darse el caso que nos interese mostrar todos los valores de una columna (todas las filas) aunque no tengan 
-- correspondencia en la otra tabla. Así podemos tener 3 casos:

--1.Mostrar todos los valores de la tabla IZQ (LEFT), con NULL para la tabla DCH cuando no hay correspondencia
select ProductID, ProductName, C.CategoryID, CategoryName, C.Description, UnitPrice, UnitsInStock
from dbo.Products P left outer join dbo.Categories C
on P.CategoryID C.CategoryID

--2.Mostrar todos los valores de la tabla DCH (RIGHT), con NULL para la tabla IZQ cuando no hay correspondencia.
select ProductID, ProductName, C.CategoryID, CategoryName, C.Description, UnitPrice, UnitsInStock
from dbo.Products P right outer join dbo.Categories C
on P.CategoryID C.CategoryID

--3.Mostrar todos los valores de ambas tablas (FULL) con NULL cuando no hay correspondencia.
select ProductID, ProductName, C.CategoryID, CategoryName, C.Description, UnitPrice, UnitsInStock
from dbo.Products P full outer join dbo.Categories C
on P.CategoryID C.CategoryID

--NOTA: La sentencia OUTER es opcional. Al incluir las sentencias LEFT, RIGHT Y FULL el sistema sabe que es una
--        consulta de combinación externa. Ejemplo anterior:

select ProductID, ProductName, C.CategoryID, CategoryName, C.Description, UnitPrice, UnitsInStock
from dbo.Products P full join dbo.Categories C
on P.CategoryID C.CategoryID

--------------------------------------------------------------------------------------------------------------------
-- INSTRUCCIÓN UNION (Unión de filas en distintas tablas)--
--------------------------------------------------------------------------------------------------------------------

--1. Unir (UNION) todas (ALL) las filas de dos columnas de tablas diferentes.
select City from dbo.Employees
union all
select 
City from dbo.Customers -- Devuelve la suma de todas las filas en ambas columnas.

--2. Unir (UNION) las filas de dos columnas de tablas diferentes sin repetir ningún valor.
select City from dbo.Employees
union
select 
City from dbo.Customers -- Devuelve la suma de todas las filas en ambas columnas pero con valores únicos.

--NOTA: Se debe cumplir que las columnas en ambas instruciones SELECT coincidan en el tipo de datos.

-------------------------------------------------------------------------------------------------------------------- 
-- INSTRUCCIÓNES EXCEPT Y INTERSECT (Diferencia e Intersección de conjuntos)--
--------------------------------------------------------------------------------------------------------------------

-- EXCEPT -- Devuelve los valores de la primera consulta que no se encuentran en la segunda.
select City from dbo.Employees
except
select 
City from dbo.Customers

-- INTERSECT -- Devueleve una intersección de todos los valores, es decir, solo los que se encuentran ambas columnas.
select City from dbo.Employees
intersect
select 
City from dbo.Customers
--------------------------------------------------------------------------------------------------------------------

 

Descarga: Consultas multi Tablas.rar (2,45 kb)

Recent Comments

Comment RSS

Month List