Crear campos calculados en consulta

[GerTorresM]

Gracias cloayza por tu tiempo la idea que tengo es la siguiente

Código Delphi [-]
function CrearCampoCalculado (pNombreCampo, pTipoCampo : String;  pDataset : TDataset) : TField;
var Campo_local : TField;
begin
  //Crea los campos Campos
  Campo_local := TFloatField.Create(pDataSet);
  Campo.FieldName:= pNombreCampo;
  Campo.FieldKind:= fkCalculated;
  Campo.DataSet:= pDataset;
  Result:= Campo_local;
end;

pero poder a su vez indicar en la función el tipo de dato que ha de manejar el campo ej.

TStringField,TSmallIntField, TIntegerField,
TBooleanField, TFloatField, TCurrencyField,
TDateField, TTimeField,TDateTimeField,
TVarBytesField, TBlobField, TMemoField,
TWordField, TBCDField,TBytesField
TGraphicsField, TAutoIncField,TNumericField

pero no que tipo de dato colocar en los párametros de entrada, lo que denomina pTipoCampo, es decir pTipoCampo que tipo de dato debe pedir, ya que a partir de dicho parámetro de entrada debo platear el constructor tal como lo vez de la línea de código

Código Delphi [-]
 TFloatField.Create(pDataSet);

muchas gracias de antemano



gertorresm
Colombia

[defcon1_es]

Hola. ¿Te refieres a algo parecido a esto?

Código Delphi [-]
function CrearCampoCalculado (pNombreCampo: String;  pDataset : TDataset; pTipoCampo: Integer) : TField;
var Campo_local : TField;
begin
  //Crea los campos Campos
  case pTipoCampo of
    0: Campo_local := TFloatField.Create(pDataSet);
    1: Campo_local := TIntegerField.Create(pDataSet);
  //.... aqui pones el resto de tipos
  end;
  Campo.FieldName:= pNombreCampo;
  Campo.FieldKind:= fkCalculated;
  Campo.DataSet:= pDataset;
  Result:= Campo_local;
end;

[Estifmauin]

Esta solución es buena, pero tiene una carencia: no tiene en cuenta que ya pueden existir campos en el dataset.
En mi caso, suelo añadir campos calculados a datasets "reales" que ya contiene campos persistentes. Un ejemplo es construir un mensaje de estado a partir de los valores de ciertos campos, y así mostrar en un grid directamente ese mensaje.
En ese caso, hay que respetar los campos existentes y luego añadirle los nuevos calculados:

Código Delphi [-]
procedure CrearCampoCalculado(DataSet :TDataSet; nombrecampo :string; tipo :TFieldType; longi :integer);
var
    f: TField;
    i: Integer;
begin
try
    //es necesario que antes estén definidos todos los campos persistentes
    DataSet.FieldDefs.Update;
    for i:=0 to DataSet.FieldDefs.Count - 1 do
        if DataSet.FindField(DataSet.FieldDefs[i].Name) = nil then
            DataSet.FieldDefs.Items[i].CreateField(DataSet);
    //ahora ya podemos comprobar el nuevo campo
    //antes comprobamos la existencia de otro campo con el mismo nombre
    if DataSet.FindField(nombrecampo) = nil then begin
        case tipo of
            ftString: f:=TStringField.Create(DataSet);
            ftInteger: f:=TIntegerField.Create(DataSet);
            ftBoolean: f:=TBooleanField.Create(DataSet);
            //contempla aqui todos los tipos que necesites
            //lógicamente, dependerán de la bbdd que uses
            else ShowMessage('Tipo de campo no contemplado: '+GetEnumName(TypeInfo(TFieldType),integer(tipo)));
        end;
        if f <> nil then begin
            f.DataSet:=DataSet;
            f.Name:=DataSet.Name+nombrecampo;
            f.FieldName:=nombrecampo;
            f.DisplayLabel:=nombrecampo;
            if tipo = ftString then
                f.Size:=longi;
            f.Calculated:=true;
        end;
    end
    else ShowMessage('Ya existe un campo de nombre "'+nombrecampo+'"');
except on e:exception do
    ShowMessage(e.Message);
end;
end;

Nota: la función GetEnumName requiere uses TypInfo;

Y llamo a esa función en el evento BeforeOpen:

Código Delphi [-]
procedure tDatasetBeforeOpen(DataSet: TDataSet);
begin
CrearCampoCalculado(DataSet, 'temporal_entero', ftInteger,0);
CrearCampoCalculado(DataSet, 'temporal_texto', ftString,20);
end;

Espero que ayude.

[roboflekto]

Es suena interesante, voy a probarlo ahora mismo. Pero por qué dices es de:
//lógicamente, dependerán de la bbdd que uses
???
¿No se trata de campos calculados, es decir que no están en la base de datos?
y otra cosa: ¿por qué en el evento BeforeOpen? ¿No se puede usar en el AfterOpen?

Saludos a todos.

[Estifmauin]

Empezado por roboflekto

Es suena interesante, voy a probarlo ahora mismo. Pero por qué dices es de:
//lógicamente, dependerán de la bbdd que uses
???
¿No se trata de campos calculados, es decir que no están en la base de datos?
y otra cosa: ¿por qué en el evento BeforeOpen? ¿No se puede usar en el AfterOpen?

Saludos a todos.

Bueno... lo de que depende de la bbdd que uses es un comentario que se me ha traspapelado: ignóralo. Es evidente que tienes razón.

Respecto a lo de llamar a la función en el evento AfterOpen, es cierto que parece lo más obvio, pero cuando hice mis pruebas daba problemas, así que cogí la mecánica de hacerlo en Before.
Te animo a que lo pruebes, y si se puede hacer, lo compartas con nosotros.

[GerTorresM]

Muchas gracias a tod@s:


Con sus aportes ya arme la función que se requeria


Agradezco de antemano su tiempo y aporte



gertorresm
colombia

[rchavezh]

Al parecer el orden de asignacion en delphi 2010 afecta por lo que actualizo la funcion

Código Delphi [-]
CrearCampoCalculado(DataSet :TDataSet; nombrecampo :string; tipo :TFieldType; longi :integer);
var
    f: TField;
    i: Integer;
begin
try
    //es necesario que antes estén definidos todos los campos persistentes
    DataSet.FieldDefs.Update;
    for i:=0 to DataSet.FieldDefs.Count - 1 do
        if DataSet.FindField(DataSet.FieldDefs[i].Name) = nil then
            DataSet.FieldDefs.Items[i].CreateField(DataSet);
    //ahora ya podemos comprobar el nuevo campo
    //antes comprobamos la existencia de otro campo con el mismo nombre
    if DataSet.FindField(nombrecampo) = nil then begin
        case tipo of
            ftString: f:=TStringField.Create(DataSet);
            ftInteger: f:=TIntegerField.Create(DataSet);
            ftFloat: f:=TFloatField.Create(DataSet);
            ftBoolean: f:=TBooleanField.Create(DataSet);
            //contempla aqui todos los tipos que necesites
            //lógicamente, dependerán de la bbdd que uses
            else GeneraLog('Tipo de campo no contemplado: ');
        end;
        if f <> nil then begin
            f.Name:=DataSet.Name+nombrecampo;
            f.FieldName:=nombrecampo;
            f.DisplayLabel:=nombrecampo;
            if tipo = ftString then
                f.Size:=longi;
            f.Calculated:=true;
            f.FieldKind := fkCalculated;
            f.DataSet:=DataSet;
        end;
    end;
except on e:exception do
    GeneraLog(e.Message);
end;