/// <summary>
/// Devuelve el valor a comparar (con comillas simples '' para strings, sin comillas simples para numéricos) con las condiciones pasadas por params:<para/>
/// ETipoDato wherecomparissonvaluetype -> tipo de dato del valor de la condición a comparar<para/>
/// string wherecomparissonvalue -> valor de la condición a comparar<para/>
/// </summary>
/// <param name="wherecomparissonvaluetype"></param>
/// <param name="wherecomparissonvalue"></param>
/// <returns></returns>
public static string SqlBuilderWhereComparissonValue(ETipoDato wherecomparissonvaluetype, string wherecomparissonvalue)
{
string sqlWhereClause = string.Empty;
switch (wherecomparissonvaluetype)
{
case ETipoDato.DBstring: sqlWhereClause += " '" + wherecomparissonvalue + "' "; break;
case ETipoDato.DBchar: sqlWhereClause += " '" + wherecomparissonvalue[0] + "' "; break;
case ETipoDato.DBbyte: sqlWhereClause += " " + wherecomparissonvalue + " "; break;
case ETipoDato.DBshort: sqlWhereClause += " " + wherecomparissonvalue + " "; break;
case ETipoDato.DBint: sqlWhereClause += " " + wherecomparissonvalue + " "; break;
case ETipoDato.DBlong: sqlWhereClause += " " + wherecomparissonvalue + " "; break;
case ETipoDato.DBdecimal: sqlWhereClause += " " + wherecomparissonvalue + " "; break;
case ETipoDato.DBdouble: sqlWhereClause += " " + wherecomparissonvalue + " "; break;
case ETipoDato.DBdatetime: sqlWhereClause += " '" + wherecomparissonvalue + "' "; break;
default: break;
}
return(sqlWhereClause);
}
/// <summary>
/// Crea la cláusula WHERE con la condición pasada por params:<para/>
/// EWhereLogicOperator -> tipo de operador lógico para WHERE múltiples (WHITESPACE, AND, OR)<para/>
/// string -> columna a comparar<para/>
/// EWhereComparisson -> tipo de comparación (LIKE, IS NULL, IS NOT NULL, =,...)<para/>
/// ETipoDato -> Dependiendo del tipo de valor, añadirá comillas simples (strings, char,...) + valor, o sólo el valor (numéricos)<para/>
/// string -> valor a comparar<para/>
/// </summary>
/// <param name="wherelogicoperator"></param>
/// <param name="column"></param>
/// <param name="wherecomparissontype"></param>
/// <param name="wherecomparissonvaluetype"></param>
/// <param name="value"></param>
/// <returns></returns>
public static string SqlBuilderWhereOneRegister(EWhereLogicOperator wherelogicoperator, string column, EWhereComparisson wherecomparissontype,
ETipoDato wherecomparissonvaluetype, string value)
{
string sqlWhereClause = string.Empty;
//Tipo de operador lógico para WHERE múltiples
sqlWhereClause += SqlBuilderWhereLogicOperator(wherelogicoperator);
//Nombre de la columna a comparar
sqlWhereClause += column;
//Tipo de comparación
sqlWhereClause += SqlBuilderWhereComparissonType(wherecomparissontype);
if (wherecomparissontype != EWhereComparisson.ISNULL && wherecomparissontype != EWhereComparisson.ISNOTNULL)
{
//Dependiendo del tipo de valor, añadirá comillas simples (strings, char,...) + valor, o sólo el valor (numéricos)
string wherecomparissonvalue = value.Equals(string.Empty) || value == null || value[0] == ' ' ? "%" : value;
sqlWhereClause += SqlBuilderWhereComparissonValue(wherecomparissonvaluetype, wherecomparissonvalue);
}
return(sqlWhereClause.Replace(" ", " ")); //eliminamos el exceso de caracteres en blanco
}
/// <summary>
/// Crea la cláusula WHERE con la List de condiciones pasadas por params:<para/>
/// EWhereLogicOperator -> tipo de operador lógico para WHERE múltiples (WHITESPACE, AND, OR)<para/>
/// string -> columna a comparar<para/>
/// EWhereComparisson -> tipo de comparación (LIKE, IS NULL, IS NOT NULL, =,...)<para/>
/// ETipoDato -> Dependiendo del tipo de valor, añadirá comillas simples (strings, char,...) + valor, o sólo el valor (numéricos)<para/>
/// string -> valor a comparar<para/>
/// </summary>
/// <param name="whereClause"></param>
/// <returns></returns>
public static string SqlBuilderWhereList(List <Tuple <EWhereLogicOperator, string, EWhereComparisson, ETipoDato, string> > whereClause)
{
string sqlWhereClause = string.Empty;
foreach (Tuple <EWhereLogicOperator, string, EWhereComparisson, ETipoDato, string> item in whereClause)
{
//Tipo de operador lógico para WHERE múltiples
sqlWhereClause += SqlBuilderWhereLogicOperator(item.Item1);
//Nombre de la columna a comparar
sqlWhereClause += item.Item2;
//Tipo de comparación
sqlWhereClause += SqlBuilderWhereComparissonType(item.Item3);
if (item.Item3 != EWhereComparisson.ISNULL && item.Item3 != EWhereComparisson.ISNOTNULL)
{ //Dependiendo del tipo de valor, añadirá comillas simples (strings, char,...) + valor, o sólo el valor (numéricos)
ETipoDato wherecomparissonvaluetype = item.Item4;
string wherecomparissonvalue = item.Item5.Equals(string.Empty) || item.Item5 == null || item.Item5[0] == ' ' ? "%" : item.Item5;
sqlWhereClause += SqlBuilderWhereComparissonValue(wherecomparissonvaluetype, wherecomparissonvalue);
}
}
return(sqlWhereClause.Replace(" ", " ")); //eliminamos el exceso de caracteres en blanco
}
public TxtTipoDeNumero()
{
this.tipo = ETipoDato.Entero;
this._listaChar = null;
}
