/// <summary>
/// Permite obtener los registro de una tabla, dentro de un DataTable existente, filtrando por diferentes campos
/// </summary>
/// <param name="nDataTable">DataTable en el que se devolveran los registros</param>
/// <param name="nDataTableName">Nombre de la tabla</param>
/// <param name="nKeys">Llave primaria del registro</param>
/// <param name="nMaxRows">Número máximo de registros a retornar, 0 para devolver todas la filas</param>
/// <param name="nOrderByParams">Parametros de ordenación, null para no rodenar</param>
internal void DBFilterFill(DataTable nDataTable, string nDataTableName, List<Parameter> nKeys, int nMaxRows, ColumnEnumList nOrderByParams)
{
bool Result;
Exception Exception;
if (this.DbManager.IsRemoting)
{
var TempDataTable = new DataTable();
this.DbManager.DataBase.DBFilterFill(ref TempDataTable, this.SchemaName, nDataTableName, nKeys, nMaxRows, nOrderByParams, out Result, out Exception);
if (!Result) throw Exception;
if (nDataTable.Columns.Count == 0)
{
nDataTable.Merge(TempDataTable);
}
else if (TempDataTable.Columns.Count == nDataTable.Columns.Count)
{
foreach (DataRow Fila in TempDataTable.Rows)
{
object[] Items = new object[nDataTable.Columns.Count];
for (int i = 0; i < nDataTable.Columns.Count; i++)
{
Items[i] = Fila[nDataTable.Columns[i].ColumnName];
}
nDataTable.Rows.Add(Items);
}
}
else
{
throw new Exception("La estructura devuelta por la base de datos no coincide con la tabla");
}
}
else
{
this.DbManager.DataBase.DBFilterFill(ref nDataTable, this.SchemaName, nDataTableName, nKeys, nMaxRows, nOrderByParams, out Result, out Exception);
if (!Result) throw Exception;
}
}
/// <summary>
/// Permite obtener los registro de una tabla filtrando por la llave primaria
/// </summary>
/// <param name="nDataTableName">Nombre de la tabla</param>
/// <param name="nKeys">Llave primaria del registro</param>
/// <param name="nMaxRows">Número máximo de registros a retornar, 0 para devolver todas la filas</param>
/// <param name="nOrderByParams">Parametros de ordenación, null para no rodenar</param>
/// <returns>Resultado de la consulta</returns>
internal DataTable DBGet(string nDataTableName, List<Parameter> nKeys, int nMaxRows, ColumnEnumList nOrderByParams)
{
bool Result;
Exception Exception;
DataTable Tabla = this.DbManager.DataBase.DBGet(this.SchemaName, nDataTableName, nKeys, nMaxRows, nOrderByParams, out Result, out Exception);
if (!Result) throw Exception;
return Tabla;
}
/// <summary>
/// Permite obtener los registro de una tabla, dentro de una tabla existente, filtrando por la llave primaria
/// </summary>
/// <param name="nDataTable">DataTable en el que se devolveran los registros</param>
/// <param name="nDataTableName">Nombre de la tabla</param>
/// <param name="nKeys">Llave primaria del registro</param>
/// <param name="nMaxRows">Número máximo de registros a retornar, 0 para devolver todas la filas</param>
/// <param name="nOrderByParams">Parametros de ordenación, null para no rodenar</param>
internal void DBFill(DataTable nDataTable, string nDataTableName, List <Parameter> nKeys, int nMaxRows, ColumnEnumList nOrderByParams)
{
bool Result;
Exception Exception;
if (this.DbManager.IsRemoting)
{
var TempDataTable = new DataTable();
this.DbManager.DataBase.DBFill(ref TempDataTable, this.SchemaName, nDataTableName, nKeys, out Result, out Exception);
if (!Result)
{
throw Exception;
}
if (nDataTable.Columns.Count == 0)
{
nDataTable.Merge(TempDataTable);
}
else if (TempDataTable.Columns.Count == nDataTable.Columns.Count)
{
foreach (DataRow Fila in TempDataTable.Rows)
{
object[] Items = new object[nDataTable.Columns.Count];
for (int i = 0; i < nDataTable.Columns.Count; i++)
{
Items[i] = Fila[nDataTable.Columns[i].ColumnName];
}
nDataTable.Rows.Add(Items);
}
}
else
{
throw new Exception("La estructura devuelta por la base de datos no coincide con la tabla");
}
}
else
{
this.DbManager.DataBase.DBFill(ref nDataTable, this.SchemaName, nDataTableName, nKeys, nMaxRows, nOrderByParams, out Result, out Exception);
if (!Result)
{
throw Exception;
}
}
}
/// <summary>
/// Permite obtener los registro de una tabla filtrando por diferentes campos
/// </summary>
/// <param name="nDataTableName">Nombre de la tabla</param>
/// <param name="nKeys">Llave primaria del registro</param>
/// <param name="nMaxRows">Número máximo de registros a retornar, 0 para devolver todas la filas</param>
/// <param name="nOrderByParams">Parametros de ordenación, null para no rodenar</param>
/// <returns>Resultado de la consulta</returns>
internal DataTable DBFilterGet(string nDataTableName, List <Parameter> nKeys, int nMaxRows, ColumnEnumList nOrderByParams)
{
bool Result;
Exception Exception;
DataTable Tabla = this.DbManager.DataBase.DBFilterGet(this.SchemaName, nDataTableName, nKeys, nMaxRows, nOrderByParams, out Result, out Exception);
if (!Result)
{
throw Exception;
}
return(Tabla);
}
/// <summary>
/// Permite obtener los registro de una tabla filtrando por diferentes campos
/// </summary>
/// <param name="nKeys">Llave primaria del registro</param>
/// <param name="nMaxRows">Número máximo de registros a retornar, 0 para devolver todas la filas</param>
/// <param name="nOrderByParams">Parametros de ordenación, null para no rodenar</param>
/// <returns>Resultado de la consulta</returns>
protected virtual DataTable DBFilterGet(List <Parameter> nKeys, int nMaxRows, ColumnEnumList nOrderByParams)
{
return(this.SchemaManager.DBFilterGet(this._ObjectName, nKeys, nMaxRows, nOrderByParams));
}
/// <summary>
/// Permite obtener los registro de una tabla, dentro de una tabla existente, filtrando por la llave primaria
/// </summary>
/// <param name="nDataTable">DataTable en el que se devolveran los registros</param>
/// <param name="nKeys">Llave primaria del registro</param>
/// <param name="nMaxRows">Número máximo de registros a retornar, 0 para devolver todas la filas</param>
/// <param name="nOrderByParams">Parametros de ordenación, null para no rodenar</param>
protected virtual void DBFill(DataTable nDataTable, List <Parameter> nKeys, int nMaxRows, ColumnEnumList nOrderByParams)
{
this.SchemaManager.DBFill(nDataTable, this._ObjectName, nKeys, nMaxRows, nOrderByParams);
}
/// <summary>
/// Permite obtener los registros de varias tablas filtrando por diferentes campos
/// </summary>
/// <param name="nDataTable">Resultado de la consulta</param>
/// <param name="nDataBaseCod">Base de datos a la que pertenece la tabla</param>
/// <param name="nSchemaName">Esquema al que pertenece la tabla</param>
/// <param name="nDataTableName">Nombre de la tabla</param>
/// <param name="nKeys">Llave primaria del registro</param>
/// <param name="nTableRelationList">Lista de relaciones con otras tablas</param>
/// <param name="nMaxRows">Número máximo de registros a retornar</param>
/// <param name="nResult">Define si la instrucción se ejecutó correctamente o no</param>
/// <param name="nException">Exepción ocurrida al ejecutar la instrucción</param>
public void DBQueryFill(ref DataTable nDataTable, string nDataBaseCod, string nSchemaName, string nDataTableName, List<Parameter> nKeys, TableRelationCollection nTableRelationList, int nMaxRows, ColumnEnumList nOrderByParams)
{
try
{
bool nResult = true;
Exception nException = null;
int index = 0;
//Ejecutar la consulta principal
var primaryRelations = new TableRelationCollection();
while (index < nTableRelationList.Count)
{
if (nTableRelationList[index].ForeignDataBaseCod != nDataBaseCod)
break;
primaryRelations.Add((TableRelation)nTableRelationList[index].Clone());
index++;
}
ManagerPool[nDataBaseCod].DataBase.DBQueryFill(ref nDataTable, "form", nSchemaName, nDataTableName, nKeys, primaryRelations, nMaxRows, nOrderByParams, out nResult, out nException);
if (!nResult) throw nException;
//TODO: Agregar consultas a relaciones a base de datos externas
while (index < nTableRelationList.Count)
{
index++;
}
}
catch (Exception ex)
{
throw new Exception("Error al recuperar los registros de la tabla [" + nDataBaseCod + "] " + nSchemaName + "." + nDataTableName + ", " + ex.Message, ex);
}
}
public override string ConvertSqlSelectToOrderBy(string sql, ColumnEnumList GroupByParams)
{
if (GroupByParams != null && GroupByParams.Count > 0)
return sql + " ORDER BY " + GroupByParams.getOrderByParams(this);
else
return sql;
}
/// <summary>
/// Permite obtener los registro de una tabla filtrando por la llave primaria
/// </summary>
/// <param name="nKeys">Llave primaria del registro</param>
/// <param name="nMaxRows">Número máximo de registros a retornar, 0 para devolver todas la filas</param>
/// <param name="nOrderByParams">Parametros de ordenación, null para no rodenar</param>
/// <returns>Resultado de la consulta</returns>
protected virtual DataTable DBGet(List<Parameter> nKeys, int nMaxRows, ColumnEnumList nOrderByParams)
{
return this.SchemaManager.DBGet(this._ObjectName, nKeys, nMaxRows, nOrderByParams);
}
/// <summary>
/// Permite obtener los registro de una tabla, dentro de un DataTable existente, filtrando por diferentes campos
/// </summary>
/// <param name="nDataTable">DataTable en el que se devolveran los registros</param>
/// <param name="nKeys">Llave primaria del registro</param>
/// <param name="nMaxRows">Número máximo de registros a retornar, 0 para devolver todas la filas</param>
/// <param name="nOrderByParams">Parametros de ordenación, null para no rodenar</param>
protected virtual void DBFilterFill(DataTable nDataTable, List<Parameter> nKeys, int nMaxRows, ColumnEnumList nOrderByParams)
{
this.SchemaManager.DBFilterFill(nDataTable, this._ObjectName, nKeys, nMaxRows, nOrderByParams);
}
public abstract string ConvertSqlSelectToOrderBy(string sql, ColumnEnumList GroupByParams);
/// <summary>
/// Construye la sentencia SQL Avanzada a una serie de tablas
/// </summary>
/// <param name="nTableAlias">Alias de la tabla</param>
/// <param name="nSchemaName">Esquema al que pertenece la tabla</param>
/// <param name="nDataTableName">Nombre de la tabla</param>
/// <param name="nKeys">Campos de filtrado</param>
/// <param name="nTableRelationList">Lista de relaciones con otras tablas</param>
/// <param name="nMaxRows">Número máximo de registros a retornar, 0 para devolver todas la filas</param>
/// <param name="nOrderByParams">Parametros de ordenación, null para no rodenar</param>
/// <returns>Sentencia SQL</returns>
public string BuildSqlQuery(string nTableAlias, string nSchemaName, string nDataTableName, List<Parameter> nKeys,
TableRelationCollection nTableRelationList, int nMaxRows,
ColumnEnumList nOrderByParams)
{
return new SqlBuilder(this).SqlQuery(nTableAlias, nSchemaName, nDataTableName, nKeys, nTableRelationList,
nMaxRows, nOrderByParams);
}
/// <summary>
/// Construye la sentencia SQL de consulta por las llaves primarias de una tabla
/// </summary>
/// <param name="nSchemaName">Esquema al que pertenece la tabla</param>
/// <param name="nDataTableName">Nombre de la tabla</param>
/// <param name="nKeys">Campos que componen la llave primaria del registro</param>
/// <param name="nMaxRows">Número máximo de registros a retornar, 0 para devolver todas la filas</param>
/// <param name="nOrderByParams">Parametros de ordenación, null para no rodenar</param>
/// <returns>Sentencia SQL</returns>
public string BuildSqlGet(string nSchemaName, string nDataTableName, List<Parameter> nKeys, int nMaxRows,
ColumnEnumList nOrderByParams)
{
return new SqlBuilder(this).SqlGet(nSchemaName, nDataTableName, nKeys, nMaxRows, nOrderByParams);
}
/// <summary>
/// Permite obtener los registros de varias tablas filtrando por diferentes campos
/// </summary>
/// <param name="nTableAlias"></param>
/// <param name="nSchemaName">Esquema al que pertenece la tabla</param>
/// <param name="nDataTableName">Nombre de la tabla</param>
/// <param name="nKeys">Llave primaria del registro</param>
/// <param name="nTableRelationList">Lista de relaciones con otras tablas</param>
/// <param name="nMaxRows">Número máximo de registros a retornar, 0 para devolver todas la filas</param>
/// <param name="nOrderByParams">Parametros de ordenación, null para no rodenar</param>
/// <param name="nResult">Define si la instrucción se ejecutó correctamente o no</param>
/// <param name="nException">Exepción ocurrida al ejecutar la instrucción</param>
/// <returns>Resultado de la consulta</returns>
public DataTable DBQueryGet(string nTableAlias, string nSchemaName, string nDataTableName, List<Parameter> nKeys,
TableRelationCollection nTableRelationList, int nMaxRows,
ColumnEnumList nOrderByParams, out bool nResult, out Exception nException)
{
nResult = true;
nException = null;
try
{
return
ExecuteQueryGet(BuildSqlQuery(nTableAlias, nSchemaName, nDataTableName, nKeys, nTableRelationList,
nMaxRows, nOrderByParams));
}
catch (Exception ex)
{
nResult = false;
nException =
new Exception(
"Error al recuperar los registros de la tabla " + nSchemaName + "." + nDataTableName + ", " +
ex.Message, ex);
return null;
}
}
/// <summary>
/// Permite obtener los registro de una tabla, dentro de un DataTable existente, filtrando por diferentes campos
/// </summary>
/// <param name="nDataTable">DataTable en el que se devolveran los registros</param>
/// <param name="nSchemaName">Esquema al que pertenece la tabla</param>
/// <param name="nDataTableName">Nombre de la tabla</param>
/// <param name="nKeys">Llave primaria del registro</param>
/// <param name="nMaxRows">Número máximo de registros a retornar, 0 para devolver todas la filas</param>
/// <param name="nOrderByParams">Parametros de ordenación, null para no rodenar</param>
/// <param name="nResult">Define si la instrucción se ejecutó correctamente o no</param>
/// <param name="nException">Exepción ocurrida al ejecutar la instrucción</param>
public void DBFilterFill(ref DataTable nDataTable, string nSchemaName, string nDataTableName,
List<Parameter> nKeys, int nMaxRows, ColumnEnumList nOrderByParams, out bool nResult,
out Exception nException)
{
nResult = true;
nException = null;
try
{
ExecuteQueryFill(ref nDataTable,
BuildSqlFilter(nSchemaName, nDataTableName, nKeys, nMaxRows, nOrderByParams));
}
catch (Exception ex)
{
nResult = false;
nException =
new Exception(
"Error al recuperar los registros de la tabla " + nSchemaName + "." + nDataTableName + ", " +
ex.Message, ex);
}
}
