Crear campos calculados en consulta

[GerTorresM]

Hola a Tod@s:


Bien la situación del día de hoy es la siguiente:

Estoy trabajando con delphi 6 y como base de datos M$ Acce$$, quiero adicionar una serie de campo calculados en una consulta, ésto son de diversos tipos, la pregunta es como la puedo hacer.

agradezco de antemano el tiempo dedicado y la colaboración que me puedan prestar.


gertorresm
Colombia

[cloayza]

Si los calculos no son demasiado complejos los puedes especificar en la misma consulta.

Por ejemplo:

Código SQL [-]
SELECT Precio, Iva,  (Precio*Iva) as Impuestos, (Precio+0.05) as Descuento
FROM TABLA

Espero te sirva, de lo contrario da un ejemplo de los calculos que requieres.

Saludos

[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.