Grabacion campos de dos campañas en una Tabla
 

Buenos dias,

Necesito copiar en una Tabla, las ventas del año 25 y del año 26, y compararlas, las ventas del año 25 están el directorio Datos25 y las del 26 en Datos26.

Por Simplificar tengo una Tabla que es la TablaPedidos, compuesta por dos Campos: Id y Ventas
y otra tabla que he creado que es TablaCompCamp con tres campos; Id,Ventas25,Ventas26

Y Básicamente lo que hago es colocarme en un Directorio:

Código SQL [-]
 
                 Procedure Boton1.Click;
                  begin
   
                       Ejercicio:'025'
                       BaseDatos:=BaseDatos+'Datos'+ejercicio
                       Basedatos.DatabaseName:=Basedatos+'\VENTAS.FDB';
                       BaseDatos.Connected:=true;

                       IbQueryCompCamp.Close;
                       IbQueryCompCamp.Clear;
                       IbQueryCompCamp.sql.text:=('insert Into  COMPCAMP (ID,VENTAS25) select ID,VENTAS from Pedidos');
                       IbQueryCompCamp.execsql;
                       IbQueryCompCamp.close;

                       Ejercicio:'026'
                       BaseDatos:=BaseDatos+'Datos'+ejercicio
                       Basedatos.DatabaseName:=Basedatos+'\VENTAS.FDB';
                       BaseDatos.Connected:=true;

                       IbQueryCompCamp.Close;
                       IbQueryCompCamp.Clear;
                       IbQueryCompCamp.sql.text:=('insert Into  COMPCAMP (ID,VENTAS26) select ID,VENTAS from Pedidos');
                       IbQueryCompCamp.execsql;
                       IbQueryCompCamp.close;

                    End;

Funciona perfectamente, el único problema que lógicamente copia las ventas en la tabla COMPCAMP en tablas separadas lógiamente una del 025 y la otra en la tabla 026.

He intentado crear una tabla fuera de la Base de datos para que no afectara el cambio de directorio y sólo afectara a Pedidos pero da error.

Ya lo único que me quedaría sería copiar los datos en StringGrid los dos años, y de ahí copiarlos a la Tabla, pero quería ver si había otra solución más sencilla sin tantos pasos.

Gracias de Antemano.

Para probar claude le he realizado tu consulta y una buena solucion seria esta:
Teniendo en cuenta el volumen de datos, no hace falta guardar una comparacion en base de datos, ja que siempre tendrias que realizar una primera funcion para validar que los datos en la tabla son correctos en este instante, y de esta manera al trabajar en tiempo real siempre son datos de este momento

Código Delphi [-]
{ ============================================================================
  COMPONENTES QUE DEBE TENER EL FORMULARIO (colocados desde la paleta):
  ============================================================================

  BaseDatos       : TIBDatabase (o TFDConnection / TIBCDatabase según tu caso)
                    -> Conexión que iremos apuntando a cada carpeta de datos
                       (Datos025, Datos026) cambiando su DatabaseName.
                       Puede estar en el formulario o en un DataModule.

  IbQueryCompCamp : TIBQuery (o TFDQuery)
                    -> Query que reutilizamos para leer la tabla PEDIDOS
                       de cada base de datos anual. Debe tener asignada
                       su propiedad Database := BaseDatos.

  StringGrid1     : TStringGrid
                    -> Grid donde se pinta el resultado final ya fusionado:
                       columnas ID, Ventas25, Ventas26, Diferencia.
                       ColCount debe ser al menos 4 (se puede fijar en
                       tiempo de diseño o por código antes de rellenar).

  ButtonComparar  : TButton
                    -> Botón que dispara todo el proceso (OnClick apunta
                       al procedimiento de abajo).

  NOTA: RutaBase se declara como constante local dentro del propio
  procedimiento (ver más abajo, 'C:\ERP\' a modo de ejemplo). Cámbiala por
  la ruta real donde tengas las carpetas Datos025 y Datos026. Si prefieres
  que sea configurable, cámbiala por una variable y léela de un INI.
  ============================================================================ }

type
  // Estructura que guarda, para un mismo producto (ID), las ventas de cada año
  TVentaAny = record
    Ventas25: Double;   // Total vendido en el ejercicio 25
    Ventas26: Double;   // Total vendido en el ejercicio 26
  end;

procedure TForm1.ButtonComparar.Click(Sender: TObject);
const
  // OJO: esta ruta es solo un ejemplo, ajústala a la ruta real de tus carpetas
  // Datos025 y Datos026 (o léela de un INI/config si prefieres no dejarla fija)
  RutaBase = 'C:\ERP\';
var
  Mapa: TDictionary;  // Diccionario: clave = ID de producto, valor = ventas de los dos años
  Par: TPair;         // Variable auxiliar para recorrer el diccionario
  Fila: Integer;                          // Contador de filas al pintar el StringGrid
  Diferencia: Double;                     // Diferencia entre ventas26 y ventas25 de cada producto

  // Procedimiento interno que carga un año concreto (25 o 26) en el diccionario
  procedure CargarAnio(const Carpeta: string; EsVentas25: Boolean);
  var
    Id: Integer;        // ID de producto leído de la tabla PEDIDOS
    Ventas: Double;      // Importe de ventas leído de la tabla PEDIDOS
    V: TVentaAny;        // Registro temporal para leer/actualizar el valor del diccionario
  begin
    // Cerramos la conexión actual antes de cambiar de base de datos
    BaseDatos.Connected := False;

    // Apuntamos la conexión a la carpeta del año que toca (Datos025 o Datos026)
    BaseDatos.DatabaseName := Carpeta + '\VENTAS.FDB';

    // Abrimos la conexión a esa base de datos anual
    BaseDatos.Connected := True;
    try
      // Nos aseguramos de que la consulta está cerrada antes de reutilizarla
      IbQueryCompCamp.Close;

      // Definimos el SQL: leemos TODOS los productos y sus ventas de este año
      IbQueryCompCamp.SQL.Text := 'SELECT ID, VENTAS FROM PEDIDOS';

      // Ejecutamos y abrimos el cursor de resultados
      IbQueryCompCamp.Open;

      // Recorremos fila a fila mientras no lleguemos al final del cursor
      while not IbQueryCompCamp.Eof do
      begin
        // Leemos el ID de producto de la fila actual
        Id := IbQueryCompCamp.FieldByName('ID').AsInteger;

        // Leemos el importe de ventas de la fila actual
        Ventas := IbQueryCompCamp.FieldByName('VENTAS').AsFloat;

        // Intentamos recuperar del diccionario lo que ya sabíamos de este producto
        // (si es la primera vez que aparece, TryGetValue devuelve False y V queda "vacío")
        if not Mapa.TryGetValue(Id, V) then
        begin
          V.Ventas25 := 0;  // Si el producto no existía aún en el diccionario, arrancamos a 0
          V.Ventas26 := 0;
        end;

        // Según si estamos cargando el año 25 o el 26, rellenamos el campo correspondiente
        if EsVentas25 then
          V.Ventas25 := Ventas
        else
          V.Ventas26 := Ventas;

        // Guardamos (o actualizamos si ya existía) el registro en el diccionario
        Mapa.AddOrSetValue(Id, V);

        // Pasamos a la siguiente fila del cursor
        IbQueryCompCamp.Next;
      end;

      // Cerramos el cursor, ya hemos leído todo lo que necesitábamos
      IbQueryCompCamp.Close;
    finally
      // Desconectamos de esta base de datos anual, tanto si ha ido bien como si ha habido error
      BaseDatos.Connected := False;
    end;
  end;

begin
  // Creamos el diccionario que va a fusionar los dos años en memoria
  Mapa := TDictionary.Create;
  try
    // Primera pasada: cargamos las ventas del ejercicio 25
    CargarAnio(RutaBase + 'Datos025', True);

    // Segunda pasada: cargamos las ventas del ejercicio 26
    // (si el producto ya existía del año 25, se completa su registro;
    //  si es nuevo, se crea con Ventas25 = 0)
    CargarAnio(RutaBase + 'Datos026', False);

    // A partir de aquí ya NO hace falta ninguna conexión a base de datos:
    // todo lo que necesitamos está en el diccionario "Mapa"

    // Preparamos el StringGrid: una fila de cabecera + una fila por cada producto
    StringGrid1.RowCount := Mapa.Count + 1;

    // Escribimos los títulos de columna en la fila 0
    StringGrid1.Cells[0,0] := 'Producte (ID)';
    StringGrid1.Cells[1,0] := 'Ventas 25';
    StringGrid1.Cells[2,0] := 'Ventas 26';
    StringGrid1.Cells[3,0] := 'Diferencia';

    // Empezamos a pintar datos a partir de la fila 1 (la 0 es la cabecera)
    Fila := 1;

    // Recorremos todo el diccionario, un producto por iteración
    for Par in Mapa do
    begin
      // Calculamos la diferencia entre lo vendido en 26 y en 25
      Diferencia := Par.Value.Ventas26 - Par.Value.Ventas25;

      // Columna 0: el ID de producto (la clave del diccionario)
      StringGrid1.Cells[0,Fila] := IntToStr(Par.Key);

      // Columna 1: ventas del año 25, formateadas con 2 decimales
      StringGrid1.Cells[1,Fila] := FormatFloat('0.00', Par.Value.Ventas25);

      // Columna 2: ventas del año 26, formateadas con 2 decimales
      StringGrid1.Cells[2,Fila] := FormatFloat('0.00', Par.Value.Ventas26);

      // Columna 3: diferencia calculada al vuelo
      StringGrid1.Cells[3,Fila] := FormatFloat('0.00', Diferencia);

      // Avanzamos a la siguiente fila del grid
      Inc(Fila);
    end;
  finally
    // Liberamos el diccionario, ya no lo necesitamos (los datos ya están en el grid)
    Mapa.Free;
  end;
end;

Estimado colega, mirando su problema le propongo la siguiente solución...

1) Crear procedimento para acceder a los datos desde las distintas bases de datos

Código SQL [-]
create or alter procedure sp_ventas_from_year(ventas_year integer)
returns (id integer, ventas double)
as
begin
  for
     execute
     statement ('select id, ventas
                 from pedidos')
     on external data source 'c:\Datos'||:ventas_year||'\ventas.fdb' as user current_user password 'masterkey'
     into :id,
          :ventas
  do
  begin
        suspend;
  end
end

2) Test para probar consultas

Código SQL [-]
//Obtener las ventas del año 2025
select a.id, 
       a.ventas 
from sp_ventas_from_year(2025) a

//Obtener las ventas del año 2026
select a.id, 
       a.ventas 
from sp_ventas_from_year(2026) a

3) Consulta comparando ventas de ambos años de cada ID
Puede crear una vista con estas consultas...O incluirlas todas en un TIBQuery

Código SQL [-]
--Todos este código debe estar en TIBQuery 
--Ventas con id en ambos años
select 
    v2025.id,
    v2025.ventas vtas_2025,
    v2026.ventas vtas_2026
from SP_VENTAS_FROM_YEAR(2025) v2025 --ventas_2025
   inner join SP_VENTAS_FROM_YEAR(2026) v2026 on (v2025.id = v2026.id)

union all

--Ventas 2025 que no estan en 2026
select 
    v2025.id,
    v2025.ventas as vtas_2025,
    0 as vtas_2026
from SP_VENTAS_FROM_YEAR(2025) v2025
   left outer join SP_VENTAS_FROM_YEAR(2026) v2026 on (v2025.id = v2026.id)
where (v2026.id is null)

union all

--Solo ventas del 2026 que no estan en 2025
select v2026.id,
       0 as vtas_2025,
       v2026.ventas vtas_2026
from SP_VENTAS_FROM_YEAR(2026) v2026
   left outer join SP_VENTAS_FROM_YEAR(2025) V2025 on (v2026.id = v2025.id)
where (v2025.id is null)

Espero le sirva...Saludos cordiales

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.

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, :DtStart, :DtEnd)';
  
  // 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;

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;