Secuencias de Tablas

SECUENCIAS EN TABLAS DE ORACLE

Una secuencia de una tabla en la base de datos de Oracle, es un consecutivo que se quiere llevar de cada uno de los registros que vamos a ingresar en dicha tabla. Para esto creamos la sencuencia de la siguiente forma:

create sequence NOMBRESECUENCIA

  start with VALORENTERO

  increment by VALORENTERO

  maxvalue VALORENTERO

  minvalue VALORENTERO

  cycle | nocycle;

- La cláusula "start with" indica el valor desde el cual comenzará la generación de números secuenciales. Si no se especifica, se inicia con el valor que indique "minvalue".

- La cláusula "increment by" especifica el incremento, es decir, la diferencia entre los números de la secuencia; debe ser un valor numérico entero positivo o negativo diferente de 0. Si no se indica, por defecto es 1.

- "maxvalue" define el valor máximo para la secuencia. Si se omite, por defecto es 99999999999999999999999999.

- "minvalue" establece el valor mínimo de la secuencia. Si se omite será 1.

- La cláusula "cycle" indica que, cuando la secuencia llegue a máximo valor (valor de "maxvalue") se reinicie, comenzando con el mínimo valor ("minvalue") nuevamente, es decir, la secuencia vuelve a utilizar los números. Si se omite, por defecto la secuencia se crea "nocycle".

Si no se especifica ninguna cláusula, excepto el nombre de la secuencia, por defecto, comenzará en 1, se incrementará en 1, el mínimo valor será 1, el máximo será 999999999999999999999999999 y "nocycle".

En el siguiente ejemplo creamos una secuencia llamada "sec_codigolibros", estableciendo que comience en 1, sus valores estén entre 1 y 99999 y se incrementen en 1, por defecto, será "nocycle":

 create sequence sec_codigolibros

  start with 1

  increment by 1

  maxvalue 99999

  minvalue 1;

Si bien, las secuencias son independientes de las tablas, se utilizarán generalmente para una tabla específica, por lo tanto, es conveniente darle un nombre que referencie a la misma.

Otro ejemplo:

 create sequence sec_numerosocios

  increment by 5

  cycle;

La secuencia anterior, "sec_numerosocios", incrementa sus valores en 5 y al llegar al máximo valor recomenzará la secuencia desde el valor mínimo; no se especifican las otras cláusulas, por lo tanto, por defecto, el valor mínimo es 1, el máximo 999999999999999999999999999 y el valor inicial es 1.

Dijimos que las secuencias son tablas; por lo tanto se accede a ellas mediante consultas, empleando "select". La diferencia es que utilizamos pseudocolumnas para recuperar el valor actual y el siguiente de la secuencia. Estas pseudocolumnas pueden incluirse en el "from" de una consulta a otra tabla o de la tabla "dual".

Para consultar el próximo valor de la secuencia, ejecutamos la siguiente consulta:

select nombreSecuencia.nextval from dual;

Para consulta el valor actual de la secuencia, ejecutamos la siguiente consulta:

select nombreSecuencia.currval from dual;

Referencia:  oracleya

No conecta la VPN de Cisco

Como arreglarlo

• Presiona Win + R y digita regedit para que se abra el editor del registro.
• Navegamos hasta la siguiente clave:  HKLM\SYSTEM\CurrentControlSet\Services\CVirtA
• Doble clic en DisplayName y para arquitectura del procesador x86, cambiamos el valor del dato “@oem8.inf,%CVirtA_Desc%;Cisco Systems VPN Adapter” por el siguiente “Cisco Systems VPN Adapter”
• Para arquitectura x64 cambiamos el valor del dato “@oem8.inf,%CVirtA_Desc%;Cisco Systems VPN Adapter for 64-bit Windows” por el siguiente “Cisco Systems VPN Adapter for 64-bit Windows”

Cerramos el editor del registro e intentamos conectarnos nuevamente. A veces no se requiere reiniciar el cliente de la VPN para que esto funcione, ni tampoco el equipo.

Series de TV

El banquete de la producción audiovisual contemporánea tiene en las series de televisión el mejor bocado. Las audiencias no mienten: hay series que obtienen la fidelidad que muchos amantes quisieran para ellos. 

Fidelidad y devoción. Pues se podrían contar por miles los fanáticos que repiten, una y otra vez, las seis temporadas de un proyecto llamado Los Soprano o de otro conocido como Mad Men. Ya pasaron seis años y dos meses desde que se emitió el último capítulo de Los Soprano y todavía hoy gana cautivos. 

Así lo expresa el crítico de televisión Ómar Rincón, quien asegura que Breaking Bad, la serie cuya quinta y última temporada se emite desde el domingo pasado en Estados Unidos, hace mucho rato entró a la categoría de culto. 

Infinidad de medios -especializados o no-, han analizado el impacto de esta serie en la historia actual de la televisión. Y explican parte de su poderosa atracción en el trabajo realizado porBryan Cranston en su representación de Walter White, un tranquilo profesor de química que llevado por las circunstancias, empieza a sintetizar metanfetaminas y luego a venderlas para convertirse en objetivo de la DEA. Y la bola de nieve adquiere proporciones impresionantes para este personaje, su cómplice y su familia. 

"Creo que este proyecto gusta mucho entre el televidente más sofisticado. Los Soprano podría tener un poco más de pegamento al cine, Lost pertenece más a los fanáticos de las redes sociales, Mad Men es de los que somos más mediáticos y buscadores de historias. Esta serie le gusta mucho a la gente que conoce el lenguaje audiovisual y que sabe de fotografía y narración", dice Rincón. 

Como valores fundamentales Breaking Bad tiene, según este analista, "la calidad del guión, la manera de contarlo, la fuerza del personaje y su antiestética televisiva". Rincón agrega que este es un personaje "angustiante, que no comete ninguna emoción esperanzadora. Yo creo que no hay mucha gente capaz de ver varios capítulos seguidos, es un personaje muy angustiante". 

En una entrevista publicada por El País de España, Cranston describe su manera de construir el personaje. 

"Pensé en mi padre, un tipo cargado de espaldas. Alguien deprimido cuando le vemos por primera vez. Ha visto pasar tantas oportunidades fallidas que solo pone un pie delante del otro. Quise que fuera invisible; su piel, su ropa, nada tenía que llamar la atención. Y luego está el pelo. Fundamental en su transformación. Me informé de los efectos de la quimioterapia, pero me interesó más cómo el pelo afecta a nuestra forma de leer un rostro. El pelo nos suaviza la cara. Por eso una cabeza rapada es lo contrario. Y si encima le dejas la barba, el efecto es amenazante".

Tip SQL!!!

• Quitar caracteres como Enter y Tabulados

¿Cómo se puede formatear cadenas de texto?

Cuando tenemos un texto y hacemos lo siguiente:
Console.WriteLine("La cantidad de dinero que tengo en el banco es : {0:C}",dinero);

Ese :C de más quiere decir que formatearemos la entrada como una moneda, por ejemplo en el caso del peso Colombiano, yen japonés, el euro alemán o el peso mexicano. La C determina el tipo de formato, y la cultura, la forma de llevarlo a cabo.

Otros ejemplos son: D para decimal, E para notación exponencial o científica, F para punto decimal fijo (i.e. 4 => 4.0), G para la versión general, es decir, la más compacta posible; N para un número con separador de miles, decimales, etc.; P para porcentaje, R para redondear, X para hexadecimal.

 s = string.Format("{0:D}", 99901); // s == 99901
s = string.Format("{0:D10}", 99901); // s == 0000099901
s = string.Format("{0:E}", 1983.42"); // s == 1.98342E+003
s = string.Format("{0:F2}", 1983"); // s == 1983.00
s = string.Format("{0:F3}", 1983.4266"); // s == 1983.427
s = string.Format(japones, "{0:N}", 1983.55); // s == 1.983,55
s = string.Format("{0:P}", 0.42); // s == 42 %
s = string.Format("{0:X4}", 255); // s == 00FF
Si ninguna de estas nos satisface, podemos crear nuestro propio formato mediante el formato de números especializado. Para hacer esto, podemos colocar en lugar del D, E, C, etc., un 0 para representar un dígito, si existe, o un cero si no; un # para representar un dígito si existe, si no, no muestra nada; El punto . para separar decimales y la coma para separar grupos. Asimismo, tenemos % para porcentaje, ‰ para por-miles, E0 para notación exponencial, ‘cadena’ para poner una cadena de texto fija.

 s = string.Format("{0:0,00.00#:D}", 99.1); // s == 0,99.10
s = string.Format(aleman, "{0:0,00.00#:D}", 99.1); // s == 0.99,10
s = string.Format("{0:000,000.000}", 9991); // s == 009,991.000
s = string.Format("{0:#,#00}", 99.1); // s == 99
s = string.Format("{0:#,#00}", 9.1); // s == 09
s = string.Format("{0:#,#00}", 9999.1); // s == 9,999
s = string.Format("{0:##-###-##}", 99942); // s == 999-42
s = string.Format("{0:##-###-##}", 4299942); // s == 42-999-42
El formato también podemos aplicarlo a las fechas, de forma muy similar a como se aplica para números. Existen muchos formatos, pero los más utilizados son los siguientes: se usa la d y D para una fecha corta y una fecha larga, respectivamente; f y F para fecha con tiempo corto y largo, u y U para formato universal corto y largo.

 CultureInfo enUS = new CultureInfo("en-US");
CultureInfo deDE = new CultureInfo("de-DE");
CultureInfo esMX = new CultureInfo("es-MX");

DateTime tm = new DateTime(2012, 12, 04, 11, 05, 42);
s = string.Format(esMX, "{0:d}", tm); // s == 12/04/2012
s = string.Format(esMX, "{0:d}", tm); // s == 04/12/2012
s = string.Format(deDE, "{0:D}", tm); // s == Dienstag, 4. Dezember 2012
s = string.Format(enUS, "{0:f}", tm); // s == Tuesday, 4 Dic, 2012 11:05
Etcétera. También podemos utilizar formato especial usando y, M, d, m, h, M, s para representar año, mes, día, minuto hora, segundo, etc. Por ejemplo, cuatro yes suponen año en formato de cuatro dígitos, como 1983. Dos yes y tendríamos 83.

 s = string.Format(esMX, "{0:ddd d MMM}", tm);
// s == mar 4 dic
s = string.Format(esMX, "{0:dddd d MMMM}", tm);
// s == martes 4 diciembre
s = string.Format(esMX, "{0:H mm ss}", tm);
// s == 11 05 42
s = string.Format(esMX, "{0:y yy yyyy yyyyy}", tm);
// s == 2 12 2012 02012

Calico Electronico

Esta es una animación que me a entretenido demasiado, es graciosa y sirve como relajación de tanto trabajo y estudio.

Cálico Electrónico 1ª Temporada Capítulo 1: Culones

Cálico Electrónico 2ª Temporada Capítulo 1: El fin de Cálico

Conceptos de C#

Enumerables

Son clases que implementan las interfaces:
IEnumerable: Que premitira enumerar sus propiedades.
IEnumerator: El que retornara las propiedades

por ejemplo: IList, Dictionary

BITARRAY

Esta clase, ubicada en el espacio de nombres System.Collections.

• Implementa ICollection.
• No permite agregar elementos luego de creado.
• El tamaño se define en el constructor. 

Ejemplos:

BitArray bits1 = new BitArray(10);

BitArray bits2 = new BitArray(bits1);

boo[] boolArray = new bool[] { true, true, false, true, false, false, false };

BitArray bits3 = new BitArray(boolArray);

BitArray bits4 = new BitArray(10, true);

byte[] byteArray = new byte[] { 0xff, 0x00 };

BitArray bits5 = new BitArray(byteArray);




La primera llamada nos genera un array con diez bits. La segunda llamada nos genera un array el cual copia el tamaño y los bits contenidos en el primer array. El tercer arreglo se crea con siete bits de la forma 1101000, y la siguiente llamada nos genera un arreglo de diez bits, todos inicializados a 1. Finalmente, la quinta llamada nos genera un array de 16 bits, con los primeros ocho bits establecidos a 1 y los siguientes ocho establecidos a 0. 

Fuente y ejemplos







COLECCIONES PARA TRABAJAR CON TEXTO

en este apunte vamos a explorar algunas de las clases que podemos utilizar, en particular, para trabajar con cadenas de texto: StringCollection, StringDictionary y NameValueCollection.

Todas están dentro del espacio de nombres System.Collections.Specialized.

StringCollection: ésta representa una colección de cadenas de texto:

• Está particularmente optimizada para trabajar con cadenas de texto.
• La colección cuenta con varias propiedades estándares, como SyncRoot e IsSynchronized para temas de concurrencia y sincronización en el acceso a elementos;
• Count: Obtiene el número de la colección.
• IsReadOnly: Saber si se puede agregar elementos a la colección.
• Indexador para obtener una cadena de acuerdo al indicado.
• Métodos Add, Remove, Insert.
• AddRange para agregar un array de cadenas de una vez.

StringDictionary: implementa un Hashtable pero fuertemente tipado para emplear cadenas de texto.

NameValueCollection: se comporta como StringDictionary, pero es una colección no un diccionario.

• Nos permite acceder a los elementos via indice y clave.
• Nos permite en el constructor especificar el comparador.

Esto es una resumida explicación del trabajo con estas colecciones.

Fuente

TRES DICCIONARIOS ESPECIALIZADOS

• ListDictionary: mientras Hashtable almacena los pares llave-valor en bloques de memoria que son accesibles vía el código hash de la llave, ListDictionary los almacena como si fuera una lista enlazada. Es decir, el primer elemento contiene el par llave-valor, más un apuntador (o referencia, en el argot de C#) al elemento siguiente, y así sucesivamente hasta llegar al final de la lista. Esto implica que ListDictionary no manipula la memoria (o al menos, no de la forma en que Hashtable lo hace) y por lo tanto el acceso a los elementos es más eficiente en términos de memoria y procesamiento. Esto quiere decir que si la lista es pequeña, el rendimiento es bueno con ListDictionary mientras que si la lista es de un tamaño grande, entonces es mejor trabajar con HashTable.

• HybridDictionary: Supongamos que tenemos un escenario en el cual tenemos un diccionario que generalmente tiene pocos elementos. Pero que bajo ciertas circunstancias, éste puede crecer. Para no perder el rendimiento, tendríamos que usar ListDictionary y cuando éste crezca, copiar todos los elementos a un Hashtable. Pues bien, hay una colección que hace precísamente eso: HybridDictionary. Esta clase emplea de forma interna un ListDictionary cuando el número de elementos se mantiene bajo, pero que cambia a Hashtable cuando el número crece.

OrderedDictionary: Es un diccionario que mantiene ordenados los elementos basados en la llave de los mismos en bloques de memoria contigua, de forma muy similar a como los almacena un array o un vector. La principal ventaja de esto es que podemos acceder a los elementos no solamente a través de la llave, sino también a través de un índice.

Y esos son los tres diccionarios especializados, aunque existen mas, pero luego hablaremos de ellos.

                                                                                                                                                          Fuente

COLLECTIONBASE, READONLYCOLLECTIONBASE Y DICTIONARYBASE

CollectionBase: Clase que sirve de base para crear colecciones.

• Implementa estas tres interfaces: IList, ICollection e IEnumerable.

ReadOnlyCollectionBase: La finalidad es que podamos crear colecciones de solo lectura, es decir, que no podamos agregar o eliminar elementos, solo leerlos.

DictionaryBase: También existe una clase análoga a CollectionBase, solo que para diccionarios: DictionaryBase. La clase está estructurada de forma similar a su contraparte. Existen los miembros Count, Clear, CopyTo y GetEnumerator como públicos, así como los métodos para realizar validaciones(OnClear, OnInsert, OnGet, OnSet, OnRemove, OnValidate, etc.) solo que acomodados para poder recibir pares llave-valor. La diferencia más grande (aparte de que esta clase implementa IDictionary en lugar de IList) es que esta clase tiene dos propiedades públicas, Dictionary (de tipo IDictionary) e InnerHashtable (de tipo Hashtable), contrapertes de List e InnerList respectivamente. Ambas representan el diccionario subyacente de DictionaryBase.

COLLECTION GENERIC

Como habrás podido imaginar, el proceso de envolver/desenvolver tipos valor es un proceso que consume recursos, y de hecho hacer esto seguido puede causar daños en rendimiento a tu programa. Comprenderás ahora el problema de utilizar ArrayList (o cualquier colección de las que hemos visto) con tipos de dato valor. Y esto es algo que ni siquiera se soluciona heredando de CollectionBase/DictionaryBase. La única forma real de solventar esta situación sería crear una clase que implemente ICollection/IList/IDictionary y utilizar arrays, los cuales tendríamos que redimensionar manualmente. Y esto no es particularmente productivo.

La llegada de los genéricos en .NET 2.0 solucionó este problema. El poder usar genéricos nos evita los boxings y unboxings para las estructuras, y naturalmente, proporciona métodos y clases fuertemente tipadas. Podríamos reescribir el método foo de hace tres párrafos de la siguiente forma.

A partir de .NET 2.0 se crearon muchas clases de colecciones genéricas, la mayoría bajo el espacio de nombres System.Collections.Generic.

INTERFACES

• IEnumerable<T>
• ICollection<T>
• IList<T>
• IDictionary<K,V>

CLASES

• Queue<T>
• Stack<T>
• SortedList<T>
• SortedDictionary<K,V>: Mantiene el diccionario ordenado por la llave
• LinkedList<T>: Un ejemplo de esta clase:

LinkedList<string> list = new LinkedList<string>();
list.AddLast("Seiya");
list.AddLast("Shiriu");
list.AddLast("Yoga");
list.AddLast("Shun");
list.AddLast("Ikki");

 for (LinkedListNode<string> node = list.First; node != null; node = node.Next)

{

    string prev = node.Previous != null ? node.Previous.Value : "NULL";

    string next = node.Next != null ? node.Next.Value : "NULL";

    Console.WriteLine("[{0}] - {1} - [{2}]", prev, node.Value, next);
}

• List<T>: Todo sobre esta clase la podemos encontrar en el siguiente link

CLASES

• Clases estaticas
• Para crear una clase no estática que permita crear solo una instancia de sí misma, vea Implementando Singleton en C#

CODIGO SNIPPETS
Esta es la ruta donde se encuentran los archivos de los códigos Snippets:
C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC#\Snippets\1033\Visual C#

Un ejemplo de un archivo, es el siguiente:
Nombre Archivo: query.snippet
Contenido:

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2008/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>query</Title>
      <Shortcut>query</Shortcut>
      <Description>Genera un método encapsulado para consultar datos en la base de datos</Description>
      <Author>Sensei - Servinte</Author>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
        <SnippetType>SurroundsWith</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Declarations>
        <Literal>
          <ID>type</ID>
          <ToolTip>método de consulta de datos</ToolTip>
          <Default>object</Default>
        </Literal>
      </Declarations>
      <Code Language="CSharp">
        <![CDATA[
        /// <summary>
        ///
        /// </summary>       
        public static $type$ nameMethod()
        {
            return GetExistMC();
        }
        /// <summary>
        ///
        /// </summary>       
        static $type$ GetNameMethod()
        {
            const string methodName = "GetOrderReportHandler::GetNameMethod()";
            bool result = false;
            ParameterValues parameters = new ParameterValues();
           
            try
            {
                BaseRuntime.Trace("chhhcecli", methodName, "Inicia:  descripcion de lo que hace el método");
                string query = ResourceHelper.GetQuery(Servinte.Clinic.Orders.Reads.Resources.Resources.Queries, BaseRuntime.ProviderName, "ID_QUERY");              
                parameters.Add(secuence, DbType.Int32);

                using (DatabaseManager db = new DatabaseManager(BaseRuntime.ProviderEnum, BaseRuntime.ConnectionString))           
                using (IDataReader reader = db.ExecuteReader(query,parameters,null))
                {
                    while (reader.Read())
                    {
                        if (!reader.IsDBNull(0))
                        {
                           
                        }
                    }
                    if (reader.IsClosed)
                        reader.Close();
                }
            }
            catch (Exception ex)
            {
                BaseRuntime.Log("chhhcecli", methodName, ex);
                throw ex;
            }
            finally
            {
                BaseRuntime.Trace("chhhcecli", methodName, "Fin:  Descripción de lo que hizo el método");
            }
            return result;
        }]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Examen 70-483: Programming in C#

En los siguientes enlaces podemos encontrar dos blog donde nos muestran el temario para el examen y el porcentaje de cada uno de los temas:

• MSDN study links for exam 70-483: Programming in C# (JAYWAY) --> En ingles
• 70-483: programming in C# (Blogoso de Fer++) --> En español.

Merge en CSharp

Se me presento un problema al realizar el Merge de dos tablas, pues llegaba un momento en el cual los nuevos datos que queria agregar a la tabla principal, de la tabla nueva, me duplicaba las columnas. Esto me complicaba luego cuando queria trabajar con los datos de la tabla, pues al tener columnas duplicadas ya se imaginaran que sucederia.
La solución fue especificarle los siguientes parámetros:
dtPrincipal.Merge(dtSecundaria,true,MissingSchemaAction.Ignore);

dtPrincipal = DataTable principal donde estamos almacenando la información.
dtSecundaria = DataTable secundaria donde tenemos los datos

Documentos en Tortoise

Para consultar los enlaces de los documentos en tortoise, que nos envian los coordinadores, se debe realizar lo siguiente:

• Clic derecho en el escritorio.
• Seleccionamos el Tortoise - Repo-Browser.
• En la ventana emergente URL, copiamos el enlace del documento que nos enviaron por correo.
• Clic en OK
• Si pide username y password, lo digitamos.
• Nos muestra el documento.
• Lo descargamos localmente para que lo podamos ver o le damos open with y elegimos el programa para abrir el documento.

Sacar Copia Caso de Uso EA

Para sacar una copia a un caso de uso del EA, se posiciona en el caso de uso, le damos clic derecho y seleccionamos las opciones mostradas en la imagen:

Asignar botones a notas del historico

Cada nota del histórico debe llevar ciertas configuraciones, por ejemplo, para asignar botones a una nota del histórico, seguimos los siguientes pasos:

1. En la entidad Messages-ClinicDocumentEntity, creamos los comandos para manejar los métodos que van a disparar el hacer clic en el botón. Estos comandos los creamos como propiedades.
2. En la misma entidad creamos unas boleanas de visibilidad, para saber si se estarán disponibles los botones o no. Estas boleanas las creamos como propiedades, las cuales van a disparar el evento de cambio de valor, tanto para la boleana sola, como la de la boleanda de mostrar comando.
3. Se crea en el DynamicTemplateHelper dependiendo del código del comando, configuramos estos en el texto estructurado.
4. En el componente del histórico de notas, se agregan al bindeo de los comandos el respectivo comando y creamos su respectivo método que va hacer lo que le corresponde.

Solucionar Bloqueos en Tablas SQL Server

Resulta que cuando una tabla es muy utilizada (muchas consultas), o cuando se “cruzan” las transacciones sobre la misma tabla, se produce un bloqueo a nivel de tabla, lo que hace que ya no se puedan realizar más consultas. 

Según lo que leí (inicialmente en blog.andr3z.org y luego en otros lugares), existen 2 posibles soluciones al problema:

•  Modificar la consulta para saltarnos el bloqueo
• Intentar resolver el bloqueo de la tabla

Cada solución tiene su propio alcance, sus pros y contras, veamos cada solución en detalle:

• Solución 1: Modificar la consulta para “saltar” el bloqueo:

    Ámbito: No se desbloquea la tabla, solo se devuelven los resultados

    Pros: Permite realizar el SELECT sin restricción.

Contras: Puede retornar resultados fuera del Committed de la base de datos (es decir que los resultados pueden no ser fidedignos)

Para implementar esta solución, basta modificar el SELECT de la consulta, agregando el modificador WITH (NOLOCK), lo que hará que se omita el bloqueo de la tabla:

SELECT Field1, Field2,… FieldN FROM [Mi_Tabla] WITH (NOLOCK) WHERE …

• Solución 2: Intentar resolver el bloqueo de la tabla:

    Ámbito: Se intenta resolver el bloqueo.

Pros: Se resuelve definitivamente el bloqueo (por lo menos hasta que se vuelva a producir un bloqueo nuevo en la misma tabla)

    Contras: Requiere tener acceso/permisos para “Matar” procesos (incluso de otros usuarios).

Para esta solución, SQL server provee un procedimiento almacenado que muestra los bloqueos en curso: sp_lock.

Basta con ejecutar:

Execute sp_lock

Para ver los bloqueos activos en la base de datos.

Cabe mencionar que adicionalmente SQL Server también provee 2 procedimientos que permiten listar los procesos que están consumiendo muchos recursos: sp_who o sp_who2 siendo este último el que provee más detalles.

Una vez se ha identificado cual es el proceso que esta provocando el bloqueo, se puede proceder a “Matar” dicho proceso utilizando la información que arrojan los procedimientos ya mencionados (básicamente se requiere el ID del proceso que se va a matar).

Ejecutar: 

Kill <id_del_proceso_a_matar>

Bueno, pues eso era todo, como siempre, espero que esta información llegue a ser útil para alguno de ustedes.

Fuente: eklectopia

Configuracion Conexiones Workbench

Para realizar las diferentes configuraciones para el gestor de bases de datos Workbench, realizamos los siguientes pasos dependiendo del motor de bases de datos:

SQL SERVER

• Para crear una conexión en el Workbench, debemos crear primero una conexión ODBC, donde ingresamos todos los datos correspondientes a la base de datos.
• Luego en la interface de configuración de las conexiones del Workbench, configuramos la conexión como vemos a continuación:

• 
  

Ya con todas estas configuraciones bien realizadas, es muy posible que no existan problemas con la conexión.

ORACLE

[Configuracion]

INFORMIX

[Configuracion]

Ventana Popup En Control WPF

Para asignar una ventana popup a un control, se puede realizar la siguiente lógica. En nuestro ejemplo vamos a mostrar una ventana popup para un boton, osea al dar clic en el botón se mostrara  la ventana.
El código para mostrar la ventana se agrega en el evento clic del botón:

private void Boton_Click(object sender, System.Windows.Input.ExecutedRoutedEventArgs e)

        {

            try

            {

                Dictionary<string, string> paramUserControl = new Dictionary<string, string>();

                paramUserControl.Add("unParametro");

                //Instanciamos el control wpf que va a mostrar la información.

                UCExample u = new UCExample ();

                u.SetContext(paramStateTreatment);

                //Instanciamos la ventana contenedora del control

                Popup popup = new Popup()

                {

                    Child = u,

                    AllowsTransparency = true,

                    StaysOpen = true,

                    IsOpen = false,

                    PlacementTarget = ((System.Windows.Controls.Control)(e.OriginalSource)),

                    Placement = PlacementMode.Left

                };

                //Binding para setear la propiedad "Width" del contenedor con la ventana de la información

                Binding widthBinding = new Binding("Width") { Mode = BindingMode.OneWay, Source = popup };

                ((FrameworkElement)u).SetBinding(WidthProperty, widthBinding);

                 //Le damos un tiempo para mostrar la ventana

                DispatcherTimer activeTimer = new DispatcherTimer { Interval = new TimeSpan(0,0,7) };

                activeTimer.Tick += (obj, ea) => ClosePopup(popup);

                activeTimer.Start();

                popup.IsOpen = true;

                return;

            }

            catch (Exception)

            {

                throw;

            }

        }

Dentro de una ventana popup puede ir cualquier template. El código del usercontrol que va a ir dentro de la ventana popup, es el siguiente:

XAML

<UserControl x:Class="Servinte.Clinic.Controls.UCSeeTreatmentStatus"

             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

             mc:Ignorable="d" Height="Auto" Width="Auto">

    <UserControl.Resources>

        <Style TargetType="Label" x:Key="lblControl">

            <Setter Property="HorizontalContentAlignment" Value="Left"/>

        </Style>

        <Style TargetType="TextBlock" x:Key="txtbControl">

            <Setter Property="HorizontalAlignment" Value="Left"/>

            <Setter Property="VerticalAlignment" Value="Center"/>

        </Style>

    </UserControl.Resources>

    <Border Background="White" BorderBrush="Black" BorderThickness="2">

        <Grid Margin="5">

            <Grid.ColumnDefinitions>

                <ColumnDefinition/>

                <ColumnDefinition Width="Auto"/>

            </Grid.ColumnDefinitions>

            <Grid.RowDefinitions>

                <RowDefinition Height="Auto"/>

                <RowDefinition Height="Auto"/>

                <RowDefinition Height="Auto"/>

                <RowDefinition Height="Auto"/>

            </Grid.RowDefinitions>

            <Label Content="Nombre " Style="{StaticResource lblControl}"/>

            <TextBlock Grid.Column="1" Name="txtbName" Style="{StaticResource txtbControl}"/>

            <Label Grid.Row="1" Content="Apellidos " Style="{StaticResource lblControl}"/>

            <TextBlock Grid.Row="1" Grid.Column="1" Name="txtbLastName" Style="{StaticResource txtbControl}"/>

            <Label Grid.Row="2" Content="Profesión " Style="{StaticResource lblControl}"/>

            <TextBlock Grid.Row="2" Grid.Column="1" Name="txtbProfession" Style="{StaticResource txtbControl}"/>

            <Label Grid.Row="3" Content="Fecha Nacimiento " Style="{StaticResource lblControl}"/>

            <TextBlock Grid.Row="3" Grid.Column="1" Name="txtbDateBorn" Style="{StaticResource txtbControl}"/>

        </Grid>

    </Border>

</UserControl>

C#

using System.Collections.Generic;

using System.Windows.Controls;

namespace MyNamespace.Controls

{

    /// <summary>

    /// Interaction logic for UCExample.xaml

    /// </summary>

    public partial class UCExample : UserControl

    {

        public UCExample()

        {

            InitializeComponent();

        }

        /// <summary>

        /// Seteamos el contexto de la ventana que informa los datos de la persona

        /// </summary>

        public void SetContext(Dictionary<string,string> param)

        {           

            //Nombre

            txtbName.Text = string.Format(": {0}", param["Name"]);

            //Apellidos

            txtbLastName.Text = string.Format(": {0}", param["LastName"]);

            //Profesion

            txtbProfession.Text = string.Format(": {0}", param["Profesion"]);

            //Fecha de nacimiento

            txtbDateBorn.Text = string.Format(": {0}",param["DateBorn"]));           

        }

    }

}

Mando de un Formula Uno

Si te gustaría conducir un auto de Fórmula Uno, primero tienes que saber cómo funciona el volante, para eso, esta práctica de los controles del nuevo MP4-28 de McLaren es ideal.

Los controles del volante del McLaren MP4-28: izquierda arriba
La cabina del auto de F1 es un lugar frugal: un asiento moldeado, un arnés de cuatro puntos y mucha fibra de carbono a la vista. Todos los controles que hacen andar a esta máquina ultra sofisticada de valor multimillonario están ubicados en el volante, y el conductor tiene que operarlo a casi 320km/h, usando unos guantes grandotes ignífugos.
1. La 'N' verde
Empecemos con algo fácil. El botón N verde grande pone la palanca de cambios en punto muerto. Probablemente, todos hayamos hecho esto en nuestro auto y está perfecto para el as de la F1 que quiere retroceder a los boxes.

2. El '+10' verde
 El botón '+10' verde lo usa el conductor cuando está viendo información del coche, puede adelantar hasta 10 páginas por vez. Debe haber mucha información…

3. El botón alargado rojo
Al costado del volante, este barril rojo giratorio con número es el interruptor diferencial. Le permite al conductor manipular las configuraciones de los diferenciales activos del auto sobre la marcha, ajustando el agarre del auto y el uso de la energía.
4. El lápiz labial rojo
No es un término técnico pero el interruptor rojo que parece un lápiz labial es en verdad el botón de la radio. El conductor lo usa para comunicarse con los expertos de la pit lane.

5. El botón 'OT' amarillo
Ahora se pone más emocionante. El botón amarillo con la 'OT' aumental as revoluciones del motor para ayudar a pasar a otros autos. Suele operarse en conjunto con el DRS y el KERS pero hablaremos de eso más adelante. OT significa 'over take',” tomar el mando” en inglés, lo que podría ser una expresión de deseo... pero nos gusta el optimismo.

6. La 'X' blanca
Parece como que podría bajar el parche del ojo y levantar la bandera negra pero en realidad el botón de la 'X' blanca solamente acepta y activa la página de información que escogió el conductor. Un poco decepcionante.

Los controles del volante del McLaren MP4-28: centro
Ahora estamos en el corazón del volante de F1.

1. Lectura en voz alta digital superior 
No es fácil de ver con el auto apagado pero en la parte superior del volante hay un tablero con pantalla digital que le informa al conductor todo tipo de cosas: tiene un indicador de velocidad, un contador de revoluciones, una pantalla de encendido, un cuentakilómetros, por lo general, con un número aterrador.

2. El cuadrante blanco
El cuadrante blanco a la izquierda controla el balance de los frenos del auto. Los frenos suelen estar a 60:40 hacia el frente pero, al conductor, sus amigos con laptop en la pit lane podrían instruirle que altere esta disposición, posiblemente para proteger las llantas.

3. El cuadrante rojo
El cuadrante rojo ajusta la cantidad de frenado de motor que tiene el auto. Esto es particularmente útil en los circuitos rápidos que el auto recorre con fuerza de agarre baja y que requieren algo de ayuda extra para la detención.

4. El cuadrante amarillo
Éste ajusta la configuración del motor del auto. El conductor puede cambiar la proporción combustible/aire sobre la marcha para influenciar sobre el rendimiento y/o la economía.


Los controles del volante del McLaren MP4-28: derecha arriba

Hay todavía más controles en el lado derecho del volante de F1.

1. El botón '+1' verde
Éste le permite al conductor hojear las páginas de información del tablero de a una a la vez.

2. El botón 'P' amarillo
Éste es el botón limitador de velocidad de la pit lane. Pínchalo y el auto baja de golpe a 80km/h para evitar un ticket por acelerar hacia dentro de los boxes.
3. El interruptor barril verde 
Este interruptor numerado controla el Sistema de Recuperación de Energía Kinética (KERS, por sus siglas en inglés). Almacena energía kinética en forma de electricidad y permite que salga toda junta en un chorro de rendimiento extra. Con este control, el conductor puede determinar cuánta energía almacena el auto.

4. El botón 'solapa' rojo
Controla el Sistema de Reducción de Arrastre. Mueve una solapa en la parte trasera para reducir el arrastre y aumentar la velocidad en el camino. Sólo recuerda volver a poner la solapa hacia atrás en la próxima esquina.

Los controles del volante McLaren MP4-28: derecha abajo
Ahora estamos en la parte derecha inferior del volante de F1 McLaren, esperamos que estés entendiendo todo.

1. El botón 'confirm' azul
Se usa cuando los boxes te están dando un regaño bienintencionado justo cuando estás esquivando una arremetida kamikaze a 250km/h en el interior de Michael Schumacher. Al presionarlo se confirma que el conductor recibió el mensaje sin que haya que hablar. Tal vez el botón podría decir 'ahora no' en lugar de 'confirmar'... o algo por el estilo.

2. El botón 'drinks' (bebidas)
Pedalear un auto de F1 es una tarea sedienta y este botón dispara un poco de ese refresco tan necesitado por la garganta del conductor. En tan sólo unos milisegundos después de presionarlo, desearás haberles pedido a los chicos del garaje que te dieran agua mineral fría y no sopa de minestrone.

3. El cuadrante de las llantas
El cuadrante grande, de aspecto impresionante en la parte inferior de esta foto es el cuadrante de las llantas. El conductor lo ajusta para decirle a la computadora qué llantas están puestas en el auto y así poder cambiar la configuración correspondiente.


Los controles del volante del McLaren MP4-28: izquierda abajo
El botón a la izquierda, minimalista en comparación, del volante del MP4-28 funciona de la siguiente manera.

1. El cuadrante púrpura
El cuadrante púrpura que está abajo a la izquierda del volante parece bastante inofensivo pero es el control multifunción y gobierna más de 50 configuraciones diferentes en todo el auto: desde el tablero que lee en voz alta hasta los parámetros del motor.
2. Distintivo Mercedes-Benz 
Les recuerda a los conductores McLaren quién construyó el motor.

Los controles del volante del McLaren MP4-28: parte posterior
¿Pensaste que ya habíamos visto todo? Piensa de nuevo, hay más en la parte posterior.

Fuera de la vista, en la parte detrás del volante, los conductores tienen palancas de cambio para cambiar la velocidad, el botón que dispara el chorro de energía del KERS y el embriague, aunque ese sólo se usa para encender el auto.