[[AgustinOrtu]]

Con respecto al AutoCommit no puedo ser muy preciso, porque nunca he usado Zeos. Pero todo apunta a que hay una propiedad AutoCommit que por defecto viene a True, y habria que pasarla a False. Yo me he acostumbrado a realizar manejo explicito de transacciones, es decir, decidir cuando inician y como finalizan

Para la segunda consulta si, me parece mucho mas adecuado que uses la forma .AsInteger/.AsString

Otra sugerencia es eliminar los with de tu codigo

Por ejemplo, cuidado con este metodo que tienes en el boton de seleccionar:

Código Delphi [-]
procedure TfListadosProductos.bSeleccionarClick(Sender: TObject);
begin
with fventas,fventas.sgDetalle,fmodulo do
fventas.sgDetalle.Cells[0,fventas.sgDetalle.RowCount-1]:= fmodulo.qProductos['idproducto'];
fventas.sgDetalle.Cells[1,fventas.sgDetalle.RowCount-1]:= fmodulo.qProductos['nombrepr'];
fventas.sgDetalle.Cells[2,fventas.sgDetalle.RowCount-1]:= fmodulo.qProductos['precio_unit'];
fventas.sgDetalle.Cells[3,fventas.sgDetalle.RowCount-1]:= eCantidad.Text ;
subtotal:=  fmodulo.qProductos['precio_unit']*StrToInt(self.eCantidad.Text)  ;
fventas.sgDetalle.Cells[4,fventas.sgDetalle.RowCount-1]:= FloattoStr(subtotal);
total:=total+subtotal;
fventas.eTotal.Text:= floattostr(total);
fventas.sgDetalle.RowCount:= fventas.sgDetalle.RowCount+1;
end;

No entiendo muy bien el porque usas el with en ese caso. Pero vamos por partes

Primero que el with al no estar delimitado por un bloque begin-end, solamente "afecta" a la siguiente instruccion inmediata. Es decir, en tu caso (coloreo con negro la linea que es "afectada" por el with, y le agrego un sangrado para que quede bien claro)

Código Delphi [-]
procedure TfListadosProductos.bSeleccionarClick(Sender: TObject);
begin
  with fventas,fventas.sgDetalle,fmodulo do
    fventas.sgDetalle.Cells[0,fventas.sgDetalle.RowCount-1]:= fmodulo.qProductos['idproducto'];

  fventas.sgDetalle.Cells[1,fventas.sgDetalle.RowCount-1]:= fmodulo.qProductos['nombrepr'];
  fventas.sgDetalle.Cells[2,fventas.sgDetalle.RowCount-1]:= fmodulo.qProductos['precio_unit'];
  fventas.sgDetalle.Cells[3,fventas.sgDetalle.RowCount-1]:= eCantidad.Text ;
  subtotal:=  fmodulo.qProductos['precio_unit']*StrToInt(self.eCantidad.Text)  ;
  fventas.sgDetalle.Cells[4,fventas.sgDetalle.RowCount-1]:= FloattoStr(subtotal);
  total:=total+subtotal;
  fventas.eTotal.Text:= floattostr(total);
  fventas.sgDetalle.RowCount:= fventas.sgDetalle.RowCount+1;
end;

Fijate como el resto de las instrucciones no son alcanzadas por tu with

Por otra parte, concentremonos en lo que quiere transmitir tu codigo. Mas alla de que no se aconseja el uso del with por los varios problemas que puede tener (sobre todo la ambiguedad), uno usa un with para "ahorrarse" el trabajo de no volver a escribir a que objeto le quiere mandar un mensaje

Pero aun asi, usas el with sobre un objeto, y en el cuerpo del codigo sigues referenciando el objeto en cuestion. Osea, el with esta totalmente de mas!

Código Delphi [-]
procedure TfListadosProductos.bSeleccionarClick(Sender: TObject);
begin
  with fventas,fventas.sgDetalle,fmodulo do
    fventas.sgDetalle.Cells[0,fventas.sgDetalle.RowCount-1]:= fmodulo.qProductos['idproducto'];

fventas no lo usas nunca
En el with, colocas un fventas.sgDetalle, pero en el codigo, en vez de usar "la forma abreviada" y obviar el fventas.sgDetalle, lo vuelves a escribir

El mismo caso es para fmodulo

Ese mismo codigo se puede escribir asi, resultando mucho mas claro de leer:

Código Delphi [-]
procedure TfListadosProductos.bSeleccionarClick(Sender: TObject);
begin
    fventas.sgDetalle.Cells[0, fventas.sgDetalle.RowCount - 1] := fmodulo.qProductos['idproducto'];
   // resto del codigo

Este mismo problema lo tenes en el codigo de grabado:

Código Delphi [-]
    with fmodulo,self do
     fmodulo.qVentas.Active:=true;

   // mas codigo

Sin embargo, mas abajo en el mismo metodo usas un begin-end para un with

Código Delphi [-]
     with fmodulo,self,sgDetalle do
     begin
       // codigo
     end;

Pregunta: Por que usas el with? Para que sirve? Quien te dijo que uses with? Usaste algun codigo de ejemplo para guiarte?. En definitiva, te recomiendo no usarlo (mejor aprenderlo desde novato asi no te queda como vicio)

Luego te recomiendo que "embellezcas" tu codigo:

1- Utiliza la sangria de forma inteligente: Respeta los distintos niveles de anidamiento de los bloques (facilita la lectura). Ejemplo:

Código Delphi [-]
  if AlgunaCondicion then
  begin
    instruccion1;
    instruccion2;
    if OtraCondicion then
    begin
      instruccion2.1;
      instruccion2.2
   end;
  end;

Eso es mucho mas facil de leer que esto, o similares, donde no se respeta un orden:

Código Delphi [-]
  if AlgunaCondicion then
  begin
  instruccion1;
      instruccion2;
  if OtraCondicion then
  begin
      instruccion2.1;
  instruccion2.2
  end;
  end;

2 - Si bien en Delphi no se distinguen mayusculas de minusculas (yo lo veo como un gran error de diseño), el escribir todo en mayusculas o todo en minusculas hace mas dificil leer el codigo. Piensa en alguien que da un discurso y usa siempre el mismo tono de voz, sin ningun tipo de pausa. Esto es lo mismo.

Código Delphi [-]
  fmodulo.qdetalle.fieldbyname('idproducto').asinteger:= strtoint(sgdetalle.cells[0,i]);  

  FModulo.qDetalle.FieldByName('IdProducto').AsInteger:= StrToInt(sgDetalle.Cells[0, I]);

Esto implica tambien respetar los nombres de las cosas que ya vienen implementadas. Por ejemplo, nadie te obliga a seguir la notacion PascalCase para escribir tu propio codigo (es cierto que estoy tocando un tema muy personal) pero si me parece correcto que lo que ya esta escrito de una manera, respetarlo: lo mas probable es que el resto de los programadores escribamos StrToInt y no strtoint o strToInt. De este modo tu codigo queda idiomatico y es mas facil de leer

3 - No gastas mas memoria por ponerle nombres largos a las variables . Es preferible un nombre de variable largo a uno corto. Es mas importante que se entienda bien para que sirve. No se en donde se aprendio que los nombres de las variables son siempre: tot, sum, i, temp, x, y, z, temp_x... ponle el nombre de lo que realmente significan!

4 - Aprende a depurar un programa. No importa si eres novato, intermedio, experto o entusiasta. Programar sin saber depurar es como pretender correr sin saber caminar. Una cosa lleva a la otra.

El depurador de Delphi es increible, podes seguir paso a paso como se ejecuta tu codigo, detenerte en el momento que quieras, ver el valor de todas las variables del programa, ver que es lo que exactamente hace, seguir el flujo de ejecucion, incluso el depurador te permite modificar los valores de las variables para "ver que pasa si aca en lugar de 100 vale 101".
Incluso podes monitorear los valores de las variables para ver como se van actualizando

Hay muchos hilos sobre como depurar en el foro, con una busqueda encontraras muchos resultados