Process p = new Process();
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.UseShellExecute = false;
p.StartInfo.Arguments = @" /C C:\spamassassin.exe -e -L < C:\SPAM_TEST.MAI";
p.StartInfo.FileName = @"C:\WINDOWS\System32\cmd.exe";
p.OutputDataReceived += (sender, arguments) => Console.WriteLine("Received output: {0}", arguments.Data);
p.Start();
p.BeginOutputReadLine();
p.WaitForExit();
Console.WriteLine("Exit code: " + p.ExitCode);
p.Close();

Here is a screenshot of the console after calling cmd.exe with a ping command:

Damien Katz also happens to be the founder and CEO of CouchDB. For those how are not familiar with this technology, here is a brief description:  CouchDB is a free and open source documented-orientated database engine. It was designed mostly to serve as a database for web applications.  Traditionally, a relational database management system (RDBMS) presents the data to the user as relations i.e. as a set of tables with each table consisting of a collection of rows and columns. In change, CouchDB stores data as a collection of JSON documents. For example, here is how a document about different chocolates is stored on my local server:

Since data is stored as a flat collection of documents without any scheme describing its internal relations, the engine is capable of storing large scale objects.  But how can semi-unstructured data (i.e. without relations) be queried? The views allows you to define functions to query  the documents of a database but without affecting the underlying document.  For example, the simplest view returns a table containing all the documents in your CouchDB server. The function goes as follow:

function(doc) {
emit(null, doc);
}

And outputs my chocolate document:

{"total_rows":1,"offset":0,"rows":[
{"id":"chocolates","key":null,"value":{"_id":"chocolates","_rev":"2-4066442969","name":null,"cacao_porcentage":null,"country":null}}
]}

Since CouchDB was build on the web, it’s no surprise it has its own HTTP API to consult it. If you are a heavy Windows user like me, you will need to switch your old query analyzer for your browser. This is what makes CouchDB a fresh and interesting abstraction.  Everything (or almost) will now be done using the HTTP API. As Jeff Atwood once pointed out, the web browser address bar is becoming the new command line. This is becoming so true with CouchDB it’s almost scary!

Since CouchDB hit recently 1.0, I was tented to give it a try using a simple C# application. First you will need to download the latest build. I got mine from a question on Stackoverflow but you can also download it from the official wiki. Although CouchDB is able to run on Windows, it is not yet officially supported. Once you have the files on your computer, you’re almost done! If you downloaded the first build mentioned you will only need to launch the couch_start.bat file inside the bin directory and the server will be loaded in seconds:

The console should now appear and tell you to relax:

You should now be able to navigate to your server at: http://127.0.0.1:5984/_utils. In order to query your CouchDB server, you will require a C# API. Several API already exists. I gave it a try with SharpCouch. I attached a small console C# project that uses SharpCouch to list all databases available inside your server:

]]> http://www.jdecuyper.com/?feed=rss2&p=256 0 http://www.jdecuyper.com/?p=206 http://www.jdecuyper.com/?p=206#comments Tue, 13 Jul 2010 22:30:43 +0000 jdecuyper http://www.jdecuyper.com/?p=206 A C# enumeration refers to a set of named constants. Every value inside an enumerator list has a default integer type which starts at zero and, if not specified otherwise, gets automatically increased by one:

enum WebsiteType {
Blog = 0,
News = 1,
Youtube = 2  };

Which is completely equivalent to:

enum WebsiteType {
Blog,
News,
Youtube  };

But not to:

enum WebsiteType {
Blog = 2,
News = 4,
Youtube = 6  };

Enumeration values can only be associated with integer values, if you want to associate an enum value with a string you will need to enhance the enumeration’s behavior. To achieve it,  I have been using the “StringEnum” class from the Code associate .NET project for quite a while now.  The StringEnum class is a helper class that allows you to associate string value to enum values such as:

public enum Animal {
[StringValue("Domestic cat")]
CAT = 0,
[StringValue("Domestic dog")]
DOG = 1,
[StringValue("Domestic golden fish")]
FISH = 3
}

Once you need to retrieve the value associated with a specific value of the enumeration, you can do the following:

string enumValue = "";
enumValue = StringEnum.GetStringValue(Animal.CAT))

It offers a very practical behavior that I have been using throughout a lot of different projects. Nevertheless, I recommend you to use the up-to date version of the class since the one I have been using is not thread safe. I downloaded it a while ago and never bothered to check for a newer version.

Recently, I created a small ASP.NET image gallery for a contest around the anniversary of the Mexican revolution and independence. People were given the right to upload an image and to vote for an image. I configured log4net in such a way that every error that got caught was sent to me by email. It is that way I discovered that an error is sometimes raised when different threads are working with the StringEnum class. I found it quite interesting since I have been using log4net and StringEnum on a lot of projects and the error had never be thrown before.

For performance reason, the StringEnum class holds a static hashtable with all the string values from the enumeration. This helps reducing the look-up costs caused by the reading of the enumerator’s attributes. When you request the StringValue of a particular enumeration value, the StringEnum class queries its hashtable. If it founds the value then it returns it otherwise it adds the new requested value.

The problem is that the hashtable is a static attribute which means it is shared by all the instances of the StringEnum class. Since there is no control over the insertion into the hashtable, when several threads were accessing it, a “System.ArgumentException” could be thrown:

Although the error message is shown in Spanish, it is quite clear that a thread was trying to add a value to the hashtable that already existed! This is not a big surprise since the MSDN documentation states that a “Hashtable is thread safe for use by multiple reader threads and a single writing thread“.  When working with multiple writing threads, things starts to go wrong.

I uploaded a small 2008 Visual Studio solution with a performance test that I applied to the old, the new version of the StringEnum class, and also to a custom version I wrote. Before writing to the hashtable, every thread must request a lock on it, this prevents multiple writing from happening. We need to make sure that while a thread is writing a new value to the hashtable, no other threads can come in and do the same thing. This is where you need to use a lock.

The new version of  StringEnum from the Code Associate locks directly on the hashtable. Although this approach is working, I prefer to use an additional variable to lock on. Creating “lock variables” makes your code a bit cleaner and prevent from having two pieces of code blocking on the same object. In the words of John Skeet: “I believe this is a bad idea (locking on a instance), because it means you have less control over your locks. Other code may well end up locking on the same object as you do within your code, which makes it far harder to ensure that you only obtain locks in an appropriate order“.

If you try out the solution, you will see that the old version of StringEnum (CA_old directory) fails while the newer version (CA_new directory) and mine (CA_custom directory) pass the test without throwing exception. Finally, if you look through my code you will see I added a line of code inside every StringEnum  class that forces the thread to sleep for 12 milliseconds. I added this line in order to provoke more quickly a writing/reading error from a thread. And for those how prefer not to download the project, the method looks like the following, where _stringValue is our hastable:

Download the 2008 Visual Studio solution with the test case.

Navegador de archivos fuentes

DotNetWinService es una mezcla de varias tecnologías entras las cuales se encuentran log4Net, Spring.NET y Quartz.NET. Permite implementar de forma declarativa (con XML) tareas programadas adentro de un servicio Windows. Las tareas se definen adentro del archivo spring-objects.xml:

Archivo spring-objects.xml

Existen, por lo pronto, 4 tipos de tareas disponibles:

TaskURL, para ejecutar una petición HTTP: cuando se trabaja sobre un sitio web en ASP.NET, a veces conviene mejor mantener toda la lógica de negocio adentro de una página que se ejecuta en un intervalo regular. Puede servir para generar un reporte y mandarlo por correo una vez por semana por ejemplo.

TaskEXE, para ejecutar un archivo EXE o BAT: éste procesa se carga solamente si es el único cargado en memoria, no pueden existir varias instancias del mismo proceso corriendo al mismo tiempo. Puede servir para realizar tareas más pesadas como procesar imágenes o generar reportes que ocupen más tiempo de computación.

TaskMethod, para disparar un método adentro de un assembly: solamente se soportan tipos primitivos y cadenas (System.String). En lugar de tener un archivo EXE, se carga el assembly en memoria, y mediante reflexión, se ejecuta un método (estático o de instancia).

TaskMethodInterop, para intercambiar datos entre dos métodos en el mismo assembly o en assemblies diferentes: el valor de retorno del primer método se convierte en el valor de entrada del segundo método. El parámetro es de tipo System.String.

El proyecto está desarrollado con C# y Visual Studio 2008. No duden en comentar o en aportar código.

En un string dado de .NET (en Unicode), considera que existen saltos de línea estándares en la forma \r\n (el equivalente de Environment.NewLine).
Escribe un método que inserte espacio entre dos saltos de líneas consecutivos con el fin de separarlos.

Me llamó mucho la atención, en primer lugar, porque en agosto del 2009 había participado en el proceso de entrevistas para trabajar como intern en Redmond. No recibí ninguna oferta pero este año, lo intentaré otra vez . Y en segundo lugar, porque desde mis entrevistas quedé muy aficionado a este tipo de preguntas técnicas sobre estructuras de datos o recursión entre otros. Dado que había encontrado el post poco tiempo después de su publicación, tuve tiempo de escribir una de las primeras respuestas. Tiene muchos defectos pero también contiene unos elementos interesantes:

string text = "hello \r\n\r\n\r\n world!";
string textResult = "";
char[] caFromText = text.ToCharArray();
for (int i = 0; i < caFromText.Length; ++i)
{
textResult += caFromText[i];
if ((int)caFromText[i] == CARRIAGE_RETURN)
{
// check if not reaching the end of the array
if (i + 3 < caFromText.Length)
{
if ((int)caFromText[i + 1] == NEW_LINE
&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp; (int)caFromText[i + 2] == CARRIAGE_RETURN
&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp; (int)caFromText[i + 3] == NEW_LINE)
{
// two consecutive breaks where detected
textResult += "\n ";
// jump to the next break
++i;
}
}
}
}

Mi idea fue transformar la cadena en un arreglo de caracteres. Luego, iterar sobre cada caracter buscando una secuencia consecutiva de saltos de líneas. Para evitar salirse del arreglo, utilicé un centinela que valida si ya estamos llegando al final del arreglo. Cuando se cumple la condición, se concatena un espacio a la cadena ‘textResult’ que nos sirve para almacenar el resultado final.

Rik Hemsley recompiló todas las repuestas que se propusieron en una bonita solución de Visual Studio. Además, agregó una serie de test para comprobar la validez de todas las implementaciones:

Me dio gusto ver que mi algoritmo sí pasó todas las pruebas mínimas requeridas para agregar un espacio entre dos saltos de líneas consecutivos. Sin embargo, la velocidad de resolución no era nada buena dado que hace uso de una cadena para concatenar el resultado. Sabía que no era la forma correcta de hacerlo, de hecho lo mencioné en mi comentario, pero no me imaginaba lo malo que podría resultar ser la concatenación. Usando el benchmark de Rik Hemsley pude detectar que mi algoritmo lograba parsear un archivo de 2,106,233 caracteres en aproximadamente 107 minutos o 1 hora y 47 minutos!

Para remediar al problema, cambié la cadena por la clase StringBuilder. Las cadenas en .NET framework son inmutables: cuando concatenamos una cadena, cada vez se crea un nuevo objecto de tipo String en memoria con el valor antiguo más el valor a concatenar. El método Append de la clase StringBuilder permite evitar la creación de una cadena a cada concatenación. A continuación, viene mi versión revisada:

using NUnit.Framework;

namespace KirilQuestion.Implementations
{
[TestFixture]
public class JdecuyperRevisited : InsertSpacesFixture
{
private const char CARRIAGE_RETURN = '\r';
private const char NEW_LINE = '\n';

public override string InsertSpaceBetweenCrLfs(string input)
{
var textResult = "";

var caFromText = input.ToCharArray();

for (var i = 0; i < caFromText.Length; ++i)
{
textResult += caFromText[i];

if (caFromText[i] == CARRIAGE_RETURN)
{
// check if not reaching the end of the array

if (i + 3 < caFromText.Length)
{
if (caFromText[i + 1] == NEW_LINE
&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp; caFromText[i + 2] == CARRIAGE_RETURN
&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp; caFromText[i + 3] == NEW_LINE)
{
// two consecutive breaks where detected
textResult += "\n ";

// jump to the next break
++i;
}
}
}
}
return input.Replace("\r\n\r\n", "\r\n \r\n");
}
}
}

Esta última versión de mi código procesó el mismo archivo en 58.5738 milisegundos, más de 10.000 veces más rápido que mi primera versión. Usar la concatenación genera un costo altísimo que más nos vale evitar. Sin embargo, no olviden que no en todas las situaciones se recomienda ocupar un StringBuilder. No usen un StringBuilder cuando las concatenaciones son mínimas ya que seguramente harán un pequeño pedazo de código mucho más complejo de leer además de crear un objeto adicional en memoria. Aunque para pequeñas concatenaciones StringBuilder es más eficiente, nunca lo es de forma significativa.

Si descargan el benchmark, podrán ver que la solución más rápida es la de Jordan Terrell y hace uso de una expresión regular muy potente:

string output = Regex.Replace(input, @"(\r\n)(?=\r\n)", "$1 ");

La expresión regular permite parsear el archivo en menos de 18 milisegundos! Aún 3 veces más rápido que mi última solución. Para entender la expresión regular, vamos a trabajar con un ejemplo un poco más sencillo donde remplacé ‘\r\n’ por ‘_’. Nuestro texto de entrada será:

string input = "hello world __";

Aplicamos primero una expresión regular sencilla:

string outWithoutGroups = Regex.Replace(input, @"__", "_ _");

El resultado se ve bastante bien ya que aparece un espacio entre los dos _:

hello world _ _

Sin embargo, si cambiamos un poco el texto de entrada las cosas se complican:

string input = "hello world______";

La salida es ahora la siguiente:

hello world _ __ __ _

¿Que estará pasando? Después de las palabras “hello world” aparecen 6 carateres que vamos a nombrar 1, 2, 3, 4, 5 y 6 (son los 6 underscores). Cada vez que la expresión realiza un match, i.e. encuentra dos caracteres _ consecutivos, los reemplaza por _ _. El primer match procesa los caracteres 1 y 2. Luego se sigue con el 3 y el 4 y finalmente con el 5 y el 6. El problema es que con esta expresión, no se procesaron los caracteres 3 y 5. Y es por eso que no aparecen espacios entre el 2 y el 3 y entre el 4 y el 5.

Kirill Osenkov realizó una imagen que explica claramente lo que no está procesando nuestra expresión regular:

Para remediar ese problema, Jordan Terrell utilizó un constructor llamado lookahead assertion que fue introducido en su tiempo por Perl 5. La aserción se representa mediante ‘?=’ y permite hacer un match de un _ seguido de otro, sin embargo el segundo _ no es parte del match y será evaluado nuevamente por su cuenta. Lo cual permite generar la salida correcta:

hello world _ _ _ _ _ _

¿Alguien ha sido confrontado con preguntas de este tipo?

Image imagenFormatoOriginal = Image.FromFile(Directory.GetCurrentDirectory() + "//test.jpg");
Image imagenFormatoThumb = imagenFormatoOriginal.GetThumbnailImage(1000, 1000, null, IntPtr.Zero);
imagenFormatoOriginal.Dispose();
imagenFormatoThumb.Save("test_thumbnail.jpg");

La imagen original pesa 1,002 KB y tiene dimensiones de 4096 por 6144 pixeles. La imagen thumbnail generada pesa 361 KB con dimensiones de 1000 por 1000. La nueva imagen representa un 36.02% del peso de la imagen original. Puede parecer un buen ratio pero en una galería de cientos de imágenes cada byte se vuelve importante tanto para el disco duro como para el ancho de banda. En el siguiente código, especificamos el formato en el cual deseamos crear el thumbnail:

Image imagenFormatoOriginal = Image.FromFile(Directory.GetCurrentDirectory() + "//test.jpg");
Image imagenFormatoThumb = imagenFormatoOriginal.GetThumbnailImage(1000, 1000, null, IntPtr.Zero);
imagenFormatoOriginal.Dispose();
imagenFormatoThumb.Save("test_thumbnail_con_formato.jpg", ImageFormat.Jpeg);

Ahora, la imagen thumbnail generada pesa 29KB y tiene dimensiones de 1000 por 1000 pixeles, lo cual representa un 0,34% del peso de la imagen original ¿Que estará suciediendo? El artículo de MSDN sobre el método ‘Save’ indica que cuando no se especifica ningún codificador, se ocupa por default el codificador del formato de gráficos de red portátiles (PNG/Portable Network Graphics). Creo que sería un mejor diseño obligar el programador a escoger siempre el formato en el cuál desea guardar su imagen o que el método ‘Save’ trate de adivinar el formato de la imagen al guardarla. Si examinamos el header de nuestros dos thumbnails generados corroboramos lo anterior. El thumbnail generado sin formato tiene un header específico del formato PNG:

Imagen en formato PNG

En cambio, el header de la segunda imagen presenta las características del formato JPG, mucho más compacto y de menor calidad que PNG:

Imagen en formato JPG

Microsoft SQL Server Management Studio 2008 - Error 916

Cuando se expande el nodo de bases de datos, SSM recolecta información sobre cada base de datos del servidor. Esa información es la misma que aparece en el “Object Explorer Details View” (pueden desplegar esa vista tecleando F7 una vez conectado a la instancia en SSM). El problema es que la información a recolectar no está disponible para las bases de datos apagadas o con la propiedad “AutoClose” prendida.  Si SSM no logra recibir toda la información que requiere, ejecuta un query hacia las bases de datos para tratar de completar su recolección de datos. Dos problemas pueden suceder:

En mi caso, es obviamente la segundo opción que aplica. Lo único que se puede realizar es apagar la propiedad “AutoClose” de todas las bases de datos y asegurar que el siguiente query nunca contenga ningún registro:

SELECT * FROM sys.databases WHERE is_auto_close_on = 1

El bug ya ha sido reportado en Microsoft. Si también te encontraste con ese problema, regístrate y agrega un upvote.

Error 42
La tarea no se ejecutó porque no se encontró "AL.exe" o porque no está instalado el SDK correcto de Microsoft Windows.
La tarea busca "AL.exe" en el subdirectorio "bin", bajo la ubicación especificada en el valor InstallationFolder de la clave del Registro HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SDKs\Windows\v6.0A.
Para resolver el problema, realice una de las siguientes acciones:
1) Instale Microsoft Windows SDK para Windows Server 2008 y .NET Framework 3.5.
2) Instale Visual Studio 2008.
3) Establezca manualmente la clave del Registro especificada anteriormente en la ubicación correcta.
3.) Pase esta ubicación al parámetro "ToolPath" de la tarea.

El mensaje indica que el proceso de compilación no encuentra el ejecutable “AL.exe”. El Assembly linker es una herramienta que ocupa Visual Studio para generar un assembly a partir de módulos escritos en MSIL (lenguaje intermedio de Microsoft) y archivos de recursos. El Assembly Linker viene incluido con el IDE, si no lo tienen instalado, deben descargar el Microsoft SDK e instalarlo. Si igual que yo, ya lo tienen instalado deben abrir el registro mencionado y verificar que el valor de la clave “InstallationFolder” apunte hacia la ubicación del Assembly Linker en su máquina. En caso que se requiera, deberán actualizar el valor de este registro. Después, también será necesario agregar una nueva variable de entorno  como lo pueden ver en la siguiente imagen:

ALTOOLPATH

El nombre de la variable de entorno es “ALTOOLPATH” y su valor en mi máquina es “C:\Program Files\Microsoft SDKs\Windows\v7.0A\bin\al.exe”. Ahora, abran Visual Studio y compilen la solución. Todo debería funcionar correctamente y si no, espero sus comentarios.

¿Cuando se requiere ocupar la búsqueda de texto completo? Como todos lo saben, en SQL Server igual que en cualquier otro sistema gestor de base de datos ya existen comandos que permiten realizar búsquedas en tablas. Por ejemplo, si queremos buscar el país ‘México’ en un catálogo de paises, basta con ejecutar el siguiente comando SQL:

SELECT * FROM Pais WHERE nombre = 'México'

Esto es más que suficiente para ese tipo de búsquedas. Sin embargo, existen casos dónde se requiere recurrir a consultas más complejas donde por ejemplo:

- se ocupan documentos o tablas con un volumen importante.
- se realiza una búsqueda con más de una palabra o una frase.
- la cercanía de las palabras es relevante: se busca la palabra ‘México’ y ‘playa’ con 5 palabras o menos entre cada uno.
- se asignan pesos/importancias diferentes en cada palabra de una frase.
- se necesita considerar las derivaciones de una palabra o de un verbo (ejemplo: correr, corrimos, corre).
- se necesita realizar un búsqueda en campo binario (varbinary o image).
- se toman en cuenta sinonimos (tesaurus)

El Full-Text Engine que dispone SQL Server 2008 permite contestar de forma eficaz a estas consultas, sus táreas más importantes son la indexación y la consulta. La indexación consiste en la creación de una tabla donde se almacenan todas las palabras encontradas en los textos analizados. Por cada palabra se conservan datos como su posición en los documentos, su frecuencia,… No todas las palabras se indexan. El motor de indexación utiliza stoplists (compuestas de stop words) para ignorar palabras como “de”, “la” o “en” con poca relevancia.

Antes, con SQL Server 2000, la indexación se realizaba mediante el servicio MSSEARCH Service (Microsoft Search). Este servicio presente en cada sistema operativo tenía la desventaja de ser compartido con otros procesos como SharePoint o Exchange. Se mejoró esa situación con SQL Server 2005 ya que se agregó funcionalidad para poder crear instancias exclusivas del servicio de búsqueda (Microsoft Full-Text Engine for SQL Server). Sin embargo, una de las consecuencias negativas de esta arquitectura divida entre varios procesos es que los datos indexados no se están respaldando en la base de datos si no en el servicio de búsqueda (externo a la base de datos), lo cual podía complicar la tarea del DBA a la hora de realizar réplicas de una máquina a otra. Al contrario de la versión 2000 & 2005, el Full-Text Engine de SQL Server 2008 está ahora totalmente integrado al mismo proceso de SQL Server como cualquier otro tipo de servicio de la base de datos. Este cambio estructural es muy importante y trae consigo beneficios tanto de rendimiento como de seguridad (leer más en MSDN).

En el siguiente ejemplo, vamos a crear un catálogo de indexación para una tabla de comentarios de un blog ficticio. El Full-Text Engine no está incluido en todas las versiones de SQL Server 2008. Si igual que yo trabajan con la versión Express, deben descargar la versión Express with Advanced Services. Pueden verificar que tengan el servicio instalado mediante la siguiente instrucción:

SELECT fulltextserviceproperty('isfulltextinstalled')

Luego, vamos a crear una base de datos para hacer nuestras pruebas:

USE master
IF DB_ID('full_text_db') IS NOT NULL
DROP DATABASE full_text_db
CREATE DATABASE full_text_db
GO

Se tiene que verificar que nuestra base de datos tenga la búsqueda de texto completo activado:

SELECT DATABASEPROPERTY('full_text_db', 'IsFullTextEnabled');

Si el servicio no está habilitado sobre la base de datos que creamos, lo pueden activar de la siguiente manera:

USE full_text_db
GO
EXEC sp_fulltext_database 'enable'

Ya con nuestra base de datos lista, podemos crear nuestro catálogo de indexación:

CREATE FULLTEXT CATALOG comentariosFullTextSearch

Creamos la tabla de comentarios cuyo contenido vamos a indexar. Es obligatorio crear un índice sobre esa tabla ya que el servicio de indexación lo requiere:

CREATE TABLE Comentarios (
ID [int] IDENTITY(1,1) NOT NULL,
contenido VARCHAR(8000) NOT NULL,
CONSTRAINT [PK_Comentarios] PRIMARY KEY CLUSTERED
(
ID ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

Nada más se tienen que indexar la columnas que se requieren. En nuestro caso vamos a avisar al Full-Text Engine que queremos indexar a la columna ‘contenido’. Mediante la instrucción ‘Language’ indicamos en que idioma está el texto que contiene la tabla:

CREATE FULLTEXT INDEX ON Articulo
(
contenido
Language 0XC0A -- Local ID para español - 3082/0XC0A
)
KEY INDEX PK_Articulo ON articulosFullTextSearch
WITH CHANGE_TRACKING AUTO

Nada más nos queda llenar nuestra tabla con datos de prueba y lanzar la indexación. Por lo general, la indexación se dispara de forma automática y se actualiza regularmente cada vez que se cambian datos en una columna indexada por ejemplo:

INSERT INTO Comentarios VALUES ('México es muy lindo.')
INSERT INTO Comentarios VALUES ('Me gusta Méchico.')
INSERT INTO Comentarios VALUES ('¡Viva Méjico!')
GO
ALTER FULLTEXT INDEX ON Comentarios
START FULL POPULATION

Si todo salió correctamente, ya deben de poder ejecutar la siguientes consultas y empezar a hacer uso del catálogo de indexación que creó el Full-Text Engine para nosotros:

SELECT * FROM Comentarios WHERE CONTAINS(contenido, '"*México*"')
SELECT * FROM Comentarios WHERE CONTAINS(contenido, '"México*" OR "Méjico"')

En mi siguiente post, les daré más explicación sobre los predicados CONTAINS y FREETEXT y sobre cómo armar consultas con sinónimos usando un archivo XML (tesaurus).

FUENTES:
http://en.wikipedia.org/wiki/Full_text_search
http://msdn.microsoft.com/es-es/library/ms142571.aspx

Para regresar esa opción:

1. Abre tu IDE.

2. Herramientas -> Importar y exportar configuraciones.

3. Seleciona “Restablecer todas las configuraciones”.

4. Puedes conservar tu configuración pero no es obligatorio.

5. Selecciona ‘Finalizar’ y listo!