Grabacion campos de dos campañas en una Tabla

[Felinotronica]

El principal problema es que hoy comparas 2025 y 2026, pero mañana lo querras hacer con 2027 y 2026. Para evitar tener que hacerlo constantemente usaria un patron Strategy. Puedes hacer algo como CompararAños(AAno1,Aano2:integer;ATabla:string):TJsonArray. La idea es crear un json con los dato de la tabla, luego creas una estrategia para recuperarlos RecuperarDatos(AAjson), puedes usar FireDac MemTable, y mover el Json a memoria manipular los datos y usarlos como quieras. Al usar patrones GoF puedes reutilizar el código, escalarlo, sin necesidad de tocar todas las capas o refactorizados complicados. Yo suelo usar strategy o facade , incluso ambos para estas cosas, luego con command hago un API interno en logica para volcarlos en la capa de vista, la UI. Para evitar lo que te pasa debes desacoplar tareas, no debes manipular datos desde la UI, puedes crear un DAO en la capa de datos que haga todo, asi evitas que el código “se rompa” si añades nuevas funciones. Si no recuerdo mal hay un cnal de youtube de un compañero con los patrones GoF. Te vas a evitar muchos problemas con los patrones.

[emailx45]

Aquí tienes un ejemplo muy sencillo para comprender su uso:
- ¡Todo es rápido y no hay necesidad de guardar datos en otra tabla!

Si utiliza Firebird, podría crear un "Procedimiento almacenado" parametrizado para poder cambiar los nombres de las tablas y los campos y adaptarlos a diferentes años...

Código SQL [-]
SET TERM ^ ;

CREATE OR ALTER PROCEDURE GetTableDataCombined (
    ATableNameA VARCHAR(31),
    ATableNameB VARCHAR(31),
    AFieldTableName VARCHAR(31),
    AFieldInputDate VARCHAR(31),
    AFieldIDRecord VARCHAR(31),
    AFieldValue VARCHAR(31),
    AStartDate DATE,
    AEndDate DATE
)
RETURNS (
    OutSourceTable VARCHAR(31),
    OutTableName VARCHAR(100),
    OutInputDate DATE,
    OutIDRecord INT64,
    OutValue NUMERIC(18,4),
    OutErrorMessage VARCHAR(255)
)
AS
DECLARE VARIABLE VSqlStatement VARCHAR(4000);
BEGIN
  OutErrorMessage = '';

  -- Crea una única consulta uniendo las dos tablas mediante UNION ALL.
  VSqlStatement = 'SELECT ''' || :ATableNameA || ''', ' || :AFieldTableName || ', ' || :AFieldInputDate || ', ' || :AFieldIDRecord || ', ' || :AFieldValue || ' ' ||
                  'FROM ' || :ATableNameA || ' ' ||
                  'WHERE ' || :AFieldInputDate || ' BETWEEN :PStart AND :PEnd ' ||
                  'UNION ALL ' ||
                  'SELECT ''' || :ATableNameB || ''', ' || :AFieldTableName || ', ' || :AFieldInputDate || ', ' || :AFieldIDRecord || ', ' || :AFieldValue || ' ' ||
                  'FROM ' || :ATableNameB || ' ' ||
                  'WHERE ' || :AFieldInputDate || ' BETWEEN :PStart AND :PEnd';

  -- El bucle FOR ejecuta la instrucción unificada de una sola vez.
  FOR EXECUTE STATEMENT :VSqlStatement (PStart := :AStartDate, PEnd := :AEndDate)
  INTO :OutSourceTable, :OutTableName, :OutInputDate, :OutIDRecord, :OutValue
  DO
  BEGIN
    SUSPEND;
  End

  -- Manejo estructurado de excepciones
  WHEN ANY DO
  BEGIN
    OutSourceTable = 'ERROR';
    OutTableName   = '';
    OutInputDate   = NULL;
    OutIDRecord    = 0;
    OutValue       = 0;
    OutErrorMessage = 'Error al ejecutar la consulta unificada con UNION ALL.';
    SUSPEND;
  END
END^

SET TERM ; ^

Ejemplo de uso en Delphi, utilizando TFDQuery o cualquier consulta similar.

Código Delphi [-]
Procedure TFormMain.FetchDataForComparison;
Begin
  FDQueryCompare.Close;
  FDQueryCompare.SQL.Text := 'SELECT * FROM GetTableDataForCompare(:TabA, :TabB, :FldTabName, :FldDate, :FldID, :FldVal, tStart, tEnd)';
  
  // Definir los parámetros de forma dinámica
  FDQueryCompare.ParamByName('TabA').AsString         := 'TableA';
  FDQueryCompare.ParamByName('TabB').AsString         := 'TableB';
  FDQueryCompare.ParamByName('FldTabName').AsString    := 'TableName';
  FDQueryCompare.ParamByName('FldDate').AsString       := 'InputDate';
  FDQueryCompare.ParamByName('FldID').AsString          := 'IDRecord';
  FDQueryCompare.ParamByName('FldVal').AsString         := 'Value';
  FDQueryCompare.ParamByName('DtStart').AsDateTime     := DateTimePickerStart.Date;
  FDQueryCompare.ParamByName('DtEnd').AsDateTime       := DateTimePickerEnd.Date;
  
  FDQueryCompare.Open;

  // Verificación de errores devuelta por el procedimiento
  If Not FDQueryCompare.FieldByName('OutErrorMessage').AsString.IsEmpty Then
  Begin
    FDQueryCompare.Close;
    //
    ShowMessage('ERROR: ' + FDQueryCompare.FieldByName('OutErrorMessage').AsString);
    //
    Exit;
  End;

  //Aquí puede iterar sobre la consulta FDQuery o usar una consulta SQL local de FireDAC para hacer referencia cruzada a los datos en memoria.
End;

[Felinotronica]

Esto es un patrón GoF Factory para pagos de un sistema POS, estoy si IDE en el bloc de notas del ipad.Disculpar si hay errores. Aquí puedo añadir nuevas clases o quitarlas. Por ejemplo si tienes TComparar2025_26 puedes añadir TComparar2026_27, de esta forma la UI, la vista o el form no accede a datos directamente, separas responsabilidades y es fácil de mantener y escalar. Yo suelo usar patrones para separar responsabilidades. Puedes crear diccionario<TTipoconsulta, funcion: boolean> y luego con un ejecutor ejecutar consultas : Ejecutar(TTipoconsulta.compararanos) por ejemplo. El objeto es que al separar responsabilidades puedas escalar y mantener el desarrollo sin refsctorizados pesados. Te dejo un ejemplo de Factory.

Código Delphi [-]
 Unit tpv.factory.pagos;
{
    Lo que hace es asegurarse de que una vez pagado, el ticket este
        - cerrado
        - con el metodo de pago utilizado
    Var metpa: IMetodoPago;
    luego . . .
    metpa := metpa.ObtenerMetodoPago(mpTarjeta);
    metpa.ProcesarPago(MiTicket);
    GuardarTicket(Miticket);
    Se podria hacer un método de, api que reciba el ticket y lo guarde 
    ya peocesado en la bbdd: GuardarTiket(TTicket,TFormaDePago). Así
    Solo habria que llamar a este metodo desde la UI y el resto lo haria
    El factory.
}

Interface

Uses tpv.clases.tticket,
     Tpv.enums;
Type 
     //TFormaDePago =(mpEfectivo,mpTarjeta,mpBizum);
     //TEstadoTicket = (etAbierto,etCerrado)
    
    IMetodoPago = interface
        [GUID]
        Procedure ProcesarPago(ATicket:TTicket);
        
     End;
     
    TEfectivo = Class(TinterfacesObject,IMetodoPago)
        Private
            FTotal:double;
        Public
            Procedure ProcesarPago(ATicket:TTicket);
    End;
    
    TTarjeta = class(TinterfscedObject, IMetodoPago)
        Private
            Ftotal:double
        Public
            Procedure ProcesarPago(ATicket:TTicket);
    End;
    
    TBizum = class(TInterfacedObject, IMetodoPago)
        Private
            FTotal:double;
        Public
            Procedure ProcesarPago(ATicket:TTicket);
    End;
    
    TPagoTicket = class
        Private
        Public
        Class function ObtenerMetodoPago(AFormaPago:TFormaPago):IMetodoPago;
    End;
    
    Implementation
    
Class function TPagoTicket.ObtenerMetodoPago(
                AFormaPago:TFormaPago):IMetodoPago;
  Begin
      Case AFormaPago of
          mpEfectivo: Result := TEfectivo.Create;
          mpTarjeta: Result := TTarjeta.Create;
          mpBizum: Result := TBizum.Create;
  end;
  
  
Procedure TEfectivo.ProcesarPago(ATicket:TTicket);
Begin
 // procesar el pago en efectivo
  ATicket.Estado := etCerrado;
  ATicket.MetodoPago := mpEfectivo;
End;

Procedure TTarjeta.ProcesarPago(ATicket:TTicket);
Begin
// procesar pago con tarjeta
   ATicket.Estado := etCerrado;
   ATicket.MetodoPago := mpTarjeta;
End;

Procedure TBizum.ProcesarPago(ATicket:TTicket);
Being
// procesar pago con bizum
    ATicket.Estado := etCerrado;
    ATicket.MetodoPago := mpBizum;
End;