UFRBuilder.pas

unit UFRBuilder;

 { PARA LA CREACION DE LOS INDICES Y LOS FOREIGN KEY SE USAN LAS UNIDADES
  UClaseCreateIndex, UClaseForeignKey

  PARA LA CREACION DE LAS FUNCIONES ESCALARES Y DE TABLA SE USAN LAS UNIDADES
  uSQLFunctionBuilder, uParameterDialog
  }


interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
  System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.Menus,
  Vcl.StdCtrls, Vcl.ExtCtrls, Vcl.WinXCtrls, IniFiles, ShellApi, Vcl.Clipbrd,
  Vcl.ComCtrls, StrUtils, System.IOUtils, System.Threading, Data.DB,
  FireDAC.Stan.Intf, FireDAC.Stan.Option, FireDAC.Stan.Error, FireDAC.UI.Intf,
  FireDAC.Phys.Intf, FireDAC.Stan.Def, FireDAC.Stan.Pool, FireDAC.Stan.Async,
  FireDAC.Phys, FireDAC.Phys.MSSQL, FireDAC.Phys.MSSQLDef, FireDAC.VCLUI.Wait,
  FireDAC.Stan.Param, FireDAC.DatS, FireDAC.DApt.Intf, FireDAC.DApt,
  FireDAC.Comp.DataSet, FireDAC.Comp.Client, FireDAC.Comp.UI,
  FireDAC.Phys.ODBCBase, dxBarBuiltInMenu, cxGraphics,
  cxControls, cxLookAndFeels, cxLookAndFeelPainters, dxSkinsCore, dxSkinBlue,
  dxSkinDevExpressDarkStyle, dxSkinMoneyTwins, dxSkinOffice2007Blue,
  dxSkinOffice2010Silver, dxSkinOffice2019Black, SkinAzul,
  dxSkinVisualStudio2013Dark, dxSkinVisualStudio2013Light, dxSkinVS2010,
  cxContainer, cxEdit, cxCheckBox, dxCore, dxSkinsForm, cxClasses,
  cxShellBrowserDialog, dxStatusBar, cxMemo, cxListBox, cxMaskEdit,
  cxDropDownEdit, cxCalc, cxCustomListBox, cxCheckListBox, dxToggleSwitch,
  cxGroupBox, cxRadioGroup, cxButtons, cxTextEdit, cxLabel, dxBevel, cxPC,
  dxGDIPlusClasses, cxListView, cxSpinEdit, cxGeometry, dxFramedControl,
  dxPanel, cxStyles, UClaseCreateIndex, UClaseForeignKey, uSQLFunctionBuilder,
  uParameterDialog, cxCustomData, cxFilter, cxData, cxDataStorage, cxNavigator,
  dxDateRanges, dxScrollbarAnnotations, cxDBData, cxGridLevel,
  cxGridCustomTableView, cxGridTableView, cxGridDBTableView, cxGridCustomView,
  cxGrid;


//Tipo de dato para el tipo de Operaciones SQL en una tabla
type
  OperationType = (OtSelect, OtInsert, OtUpdate, OtDelete);


type
  TFRBuilder = class(TForm)
    BalloonHint1: TBalloonHint;
    cxPageControl1: TcxPageControl;
    cxTabSheet5: TcxTabSheet;
    cxTabSheet6: TcxTabSheet;
    cxGroupBox1: TcxGroupBox;
    dxBevel1: TdxBevel;
    cxLabel1: TcxLabel;
    TxtTabla: TcxTextEdit;
    BtBuscar: TcxButton;
    cxLabel9: TcxLabel;
    EdRutaArchivo: TcxTextEdit;
    BtRutaArchivo: TcxButton;
    BtEstructuraTabla: TcxButton;
    BtFieldByName: TcxButton;
    RgFormatoSalida: TcxRadioGroup;
    cxPageControl2: TcxPageControl;
    cxTabSheet1: TcxTabSheet;
    ListCamposWhereSelect: TcxCheckListBox;
    BtGenerar_SELECT: TcxButton;
    CkbListTodoSelect: TcxCheckBox;
    CkbListWhereSelect: TcxCheckBox;
    ListCamposOrderBy: TcxCheckListBox;
    CkbListOrderBy: TcxCheckBox;
    EdBusquedaCampo: TcxTextEdit;
    cxTabSheet2: TcxTabSheet;
    ListCamposInsert: TcxCheckListBox;
    BtGenerar_INSERT: TcxButton;
    CkbListInsert: TcxCheckBox;
    cxTabSheet3: TcxTabSheet;
    BtGenerar_UPDATE: TcxButton;
    ListCamposUpdate: TcxCheckListBox;
    ListCamposWhereUpdate: TcxCheckListBox;
    CkbListUpdate: TcxCheckBox;
    CkbListWhereUpdate: TcxCheckBox;
    cxTabSheet4: TcxTabSheet;
    BtGenerar_DELETE: TcxButton;
    ListCamposWhereDelete: TcxCheckListBox;
    CkbListWhereDelete: TcxCheckBox;
    cxGroupBox2: TcxGroupBox;
    dxBevel2: TdxBevel;
    cxLabel13: TcxLabel;
    EdNombreTabla: TcxTextEdit;
    RgFormatoSalida1: TcxRadioGroup;
    CkbQuitarArroba: TcxCheckBox;
    StbBarraEstado: TdxStatusBar;
    dxBevel3: TdxBevel;
    BtScriptStoreProcedure: TcxButton;
    ListCamposInsertSel: TcxListBox;
    BtAddItem: TcxButton;
    BtRemoveItem: TcxButton;
    BtItemUp: TcxButton;
    BtItemDown: TcxButton;
    cxButton1: TcxButton;
    cxButton2: TcxButton;
    cxButton3: TcxButton;
    cxButton4: TcxButton;
    cxButton5: TcxButton;
    cxButton6: TcxButton;
    cxButton7: TcxButton;
    cxButton8: TcxButton;
    cxButton9: TcxButton;
    cxButton10: TcxButton;
    cxButton11: TcxButton;
    cxButton12: TcxButton;
    cxShellBrowserDialog1: TcxShellBrowserDialog;
    ListCamposSelect: TcxCheckListBox;
    DataBase: TFDConnection;
    FDPhysMSSQLDriverLink1: TFDPhysMSSQLDriverLink;
    FDGUIxWaitCursor1: TFDGUIxWaitCursor;
    QryPrimaryKeys: TFDQuery;
    QryTableColumns: TFDQuery;
    QryConsulta: TFDQuery;
    QryUtils: TFDQuery;
    dxSkinController1: TdxSkinController;
    LbQueryBuilder: TcxLabel;
    Image1: TImage;
    cxTabSheet7: TcxTabSheet;
    CheckListBoxFields: TcxCheckListBox;
    CheckListBoxWhere: TcxCheckListBox;
    RgTipoOperacion: TcxRadioGroup;
    BtBuscarTabla: TcxButton;
    CheckListBoxOrderBy: TcxCheckListBox;
    Panel1: TPanel;
    Panel2: TPanel;
    Panel3: TPanel;
    cxGroupBox3: TcxGroupBox;
    dxBevel4: TdxBevel;
    cxLabel12: TcxLabel;
    edtNombreVariable: TcxTextEdit;
    cxLabel15: TcxLabel;
    edtNombreTabla: TcxTextEdit;
    btnGenerar: TcxButton;
    btnCopiar: TcxButton;
    memResultado: TcxMemo;
    cxTabSheet8: TcxTabSheet;
    cxTabSheet9: TcxTabSheet;
    BtCrearIndice: TcxButton;
    RgFormatoSalida2: TcxRadioGroup;
    LblFactorRelleno: TcxLabel;
    ChkUsarFactorRelleno: TcxCheckBox;
    RgTipoIndice: TcxRadioGroup;
    cxGroupBox4: TcxGroupBox;
    cxGroupBox5: TcxGroupBox;
    LvCamposDisponibles: TcxListView;
    LvCamposIndice: TcxListView;
    cxGroupBox6: TcxGroupBox;
    LvCamposIncluidos: TcxListView;
    cxGroupBox7: TcxGroupBox;
    LblTabla: TcxLabel;
    CmbTabla: TcxComboBox;
    LblNombreIndice: TcxLabel;
    EdNombreIndice: TcxTextEdit;
    BtnCargarTablas: TcxButton;
    BtnCargarCampos: TcxButton;
    PnlBotonesCampos: TPanel;
    BtnAgregarCampo: TcxButton;
    BtnQuitarCampo: TcxButton;
    BtnSubirCampo: TcxButton;
    BtnBajarCampo: TcxButton;
    BtnAgregarInclude: TcxButton;
    BtnQuitarInclude: TcxButton;
    cxGroupBox8: TcxGroupBox;
    MmDescripcion: TcxMemo;
    SeFactorRelleno: TcxSpinEdit;
    PnlTop: TdxPanel;
    EdNombreFK: TcxTextEdit;
    PnlTablas: TdxPanel;
    CmbTablaOrigen: TcxComboBox;
    CmbTablaDestino: TcxComboBox;
    PnlCampos: TdxPanel;
    PnlCamposOrigen: TdxPanel;
    LvCamposOrigen: TcxListView;
    PnlCamposDestino: TdxPanel;
    LvCamposDestino: TcxListView;
    PnlMapeo: TdxPanel;
    LvMapeo: TcxListView;
    PnlOpciones: TdxPanel;
    CmbAccionUpdate: TcxComboBox;
    CmbAccionDelete: TcxComboBox;
    PnlDescripcion: TdxPanel;
    PnlButtons: TdxPanel;
    cxLabel16: TcxLabel;
    cxLabel17: TcxLabel;
    BtCargarTablas: TcxButton;
    cxLabel18: TcxLabel;
    BtGenerarFK: TcxButton;
    BtGenerarFKDrop: TcxButton;
    BtnAgregarMapeo: TcxButton;
    BtnQuitarMapeo: TcxButton;
    cxLabel19: TcxLabel;
    cxLabel20: TcxLabel;
    MmDescripcionFK: TcxMemo;
    RgFormatoSalida3: TcxRadioGroup;
    QryDatabaseTables: TFDQuery;
    BtLimpiarPantalla: TcxButton;
    cxTabSheet10: TcxTabSheet;
    dxToggleSwitch1: TdxToggleSwitch;
    Panel4: TPanel;
    Panel5: TPanel;
    Panel6: TPanel;
    Panel7: TPanel;
    Panel8: TPanel;
    Panel9: TPanel;
    Panel10: TPanel;
    Panel11: TPanel;
    Panel12: TPanel;
    Panel13: TPanel;
    Panel14: TPanel;
    pcFunctions: TcxPageControl;
    tsScalarFunction: TcxTabSheet;
    pnlScalarTop: TdxPanel;
    edtScalarFunctionName: TcxTextEdit;
    cbScalarSchema: TcxComboBox;
    cbScalarReturnType: TcxComboBox;
    edtScalarTypeLength: TcxTextEdit;
    lblScalarFunctionName: TcxLabel;
    lblScalarSchema: TcxLabel;
    lblScalarReturnType: TcxLabel;
    lblScalarTypeLength: TcxLabel;
    pnlScalarLeft: TdxPanel;
    pnlScalarParameters: TdxPanel;
    grdScalarParameters: TcxGrid;
    grdScalarParametersView: TcxGridDBTableView;
    grdScalarParametersViewName: TcxGridDBColumn;
    grdScalarParametersViewDataType: TcxGridDBColumn;
    grdScalarParametersViewLength: TcxGridDBColumn;
    grdScalarParametersViewPrecision: TcxGridDBColumn;
    grdScalarParametersViewScale: TcxGridDBColumn;
    grdScalarParametersLevel: TcxGridLevel;
    pnlScalarParamButtons: TdxPanel;
    btnScalarAddParam: TcxButton;
    btnScalarEditParam: TcxButton;
    btnScalarDeleteParam: TcxButton;
    Panel15: TPanel;
    pnlScalarRight: TdxPanel;
    memScalarBody: TcxMemo;
    Panel16: TPanel;
    pnlScalarBottom: TdxPanel;
    memScalarSQL: TcxMemo;
    btnGenerateScalarSQL: TcxButton;
    btnCopyScalarSQL: TcxButton;
    Panel17: TPanel;
    tsTableFunction: TcxTabSheet;
    pnlTableTop: TdxPanel;
    edtTableFunctionName: TcxTextEdit;
    cbTableSchema: TcxComboBox;
    lblTableFunctionName: TcxLabel;
    lblTableSchema: TcxLabel;
    pnlTableLeft: TdxPanel;
    pnlTableParameters: TdxPanel;
    grdTableParameters: TcxGrid;
    grdTableParametersView: TcxGridDBTableView;
    grdTableParametersViewName: TcxGridDBColumn;
    grdTableParametersViewDataType: TcxGridDBColumn;
    grdTableParametersViewLength: TcxGridDBColumn;
    grdTableParametersViewPrecision: TcxGridDBColumn;
    grdTableParametersViewScale: TcxGridDBColumn;
    grdTableParametersLevel: TcxGridLevel;
    pnlTableParamButtons: TdxPanel;
    btnTableAddParam: TcxButton;
    btnTableEditParam: TcxButton;
    btnTableDeleteParam: TcxButton;
    Panel18: TPanel;
    pnlTableColumns: TdxPanel;
    grdTableColumns: TcxGrid;
    grdTableColumnsView: TcxGridDBTableView;
    grdTableColumnsViewName: TcxGridDBColumn;
    grdTableColumnsViewDataType: TcxGridDBColumn;
    grdTableColumnsViewLength: TcxGridDBColumn;
    grdTableColumnsViewPrecision: TcxGridDBColumn;
    grdTableColumnsViewScale: TcxGridDBColumn;
    grdTableColumnsLevel: TcxGridLevel;
    pnlTableColButtons: TdxPanel;
    btnTableAddColumn: TcxButton;
    btnTableEditColumn: TcxButton;
    btnTableDeleteColumn: TcxButton;
    Panel19: TPanel;
    pnlTableRight: TdxPanel;
    memTableBody: TcxMemo;
    Panel20: TPanel;
    pnlTableBottom: TdxPanel;
    memTableSQL: TcxMemo;
    btnGenerateTableSQL: TcxButton;
    btnCopyTableSQL: TcxButton;
    Panel21: TPanel;
    cxStyleRepository1: TcxStyleRepository;
    Activo: TcxStyle;
    RgTipoScript: TcxRadioGroup;
    EdCantidadCampos: TcxCalcEdit;
    cxLabel7: TcxLabel;
    procedure FormCreate(Sender: TObject);
    procedure BtGenerar_INSERTClick(Sender: TObject);
    procedure BtBuscarClick(Sender: TObject);
    procedure BtGenerar_SELECTClick(Sender: TObject);
    procedure BtGenerar_UPDATEClick(Sender: TObject);
    procedure BtGenerar_DELETEClick(Sender: TObject);
    procedure BtRutaArchivoClick(Sender: TObject);
    procedure FormShow(Sender: TObject);
    procedure CkbListTodoSelectClick(Sender: TObject);
    procedure CkbListWhereSelectClick(Sender: TObject);
    procedure CkbListInsertClick(Sender: TObject);
    procedure CkbListUpdateClick(Sender: TObject);
    procedure CkbListWhereUpdateClick(Sender: TObject);
    procedure CkbListWhereDeleteClick(Sender: TObject);
    procedure BtRutaArchivoMouseEnter(Sender: TObject);
    procedure BtRutaArchivoMouseLeave(Sender: TObject);
    procedure CkbListOrderByClick(Sender: TObject);
    procedure BtEstructuraTablaClick(Sender: TObject);
    procedure ListCamposSelectDrawItem(Control: TWinControl; Index: Integer;
      Rect: TRect; State: TOwnerDrawState);
    procedure EdBusquedaCampoKeyPress(Sender: TObject; var Key: Char);
    procedure EdBusquedaCampoPropertiesChange(Sender: TObject);
    procedure BtFieldByNameClick(Sender: TObject);
    procedure cxPageControl1Change(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    procedure ListCamposSelectClickCheck(Sender: TObject; AIndex: Integer;
      APrevState, ANewState: TcxCheckBoxState);
    procedure ListCamposInsertClickCheck(Sender: TObject; AIndex: Integer;
      APrevState, ANewState: TcxCheckBoxState);
    procedure ListCamposUpdateClickCheck(Sender: TObject; AIndex: Integer;
      APrevState, ANewState: TcxCheckBoxState);
    procedure BtItemUpClick(Sender: TObject);
    procedure BtItemDownClick(Sender: TObject);
    procedure BtRemoveItemClick(Sender: TObject);
    procedure BtAddItemClick(Sender: TObject);
    procedure cxButton1Click(Sender: TObject);
    procedure cxButton2Click(Sender: TObject);
    procedure cxButton3Click(Sender: TObject);
    procedure cxButton4Click(Sender: TObject);
    procedure cxButton5Click(Sender: TObject);
    procedure cxButton6Click(Sender: TObject);
    procedure cxButton7Click(Sender: TObject);
    procedure cxButton8Click(Sender: TObject);
    procedure cxButton9Click(Sender: TObject);
    procedure cxButton10Click(Sender: TObject);
    procedure cxButton11Click(Sender: TObject);
    procedure cxButton12Click(Sender: TObject);
    procedure dxToggleSwitch1Click(Sender: TObject);
    procedure Image1Click(Sender: TObject);
    procedure BtScriptStoreProcedureClick(Sender: TObject);
    procedure BtBuscarTablaClick(Sender: TObject);
    procedure btnGenerarClick(Sender: TObject);
    procedure btnCopiarClick(Sender: TObject);
    procedure BtnCargarTablasClick(Sender: TObject);
    procedure BtnCargarCamposClick(Sender: TObject);
    procedure BtnAgregarCampoClick(Sender: TObject);
    procedure BtnQuitarCampoClick(Sender: TObject);
    procedure BtnSubirCampoClick(Sender: TObject);
    procedure BtnBajarCampoClick(Sender: TObject);
    procedure BtnAgregarIncludeClick(Sender: TObject);
    procedure BtnQuitarIncludeClick(Sender: TObject);
    procedure ChkUsarFactorRellenoClick(Sender: TObject);
    procedure BtCrearIndiceClick(Sender: TObject);
    procedure BtCargarTablasClick(Sender: TObject);
    procedure CmbTablaOrigenPropertiesChange(Sender: TObject);
    procedure CmbTablaDestinoPropertiesChange(Sender: TObject);
    procedure BtnAgregarMapeoClick(Sender: TObject);
    procedure BtnQuitarMapeoClick(Sender: TObject);
    procedure BtGenerarFKClick(Sender: TObject);
    procedure BtGenerarFKDropClick(Sender: TObject);
    procedure BtLimpiarPantallaClick(Sender: TObject);
    procedure BtCrearFuncionClick(Sender: TObject);
    procedure cbScalarReturnTypePropertiesChange(Sender: TObject);
    procedure btnScalarAddParamClick(Sender: TObject);
    procedure btnScalarEditParamClick(Sender: TObject);
    procedure btnScalarDeleteParamClick(Sender: TObject);
    procedure btnGenerateScalarSQLClick(Sender: TObject);
    procedure btnCopyScalarSQLClick(Sender: TObject);
    procedure btnTableAddParamClick(Sender: TObject);
    procedure btnTableEditParamClick(Sender: TObject);
    procedure btnTableDeleteParamClick(Sender: TObject);
    procedure btnTableAddColumnClick(Sender: TObject);
    procedure btnTableEditColumnClick(Sender: TObject);
    procedure btnTableDeleteColumnClick(Sender: TObject);
    procedure btnGenerateTableSQLClick(Sender: TObject);
    procedure btnCopyTableSQLClick(Sender: TObject);
    procedure RgTipoOperacionClick(Sender: TObject);
  private
    FForeignKey : TForeignKey;

    // Variables para la creacion de las funciones escalares y de tabla

    FScalarParamsDataSet : TFDMemTable;
    FTableParamsDataSet  : TFDMemTable;
    FTableColumnsDataSet : TFDMemTable;
    FFunctionBuilder     : TSQLFunctionBuilder;

    // Métodos para la creacion de los Store Procedure SELECT, INSERT, UPDATE Y DELETE
    procedure GenerarStoreProcedure(TipoStoreProcedure : OperationType);
    procedure GenerarSPSelect(Script : TStringList; Tabla, SpName : string);
    procedure GenerarSPInsert(Script : TStringList; Tabla, SpName : string);
    procedure GenerarSPUpdate(Script : TStringList; Tabla, SpName, CamposClave : string);
    procedure GenerarSPDelete(Script : TStringList; Tabla, SpName, CamposClave : string);
    function ObtenerTipoDato(Tabla, Campo : string) : string;

    function GenerarDeclaracionTabla(const NombreTabla, NombreVariable : string) : string;


    // Métodos para la creacion de los querys SELECT, INSERT, UPDATE Y DELETE
    procedure GenerarParametrosDelphi(Query : TFDQuery; ListaCampos : TcxCheckListBox;
                                      Parametros : TStringList; const Prefijo : string = '');
    function BuscarCampoPorNombre(Query : TFDQuery; const NombreCampo : string) : TField;
    function ObtenerTipoParametro(Campo : TField) : string;

    procedure ProcesarSalida(const NombreArchivo, Titulo : string);

    // Métodos para la creacion de los indices
    procedure CargarTablas;
    procedure CargarCamposTabla(const NombreTabla : string); overload;
    function ValidarDatos : Boolean;
    function GenerarNombreIndiceAutomatico : string;


    // Métodos para la creacion de los Foreign Key
    procedure CargarCamposTabla(const NombreTabla : string; ListView : TcxListView); overload;
    function GenerarNombreConstraintAutomatico : string;
    function ValidarDatosFK : Boolean;


    // Métodos para la creacion de las funciones escalares y de tabla

    procedure InitializeControls;
    procedure LoadSchemasFromDB;
    procedure LoadDataTypes;
    procedure CreateDataSets;
    procedure SetupGrids;
    procedure ShowParameterDialog(ADataSet : TFDMemTable; const AIsEdit : Boolean);
    procedure ShowColumnDialog(ADataSet : TFDMemTable; const AIsEdit : Boolean);
    procedure GenerateScalarFunctionSQL;
    procedure GenerateTableFunctionSQL;


    procedure LimpiarListados;
    procedure SeleccionarTodo(CheckList : TcxCheckListBox; Value : Boolean);

    function MasLargo(Lista : TStringList) : Integer; overload;
    function MasLargo(CheckList : TcxCheckListBox) : Integer; overload;
    function TotalChecked(CheckList : TcxCheckListBox) : Integer;
    function UltimoIndiceSeleccionado(CheckList : TcxCheckListBox) : Integer;


    // function BuscarElementoLista(Elemento : string; Lista : TcxCheckListBox) : Integer;
    procedure LbMoveItemUp(AListBox : TcxListBox);
    procedure LbMoveItemDown(AListBox : TcxListBox);
    function FindSelectedItem(ACheckListBox : TcxCheckListBox) : Integer;
    procedure ClbMoveItemUp(ACheckListBox : TcxCheckListBox);
    procedure ClbMoveItemDown(ACheckListBox : TcxCheckListBox);

  public


  end;


var
  FRBuilder: TFRBuilder;
  UltIndice : Integer = -1;

implementation

uses
  Utileria, UFRSelectQueryBuilder, ModoOscuroClaro, UResolucionPantalla,
  UFunctionBuilderForm;

{$R *.dfm}

//{ TcxMyShellBrowserDialog }
//
//function TcxMyShellBrowserDialog.CreateForm: TcxShellBrowserDlg;
//begin
//  Result := inherited CreateForm;
//  Result.Width   := 3000;
//  Result.Height  := 1000;
//  Result.cxButton1.Caption := 'Aceptar';
//  Result.cxButton2.Caption := 'Cancelar';
////  Result.Font.Size := 16;
//end;

procedure TFRBuilder.BtBuscarClick(Sender: TObject);
var
  I : Integer;
begin
  if EdRutaArchivo.Text = EmptyStr then
    begin
      Mensaje('Debe Elegir la Ruta donde se Guardara el Archivo de Texto!!!',
              'Operación Invalida', Advertencia);
      BtRutaArchivo.SetFocus;
      Abort;
    end;

  if TxtTabla.Text = EmptyStr then
    begin
      Mensaje('Debe Digitar la Tabla para Realizar las Operaciones!!!',
              'Operación Invalida', Advertencia);
      TxtTabla.SetFocus;
      Abort;
    end;

  with QryUtils, SQL do
    begin
      Close;
      Clear;
      Add('SELECT * FROM INFORMATION_SCHEMA.TABLES');
      Add('WHERE TABLE_SCHEMA = ' + QuotedStr('dbo'));
      Add('AND TABLE_NAME = ' + QuotedStr(Trim(TxtTabla.Text)));
      Open;

      if RecordCount = 0 then
        begin
          Mensaje('La Tabla Digitada No Existe en la Base de Datos' +#13+
                  'ó No Tienes Permiso de Lectura.'+#13+
                  'Por Favor Verifique!!!','Tabla No Existe', Error);
          TxtTabla.SetFocus;
          Abort;
        end;
    end;

  CkbListTodoSelect.Checked  := False;
  CkbListWhereSelect.Checked := False;
  CkbListOrderBy.Checked     := False;
  CkbListInsert.Checked      := False;
  CkbListUpdate.Checked      := False;
  CkbListWhereUpdate.Checked := False;
  CkbListWhereDelete.Checked := False;

  LimpiarListados;

  QryConsulta.Close;
  QryConsulta.SQL.Text := 'SELECT TOP 1 * FROM ' + TxtTabla.Text;
  QryConsulta.Open;

  //AL CARGAR LOS DATOS EN LOS TcxCheckListBox MINIMIZAMOS EL PARPADEO
  for I := 0 to Self.ComponentCount - 1 do
    begin
      if Self.Components[I] is TcxCheckListBox then
        begin
          (Self.Components[I] as TcxCheckListBox).DoubleBuffered := True;

          (Self.Components[I] as TcxCheckListBox).Items.BeginUpdate;
        end;
    end;


//  ListCamposInsert.Items.BeginUpdate;
//
//  ListCamposSelect.Items.BeginUpdate;
//  ListCamposWhereSelect.Items.BeginUpdate;
//  ListCamposOrderBy.Items.BeginUpdate;
//
//  ListCamposUpdate.Items.BeginUpdate;
//  ListCamposWhereUpdate.Items.BeginUpdate;
//
//  ListCamposWhereDelete.Items.BeginUpdate;

  QryConsulta.First;
  for I := 0 to QryConsulta.Fields.Count - 1 do
    begin
      //INSERT
      with ListCamposInsert.Items.Add do
        begin
          Text  := QryConsulta.Fields[I].FieldName;
          State := cbsUnchecked;
        end;

      //SELECT
      with ListCamposSelect.Items.Add do
        begin
          Text  := QryConsulta.Fields[I].FieldName;
          State := cbsUnchecked;
        end;

      with ListCamposWhereSelect.Items.Add do
        begin
          Text  := QryConsulta.Fields[I].FieldName;
          State := cbsUnchecked;
        end;

      with ListCamposOrderBy.Items.Add do
        begin
          Text  := QryConsulta.Fields[I].FieldName;
          State := cbsUnchecked;
        end;

      //UPDATE
      with ListCamposUpdate.Items.Add do
        begin
          Text  := QryConsulta.Fields[I].FieldName;
          State := cbsUnchecked;
        end;

      with ListCamposWhereUpdate.Items.Add do
        begin
          Text  := QryConsulta.Fields[I].FieldName;
          State := cbsUnchecked;
        end;

      //DELETE
      with ListCamposWhereDelete.Items.Add do
        begin
          Text  := QryConsulta.Fields[I].FieldName;
          State := cbsUnchecked;
        end;

        QryConsulta.Next;
    end;

  for I := 0 to Self.ComponentCount - 1 do
    begin
      if Self.Components[I] is TcxCheckListBox then
        begin
//          (Self.Components[I] as TcxCheckListBox).Sorted := True;

          (Self.Components[I] as TcxCheckListBox).Items.EndUpdate;
        end;
    end;


//  ListCamposInsert.Sorted      := True;
//  ListCamposSelect.Sorted      := True;
//  ListCamposWhereSelect.Sorted := True;
//  ListCamposOrderBy.Sorted     := True;
//  ListCamposUpdate.Sorted      := True;
//  ListCamposWhereUpdate.Sorted := True;
//  ListCamposWhereDelete.Sorted := True;

//  ListCamposInsert.Items.EndUpdate;
//
//  ListCamposSelect.Items.EndUpdate;
//  ListCamposWhereSelect.Items.EndUpdate;
//  ListCamposOrderBy.Items.EndUpdate;
//
//  ListCamposUpdate.Items.EndUpdate;
//  ListCamposWhereUpdate.Items.EndUpdate;
//
//  ListCamposWhereDelete.Items.EndUpdate;

end;

procedure TFRBuilder.BtGenerar_SELECTClick(Sender: TObject);
var
  SelectTodos, PrimeraVez : Boolean;
  TextFile, RutaArchivo, LineaActual, CamposWhere, CamposOrderBy : string;
  Lineas, Parametros : TStringList;
  I, CamposPorLinea, Contador : Integer;
begin
  // Validaciones iniciales
  if TotalChecked(ListCamposSelect) = 0 then
    begin
      Mensaje('Debe Seleccionar los campos que tendrá el script.',
              'Operación Invalida', Advertencia);
      BtBuscar.SetFocus;
      Exit;
    end;

  RutaArchivo := EdRutaArchivo.Text;

  if not DirectoryExists(RutaArchivo) then
    begin
      Mensaje('Debe Seleccionar un Directorio Válido!!!',
              'Ruta del Archivo Inválida', Advertencia);
      BtRutaArchivo.SetFocus;
      Exit;
    end;

  // Obtener la cantidad de campos por línea
  if EdCantidadCampos.Value > 0 then
    CamposPorLinea := StrToInt(EdCantidadCampos.Text)
  else
    CamposPorLinea := 1;

  SelectTodos := False;

  if CkbListTodoSelect.Checked then
    begin
      if Mensaje('¿Desea Generar el SELECT con * ?',
                 'Generación SELECT', Pregunta, 2) then
        SelectTodos := True;
    end;

//  TextFile := TPath.GetAppPath + '\SQL_SELECT.txt';
//  TextFile := TPath.Combine(TPath.GetAppPath, '\SQL_SELECT.txt');

  TextFile := RutaArchivo + 'SQL_SELECT.txt';
  Lineas   := TStringList.Create;

  try
    case RgTipoScript.ItemIndex of
      0 : begin // FORMATO DELPHI
            Lineas.Add('with QryDataset, SQL do');
            Lineas.Add('begin');
            Lineas.Add('  Close;');
            Lineas.Add('  Clear;');

            if SelectTodos then    // Construir SELECT
              begin
                Lineas.Add('  Add(''SELECT * FROM ' + Trim(TxtTabla.Text) + ''');');
              end
            else
              begin
                Contador    := 0;
                LineaActual := '';

                for I := 0 to ListCamposSelect.Items.Count - 1 do
                begin
                  if ListCamposSelect.Items[I].State = cbsChecked then
                    begin
                      Inc(Contador);

                      // Si es el primer campo de la consulta completa
                      if Contador = 1 then
                        LineaActual := 'SELECT ' + ListCamposSelect.Items[I].Text
                      else
                        begin
                          // Si es el primer campo de una nueva línea (pero no el primero absoluto)
                          if LineaActual = '' then
                            LineaActual := ListCamposSelect.Items[I].Text
                          else
                            LineaActual := LineaActual + ', ' + ListCamposSelect.Items[I].Text;
                        end;

                      // Si hemos alcanzado el número de campos por línea o es el último campo
                      if (Contador mod CamposPorLinea = 0) or
                         (Contador = TotalChecked(ListCamposSelect)) then
                        begin
                          // Si no es el último campo total, agregamos coma al final
                          if Contador < TotalChecked(ListCamposSelect) then
                            LineaActual := LineaActual + ',';

                          Lineas.Add('  Add(''' + LineaActual + ''');');
                          LineaActual := '';
                        end;
                    end;
                end;

                Lineas.Add('  Add(''FROM ' + Trim(TxtTabla.Text) + ''');');

              end;

            // Construir WHERE
            PrimeraVez := True;

            for I := 0 to ListCamposWhereSelect.Items.Count - 1 do
            begin
              if ListCamposWhereSelect.Items[I].State = cbsChecked then
                begin
                  if PrimeraVez = True then
                    begin
                      Lineas.Add('  Add(''WHERE ' + ListCamposWhereSelect.Items[I].Text + ' = :' +
                                 ListCamposWhereSelect.Items[I].Text + ''');');
                      PrimeraVez := False;
                    end
                  else
                    Lineas.Add('  Add(''AND ' + ListCamposWhereSelect.Items[I].Text +
                                   ' = :' + ListCamposWhereSelect.Items[I].Text + ''');');
                end;
            end;

            // Generar los parámetros con sus tipos de datos
            Parametros := TStringList.Create;
            try
              GenerarParametrosDelphi(QryConsulta, ListCamposWhereSelect, Parametros, '  ');

              for I := 0 to Parametros.Count - 1 do
                Lineas.Add(Parametros[I]);
            finally
              Parametros.Free;
            end;

            // Construir ORDER BY

            CamposOrderBy := EmptyStr;

            for I := 0 to ListCamposOrderBy.Items.Count - 1 do
            begin
              if ListCamposOrderBy.Items[I].State = cbsChecked then
                begin
                  if CamposOrderBy = EmptyStr then
                    CamposOrderBy := 'ORDER BY ' + ListCamposOrderBy.Items[I].Text
                  else
                    CamposOrderBy := CamposOrderBy + ', ' + ListCamposOrderBy.Items[I].Text;
                end;
            end;

            if CamposOrderBy <> EmptyStr then
              Lineas.Add('  Add(''' + CamposOrderBy + ''');');

            Lineas.Add('  Open;');
            Lineas.Add('end;');
          end;

      1 : begin // FORMATO SQL SERVER
            // Construir SELECT
            if SelectTodos then
              begin
                Lineas.Add('SELECT * FROM ' + Trim(TxtTabla.Text));
              end
            else
              begin
                Contador    := 0;
                LineaActual := '';

                for I := 0 to ListCamposSelect.Items.Count - 1 do
                begin
                  if ListCamposSelect.Items[I].State = cbsChecked then
                    begin
                      Inc(Contador);

                      // Si es el primer campo de la consulta completa
                      if Contador = 1 then
                        LineaActual := 'SELECT ' + ListCamposSelect.Items[I].Text
                      else
                        begin
                          // Si es el primer campo de una nueva línea (pero no el primero absoluto)
                          if LineaActual = '' then
                            LineaActual := ListCamposSelect.Items[I].Text
                          else
                            LineaActual := LineaActual + ', ' + ListCamposSelect.Items[I].Text;
                        end;

                      // Si hemos alcanzado el número de campos por línea o es el último campo
                      if (Contador mod CamposPorLinea = 0) or
                         (Contador = TotalChecked(ListCamposSelect)) then
                        begin
                          // Si no es el último campo total, agregamos coma al final
                          if Contador < TotalChecked(ListCamposSelect) then
                            LineaActual := LineaActual + ',';

                          Lineas.Add(LineaActual);
                          LineaActual := '';
                        end;
                    end;
                end;

                Lineas.Add('FROM ' + Trim(TxtTabla.Text));
              end;

            // Construir WHERE
            CamposWhere := EmptyStr;

            for I := 0 to ListCamposWhereSelect.Items.Count - 1 do
            begin
              if ListCamposWhereSelect.Items[I].State = cbsChecked then
                begin
                  if CamposWhere = EmptyStr then
                    CamposWhere := 'WHERE ' + ListCamposWhereSelect.Items[I].Text + ' = @' +
                                   ListCamposWhereSelect.Items[I].Text
                  else
                    CamposWhere := CamposWhere + sLineBreak + 'AND ' + ListCamposWhereSelect.Items[I].Text +
                                   ' = @' + ListCamposWhereSelect.Items[I].Text;
                end;
            end;

            if CamposWhere <> EmptyStr then
              Lineas.Add(CamposWhere);

            // Construir ORDER BY
            CamposOrderBy := EmptyStr;

            for I := 0 to ListCamposOrderBy.Items.Count - 1 do
            begin
              if ListCamposOrderBy.Items[I].State = cbsChecked then
                begin
                  if CamposOrderBy = EmptyStr then
                    CamposOrderBy := 'ORDER BY ' + ListCamposOrderBy.Items[I].Text
                  else
                    CamposOrderBy := CamposOrderBy + ', ' + ListCamposOrderBy.Items[I].Text;
                end;
            end;

            if CamposOrderBy <> EmptyStr then
              Lineas.Add(CamposOrderBy);
          end;
    end;

    // Guardar archivo
    TFile.WriteAllText(TextFile, Lineas.Text, TEncoding.UTF8);

    // Procesar salida (portapapeles ó archivo)
    ProcesarSalida('SQL_SELECT.txt', 'El Código SQL SELECT');
  finally
    Lineas.Free;
  end;
end;

procedure TFRBuilder.BtGenerar_INSERTClick(Sender: TObject);
var
  TextFile, RutaArchivo, LineaActual : string;
  Lineas, Parametros : TStringList;
  I, CamposPorLinea, Contador : Integer;
begin
  // Validaciones iniciales
  if ListCamposInsertSel.Items.Count = 0 then
    begin
      Mensaje('Debe Seleccionar los Campos a Generar!!!',
              'Operación Invalida', Advertencia);
      BtBuscar.SetFocus;
      Exit;
    end;

  RutaArchivo := EdRutaArchivo.Text;

  if not DirectoryExists(RutaArchivo) then
    begin
      Mensaje('Debe Seleccionar un Directorio Válido!!!',
              'Ruta del Archivo Inválida', Advertencia);
      BtRutaArchivo.SetFocus;
      Exit;
    end;

  if EdCantidadCampos.Value > 0 then
    CamposPorLinea := StrToInt(EdCantidadCampos.Text)
  else
    CamposPorLinea := 1;

  TextFile := RutaArchivo + 'SQL_INSERT.txt';
  Lineas   := TStringList.Create;

  try
    case RgTipoScript.ItemIndex of
      0 : begin // Formato Delphi
            Lineas.Add('with QryDataset, SQL do');
            Lineas.Add('begin');
            Lineas.Add('  Close;');
            Lineas.Add('  Clear;');
            Lineas.Add('  Add(''INSERT INTO ' + Trim(TxtTabla.Text) + ' ('');');

            // Campos INSERT - Divididos por CamposPorLinea
            Contador    := 0;
            LineaActual := '';
            for I := 0 to ListCamposInsertSel.Items.Count - 1 do
            begin
              if LineaActual <> '' then
                LineaActual := LineaActual + ', ';

              LineaActual := LineaActual + ListCamposInsertSel.Items.Strings[I];
              Inc(Contador);

              if (Contador >= CamposPorLinea) or (I = ListCamposInsertSel.Items.Count - 1) then
                begin
                  if I < ListCamposInsertSel.Items.Count - 1 then
                    Lineas.Add('  Add(''' + LineaActual + ','');')
                  else
                    Lineas.Add('  Add(''' + LineaActual + ')'');');

                  LineaActual := '';
                  Contador    := 0;
                end;
            end;

            Lineas.Add('  Add(''VALUES ('');');

            // Parámetros VALUES - Divididos por CamposPorLinea
            Contador    := 0;
            LineaActual := '';
            for I := 0 to ListCamposInsertSel.Items.Count - 1 do
            begin
              if LineaActual <> '' then
                LineaActual := LineaActual + ', ';

              LineaActual := LineaActual + ':' + ListCamposInsertSel.Items.Strings[I];
              Inc(Contador);

              if (Contador >= CamposPorLinea) or (I = ListCamposInsertSel.Items.Count - 1) then
                begin
                  if I < ListCamposInsertSel.Items.Count - 1 then
                    Lineas.Add('  Add(''' + LineaActual +  ','');')
                  else
                    Lineas.Add('  Add(''' + LineaActual + ')'');');

                  LineaActual := '';
                  Contador    := 0;
                end;
            end;

            // Generar los parámetros con sus tipos de datos
            Parametros := TStringList.Create;
            try
              GenerarParametrosDelphi(QryConsulta, ListCamposInsert, Parametros, '  ');

              for I := 0 to Parametros.Count - 1 do
                Lineas.Add(Parametros[I]);
            finally
              Parametros.Free;
            end;

            Lineas.Add('  ExecSQL;');
            Lineas.Add('end;');
          end;

      1 : begin // Formato SQL Server
            Lineas.Add('INSERT INTO ' + Trim(TxtTabla.Text) + ' (');

            Contador    := 0;
            LineaActual := '  '; // Dos espacios de indentación

            for I := 0 to ListCamposInsertSel.Items.Count - 1 do
            begin
              if I < ListCamposInsertSel.Items.Count- 1 then
                LineaActual := LineaActual + ListCamposInsertSel.Items.Strings[I] + ', '
              else
                LineaActual := LineaActual + ListCamposInsertSel.Items.Strings[I] + ')';

              Inc(Contador);

              // Si alcanzamos el límite de campos por línea, agregar al resultado
              if (Contador >= CamposPorLinea) or (I = ListCamposInsertSel.Items.Count - 1) then
                begin
                  Lineas.Add(LineaActual);
                  // Preparar nueva línea
                  LineaActual := '  ';
                  Contador    := 0;
                end;
            end;

            Lineas.Add('VALUES (');

            Contador    := 0;
            LineaActual := '  '; // Dos espacios de indentación

            for I := 0 to ListCamposInsertSel.Items.Count - 1 do
            begin
              if I < ListCamposInsertSel.Items.Count- 1 then
                LineaActual := LineaActual + '@' + ListCamposInsertSel.Items.Strings[I] + ', '
              else
                LineaActual := LineaActual + '@' + ListCamposInsertSel.Items.Strings[I] + ')';

              Inc(Contador);

              // Si alcanzamos el límite de campos por línea, agregar al resultado
              if (Contador >= CamposPorLinea) or (I = ListCamposInsertSel.Items.Count - 1) then
                begin
                  Lineas.Add(LineaActual);
                  // Preparar nueva línea
                  LineaActual := '  ';
                  Contador    := 0;
                end;
            end;
          end;

    end;

    // Guardar archivo
    TFile.WriteAllText(TextFile, Lineas.Text, TEncoding.UTF8);

    // Procesar salida
    ProcesarSalida('SQL_INSERT.txt', 'El Código SQL INSERT');
  finally
    Lineas.Free;
  end;
end;

procedure TFRBuilder.BtGenerar_UPDATEClick(Sender: TObject);
var
  TextFile, RutaArchivo, LineaActual : string;
  Lineas, Parametros : TStringList;
  I, CamposPorLinea, Contador : Integer;
begin
  // Validaciones iniciales
  if TotalChecked(ListCamposUpdate) = 0 then
    begin
      Mensaje('Debe Seleccionar los campos que tendrá el script.',
              'Operación Invalida', Advertencia);
      BtBuscar.SetFocus;
      Exit;
    end;

  RutaArchivo := EdRutaArchivo.Text;

  if not DirectoryExists(RutaArchivo) then
    begin
      Mensaje('Debe Seleccionar un Directorio Válido!!!',
              'Ruta del Archivo Inválida', Advertencia);
      BtRutaArchivo.SetFocus;
      Exit;
    end;

  if EdCantidadCampos.Value > 0 then
    CamposPorLinea := StrToInt(EdCantidadCampos.Text)
  else
    CamposPorLinea := 1;

  TextFile := RutaArchivo + 'SQL_UPDATE.txt';
  Lineas   := TStringList.Create;

  try
    case RgTipoScript.ItemIndex of
      0 : begin // Formato Delphi
            Lineas.Add('with QryDataset, SQL do');
            Lineas.Add('begin');
            Lineas.Add('  Close;');
            Lineas.Add('  Clear;');
            Lineas.Add('  Add(''UPDATE ' + Trim(TxtTabla.Text) + ' SET'');');

            Contador    := 0;       // CAMPOS DEL SET
            LineaActual := '';

            for I:= 0 to ListCamposUpdate.Items.Count - 1 do
            begin
              if ListCamposUpdate.Items.Items[I].State = cbsChecked then
                begin
                  if LineaActual <> '' then
                    LineaActual := LineaActual + ', ';

                  LineaActual := LineaActual + ListCamposUpdate.Items.Items[I].Text + ' = :' + ListCamposUpdate.Items.Items[I].Text;
                  Inc(Contador);

                  if (Contador >= CamposPorLinea) or (I = UltimoIndiceSeleccionado(ListCamposUpdate)) then
                    begin
                      if I < UltimoIndiceSeleccionado(ListCamposUpdate) then
                        Lineas.Add('  Add(''' + LineaActual + ','');')
                      else
                        Lineas.Add('  Add(''' + LineaActual + ''');');

                      LineaActual := '';
                      Contador    := 0;
                    end;
                end;
            end;

            // CAMPOS DEL WHERE

            for I := 0 to ListCamposWhereUpdate.Items.Count - 1 do
            begin
              if ListCamposWhereUpdate.Items.Items[I].State = cbsChecked then
                begin
//                  if I < ListCamposWhereUpdate.Items.Count - 1 then
                  if I < TotalChecked(ListCamposWhereUpdate) then
                    Lineas.Add('  Add(''WHERE ' + ListCamposWhereUpdate.Items.Items[I].Text + ' = :' + ListCamposWhereUpdate.Items.Items[I].Text + ''');')
                  else
                    Lineas.Add('  Add(''AND ' + ListCamposWhereUpdate.Items.Items[I].Text + ' = :' + ListCamposWhereUpdate.Items.Items[I].Text + ''');');
                end;
            end;

            // Generar los parámetros con sus tipos de datos
            // IMPORTANTE: Aquí está el cambio principal para corregir la alineación

            // Generar los parámetros del set con sus tipos de datos
            Parametros := TStringList.Create;
            try
              GenerarParametrosDelphi(QryConsulta, ListCamposUpdate, Parametros, '  ');

              for I := 0 to Parametros.Count - 1 do
                Lineas.Add(Parametros[I]);
            finally
              Parametros.Free;
            end;

            // Generar los parámetros del where con sus tipos de datos
            Parametros := TStringList.Create;
            try
              GenerarParametrosDelphi(QryConsulta, ListCamposWhereUpdate, Parametros, '  ');

              for I := 0 to Parametros.Count - 1 do
                Lineas.Add(Parametros[I]);
            finally
              Parametros.Free;
            end;

            Lineas.Add('  ExecSQL;');
            Lineas.Add('end;');
          end;

      1 : begin // Formato SQL Server
            Lineas.Add('UPDATE ' + Trim(TxtTabla.Text) + ' SET');

            Contador    := 0;       // CAMPOS DEL SET
            LineaActual := '';

            for I:= 0 to ListCamposUpdate.Items.Count - 1 do
            begin
              if ListCamposUpdate.Items.Items[I].State = cbsChecked then
                begin
                  if LineaActual <> '' then
                    LineaActual := LineaActual + ', ';

                  LineaActual := LineaActual + '  ' + ListCamposUpdate.Items.Items[I].Text + ' = @' + ListCamposUpdate.Items.Items[I].Text;
                  Inc(Contador);

                  if (Contador >= CamposPorLinea) or (I = UltimoIndiceSeleccionado(ListCamposUpdate)) then
                    begin
                      if I < UltimoIndiceSeleccionado(ListCamposUpdate) then
                        Lineas.Add(LineaActual + ', ')
                      else
                        Lineas.Add(LineaActual);  // Sin coma para el último campo

                      LineaActual := '';
                      Contador    := 0;
                    end;
                end;
            end;

            // CAMPOS DEL WHERE

            var PrimeraVez := True;

            for I := 0 to ListCamposWhereUpdate.Items.Count - 1 do
            begin
              if ListCamposWhereUpdate.Items.Items[I].State = cbsChecked then
                begin
                  if PrimeraVez = True then
                    begin
                      Lineas.Add('WHERE ' + ListCamposWhereUpdate.Items.Items[I].Text + ' = @' + ListCamposWhereUpdate.Items.Items[I].Text);
                      PrimeraVez := False;
                    end
                  else
                    Lineas.Add('AND ' + ListCamposWhereUpdate.Items.Items[I].Text + ' = @' + ListCamposWhereUpdate.Items.Items[I].Text);
                end;
            end;

          end;
    end;


    // Guardar archivo
    TFile.WriteAllText(TextFile, Lineas.Text, TEncoding.UTF8);

    // Procesar salida
    ProcesarSalida('SQL_UPDATE.txt', 'El Código SQL UPDATE');
  finally
    Lineas.Free;
  end;
end;

procedure TFRBuilder.BtGenerar_DELETEClick(Sender: TObject);
var
  TextFile, RutaArchivo : string;
  Lineas, Parametros : TStringList;
  I : Integer;
begin
  // Validaciones iniciales
  if TotalChecked(ListCamposWhereDelete) = 0 then
    begin
      Mensaje('Debe Seleccionar los campos que tendrá el script.',
              'Operación Invalida', Advertencia);
      BtBuscar.SetFocus;
      Exit;
    end;

  RutaArchivo := EdRutaArchivo.Text;

  if not DirectoryExists(RutaArchivo) then
    begin
      Mensaje('Debe Seleccionar un Directorio Válido!!!',
              'Ruta del Archivo Inválida', Advertencia);
      BtRutaArchivo.SetFocus;
      Exit;
    end;

  TextFile := RutaArchivo + 'SQL_DELETE.txt';
  Lineas   := TStringList.Create;

  try
    case RgTipoScript.ItemIndex of
      0 : begin // Formato Delphi
            Lineas.Add('with QryDataset, SQL do');
            Lineas.Add('begin');
            Lineas.Add('  Close;');
            Lineas.Add('  Clear;');
            Lineas.Add('  Add(''DELETE FROM ' + Trim(TxtTabla.Text) + ''');');

            // Recopilar campos WHERE
            var PrimeraVez := True;

            for I := 0 to ListCamposWhereDelete.Items.Count - 1 do
            begin
              if ListCamposWhereDelete.Items.Items[I].State = cbsChecked then
                begin
                  if PrimeraVez = True then
                    begin
                      Lineas.Add('  Add(''WHERE ' + ListCamposWhereDelete.Items.Items[I].Text + ' = :' + ListCamposWhereDelete.Items.Items[I].Text + ''');');
                      PrimeraVez := False;
                    end
                  else
                    Lineas.Add('  Add(''AND ' + ListCamposWhereDelete.Items.Items[I].Text + ' = :' + ListCamposWhereDelete.Items.Items[I].Text + ''');');
                end;
            end;

            // Generar los parámetros con sus tipos de datos
            Parametros := TStringList.Create;

            try
              GenerarParametrosDelphi(QryConsulta, ListCamposWhereDelete, Parametros, '  ');

              for I := 0 to Parametros.Count - 1 do
                Lineas.Add(Parametros[I]);
            finally
              Parametros.Free;
            end;

            Lineas.Add('  ExecSQL;');
            Lineas.Add('end;');
          end;

      1 : begin // Formato SQL Server
            Lineas.Add('DELETE FROM ' + Trim(TxtTabla.Text));

            var PrimeraVez := True;

            for I := 0 to ListCamposWhereDelete.Items.Count - 1 do
            begin
              if ListCamposWhereDelete.Items.Items[I].State = cbsChecked then
                begin
                  if PrimeraVez = True then
                    begin
                      Lineas.Add('WHERE ' + ListCamposWhereDelete.Items.Items[I].Text + ' = @' + ListCamposWhereDelete.Items.Items[I].Text);
                      PrimeraVez := False;
                    end
                  else
                    Lineas.Add('AND ' + ListCamposWhereDelete.Items.Items[I].Text + ' = @' + ListCamposWhereDelete.Items.Items[I].Text);
                end;
            end;

          end;
    end;

    // Guardar archivo
    TFile.WriteAllText(TextFile, Lineas.Text, TEncoding.UTF8);

    // Procesar salida
    ProcesarSalida('SQL_DELETE.txt', 'El Código SQL DELETE');
  finally
    Lineas.Free;
  end;
end;

procedure TFRBuilder.BtItemDownClick(Sender: TObject);
begin
  LbMoveItemDown(ListCamposInsertSel);
end;

procedure TFRBuilder.BtItemUpClick(Sender: TObject);
begin
  LbMoveItemUp(ListCamposInsertSel);
end;

procedure TFRBuilder.btnCopiarClick(Sender: TObject);
begin
  if Trim(memResultado.Text) <> '' then
    begin
      Clipboard.AsText := memResultado.Text;
      Mensaje('El texto ha sido copiado al portapapeles.',
              'Copiar texto', Informacion);
    end
  else
    Mensaje('No hay texto para copiar.',
            'Operación invalida', Advertencia);
end;

procedure TFRBuilder.btnGenerarClick(Sender: TObject);
var
  NombreTabla, NombreVariable : string;
begin
  NombreTabla    := Trim(edtNombreTabla.Text);
  NombreVariable := Trim(edtNombreVariable.Text);

  if NombreTabla = '' then
    begin
      Mensaje('Debe ingresar el nombre de la tabla.',
              'Operación invalida', Advertencia);
      edtNombreTabla.SetFocus;
      Exit;
    end;

  if NombreVariable = '' then
    begin
      Mensaje('Debe ingresar el nombre de la variable.',
              'Operación invalida', Advertencia);
      edtNombreTabla.SetFocus;
      edtNombreVariable.SetFocus;
      Exit;
    end;

  try
    memResultado.Lines.Text := GenerarDeclaracionTabla(NombreTabla, NombreVariable);

    if QryTableColumns.RecordCount = 0 then
      begin
        memResultado.Lines.Clear;
        Mensaje('No existe una tabla con ese nombre.',
                'Tabla inexistente', Advertencia);
        edtNombreTabla.SetFocus;
        Exit;
      end;

    Mensaje('Declaración de tabla generada correctamente.',
            'Operación completada', Informacion);
  except
    on E : Exception do
      Mensaje('Error al generar la declaración : ' +#13+ E.Message,
              'Operación invalida', Error);
  end;
end;

procedure TFRBuilder.BtEstructuraTablaClick(Sender: TObject);
var
  TextFile, RutaArchivo, Columna, TipoDato, Longitud : string;
  I : Integer;
  Lineas : TStringList;

const
  TiposEnteros   : array[1..3] of string = ('SmallInt', 'Byte', 'AutoInc');
  TiposDecimales : array[1..3] of string = ('BCD', 'Single', 'Float');
  TiposStrings   : array[1..4] of string = ('Memo', 'WideString', 'WideMemo', 'WideString');
  TiposFechas    : array[1..2] of string = ('TimeStamp', 'TimeStampOffset');
begin
  RutaArchivo := EdRutaArchivo.Text;

  TextFile := RutaArchivo + 'FieldList.txt';
  Lineas   := TStringList.Create;

  try
    Lineas.Add(DupeString('=', 60));
    Lineas.Add(Justifica('COLUMNA',30,' ',tjLeft) +' '+ Justifica('TIPO DE DATO',15,' ',tjLeft));
    Lineas.Add(DupeString('=', 60));

    if Mensaje('¿DESEA OBTENER LOS CAMPOS EN FORMA NATIVA DE LA BASE DE DATOS?',
               'Estructura de la Tabla',Pregunta, 2) = True then
      begin
        with QryTableColumns do
          begin
            Close;
            ParamByName('TABLE_NAME').AsString := Trim(TxtTabla.Text);
            Open;
            First;
            while not Eof do
              begin
                Columna  := FieldByName('COLUMN_NAME').AsString;
                TipoDato := FieldByName('DATA_TYPE_2').AsString;
                Lineas.Add(Justifica(Columna,30,' ',tjLeft) +' '+ Justifica(TipoDato,15,' ',tjLeft));
                Next;
              end;
          end;
      end
    else
      begin
//        if QryConsulta.RecordCount = 0 then
//          begin
//            Mensaje('Debe Realizar la Consulta Primero!!!',
//                    'Operación Invalida', Advertencia);
//            BtBuscar.SetFocus;
//            Abort;
//          end;

        QryConsulta.First;
        for I := 0 to QryConsulta.FieldCount - 1 do
          begin
            Columna  := QryConsulta.FieldDefs.Items[I].Name;
            TipoDato := FieldTypeNames[QryConsulta.Fields.Fields[I].DataType];

            if AnsiMatchStr(FieldTypeNames[QryConsulta.Fields.Fields[I].DataType], TiposFechas) then   //Si lo que seleccione esta en el array
              TipoDato := 'DateTime';

            if AnsiMatchStr(FieldTypeNames[QryConsulta.Fields.Fields[I].DataType], TiposEnteros) then
              TipoDato := 'Integer';

            if AnsiMatchStr(FieldTypeNames[QryConsulta.Fields.Fields[I].DataType], TiposDecimales) then
              TipoDato := 'Currency';

            if AnsiMatchStr(FieldTypeNames[QryConsulta.Fields.Fields[I].DataType], TiposStrings) then
              TipoDato := 'String';

            Longitud := IntToStr(QryConsulta.FieldDefs.Items[I].Size);

//            if (TipoDato = 'String') then
//              begin
//                Insert('(',Longitud,1);
//                Insert(')',Longitud,Length(Longitud)+1);
//                Lineas.Add(Justifica(Columna,30,' ',tjLeft) +' '+ Justifica(TipoDato + Longitud,15,' ',tjLeft));
//              end;
//
//            if (TipoDato = 'DateTime') {or (TipoDato = 'TimeStamp')} or (TipoDato = 'Integer')
//            or (TipoDato = 'Float') or (TipoDato = 'LargeInt')
//            or (TipoDato = 'Boolean') then
//              begin
//                Lineas.Add(Justifica(Columna,30,' ',tjLeft) +' '+ Justifica(TipoDato,15,' ',tjLeft));
//              end;

            Lineas.Add(Justifica(Columna,30,' ',tjLeft) +' '+ Justifica(TipoDato,15,' ',tjLeft));

            QryConsulta.Next;
          end;
      end;

    // Guardar archivo
    TFile.WriteAllText(TextFile, Lineas.Text, TEncoding.UTF8);

  finally
    Lineas.Free;
  end;

  //ABRIMOS EL ARCHIVO GENERADO
  ShellExecute(Handle,'open','c:\windows\notepad.exe',
    PWideChar(RutaArchivo + '\FieldList.txt'), nil, SW_SHOWNORMAL);
end;

procedure TFRBuilder.BtRemoveItemClick(Sender: TObject);
begin
  if ListCamposInsertSel.Items.Count > -1 then
    ListCamposInsertSel.Items.Delete(ListCamposInsertSel.ItemIndex);
end;

procedure TFRBuilder.BtRutaArchivoClick(Sender: TObject);
begin
  with TFileOpenDialog.Create(nil) do
    try
      Options := [fdoPickFolders, fdoPathMustExist, fdoForceFileSystem];

      DefaultFolder := ExtractFilePath(Application.ExeName);

      if Execute then
        EdRutaArchivo.Text := IncludeTrailingPathDelimiter(FileName);
    finally
      Free;
    end;

//  cxShellBrowserDialog1.Path := ExtractFilePath(Application.ExeName);
//  if cxShellBrowserDialog1.Execute then
//    EdRutaArchivo.Text :=  IncludeTrailingPathDelimiter(cxShellBrowserDialog1.Path);
end;

procedure TFRBuilder.BtRutaArchivoMouseEnter(Sender: TObject);
begin
  TcxButton(Sender).Font.Style := [fsBold];
end;

procedure TFRBuilder.BtRutaArchivoMouseLeave(Sender: TObject);
begin
  TcxButton(Sender).Font.Style := [];
end;

procedure TFRBuilder.BtFieldByNameClick(Sender: TObject);

  // Función para determinar la longitud máxima de la línea completa antes del :=
  function MaxLineLength(CheckList : TcxCheckListBox; Query : TFDQuery) : Integer;
  var
    I, J, MaxLength, CurrentLength : Integer;
    DataTypeStr : string;
  begin
    MaxLength := 0;

    for J := 0 to CheckList.Items.Count - 1 do
    begin
      if CheckList.Items.Items[J].State = cbsChecked then
        begin
          Query.First;
          for I := 0 to Query.Fields.Count - 1 do
          begin
            if CheckList.Items.Items[J].Text = Query.Fields[I].FieldName then
              begin
                // Determinar el tipo de datos
                if (Query.Fields[I].DataType = ftFloat) or
                   (Query.Fields[I].DataType = ftCurrency) or
                   (Query.Fields[I].DataType = ftBCD) then
                  DataTypeStr := '.AsFloat'
                else if (Query.Fields[I].DataType = ftString) or
                        (Query.Fields[I].DataType = ftMemo) then
                  DataTypeStr := '.AsString'
                else if (Query.Fields[I].DataType = ftDate) then
                  DataTypeStr := '.AsDate'
                else if (Query.Fields[I].DataType = ftDateTime) or
                        (Query.Fields[I].DataType = ftTimeStamp) then
                  DataTypeStr := '.AsDateTime'
                else if (Query.Fields[I].DataType = ftInteger) or
                        (Query.Fields[I].DataType = ftLargeint) or
                        (Query.Fields[I].DataType = ftSmallint) or
                        (Query.Fields[I].DataType = ftWord) or
                        (Query.Fields[I].DataType = ftLongWord) then
                  DataTypeStr := '.AsInteger'
                else if (Query.Fields[I].DataType = ftBoolean) then
                  DataTypeStr := '.AsBoolean'
                else
                  DataTypeStr := '.AsVariant';

                // Calcular longitud total: QryDataset.FieldByName('NombreCampo').AsXXXX
                CurrentLength := Length('QryDataset.FieldByName(' + QuotedStr(Query.Fields[I].FieldName) + ')' + DataTypeStr);

                if CurrentLength > MaxLength then
                  MaxLength := CurrentLength;

                Break;
              end;
            Query.Next;
          end;
        end;
    end;

    Result := MaxLength;
  end;


var
  I, J, MaxLength : Integer;
  TextFile, RutaArchivo, LineaCompleta : string;
  Lineas : TStringList;
begin
  cxPageControl1.ActivePageIndex := 0;

  if QryConsulta.RecordCount = 0 then
    begin
      Mensaje('Debe Realizar la Consulta Primero!!!',
              'Operación Invalida', Advertencia);
      BtBuscar.SetFocus;
      Abort;
    end;

  if TotalChecked(ListCamposSelect) = 0 then
    begin
      Mensaje('Debe Seleccionar los campos que tendrá el script.',
              'Operación Invalida', Advertencia);
      BtBuscar.SetFocus;
      Abort;
    end;

  RutaArchivo := EdRutaArchivo.Text;
  TextFile    := RutaArchivo + 'CAMPOS_FieldByName.txt';
  Lineas      := TStringList.Create;

  try
    // Calcular la longitud máxima para alineación
    MaxLength := MaxLineLength(ListCamposSelect, QryConsulta);

    Lineas.Add(DupeString('=', 60));
    Lineas.Add('CAMPOS DE LA TABLA ' + TxtTabla.Text);
    Lineas.Add(DupeString('=', 60));

    for J := 0 to ListCamposSelect.Items.Count - 1 do
    begin
      if ListCamposSelect.Items.Items[J].State = cbsChecked then
        begin
          QryConsulta.First;
          for I := 0 to QryConsulta.Fields.Count - 1 do
          begin
            if ListCamposSelect.Items.Items[J].Text = QryConsulta.Fields[I].FieldName then
              begin
                if (QryConsulta.Fields[I].DataType = ftFloat)
                or (QryConsulta.Fields[I].DataType = ftCurrency)
                or (QryConsulta.Fields[I].DataType = ftBCD) then
                  begin
                    LineaCompleta := 'QryDataset.FieldByName(' + QuotedStr(QryConsulta.Fields[I].FieldName) + ').AsFloat';
                    Lineas.Add(Justifica(LineaCompleta, MaxLength, ' ', tjLeft) + ' := ');
                  end;

                if (QryConsulta.Fields[I].DataType = ftString)
                or (QryConsulta.Fields[I].DataType = ftMemo) then
                  begin
                    LineaCompleta := 'QryDataset.FieldByName(' + QuotedStr(QryConsulta.Fields[I].FieldName) + ').AsString';
                    Lineas.Add(Justifica(LineaCompleta, MaxLength, ' ', tjLeft) + ' := ');
                  end;

                if (QryConsulta.Fields[I].DataType = ftDate) then
                  begin
                    LineaCompleta := 'QryDataset.FieldByName(' + QuotedStr(QryConsulta.Fields[I].FieldName) + ').AsDate';
                    Lineas.Add(Justifica(LineaCompleta, MaxLength, ' ', tjLeft) + ' := ');
                  end;

                if (QryConsulta.Fields[I].DataType = ftDateTime)
                or (QryConsulta.Fields[I].DataType = ftTimeStamp) then
                  begin
                    LineaCompleta := 'QryDataset.FieldByName(' + QuotedStr(QryConsulta.Fields[I].FieldName) + ').AsDateTime';
                    Lineas.Add(Justifica(LineaCompleta, MaxLength, ' ', tjLeft) + ' := ');
                  end;

                if (QryConsulta.Fields[I].DataType = ftInteger)
                or (QryConsulta.Fields[I].DataType = ftLargeint)
                or (QryConsulta.Fields[I].DataType = ftSmallint)
                or (QryConsulta.Fields[I].DataType = ftWord)
                or (QryConsulta.Fields[I].DataType = ftLongWord) then
                  begin
                    LineaCompleta := 'QryDataset.FieldByName(' + QuotedStr(QryConsulta.Fields[I].FieldName) + ').AsInteger';
                    Lineas.Add(Justifica(LineaCompleta, MaxLength, ' ', tjLeft) + ' := ');
                  end;

                if (QryConsulta.Fields[I].DataType = ftBoolean) then
                  begin
                    LineaCompleta := 'QryDataset.FieldByName(' + QuotedStr(QryConsulta.Fields[I].FieldName) + ').AsBoolean';
                    Lineas.Add(Justifica(LineaCompleta, MaxLength, ' ', tjLeft) + ' := ');
                  end;

                Break; // Salir del loop interno una vez encontrado el campo
              end;
          end;
        end;
    end;

    // Guardar archivo
    TFile.WriteAllText(TextFile, Lineas.Text, TEncoding.UTF8);

  finally
    Lineas.Free;
  end;

  Mensaje('Los Campos FieldByName para Delphi se Realizaron con Exito!!!',
          'Operación Completada', Informacion);

  //ABRIMOS EL ARCHIVO GENERADO
  ShellExecute(Handle,'open','c:\windows\notepad.exe',
    PWideChar(RutaArchivo + '\CAMPOS_FieldByName.txt'), nil, SW_SHOWNORMAL);
end;

procedure TFRBuilder.FormClose(Sender: TObject; var Action: TCloseAction);
 var
  Archivo : string;
begin
  Archivo := ExtractFilePath(Application.ExeName) + ChangeFileExt('Conexion','.ini');

  if FileExists(Archivo) then
    begin
      with TIniFile.Create(Archivo) do
        try
          WriteString('Opciones', 'Tabla', Trim(TxtTabla.Text));
          WriteString('Opciones', 'RutaGuardarArhivos', Trim(EdRutaArchivo.Text));
        finally
          Free;
        end;
    end;

  FForeignKey.Free; // Liberamos la clase

  // Liberamos los objetos
  FFunctionBuilder.Free;
  FScalarParamsDataSet.Free;
  FTableParamsDataSet.Free;
  FTableColumnsDataSet.Free;

end;

procedure TFRBuilder.FormCreate(Sender: TObject);
var
  Archivo : string;
  DebeCerrar : Boolean;  //Con esta bandera me aseguro de cerrar la app si se dispara la Exception
begin
  DebeCerrar := False;
  Archivo := ExtractFilePath(Application.ExeName) + ChangeFileExt('Conexion','.ini');

  if FileExists(Archivo) then
    begin
      with TIniFile.Create(Archivo) do
        try
          // PRIMERO HACEMOS UN MAPEO DE UNOS CAMPOS QUE NO QUEREMOS CONTEMPLAR
          with DataBase.FormatOptions do
          begin
            OwnMapRules := True;
            with MapRules.Add do
            begin
              ScaleMin := 0;
              ScaleMax := 2;
              PrecMin  := 0;
              PrecMax  := 18;
              SourceDataType := dtBcd;
              TargetDataType := dtCurrency;
            end;
            with MapRules.Add do
            begin
              ScaleMin := 0;
              ScaleMax := 2;
              PrecMin  := 0;
              PrecMax  := 18;
              SourceDataType := dtFmtBCD;
              TargetDataType := dtCurrency;
            end;
            with MapRules.Add do
            begin
              ScaleMin := 0;
              ScaleMax := 0;
              PrecMin  := 0;
              PrecMax  := 0;
              SourceDataType := dtDateTimeStamp;
              TargetDataType := dtDateTime;
            end;

            with MapRules.Add do
            begin
              ScaleMin := 0;
              ScaleMax := 0;
              PrecMin  := 0;
              PrecMax  := 0;
              SourceDataType := dtDateTimeStampOff;
              TargetDataType := dtDateTime;
            end;

            with MapRules.Add do
            begin
              ScaleMin := 0;
              ScaleMax := 0;
              PrecMin  := 0;
              PrecMax  := 0;
              SourceDataType := dtMemo;
              TargetDataType := dtAnsiString;
            end;
          end;

          DataBase.Params.Values['Server']    := ReadString('Conexion', 'Servidor', '');
          DataBase.Params.Values['Database']  := ReadString('Conexion', 'Database', '');
          DataBase.Params.Values['User_Name'] := ReadString('Conexion', 'Usuario',  '');
          DataBase.Params.Values['Password']  := ReadString('Conexion', 'Password', '');

          try
            DataBase.Connected := True;
          except
            on E : Exception do
            begin
              Mensaje('No Existe el Servidor ó Hay Problemas de Conexión'
                      +#13+ E.Message +#13+#13+ 'Verifique los parametros en el archivo de conexión',
                      'Error de Conexión',Error);
              DebeCerrar := True;
            end;
          end;

          TxtTabla.Text      := ReadString('Opciones', 'Tabla','');
          EdRutaArchivo.Text := ReadString('Opciones', 'RutaGuardarArhivos','');

        finally
          Free;
        end;
    end
  else
    begin
      if Mensaje('No se ha Encontrado el Fichero de Configuración.' +'  '+
                 '¿Desea Crear el Archivo de Configuración?',
                 'El Archivo de Configuración NO EXISTE',Pregunta) then
        begin
          with TIniFile.Create(Archivo) do
            try
              WriteString('Conexion', 'Servidor', DataBase.Params.Values['Server']);
              WriteString('Conexion', 'Database', DataBase.Params.Values['Database']);
              WriteString('Conexion', 'Usuario', DataBase.Params.Values['User_Name']);
              WriteString('Conexion', 'Password', DataBase.Params.Values['Password']);
              WriteString('Opciones', 'Tabla', Trim(TxtTabla.Text));
              WriteString('Opciones', 'RutaGuardarArhivos', Trim(EdRutaArchivo.Text));
            finally
              Free;
            end;

          Mensaje('Escriba los parametros de conexión en el archivo e inicie la aplicación nuevamente.',
                  'Creación del archivo de Conexión',Informacion);
          DebeCerrar := True;
        end
      else
        DebeCerrar := True;
    end;

  if DebeCerrar then
    begin
      Application.Terminate; //marca la aplicación para que se cierre después de que se complete el evento actual.
      Close; // Cierra el formulario principal
    end;


  //INICIALIZAMOS LOS COMPONENTES QUE TRATAN LA CREACION DE LOS INDICES

  // Configurar los ListView
  with LvCamposDisponibles do
  begin
    ViewStyle           := vsReport;
    RowSelect           := True;
    MultiSelect         := False;
    Columns.Add.Caption := 'Campo';
    Columns.Add.Caption := 'Tipo';
    Columns.Add.Width   := 120;
  end;

  with LvCamposIndice do
  begin
    ViewStyle           := vsReport;
    RowSelect           := True;
    MultiSelect         := False;
    Columns.Add.Caption := 'Campo';
  end;

  with LvCamposIncluidos do
  begin
    ViewStyle           := vsReport;
    RowSelect           := True;
    MultiSelect         := False;
    Columns.Add.Caption := 'Campo';
  end;

  //Auto ajustamos las columnas de los cxListViews
  LvCamposIndice.Columns.Items[0].AutoSize      := True;
  LvCamposIncluidos.Columns.Items[0].AutoSize   := True;
  LvCamposDisponibles.Columns.Items[0].AutoSize := True;
  LvCamposDisponibles.Columns.Items[1].AutoSize := True;

  // Deshabilitar el campo de factor de relleno inicialmente
  SeFactorRelleno.Enabled := False;

  //INICIALIZAMOS LOS COMPONENTES QUE TRATAN LA CREACION DE LOS FOREIGN KEY

  FForeignKey := TForeignKey.Create; // Instanciamos la clase


   //INICIALIZAMOS LOS COMPONENTES QUE TRATAN LA CREACION DE LAS FUNCIONES

  FFunctionBuilder := TSQLFunctionBuilder.Create;
  CreateDataSets;
  InitializeControls;
  SetupGrids;
  LoadSchemasFromDB;

end;

procedure TFRBuilder.FormShow(Sender: TObject);
begin
  //ASIGNAMOS EL CONTROLLER A LA LIBRERIA DEL MANEJO DE TEMAS
  ModoOscuroClaro.SkinController := dxSkinController1;

  cxPageControl1.ActivePageIndex:= 0;
  cxPageControl1Change(nil);
  cxPageControl2.ActivePageIndex:= 0;

  StbBarraEstado.Panels.Items[0].Text := 'Servidor : ' + DataBase.Params.Values['Server'];
  StbBarraEstado.Panels.Items[1].Text := 'Base de Datos : ' + DataBase.Params.Values['Database'];
end;

procedure TFRBuilder.Image1Click(Sender: TObject);
begin
  if DataBase.Connected then
    begin
      FRSelectQueryBuilder := TFRSelectQueryBuilder.Create(Self);
      AplicarTema(FRSelectQueryBuilder); //Aplicamos el tema despues de crear el form
      FRSelectQueryBuilder.ShowModal;
      FRSelectQueryBuilder.Free;
    end
  else
    Mensaje('Por favor, conectese a la base de datos primero.',
            'Base de datos sin conexion', Advertencia);

end;

procedure TFRBuilder.LimpiarListados;
begin
  ListCamposInsert.Items.Clear;
  ListCamposInsertSel.Items.Clear;
  ListCamposSelect.Items.Clear;
  ListCamposWhereSelect.Items.Clear;
  ListCamposOrderBy.Items.Clear;
  ListCamposUpdate.Items.Clear;
  ListCamposWhereUpdate.Items.Clear;
  ListCamposWhereDelete.Items.Clear;

  CheckListBoxFields.Items.Clear;
  CheckListBoxWhere.Items.Clear;
  CheckListBoxOrderBy.Items.Clear;
end;

procedure TFRBuilder.ListCamposInsertClickCheck(Sender: TObject;
  AIndex: Integer; APrevState, ANewState: TcxCheckBoxState);
var
  CantSel : Integer;
begin
  CantSel        := TotalChecked(ListCamposInsert);
  Panel7.Caption := 'LISTA DE CAMPOS ' + '[ '+  IntToStr(CantSel) + ' ]';
end;

procedure TFRBuilder.ListCamposSelectClickCheck(Sender: TObject;
  AIndex: Integer; APrevState, ANewState: TcxCheckBoxState);
var
  CantSel : Integer;
begin
  CantSel        := TotalChecked(ListCamposSelect);
  Panel4.Caption := 'LISTA DE CAMPOS ' + '[ '+  IntToStr(CantSel) + ' ]';
end;

procedure TFRBuilder.ListCamposSelectDrawItem(Control: TWinControl;
  Index: Integer; Rect: TRect; State: TOwnerDrawState);
var
  ACanvas      : TcxCanvas;
  AText        : string;
  ATextRect    : TRect;
  AListBox     : TcxCheckListBox;
  ACanvasFont  : TFont;
  AItemState   : TcxCheckBoxState;
begin      //AQUI MANEJAMOS EL ESTILO NEGRITA SI MARCAMOS ALGUN ITEM
  AListBox     := (Control as TcxCheckListBox);
  ACanvas      := AListBox.InnerCheckListBox.Canvas;
  ACanvasFont  := ACanvas.Font;
  AItemState   := AListBox.Items[Index].State;

  case AItemState of
    cbsUnchecked :
      begin
        if dxToggleSwitch1.Checked then    //Si estamos en el modo oscuro
          ACanvasFont.Color := clGray
        else
          ACanvasFont.Color := clBlack;
      end;
    cbsChecked :
      begin
        if dxToggleSwitch1.Checked then
          ACanvasFont.Color := clWhite
        else
          ACanvasFont.Color := clBlack;

        ACanvasFont.Style := [fsBold];
      end;
    cbsGrayed :
      begin
        ACanvasFont.Color := clGray;
      end;
  end;

  //MANEJAMOS EL COLOR DE FONDO SEGUN CORRESPONDA

  if dxToggleSwitch1.Checked then    //Si estamos en el modo oscuro
    ACanvas.Brush.Color := $00262525
  else
    ACanvas.Brush.Color := clWhite;

  ACanvas.FillRect(Rect);
  AText     := AListBox.Items[Index].Text;
  ATextRect := Rect;
  ACanvas.DrawTexT(AText, ATextRect, 0);
end;

procedure TFRBuilder.ListCamposUpdateClickCheck(Sender: TObject;
  AIndex: Integer; APrevState, ANewState: TcxCheckBoxState);
var
  CantSel : Integer;
begin
  CantSel          := TotalChecked(ListCamposUpdate);
  Panel8.Caption := 'LISTA DE CAMPOS ' + '[ '+  IntToStr(CantSel) + ' ]';
end;

function TFRBuilder.TotalChecked(CheckList : TcxCheckListBox) : Integer;
var
  I, Cant : Integer;
begin
  Cant := 0;
  for I := 0 to CheckList.Items.Count - 1 do
    if CheckList.Items.Items[I].State = cbsChecked then
      Inc(Cant);
  Result := Cant;
end;

// Funcion para encontrar el último índice seleccionado en un cxCheckListBox
function TFRBuilder.UltimoIndiceSeleccionado(CheckList : TcxCheckListBox) : Integer;
var
  I : Integer;
begin
  Result := -1;
  for I := CheckList.Items.Count - 1 downto 0 do
  begin
    if CheckList.Items.Items[I].State = cbsChecked then
      begin
        Result := I;
        Break;
      end;
  end;
end;

procedure TFRBuilder.CkbListInsertClick(Sender: TObject);
begin
  if CkbListInsert.Checked then
    SeleccionarTodo(ListCamposInsert, True)
  else
    SeleccionarTodo(ListCamposInsert, False);

  ListCamposInsert.Refresh;
end;

procedure TFRBuilder.CkbListOrderByClick(Sender: TObject);
begin
  if CkbListOrderBy.Checked then
    SeleccionarTodo(ListCamposOrderBy, True)
  else
    SeleccionarTodo(ListCamposOrderBy, False);

  ListCamposOrderBy.Refresh;
end;

procedure TFRBuilder.CkbListTodoSelectClick(Sender: TObject);
var
  CantSel : Integer;
begin
  if CkbListTodoSelect.Checked then
    SeleccionarTodo(ListCamposSelect, True)
  else
    SeleccionarTodo(ListCamposSelect, False);

  CantSel        := TotalChecked(ListCamposSelect);
  Panel4.Caption := 'LISTA DE CAMPOS ' + '[ '+  IntToStr(CantSel) + ' ]';

  ListCamposSelect.Refresh;
end;

procedure TFRBuilder.CkbListUpdateClick(Sender: TObject);
begin
  if CkbListUpdate.Checked then
    SeleccionarTodo(ListCamposUpdate, True)
  else
    SeleccionarTodo(ListCamposUpdate, False);

  ListCamposUpdate.Refresh;
end;

procedure TFRBuilder.CkbListWhereDeleteClick(Sender: TObject);
begin
  if CkbListWhereDelete.Checked then
    SeleccionarTodo(ListCamposWhereDelete, True)
  else
    SeleccionarTodo(ListCamposWhereDelete, False);

  ListCamposWhereDelete.Refresh;
end;

procedure TFRBuilder.CkbListWhereSelectClick(Sender: TObject);
begin
  if CkbListWhereSelect.Checked then
    SeleccionarTodo(ListCamposWhereSelect, True)
  else
    SeleccionarTodo(ListCamposWhereSelect, False);

  ListCamposWhereSelect.Refresh;
end;

procedure TFRBuilder.CkbListWhereUpdateClick(Sender: TObject);
begin
  if CkbListWhereUpdate.Checked then
    SeleccionarTodo(ListCamposWhereUpdate, True)
  else
    SeleccionarTodo(ListCamposWhereUpdate, False);

  ListCamposWhereUpdate.Refresh;
end;

procedure TFRBuilder.BtAddItemClick(Sender: TObject);
var
  I : Integer;
begin
  for I := 0 to ListCamposInsert.Items.Count - 1 do
    begin
      if ListCamposInsert.Items.Items[I].State = cbsChecked then
        begin
          if ListCamposInsertSel.Items.IndexOf(ListCamposInsert.Items.Items[I].Text) = -1 then
            ListCamposInsertSel.Items.Add(ListCamposInsert.Items.Items[I].Text);
        end;
    end;

end;

procedure TFRBuilder.cxButton1Click(Sender: TObject);
begin
  ClbMoveItemUp(ListCamposSelect);
end;

procedure TFRBuilder.cxButton2Click(Sender: TObject);
begin
  ClbMoveItemDown(ListCamposSelect);
end;

procedure TFRBuilder.cxButton3Click(Sender: TObject);
begin
  ClbMoveItemUp(ListCamposWhereSelect);
end;

procedure TFRBuilder.cxButton4Click(Sender: TObject);
begin
  ClbMoveItemDown(ListCamposWhereSelect);
end;

procedure TFRBuilder.cxButton5Click(Sender: TObject);
begin
  ClbMoveItemUp(ListCamposOrderBy);
end;

procedure TFRBuilder.cxButton6Click(Sender: TObject);
begin
  ClbMoveItemDown(ListCamposOrderBy);
end;

procedure TFRBuilder.cxButton7Click(Sender: TObject);
begin
  ClbMoveItemUp(ListCamposUpdate);
end;

procedure TFRBuilder.cxButton8Click(Sender: TObject);
begin
  ClbMoveItemDown(ListCamposUpdate);
end;

procedure TFRBuilder.cxButton9Click(Sender: TObject);
begin
  ClbMoveItemUp(ListCamposWhereUpdate);
end;

procedure TFRBuilder.cxButton10Click(Sender: TObject);
begin
  ClbMoveItemDown(ListCamposWhereUpdate);
end;

procedure TFRBuilder.cxButton11Click(Sender: TObject);
begin
  ClbMoveItemUp(ListCamposWhereDelete);
end;

procedure TFRBuilder.cxButton12Click(Sender: TObject);
begin
  ClbMoveItemDown(ListCamposWhereDelete);
end;

procedure TFRBuilder.cxPageControl1Change(Sender: TObject);
begin
  //Manejamos el tamaño del formulario de acuerdo a la resolución de pantalla

  if GetScreenResolution = st4K then
    begin
      case cxPageControl1.ActivePageIndex of
        0 : begin
              Self.Constraints.MinHeight := 1190;
              Self.Constraints.MaxHeight := 1190;
              Self.Height                := 1190;

              Self.Constraints.MinWidth := 1230;
              Self.Constraints.MaxWidth := 1230;
              Self.Width                := 1230;

              cxPageControl1.Width := 1211;
              TxtTabla.SetFocus;
            end;

        1 : begin
              Self.Constraints.MinHeight := 1190;
              Self.Constraints.MaxHeight := 1190;
              Self.Height                := 1190;

              Self.Constraints.MinWidth := 1230;
              Self.Constraints.MaxWidth := 1230;
              Self.Width                := 1230;

              cxPageControl1.Width := 1211;
              EdNombreTabla.SetFocus;

              RgTipoOperacionClick(Self);
            end;

          2 : begin
                Self.Constraints.MinHeight := 1190;
                Self.Constraints.MaxHeight := 1190;
                Self.Height                := 1190;

                Self.Constraints.MinWidth := 1230;
                Self.Constraints.MaxWidth := 1230;
                Self.Width                := 1230;

                cxPageControl1.Width := 1211;
                edtNombreTabla.SetFocus;
              end;

          3 : begin
                Self.Constraints.MinHeight := 1190;
                Self.Constraints.MaxHeight := 1190;
                Self.Height                := 1190;

                Self.Constraints.MinWidth := 1420;
                Self.Constraints.MaxWidth := 1420;
                Self.Width                := 1420;

                cxPageControl1.Width := 1395;
                EdNombreIndice.SetFocus;
              end;

          4, 5 : begin
                   Self.Constraints.MinHeight := 1190;
                   Self.Constraints.MaxHeight := 1190;
                   Self.Height                := 1190;

                   Self.Constraints.MinWidth := 1420;
                   Self.Constraints.MaxWidth := 1420;
                   Self.Width                := 1420;

                   cxPageControl1.Width := 1395;

                   if cxPageControl1.ActivePageIndex = 4 then
                     EdNombreFK.SetFocus
                   else
                     if cxPageControl1.ActivePageIndex = 5 then
                       edtScalarFunctionName.SetFocus;
              end;
      end;
    end
  else
    if GetScreenResolution = stQHD then
      begin
        case cxPageControl1.ActivePageIndex of
          0 : begin
                Self.Constraints.MinHeight := 1390;
                Self.Constraints.MaxHeight := 1390;
                Self.Height                := 1390;

                Self.Constraints.MinWidth := 1435;
                Self.Constraints.MaxWidth := 1435;
                Self.Width                := 1435;

                cxPageControl1.Width := 1410;
                TxtTabla.SetFocus;
              end;

          1 : begin
                Self.Constraints.MinHeight := 1390;
                Self.Constraints.MaxHeight := 1390;
                Self.Height                := 1390;

                Self.Constraints.MinWidth := 1435;
                Self.Constraints.MaxWidth := 1435;
                Self.Width                := 1435;

                cxPageControl1.Width := 1410;
                EdNombreTabla.SetFocus;
              end;

          2 : begin
                Self.Constraints.MinHeight := 1390;
                Self.Constraints.MaxHeight := 1390;
                Self.Height                := 1390;

                Self.Constraints.MinWidth := 1435;
                Self.Constraints.MaxWidth := 1435;
                Self.Width                := 1435;

                cxPageControl1.Width := 1410;
                edtNombreTabla.SetFocus;
              end;

          3 : begin
                Self.Constraints.MinHeight := 1390;
                Self.Constraints.MaxHeight := 1390;
                Self.Height                := 1390;

                Self.Constraints.MinWidth := 1650;
                Self.Constraints.MaxWidth := 1650;
                Self.Width                := 1650;

                cxPageControl1.Width := 1625;
                EdNombreIndice.SetFocus;
              end;

          4, 5 : begin
                  Self.Constraints.MinHeight := 1390;
                  Self.Constraints.MaxHeight := 1390;
                  Self.Height                := 1390;

                  Self.Constraints.MinWidth := 1650;
                  Self.Constraints.MaxWidth := 1650;
                  Self.Width                := 1650;

                  cxPageControl1.Width := 1625;
                  EdNombreFK.SetFocus;

                  if cxPageControl1.ActivePageIndex = 4 then
                    EdNombreFK.SetFocus
                  else
                    if cxPageControl1.ActivePageIndex = 5 then
                      edtScalarFunctionName.SetFocus;
              end;
        end;
      end;

end;

procedure TFRBuilder.EdBusquedaCampoKeyPress(Sender: TObject; var Key: Char);
var                 //MANEJO DE LA BUSQUEDA DE LOS CAMPOS EN EL CHECKLISTBOX
  I, J : Integer;
  Nombre : string;
begin
  if Key = #13 then
    begin
      if Trim(EdBusquedaCampo.Text) <> '' then
        begin
          for I := 0 to (ListCamposSelect.Items.Count - 1) do
            begin
              //OBTENEMOS EL NOMBRE DEL CAMPO
              Nombre := ListCamposSelect.Items.Items[I].Text;

{              case RgTipoBusqueda.ItemIndex of
                0 : begin            //BUSQUEDA EXACTA...
                      if (AnsiStrLIComp(PChar(Nombre), PChar(EdBusquedaCampo.Text), Length(EdBusquedaCampo.Text)) = 0) and (I > UltIndice) then
                        begin
                          J                          := I;
                          UltIndice                  := J;
                          ListCamposSelect.ItemIndex := J;
                          Break;
                        end
                      else
                        ListCamposSelect.ItemIndex := UltIndice;
                    end;

                1 : begin  }          //BUSQUEDA APROXIMADA...
                      if (Pos(AnsiUpperCase(Trim(EdBusquedaCampo.Text)), AnsiUpperCase(ListCamposSelect.Items.Items[I].Text)) > 0) and (I > UltIndice) then
                        begin
                          J                          := I;
                          UltIndice                  := J;
                          ListCamposSelect.ItemIndex := J;
                          Break;
                        end
                      else
                        ListCamposSelect.ItemIndex := UltIndice;
//                    end;
//              end;
            end;
        end;
      EdBusquedaCampo.SetFocus;
    end;

end;

procedure TFRBuilder.EdBusquedaCampoPropertiesChange(Sender: TObject);
begin
  UltIndice := -1;
end;

procedure TFRBuilder.SeleccionarTodo(CheckList : TcxCheckListBox; Value : Boolean);
var
  I : Integer;
begin
  for I := 0 to CheckList.Items.Count - 1 do
    if Value = True then
      CheckList.Items.Items[I].State:= cbsChecked
    else
      CheckList.Items.Items[I].State:= cbsUnchecked;
end;

//Función para saber cual es la linea mas larga que tiene el StringList
function TFRBuilder.MasLargo(Lista : TStringList) : Integer;
var
  I, Valor, Max : Integer;
begin
  Max := 0;
  for I := 0 to Lista.Count - 1 do
    begin
      Valor := Length(Lista.Strings[I]);
      if Valor > Max then
          Max := Valor;
    end;
  Result := Max;
end;

//Función para determinar la longitud máxima del nombre de campo que tiene el cxCheckListBox
function TFRBuilder.MasLargo(CheckList : TcxCheckListBox) : Integer;
var
  I, MaxLength : Integer;
begin
  MaxLength := 0;
  for I := 0 to CheckList.Items.Count - 1 do
  begin
    if CheckList.Items[I].State = cbsChecked then
      begin
        if Length(CheckList.Items[I].Text) > MaxLength then
          MaxLength := Length(CheckList.Items[I].Text);
      end;
  end;

  Result := MaxLength;
end;

procedure TFRBuilder.dxToggleSwitch1Click(Sender: TObject);
begin
  if dxToggleSwitch1.Checked then
    begin
      if TemaActual = TAppTema.Claro then
        TemaActual := TAppTema.Oscuro;
    end
  else
    begin
      TemaActual := TAppTema.Claro;
    end;

  // Aplicar tema al formulario principal
  AplicarTema(Self);

  // Notificar a los demás formularios abiertos
//  for var I := 0 to Screen.FormCount - 1 do
//    if Screen.Forms[I] <> Self then
//      AplicarTema(Screen.Forms[I]);


end;

//function TFRBuilder.BuscarElementoLista(Elemento : string; Lista : TcxCheckListBox) : Integer;
//var
//  I : Integer;
//begin
//  Result := -1;
//
//  for I := 0 to Lista.Items.Count - 1 do
//    begin
//      if AnsiUpperCase(Lista.Items.Items[I].Text) = AnsiUpperCase(Elemento) then
//        begin
//          Result := I;
//          Exit;
//        end;
//    end;
//end;

procedure TFRBuilder.LbMoveItemUp(AListBox : TcxListBox);
var
  CurrIndex : Integer;
begin
  with AListBox do
    if ItemIndex > 0 then
      begin
        CurrIndex := ItemIndex;
        Items.Move(ItemIndex, (CurrIndex - 1));
        ItemIndex := CurrIndex - 1;
      end;
end;

procedure TFRBuilder.LbMoveItemDown(AListBox : TcxListBox);
var
  CurrIndex, LastIndex : Integer;
begin
  with AListBox do
    begin
      CurrIndex := ItemIndex;
      LastIndex := Items.Count;
      if ItemIndex <> -1 then
        begin
          if CurrIndex + 1 < LastIndex then
            begin
              Items.Move(ItemIndex, (CurrIndex + 1));
              ItemIndex := CurrIndex + 1;
            end;
        end;
    end;
end;

function TFRBuilder.FindSelectedItem(ACheckListBox : TcxCheckListBox) : Integer;
var
  I : Integer;
begin
  Result := -1;
  for I := 0 to ACheckListBox.Count - 1 do
    if ACheckListBox.Selected[I] then
    begin
      Result := I;
      Break;
    end;
end;

procedure TFRBuilder.ClbMoveItemUp(ACheckListBox : TcxCheckListBox);
var
  ItemIndex : Integer;
begin
  ItemIndex := FindSelectedItem(ACheckListBox);
  if (ItemIndex <> -1) then
    begin
      try
        ACheckListBox.Items[ItemIndex].Index  := ACheckListBox.Items[ItemIndex].Index - 1;
        ACheckListBox.Selected[ItemIndex - 1] := True;

      except
        on E : EArgumentOutOfRangeException do
        begin

        end;
      end;
    end;
end;

procedure TFRBuilder.ClbMoveItemDown(ACheckListBox : TcxCheckListBox);
var
  ItemIndex : Integer;
begin
  ItemIndex := FindSelectedItem(ACheckListBox);
  if (ItemIndex <> -1) then
    begin
      try
        ACheckListBox.Items[ItemIndex].Index  := ACheckListBox.Items[ItemIndex].Index + 1;
        ACheckListBox.Selected[ItemIndex + 1] := True;

      except
        on E : EArgumentOutOfRangeException do
        begin

        end;
      end;
    end;
end;

procedure TFRBuilder.BtBuscarTablaClick(Sender: TObject);
var
  I : Integer;
begin
  if EdNombreTabla.Text = EmptyStr then
    begin
      Mensaje('Debe Digitar la Tabla para Realizar las Operaciones!!!',
              'Operación Invalida', Advertencia);
      EdNombreTabla.SetFocus;
      Exit;
    end;

  with QryUtils, SQL do
    begin
      Close;
      Clear;
      Add('SELECT * FROM INFORMATION_SCHEMA.TABLES');
      Add('WHERE TABLE_SCHEMA = ' + QuotedStr('dbo'));
      Add('AND TABLE_NAME = ' + QuotedStr(Trim(EdNombreTabla.Text)));
      Open;

      if RecordCount = 0 then
        begin
          Mensaje('La Tabla Digitada No Existe en la Base de Datos' +#13+
                  'ó No Tienes Permiso de Lectura.'+#13+
                  'Por Favor Verifique!!!','Tabla No Existe', Advertencia);
          EdNombreTabla.SetFocus;
          Exit;
        end;
    end;

  LimpiarListados;

  QryConsulta.Close;
  QryConsulta.SQL.Text := 'SELECT TOP 1 * FROM ' + EdNombreTabla.Text;
  QryConsulta.Open;

  //AL CARGAR LOS DATOS EN LOS TcxCheckListBox MINIMIZAMOS EL PARPADEO
  for I := 0 to Self.ComponentCount - 1 do
    begin
      if Self.Components[I] is TcxCheckListBox then
        begin
          (Self.Components[I] as TcxCheckListBox).DoubleBuffered := True;

          (Self.Components[I] as TcxCheckListBox).Items.BeginUpdate;
        end;
    end;

  QryConsulta.First;
  for I := 0 to QryConsulta.Fields.Count - 1 do
    begin
      with CheckListBoxFields.Items.Add do
        begin
          Text  := QryConsulta.Fields[I].FieldName;
          State := cbsUnchecked;
        end;

      with CheckListBoxWhere.Items.Add do
        begin
          Text  := QryConsulta.Fields[I].FieldName;
          State := cbsUnchecked;
        end;

      with CheckListBoxOrderBy.Items.Add do
        begin
          Text  := QryConsulta.Fields[I].FieldName;
          State := cbsUnchecked;
        end;

        QryConsulta.Next;
    end;

  for I := 0 to Self.ComponentCount - 1 do
    begin
      if Self.Components[I] is TcxCheckListBox then
        begin
//          (Self.Components[I] as TcxCheckListBox).Sorted := True;
          (Self.Components[I] as TcxCheckListBox).Items.EndUpdate;
        end;
    end;

end;

procedure TFRBuilder.BtScriptStoreProcedureClick(Sender: TObject);
begin
  if EdNombreTabla.Text = EmptyStr then
    begin
      Mensaje('Debe Digitar la Tabla para Realizar las Operaciones!!!',
              'Operación Invalida', Advertencia);
      EdNombreTabla.SetFocus;
      Exit;
    end;

  with QryTableColumns, SQL do
    begin
      Close;
      ParamByName('TABLE_NAME').AsString := Trim(EdNombreTabla.Text);
      Open;

      if RecordCount = 0 then
        begin
          Mensaje('La Tabla Digitada No Existe en la Base de Datos' +#13+
                  'ó No Tienes Permiso de Lectura.'+#13+
                  'Por Favor Verifique!!!','Tabla No Existe', Advertencia);
          EdNombreTabla.SetFocus;
          Exit;
        end;
    end;

  case RgTipoOperacion.ItemIndex of
    0 : GenerarStoreProcedure(OtSelect);
    1 : GenerarStoreProcedure(OtInsert);
    2 : GenerarStoreProcedure(OtUpdate);
    3 : GenerarStoreProcedure(OtDelete);
  end;

end;

procedure TFRBuilder.GenerarStoreProcedure(TipoStoreProcedure : OperationType);
var
  Script : TStringList;
  Tabla, CamposClave, SpName : string;
  I : Integer;
begin
  Script := TStringList.Create;
  try
    Tabla  := EdNombreTabla.Text;
    SpName := '';

    // Nombres de los SPs basados en el tipo
    case TipoStoreProcedure of
      OtSelect : SpName := 'sp_' + Tabla + '_Select';
      OtInsert : SpName := 'sp_' + Tabla + '_Insert';
      OtUpdate : SpName := 'sp_' + Tabla + '_Update';
      OtDelete : SpName := 'sp_' + Tabla + '_Delete';
    end;

    // Identificar campos clave (se usarán en WHERE)
    CamposClave := '';
    for I := 0 to CheckListBoxWhere.Items.Count - 1 do
    begin
      if CheckListBoxWhere.Items.Items[I].State = cbsChecked then
        begin
          if CamposClave <> '' then
            CamposClave := CamposClave + ', ';
          CamposClave := CamposClave + CheckListBoxWhere.Items.Items[I].Text;
        end;
    end;

    // Generar script según el tipo
    case TipoStoreProcedure of
      OtSelect : GenerarSPSelect(Script, Tabla, SpName);
      OtInsert : GenerarSPInsert(Script, Tabla, SpName);
      OtUpdate : GenerarSPUpdate(Script, Tabla, SpName, CamposClave);
      OtDelete : GenerarSPDelete(Script, Tabla, SpName, CamposClave);
    end;

    // Salida según el formato seleccionado


    case RgFormatoSalida1.ItemIndex of
      0 : Clipboard.AsText := Script.Text;
      1 : begin
            Script.SaveToFile(EdRutaArchivo.Text + '\' + SpName + '.txt', TEncoding.UTF8);
            ShellExecute(Handle, 'open', 'c:\windows\notepad.exe',
            PWideChar(EdRutaArchivo.Text + '\' + SpName + '.txt'), nil, SW_SHOWNORMAL);
          end;
    end;

    Mensaje('Store Procedure generado correctamente','Creación Store Procedure',
            Informacion);
  finally
    Script.Free;
  end;
end;

procedure TFRBuilder.GenerarSPSelect(Script : TStringList; Tabla, SpName : string);
var
  CamposSelect, CamposParametros, CamposWhere, CamposOrderBy : string;
  I : Integer;
  TipoDato : string;
begin
  // Preparar campos para SELECT
  CamposSelect := '';
  for I := 0 to CheckListBoxFields.Items.Count - 1 do
  begin
    if CheckListBoxFields.Items.Items[I].State = cbsChecked then
      begin
        if CamposSelect <> '' then
          CamposSelect := CamposSelect + ',' + sLineBreak + '    ';
        CamposSelect := CamposSelect + CheckListBoxFields.Items.Items[I].Text;
      end;
  end;

  // Preparar parámetros y condiciones WHERE
  CamposParametros := '';
  CamposWhere      := '';
  for I := 0 to CheckListBoxWhere.Items.Count - 1 do
  begin
    if CheckListBoxWhere.Items.Items[I].State = cbsChecked then
      begin
        // Obtener tipo de dato desde INFORMATION_SCHEMA
        TipoDato := ObtenerTipoDato(Tabla, CheckListBoxWhere.Items.Items[I].Text);

        if CamposParametros <> '' then
          begin
            CamposParametros := CamposParametros + ',' + sLineBreak + '    ';
            CamposWhere      := CamposWhere + sLineBreak + '    AND ';
          end;

        CamposParametros := CamposParametros + '@' + CheckListBoxWhere.Items.Items[I].Text + ' ' + TipoDato;
        CamposWhere      := CamposWhere + CheckListBoxWhere.Items.Items[I].Text + ' = @' + CheckListBoxWhere.Items.Items[I].Text;
      end;
  end;

  // NUEVO: Preparar campos ORDER BY
  CamposOrderBy := '';
  for I := 0 to CheckListBoxOrderBy.Items.Count - 1 do
  begin
    if CheckListBoxOrderBy.Items.Items[I].State = cbsChecked then
      begin
        if CamposOrderBy <> '' then
          CamposOrderBy := CamposOrderBy + ',' + sLineBreak + '    ';
        CamposOrderBy := CamposOrderBy + CheckListBoxOrderBy.Items.Items[I].Text;
      end;
  end;

  // Generar el script
  Script.Add('CREATE OR ALTER PROCEDURE ' + SpName);
  if CamposParametros <> '' then
    begin
      Script.Add('(');
      Script.Add('    ' + CamposParametros);
      Script.Add(')');
    end;

  Script.Add('AS');
  Script.Add('BEGIN');
  Script.Add('    SET NOCOUNT ON;');
  Script.Add('');
  Script.Add('    SELECT');
  Script.Add('    ' + CamposSelect);
  Script.Add('    FROM ' + Tabla);

  if CamposWhere <> '' then
    begin
      Script.Add('    WHERE ' + CamposWhere);
    end;

  // NUEVO: Agregar cláusula ORDER BY si se seleccionaron campos
  if CamposOrderBy <> '' then
    begin
      Script.Add('    ORDER BY');
      Script.Add('    ' + CamposOrderBy);
    end;

  Script.Add('');
  Script.Add('    SET NOCOUNT OFF;');
  Script.Add('END');
  Script.Add('GO');
end;

procedure TFRBuilder.GenerarSPInsert(Script : TStringList; Tabla, SpName : string);
var
  CamposInsert, ValoresInsert, CamposParametros : string;
  I : Integer;
  TipoDato : string;
begin
  // Preparar campos para INSERT
  CamposInsert     := '';
  ValoresInsert    := '';
  CamposParametros := '';

  for I := 0 to CheckListBoxFields.Items.Count - 1 do
  begin
    if CheckListBoxFields.Items.Items[I].State = cbsChecked then
      begin
        // Obtener tipo de dato desde INFORMATION_SCHEMA
        TipoDato := ObtenerTipoDato(Tabla, CheckListBoxFields.Items.Items[I].Text);

        if CamposInsert <> '' then
          begin
            CamposInsert     := CamposInsert + ',' + sLineBreak + '        ';
            ValoresInsert    := ValoresInsert + ',' + sLineBreak + '        ';
            CamposParametros := CamposParametros + ',' + sLineBreak + '    ';
          end;

        CamposInsert     := CamposInsert + CheckListBoxFields.Items.Items[I].Text;
        ValoresInsert    := ValoresInsert + '@' + CheckListBoxFields.Items.Items[I].Text;
        CamposParametros := CamposParametros + '@' + CheckListBoxFields.Items.Items[I].Text + ' ' + TipoDato;
      end;
  end;

  // Generar el script
  Script.Add('CREATE OR ALTER PROCEDURE ' + SpName);
  if CamposParametros <> '' then
    begin
      Script.Add('(');
      Script.Add('    ' + CamposParametros);
      Script.Add(')');
    end;

  Script.Add('AS');
  Script.Add('BEGIN');
  Script.Add('    SET NOCOUNT ON;');
  Script.Add('');
  Script.Add('    INSERT INTO ' + Tabla);
  Script.Add('    (');
  Script.Add('        ' + CamposInsert);
  Script.Add('    )');
  Script.Add('    VALUES');
  Script.Add('    (');
  Script.Add('        ' + ValoresInsert);
  Script.Add('    )');
  Script.Add('');
  Script.Add('    SET NOCOUNT OFF;');
  Script.Add('END');
  Script.Add('GO');
end;

procedure TFRBuilder.GenerarSPUpdate(Script : TStringList; Tabla, SpName, CamposClave : string);
var
  CamposUpdate, CamposWhere, CamposParametros : string;
  I : Integer;
  TipoDato : string;
begin
  // Preparar campos para UPDATE
  CamposUpdate     := '';
  CamposParametros := '';

  for I := 0 to CheckListBoxFields.Items.Count - 1 do
  begin
    if CheckListBoxFields.Items.Items[I].State = cbsChecked then
      begin
        // Obtener tipo de dato desde INFORMATION_SCHEMA
        TipoDato := ObtenerTipoDato(Tabla, CheckListBoxFields.Items.Items[I].Text);

        if CamposUpdate <> '' then
        begin
          CamposUpdate     := CamposUpdate + ',' + sLineBreak + '        ';
          CamposParametros := CamposParametros + ',' + sLineBreak + '    ';
        end;

        CamposUpdate     := CamposUpdate + CheckListBoxFields.Items.Items[I].Text + ' = @' + CheckListBoxFields.Items.Items[I].Text;
        CamposParametros := CamposParametros + '@' + CheckListBoxFields.Items.Items[I].Text + ' ' + TipoDato;
      end;
  end;

  // Preparar condiciones WHERE
  CamposWhere := '';
  for I := 0 to CheckListBoxWhere.Items.Count - 1 do
  begin
    if CheckListBoxWhere.Items.Items[I].State = cbsChecked then
      begin
        // Verificar si ya está en la lista de parámetros
        if Pos('@' + CheckListBoxWhere.Items.Items[I].Text, CamposParametros) = 0 then
          begin
            TipoDato := ObtenerTipoDato(Tabla, CheckListBoxWhere.Items.Items[I].Text);
            CamposParametros := CamposParametros + ',' + sLineBreak + '    @' + CheckListBoxWhere.Items.Items[I].Text + ' ' + TipoDato;
          end;

        if CamposWhere <> '' then
          CamposWhere := CamposWhere + sLineBreak + '        AND ';
        CamposWhere := CamposWhere + CheckListBoxWhere.Items.Items[I].Text + ' = @' + CheckListBoxWhere.Items.Items[I].Text;
      end;
  end;

  // Generar el script
  Script.Add('CREATE OR ALTER PROCEDURE ' + SpName);
  if CamposParametros <> '' then
  begin
    Script.Add('(');
    Script.Add('    ' + CamposParametros);
    Script.Add(')');
  end;
  Script.Add('AS');
  Script.Add('BEGIN');
  Script.Add('    SET NOCOUNT ON;');
  Script.Add('');
  Script.Add('    UPDATE ' + Tabla);
  Script.Add('    SET');
  Script.Add('        ' + CamposUpdate);

  if CamposWhere <> '' then
  begin
    Script.Add('    WHERE');
    Script.Add('        ' + CamposWhere);
  end;

  Script.Add('');
  Script.Add('    SET NOCOUNT OFF;');
  Script.Add('END');
  Script.Add('GO');
end;

procedure TFRBuilder.GenerarSPDelete(Script : TStringList; Tabla, SpName, CamposClave : string);
var
  CamposWhere, CamposParametros : string;
  I : Integer;
  TipoDato : string;
begin
  // Preparar condiciones WHERE y parámetros
  CamposWhere      := '';
  CamposParametros := '';

  for I := 0 to CheckListBoxWhere.Items.Count - 1 do
  begin
    if CheckListBoxWhere.Items.Items[I].State = cbsChecked then
      begin
        // Obtener tipo de dato desde INFORMATION_SCHEMA
        TipoDato := ObtenerTipoDato(Tabla, CheckListBoxWhere.Items.Items[I].Text);

        if CamposParametros <> '' then
          begin
            CamposParametros := CamposParametros + ',' + sLineBreak + '    ';
            CamposWhere      := CamposWhere + sLineBreak + '        AND ';
          end;

        CamposParametros := CamposParametros + '@' + CheckListBoxWhere.Items.Items[I].Text + ' ' + TipoDato;
        CamposWhere      := CamposWhere + CheckListBoxWhere.Items.Items[I].Text + ' = @' + CheckListBoxWhere.Items.Items[I].Text;
      end;
  end;

  // Generar el script
  Script.Add('CREATE OR ALTER PROCEDURE ' + SpName);
  if CamposParametros <> '' then
  begin
    Script.Add('(');
    Script.Add('    ' + CamposParametros);
    Script.Add(')');
  end;
  Script.Add('AS');
  Script.Add('BEGIN');
  Script.Add('    SET NOCOUNT ON;');
  Script.Add('');
  Script.Add('    DELETE FROM ' + Tabla);

  if CamposWhere <> '' then
  begin
    Script.Add('    WHERE');
    Script.Add('        ' + CamposWhere);
  end;

  Script.Add('');
  Script.Add('    SET NOCOUNT OFF;');
  Script.Add('END');
  Script.Add('GO');
end;

function TFRBuilder.ObtenerTipoDato(Tabla, Campo : string) : string;
const
  // Tipos que no necesitan longitud ni precisión
  TiposDatosSinModificador : array[0..14] of string =
    ('float', 'uniqueidentifier', 'datetime', 'bit', 'bigint', 'int',
     'image', 'money', 'xml', 'varbinary', 'tinyint', 'text', 'ntext',
     'smallint', 'smallmoney');

  // Tipos que necesitan precisión y escala
  TiposDatosConPrecision : array[0..1] of string =
    ('decimal', 'numeric');
var
  Query : TFDQuery;
  TipoDato : string;
  Longitud, Precision, Escala : Integer;
  I : Integer;
begin
  Query := TFDQuery.Create(nil);
  try
    Query.Connection := DataBase; // Tu conexión a la base de datos
    Query.Close;
    Query.SQL.Clear;
    Query.SQL.Add('SELECT DATA_TYPE, CHARACTER_MAXIMUM_LENGTH,');
    Query.SQL.Add('NUMERIC_PRECISION, NUMERIC_SCALE');
    Query.SQL.Add('FROM INFORMATION_SCHEMA.COLUMNS');
    Query.SQL.Add('WHERE TABLE_NAME = :Tabla AND COLUMN_NAME = :Campo');
    Query.ParamByName('Tabla').AsString := Tabla;
    Query.ParamByName('Campo').AsString := Campo;
    Query.Open;

    if not Query.IsEmpty then
      begin
        TipoDato := AnsiLowerCase(Query.FieldByName('DATA_TYPE').AsString);

        // Verificar si el tipo de dato no necesita modificadores
        for I := 0 to High(TiposDatosSinModificador) do
        begin
          if TipoDato = TiposDatosSinModificador[I] then
            begin
              Result := AnsiUpperCase(TipoDato);
              Exit;
            end;
        end;

        // Verificar si el tipo de dato necesita precisión y escala
        for I := 0 to High(TiposDatosConPrecision) do
        begin
          if TipoDato = TiposDatosConPrecision[I] then
            begin
              Precision := Query.FieldByName('NUMERIC_PRECISION').AsInteger;
              Escala    := Query.FieldByName('NUMERIC_SCALE').AsInteger;
              Result    := AnsiUpperCase(TipoDato) + '(' + IntToStr(Precision) + ', ' + IntToStr(Escala) + ')';
              Exit;
            end;
        end;

        // Para los demás tipos (varchar, nvarchar, char, nchar, etc)
        Longitud := Query.FieldByName('CHARACTER_MAXIMUM_LENGTH').AsInteger;
        if Longitud = -1 then // MAX
          Result := AnsiUpperCase(TipoDato) + '(MAX)'
        else
          Result := AnsiUpperCase(TipoDato) + '(' + IntToStr(Longitud) + ')';
      end
    else
      Result := 'VARCHAR(100)'; // Valor por defecto
  finally
    Query.Free;
  end;
end;

function TFRBuilder.GenerarDeclaracionTabla(const NombreTabla, NombreVariable : string) : string;
var
  Resultado : TStringList;
begin
  Resultado := TStringList.Create;
  try
    // Ejecutar la consulta
    with QryTableColumns do
      begin
        Close;
        ParamByName('TABLE_NAME').AsString := NombreTabla;
        Open;
      end;

    // Generar la declaración de la variable de tabla
    Resultado.Add('DECLARE @' + NombreVariable + ' TABLE (');

    // Iterar a través de los campos
    QryTableColumns.First;
    while not QryTableColumns.Eof do
      begin
        if QryTableColumns.RecNo < QryTableColumns.RecordCount then
          Resultado.Add('    ' + QryTableColumns.FieldByName('COLUMN_NAME').AsString + ' ' +
                       QryTableColumns.FieldByName('DATA_TYPE_2').AsString + ',')
        else
          Resultado.Add('    ' + QryTableColumns.FieldByName('COLUMN_NAME').AsString + ' ' +

                       QryTableColumns.FieldByName('DATA_TYPE_2').AsString);

        QryTableColumns.Next;
      end;

    Resultado.Add(')');

    Result := Resultado.Text;
  finally
    Resultado.Free;
  end;
end;

// Genera la lista de parámetros para código Delphi
procedure TFRBuilder.GenerarParametrosDelphi(Query: TFDQuery; ListaCampos: TcxCheckListBox;
  Parametros: TStringList; const Prefijo: string = '');
var
  I               : Integer;
  Campo           : TField;
  ParamTexto      : string;
  MaxLongitud     : Integer;
  ParamsAlineados : TStringList;
begin
  if (Query = nil) or (ListaCampos = nil) or (Parametros = nil) then
    Exit;

  ParamsAlineados := TStringList.Create;
  try
    // Primero generamos los textos de los parámetros
    for I := 0 to ListaCampos.Items.Count - 1 do
    begin
      if ListaCampos.Items.Items[I].State = cbsChecked then
      begin
        Campo := BuscarCampoPorNombre(Query, ListaCampos.Items.Items[I].Text);
        if Campo <> nil then
        begin
          ParamTexto := Prefijo + 'ParamByName(' + QuotedStr(Campo.FieldName) +
                       ').' + ObtenerTipoParametro(Campo);
          ParamsAlineados.Add(ParamTexto);
        end;
      end;
    end;

    // Calcular longitud máxima
    MaxLongitud := MasLargo(ParamsAlineados);

    // Finalmente alineamos los parámetros
    for I := 0 to ParamsAlineados.Count - 1 do
    begin
      Parametros.Add(Justifica(ParamsAlineados[I], MaxLongitud, ' ', tjLeft) + ' := ;');
    end;
  finally
    ParamsAlineados.Free;
  end;
end;

// Busca un campo por nombre en un query y devuelve el objeto TField correspondiente
function TFRBuilder.BuscarCampoPorNombre(Query : TFDQuery; const NombreCampo : string) : TField;
begin
  Result := nil;
  if Query = nil then
    Exit;

  Query.First;
  while not Query.Eof do
  begin
    if Query.FindField(NombreCampo) <> nil then
      begin
        Result := Query.FindField(NombreCampo);
        Break;
      end;
    Query.Next;
  end;
end;

// Determina el tipo de parámetro según el tipo de campo
function TFRBuilder.ObtenerTipoParametro(Campo : TField) : string;
begin
  Result := 'AsString'; // Valor por defecto

  if Campo = nil then
    Exit;

  if (Campo.DataType = ftFloat) or (Campo.DataType = ftCurrency)
  or (Campo.DataType = ftBCD) then
    Result := 'AsFloat'
  else if (Campo.DataType = ftString) or (Campo.DataType = ftMemo) then
         Result := 'AsString'
  else if (Campo.DataType = ftDate) then
         Result := 'AsDate'
  else if (Campo.DataType = ftDateTime) or (Campo.DataType = ftTimeStamp) then
         Result := 'AsDateTime'
  else if (Campo.DataType = ftTime) then
         Result := 'AsTime'
  else if (Campo.DataType = ftInteger) or (Campo.DataType = ftSmallint)
  or (Campo.DataType = ftWord) or (Campo.DataType = ftLongWord)
  or (Campo.DataType = ftShortint) or (Campo.DataType = ftByte) then
         Result := 'AsInteger'
  else if (Campo.DataType = ftLargeint) then
         Result := 'AsLargeInt'
  else if (Campo.DataType = ftBoolean) then
         Result := 'AsBoolean';
end;

// Procedimiento para procesar la salida (portapapeles o archivo)
procedure TFRBuilder.ProcesarSalida(const NombreArchivo, Titulo : string);
var
  RutaCompleta : string;
begin
  RutaCompleta := IncludeTrailingPathDelimiter(EdRutaArchivo.Text) + NombreArchivo;

  Mensaje(Titulo + ' se Realizó con Éxito!!!', 'Operación Completada', Informacion);

  if RgFormatoSalida.ItemIndex = 0 then
    CopiarAlPortaPapeles(RutaCompleta)
  else
    begin
      ShellExecute(Handle, 'open', 'c:\windows\notepad.exe',
                   PWideChar(RutaCompleta), nil, SW_SHOWNORMAL);
    end;
end;

procedure TFRBuilder.RgTipoOperacionClick(Sender: TObject);
begin
  case RgTipoOperacion.ItemIndex of
    0 : begin   // SELECT
          CheckListBoxFields.Enabled  := True;
          CheckListBoxWhere.Enabled   := True;
          CheckListBoxOrderBy.Enabled := True;
        end;

    1 : begin  // INSERT
          CheckListBoxFields.Enabled  := True;
          CheckListBoxWhere.Enabled   := False;
          CheckListBoxOrderBy.Enabled := False;
        end;

    2 : begin   // UPDATE
          CheckListBoxFields.Enabled  := True;
          CheckListBoxWhere.Enabled   := True;
          CheckListBoxOrderBy.Enabled := False;
        end;

    3 : begin   // DELETE
          CheckListBoxFields.Enabled  := True;
          CheckListBoxWhere.Enabled   := True;
          CheckListBoxOrderBy.Enabled := False;
        end;
  end;
end;

// METODOS PARA LA CREACION DE INDICES

// Consulta para obtener todas las tablas de la base de datos
procedure TFRBuilder.CargarTablas;
begin
  // de la pestaña indices
  CmbTabla.Properties.Items.Clear;

  //de la pestaña Foreign Keys
  CmbTablaOrigen.Properties.Items.Clear;
  CmbTablaDestino.Properties.Items.Clear;

  with QryDatabaseTables do
    begin
      Close;
      Open;
      First;

      while not Eof do
      begin
        CmbTabla.Properties.Items.Add(FieldByName('TABLE_NAME').AsString);

        CmbTablaOrigen.Properties.Items.Add(FieldByName('TABLE_NAME').AsString);
        CmbTablaDestino.Properties.Items.Add(FieldByName('TABLE_NAME').AsString);

        Next;
      end;
    end;

end;

// Consulta para obtener los campos de una tabla
procedure TFRBuilder.CargarCamposTabla(const NombreTabla : string);
var
  Item : TListItem;
begin
  with QryTableColumns do
    begin
      Close;
      ParamByName('TABLE_NAME').AsString := Trim(NombreTabla);
      Open;
      First;
    end;

    LvCamposDisponibles.Items.Clear;
    LvCamposIndice.Items.Clear;
    LvCamposIncluidos.Items.Clear;

    while not QryTableColumns.Eof do
    begin
      Item         := LvCamposDisponibles.Items.Add;
      Item.Caption := QryTableColumns.FieldByName('COLUMN_NAME').AsString;
      Item.SubItems.Add(QryTableColumns.FieldByName('DATA_TYPE_2').AsString);

      QryTableColumns.Next;
    end;

  //Auto ajustamos las columnas de los cxListViews
  LvCamposIndice.Columns.Items[0].AutoSize      := True;
  LvCamposIncluidos.Columns.Items[0].AutoSize   := True;
  LvCamposDisponibles.Columns.Items[0].AutoSize := True;
  LvCamposDisponibles.Columns.Items[1].AutoSize := True;
end;

function TFRBuilder.GenerarNombreIndiceAutomatico : string;
begin
  // Generar un nombre de índice automático basado en la tabla seleccionada
  Result := 'IX_' + CmbTabla.Text;
end;

function TFRBuilder.ValidarDatos : Boolean;
var
  FactorRelleno : Integer;
begin
  Result := False;

  // Validar que se haya seleccionado una tabla
  if CmbTabla.Text = '' then
    begin
      Mensaje('Debe seleccionar una tabla', 'Operación invalida', Advertencia);
      Exit;
    end;

  // Validar que se haya ingresado un nombre de índice
  if EdNombreIndice.Text = '' then
    begin
      Mensaje('Debe ingresar un nombre para el índice',
              'Operación invalida', Advertencia);
      Exit;
    end;

  // Validar que se haya seleccionado al menos un campo
  if LvCamposIndice.Items.Count = 0 then
    begin
      Mensaje('Debe seleccionar al menos un campo para el índice',
              'Operación invalida', Advertencia);
      Exit;
    end;

  // Validar el factor de relleno
  if ChkUsarFactorRelleno.Checked then
    begin
      if not TryStrToInt(SeFactorRelleno.Value, FactorRelleno) then
        begin
          Mensaje('El factor de relleno debe ser un número entero',
                  'Operación invalida', Advertencia);
          Exit;
        end;

      if (FactorRelleno < 1) or (FactorRelleno > 100) then
        begin
          Mensaje('El factor de relleno debe estar entre 1 y 100',
                  'Operación invalida', Advertencia);
          Exit;
        end;
    end;

  Result := True;
end;

procedure TFRBuilder.BtnCargarTablasClick(Sender: TObject);
begin
  CargarTablas;
end;

procedure TFRBuilder.BtnCargarCamposClick(Sender: TObject);
begin
  if CmbTabla.Text <> '' then
    begin
      CargarCamposTabla(CmbTabla.Text);
      EdNombreIndice.Text := GenerarNombreIndiceAutomatico;
    end;
end;

procedure TFRBuilder.BtnAgregarCampoClick(Sender: TObject);
var
  Item : TListItem;
begin
  if LvCamposDisponibles.Selected = nil then
    Exit;

  // Agregar el campo seleccionado a la lista de campos del índice
  Item         := LvCamposIndice.Items.Add;
  Item.Caption := LvCamposDisponibles.Selected.Caption;

  // Actualizar nombre del índice si es el primer campo
  if LvCamposIndice.Items.Count = 1 then
    EdNombreIndice.Text := 'IX_' + CmbTabla.Text + '_' + Item.Caption;
end;

procedure TFRBuilder.BtnQuitarCampoClick(Sender: TObject);
begin
  if LvCamposIndice.Selected = nil then
    Exit;

  LvCamposIndice.DeleteSelected;

  // Actualizar nombre del índice si es necesario
  if LvCamposIndice.Items.Count > 0 then
    EdNombreIndice.Text := 'IX_' + CmbTabla.Text + '_' + LvCamposIndice.Items[0].Caption
  else
    EdNombreIndice.Text := 'IX_' + CmbTabla.Text;
end;

procedure TFRBuilder.BtnSubirCampoClick(Sender: TObject);
var
  Index       : Integer;
  TempCaption : string;
begin
  if (LvCamposIndice.Selected = nil) or (LvCamposIndice.Selected.Index = 0) then
    Exit;

  Index := LvCamposIndice.Selected.Index;

  // Intercambiar con el ítem anterior
  TempCaption := LvCamposIndice.Items[Index].Caption;
  LvCamposIndice.Items[Index].Caption     := LvCamposIndice.Items[Index - 1].Caption;
  LvCamposIndice.Items[Index - 1].Caption := TempCaption;

  // Seleccionar el ítem movido
  LvCamposIndice.Items[Index - 1].Selected := True;

  // Actualizar nombre del índice si es necesario
  if Index = 1 then
    EdNombreIndice.Text := 'IX_' + CmbTabla.Text + '_' + LvCamposIndice.Items[0].Caption;
end;

procedure TFRBuilder.BtnBajarCampoClick(Sender: TObject);
var
  Index       : Integer;
  TempCaption : string;
begin
  if (LvCamposIndice.Selected = nil)
  or (LvCamposIndice.Selected.Index = LvCamposIndice.Items.Count - 1) then
    Exit;

  Index := LvCamposIndice.Selected.Index;

  // Intercambiar con el ítem siguiente
  TempCaption                             := LvCamposIndice.Items[Index].Caption;
  LvCamposIndice.Items[Index].Caption     := LvCamposIndice.Items[Index + 1].Caption;
  LvCamposIndice.Items[Index + 1].Caption := TempCaption;

  // Seleccionar el ítem movido
  LvCamposIndice.Items[Index + 1].Selected := True;

  // Actualizar nombre del índice si es necesario
  if Index = 0 then
    EdNombreIndice.Text := 'IX_' + CmbTabla.Text + '_' + LvCamposIndice.Items[0].Caption;
end;

procedure TFRBuilder.BtnAgregarIncludeClick(Sender: TObject);
var
  Item : TListItem;
begin
  if LvCamposDisponibles.Selected = nil then
    Exit;

  // Verificar si el campo ya está en el índice principal
  for var I := 0 to LvCamposIndice.Items.Count - 1 do
    if LvCamposIndice.Items[I].Caption = LvCamposDisponibles.Selected.Caption then
    begin
      Mensaje('El campo ya está incluido en el índice principal',
              'Operación invalida', Advertencia);
      Exit;
    end;

  // Verificar si el campo ya está en los campos incluidos
  for var I := 0 to LvCamposIncluidos.Items.Count - 1 do
    if LvCamposIncluidos.Items[I].Caption = LvCamposDisponibles.Selected.Caption then
    begin
      Mensaje('El campo ya está en la lista de campos incluidos',
              'Operación invalida', Advertencia);
      Exit;
    end;

  // Agregar el campo seleccionado a la lista de campos incluidos
  Item         := LvCamposIncluidos.Items.Add;
  Item.Caption := LvCamposDisponibles.Selected.Caption;
end;

procedure TFRBuilder.BtnQuitarIncludeClick(Sender: TObject);
begin
  if LvCamposIncluidos.Selected = nil then
    Exit;

  LvCamposIncluidos.DeleteSelected;
end;

procedure TFRBuilder.ChkUsarFactorRellenoClick(Sender: TObject);
begin
  SeFactorRelleno.Enabled := ChkUsarFactorRelleno.Checked;

  if ChkUsarFactorRelleno.Checked then
    SeFactorRelleno.Value := 80
  else
    SeFactorRelleno.Value := 0;
end;

procedure TFRBuilder.BtCrearFuncionClick(Sender: TObject);
begin
//  if DataBase.Connected then
//    begin
//      FunctionBuilderForm := TFunctionBuilderForm.Create(Self);
//      try
//        FunctionBuilderForm.Initialize(DataBase);
//        FunctionBuilderForm.ShowModal;
//      finally
//        FunctionBuilderForm.Free;
//      end;
//    end
//  else
//    Mensaje('Por favor, conectese a la base de datos primero.',
//            'Base de datos sin conexion', Advertencia);

end;

procedure TFRBuilder.BtCrearIndiceClick(Sender: TObject);
var
  Indice : TIndice;   //Instanciamos la clase TIndice
  Script, RutaArchivo : string;
  I : Integer;
begin
  if not ValidarDatos then
    Exit;

  Indice := TIndice.Create;
  try
    // Configurar el índice
    Indice.Nombre := EdNombreIndice.Text;
    Indice.Tabla  := CmbTabla.Text;
    Indice.Tipo   := TTipoIndice(RgTipoIndice.ItemIndex);

    // Agregar campos
    for I := 0 to LvCamposIndice.Items.Count - 1 do
      Indice.Campos.Add(LvCamposIndice.Items[I].Caption);

    // Agregar campos incluidos
    for I := 0 to LvCamposIncluidos.Items.Count - 1 do
      Indice.CamposIncluidos.Add(LvCamposIncluidos.Items[I].Caption);

    // Factor de relleno
    if ChkUsarFactorRelleno.Checked then
      Indice.FactorRelleno := StrToInt(SeFactorRelleno.Value)
    else
      Indice.FactorRelleno := 0;

    // Descripción
    Indice.Descripcion := MmDescripcion.Text;

    // Generar script
    Script := Indice.GenerarScriptSQL;

    // Guardar script a archivo
    RutaArchivo := IncludeTrailingPathDelimiter(EdRutaArchivo.Text) + 'Indice_' + Indice.Nombre + '.txt';
    TFile.WriteAllText(RutaArchivo, Script);

    // Mostrar mensaje de éxito
    Mensaje('El script del índice se generó con éxito.',
            'Operación Completada', Informacion);

    // Procesar salida
    case RgFormatoSalida2.ItemIndex of
      0 : Clipboard.AsText := Script;
      1 : ShellExecute(Handle, 'open', 'c:\windows\notepad.exe', PWideChar(RutaArchivo), nil, SW_SHOWNORMAL);
    end;

  finally
    Indice.Free;
  end;
end;

// METODOS PARA LA CREACION DE FOREIGN KEYS

procedure TFRBuilder.BtCargarTablasClick(Sender: TObject);
begin
  CargarTablas;
end;

procedure TFRBuilder.BtLimpiarPantallaClick(Sender: TObject);
begin
  CmbTablaOrigen.Clear;
  CmbTablaDestino.Clear;
  LvCamposOrigen.Items.Clear;
  LvCamposDestino.Items.Clear;
  LvMapeo.Items.Clear;
  MmDescripcionFK.Lines.Clear;
end;

procedure TFRBuilder.CmbTablaOrigenPropertiesChange(Sender: TObject);
begin
  if CmbTablaOrigen.Text <> '' then
    begin
      CargarCamposTabla(CmbTablaOrigen.Text, LvCamposOrigen);
      EdNombreFK.Text := GenerarNombreConstraintAutomatico;
      LvMapeo.Items.Clear;

      LvCamposOrigen.Columns.Items[0].AutoSize := True;
      LvCamposOrigen.Columns.Items[1].AutoSize := True;
    end;
end;

procedure TFRBuilder.CmbTablaDestinoPropertiesChange(Sender: TObject);
begin
  if CmbTablaDestino.Text <> '' then
    begin
      CargarCamposTabla(CmbTablaDestino.Text, LvCamposDestino);
      EdNombreFK.Text := GenerarNombreConstraintAutomatico;
      LvMapeo.Items.Clear;

      LvCamposDestino.Columns.Items[0].AutoSize := True;
      LvCamposDestino.Columns.Items[1].AutoSize := True;
    end;
end;

procedure TFRBuilder.BtnAgregarMapeoClick(Sender: TObject);
var
  Item : TListItem;
begin
  if (LvCamposOrigen.Selected = nil) or (LvCamposDestino.Selected = nil) then
    begin
      Mensaje('Debe seleccionar un campo origen y un campo destino',
              'Operación Invalida', Advertencia);
      Exit;
    end;

  // Verificar tipos de datos compatibles
  if LvCamposOrigen.Selected.SubItems[0] <> LvCamposDestino.Selected.SubItems[0] then
    begin
      if Mensaje('Los tipos de datos son diferentes.' +#13+
                 '¿Desea continuar de todos modos?',
                 'Tipo de datos diferente',Pregunta) = False then
        Exit;
    end;

  // Verificar si ya existe un mapeo para el campo origen
  for var I := 0 to LvMapeo.Items.Count - 1 do
  begin
    if LvMapeo.Items[I].Caption = LvCamposOrigen.Selected.Caption then
      begin
        Mensaje('El campo origen ya está mapeado',
                'Operación Invalida', Advertencia);
        Exit;
      end;
  end;

  // Agregar el mapeo
  Item         := LvMapeo.Items.Add;
  Item.Caption := LvCamposOrigen.Selected.Caption;
  Item.SubItems.Add(LvCamposDestino.Selected.Caption);

  // Agregar a la lista de campos del objeto ForeignKey
  FForeignKey.CamposOrigen.Add(LvCamposOrigen.Selected.Caption);
  FForeignKey.CamposDestino.Add(LvCamposDestino.Selected.Caption);

//  LvMapeo.Columns.Items[0].AutoSize := True;
//  LvMapeo.Columns.Items[1].AutoSize := True;

end;

procedure TFRBuilder.BtnQuitarMapeoClick(Sender: TObject);
var
  Index : Integer;
begin
  if LvMapeo.Selected = nil then
    Exit;

  Index := LvMapeo.Selected.Index;

  // Eliminar de las listas de campos del objeto ForeignKey
  FForeignKey.CamposOrigen.Delete(Index);
  FForeignKey.CamposDestino.Delete(Index);

  // Eliminar del ListView
  LvMapeo.DeleteSelected;
end;

procedure TFRBuilder.BtGenerarFKClick(Sender: TObject);
var
  Script, RutaArchivo : string;
begin
  if not ValidarDatosFK then
    Exit;

  // Configurar propiedades finales del constraint
  FForeignKey.Nombre       := EdNombreFK.Text;
  FForeignKey.TablaOrigen  := CmbTablaOrigen.Text;
  FForeignKey.TablaDestino := CmbTablaDestino.Text;
  FForeignKey.AccionUpdate := TAccionReferencial(CmbAccionUpdate.ItemIndex);
  FForeignKey.AccionDelete := TAccionReferencial(CmbAccionDelete.ItemIndex);
  FForeignKey.Descripcion  := MmDescripcionFK.Lines.Text;

  // Generar el script
  Script := FForeignKey.GenerarScriptCreacion;

  // Asegurar que la carpeta existe
  if not DirectoryExists(EdRutaArchivo.Text) then
    ForceDirectories(EdRutaArchivo.Text);

  // Guardar el script a un archivo
  RutaArchivo := IncludeTrailingPathDelimiter(EdRutaArchivo.Text) +
                'FK_' + FForeignKey.Nombre + '.txt';
  TFile.WriteAllText(RutaArchivo, Script);

  // Mostrar mensaje de éxito
  Mensaje('El script del constraint FOREIGN KEY se generó con éxito.',
          'Operación completada', Informacion);

    // Procesar salida
    case RgFormatoSalida3.ItemIndex of
      0 : Clipboard.AsText := Script;
      1 : ShellExecute(Handle, 'open', 'c:\windows\notepad.exe', PWideChar(RutaArchivo), nil, SW_SHOWNORMAL);
    end;

end;

procedure TFRBuilder.BtGenerarFKDropClick(Sender: TObject);
var
  Script, RutaArchivo : string;
begin
  if not ValidarDatosFK then
    Exit;

  // Configurar propiedades finales del constraint
  FForeignKey.Nombre      := EdNombreFK.Text;
  FForeignKey.TablaOrigen := CmbTablaOrigen.Text;

  // Generar el script
  Script := FForeignKey.GenerarScriptEliminacion;

  // Asegurar que la carpeta existe
  if not DirectoryExists(EdRutaArchivo.Text) then
    ForceDirectories(EdRutaArchivo.Text);

  // Guardar el script a un archivo
  RutaArchivo := IncludeTrailingPathDelimiter(EdRutaArchivo.Text) +
                'DROP_FK_' + FForeignKey.Nombre + '.txt';

  TFile.WriteAllText(RutaArchivo, Script);

  // Mostrar mensaje de éxito
  Mensaje('El script para eliminar el constraint FOREIGN KEY se generó con éxito.',
          'Operación completada', Informacion);

  // Procesar salida
  if RgFormatoSalida.ItemIndex = 0 then
    CopiarAlPortaPapeles(RutaArchivo)
  else
    ShellExecute(Handle, 'open', PWideChar('notepad.exe'), PWideChar(RutaArchivo), nil, SW_SHOWNORMAL);
end;

procedure TFRBuilder.CargarCamposTabla(const NombreTabla : string; ListView : TcxListView);
var
  Item : TListItem;
begin
  ListView.Items.Clear;

  with QryTableColumns do
    begin
      Close;
      ParamByName('TABLE_NAME').AsString := Trim(NombreTabla);
      Open;
      First;

      while not Eof do
      begin
        Item         := ListView.Items.Add;
        Item.Caption := FieldByName('COLUMN_NAME').AsString;
        Item.SubItems.Add(FieldByName('DATA_TYPE_2').AsString);
        Next;
      end;
    end;

end;

function TFRBuilder.GenerarNombreConstraintAutomatico : string;
begin
  // Generar un nombre de constraint automático basado en las tablas seleccionadas
  if (CmbTablaOrigen.Text <> '') and (CmbTablaDestino.Text <> '') then
    Result := 'FK_' + CmbTablaOrigen.Text + '_' + CmbTablaDestino.Text
  else if CmbTablaOrigen.Text <> '' then
    Result := 'FK_' + CmbTablaOrigen.Text
  else
    Result := 'FK_NewConstraint';
 end;

function TFRBuilder.ValidarDatosFK : Boolean;
begin
  Result := False;

  // Validar que se haya ingresado un nombre para el constraint
  if EdNombreFK.Text = '' then
    begin
      Mensaje('Debe ingresar un nombre para el constraint',
              'Operación Invalida', Advertencia);
      EdNombreFK.SetFocus;
      Exit;
    end;

  // Validar que se haya seleccionado tabla origen y destino
  if CmbTablaOrigen.Text = '' then
    begin
      Mensaje('Debe seleccionar una tabla origen',
              'Operación Invalida', Advertencia);
      CmbTablaOrigen.SetFocus;
      Exit;
    end;

  if CmbTablaDestino.Text = '' then
    begin
      Mensaje('Debe seleccionar una tabla destino',
              'Operación Invalida', Advertencia);
      CmbTablaDestino.SetFocus;
      Exit;
    end;

  // Validar que se haya definido al menos un mapeo de campos
  if LvMapeo.Items.Count = 0 then
    begin
      Mensaje('Debe definir al menos un mapeo de campos',
              'Operación Invalida', Advertencia);
      Exit;
    end;

  Result := True;
end;


// METODOS PARA LA CREACION DE FUNCIONES ESCALARES Y DE TABLAS

procedure TFRBuilder.InitializeControls;
begin
  // Set source for grids
  grdScalarParametersView.DataController.DataSource         := TDataSource.Create(Self);
  grdScalarParametersView.DataController.DataSource.DataSet := FScalarParamsDataSet;

  grdTableParametersView.DataController.DataSource         := TDataSource.Create(Self);
  grdTableParametersView.DataController.DataSource.DataSet := FTableParamsDataSet;

  grdTableColumnsView.DataController.DataSource         := TDataSource.Create(Self);
  grdTableColumnsView.DataController.DataSource.DataSet := FTableColumnsDataSet;

  // Default to scalar function tab
  pcFunctions.ActivePage := tsScalarFunction;

  // Load data types
  LoadDataTypes;

  // Set initial text for function body
  memScalarBody.Lines.Clear;
  memScalarBody.Lines.Add('RETURN');

  memTableBody.Lines.Clear;
  memTableBody.Lines.Add('RETURN');
end;


procedure TFRBuilder.LoadSchemasFromDB;
var
  Query : TFDQuery;
begin
  cbScalarSchema.Properties.Items.Clear;
  cbTableSchema.Properties.Items.Clear;

  Query := TFDQuery.Create(nil);
  try
    Query.Connection := DataBase;
    Query.SQL.Text   := 'SELECT schema_name FROM information_schema.schemata ORDER BY schema_name';

    try
      Query.Open;
      while not Query.Eof do
      begin
        cbScalarSchema.Properties.Items.Add(Query.FieldByName('schema_name').AsString);
        cbTableSchema.Properties.Items.Add(Query.FieldByName('schema_name').AsString);
        Query.Next;
      end;
    except
      on E : Exception do
        Mensaje('Error al obtener los esquemas: ' + E.Message,
                'Error de esquemas', Error);
    end;
  finally
    Query.Free;
  end;

  // Default to dbo schema
  if cbScalarSchema.Properties.Items.IndexOf('dbo') >= 0 then
    begin
      cbScalarSchema.ItemIndex := cbScalarSchema.Properties.Items.IndexOf('dbo');
      cbTableSchema.ItemIndex  := cbTableSchema.Properties.Items.IndexOf('dbo');
    end
  else
    if cbScalarSchema.Properties.Items.Count > 0 then
      begin
        cbScalarSchema.ItemIndex := 0;
        cbTableSchema.ItemIndex  := 0;
      end;
end;

procedure TFRBuilder.LoadDataTypes;
begin
  cbScalarReturnType.Properties.Items.Clear;

  // Add SQL Server data types
  cbScalarReturnType.Properties.Items.AddStrings([
    'INT', 'BIGINT', 'SMALLINT', 'TINYINT', 'BIT',
    'DECIMAL', 'NUMERIC', 'MONEY', 'SMALLMONEY', 'FLOAT', 'REAL',
    'DATE', 'DATETIME', 'DATETIME2', 'DATETIMEOFFSET', 'SMALLDATETIME', 'TIME',
    'CHAR', 'VARCHAR', 'TEXT', 'NCHAR', 'NVARCHAR', 'NTEXT',
    'BINARY', 'VARBINARY', 'IMAGE',
    'UNIQUEIDENTIFIER', 'XML', 'JSON'
  ]);

  if cbScalarReturnType.Properties.Items.Count > 0 then
    cbScalarReturnType.ItemIndex := 0;
end;

procedure TFRBuilder.CreateDataSets;
begin
  FScalarParamsDataSet := TFDMemTable.Create(Self);
  with FScalarParamsDataSet do
  begin
    FieldDefs.Add('Name', ftString, 128);
    FieldDefs.Add('DataType', ftString, 50);
    FieldDefs.Add('Length', ftInteger);
    FieldDefs.Add('Precision', ftInteger);
    FieldDefs.Add('Scale', ftInteger);
    CreateDataSet;
  end;

  FTableParamsDataSet := TFDMemTable.Create(Self);
  with FTableParamsDataSet do
  begin
    FieldDefs.Add('Name', ftString, 128);
    FieldDefs.Add('DataType', ftString, 50);
    FieldDefs.Add('Length', ftInteger);
    FieldDefs.Add('Precision', ftInteger);
    FieldDefs.Add('Scale', ftInteger);
    CreateDataSet;
  end;

  FTableColumnsDataSet := TFDMemTable.Create(Self);
  with FTableColumnsDataSet do
  begin
    FieldDefs.Add('Name', ftString, 128);
    FieldDefs.Add('DataType', ftString, 50);
    FieldDefs.Add('Length', ftInteger);
    FieldDefs.Add('Precision', ftInteger);
    FieldDefs.Add('Scale', ftInteger);
    CreateDataSet;
  end;
end;

procedure TFRBuilder.SetupGrids;
begin
  // Configure grid columns for scalar parameters
  with grdScalarParametersView do
    begin
      with grdScalarParametersViewName do
      begin
        DataBinding.FieldName := 'Name';
        Caption               := 'Nombre';
        Width                 := 135;
      end;

      with grdScalarParametersViewDataType do
      begin
        DataBinding.FieldName := 'DataType';
        Caption               := 'Tipo de Dato';
        Width                 := 135;
      end;

      with grdScalarParametersViewLength do
      begin
        DataBinding.FieldName := 'Length';
        Caption               := 'Longitud';
        Width                 := 95;
      end;

      with grdScalarParametersViewPrecision do
      begin
        DataBinding.FieldName := 'Precision';
        Caption               := 'Precisión';
        Width                 := 95;
      end;

      with grdScalarParametersViewScale do
      begin
        DataBinding.FieldName := 'Scale';
        Caption               := 'Escala';
        Width                 := 70;
      end;
    end;

  // Configure grid columns for table parameters (same as scalar)
  with grdTableParametersView do
  begin
    with grdTableParametersViewName do
    begin
      DataBinding.FieldName := 'Name';
      Caption               := 'Nombre';
      Width                 := 135;
    end;

    with grdTableParametersViewDataType do
    begin
      DataBinding.FieldName := 'DataType';
      Caption               := 'Tipo de Dato';
      Width                 := 135;
    end;

    with grdTableParametersViewLength do
    begin
      DataBinding.FieldName := 'Length';
      Caption               := 'Longitud';
      Width                 := 95;
    end;

    with grdTableParametersViewPrecision do
    begin
      DataBinding.FieldName := 'Precision';
      Caption               := 'Precisión';
      Width                 := 95;
    end;

    with grdTableParametersViewScale do
    begin
      DataBinding.FieldName := 'Scale';
      Caption               := 'Escala';
      Width                 := 70;
    end;
  end;

  // Configure grid columns for table columns (same structure)
  with grdTableColumnsView do
  begin
    with grdTableColumnsViewName do
    begin
      DataBinding.FieldName := 'Name';
      Caption               := 'Nombre';
      Width                 := 135;
    end;

    with grdTableColumnsViewDataType do
    begin
      DataBinding.FieldName := 'DataType';
      Caption               := 'Tipo de Dato';
      Width                 := 135;
    end;

    with grdTableColumnsViewLength do
    begin
      DataBinding.FieldName := 'Length';
      Caption               := 'Longitud';
      Width                 := 95;
    end;

    with grdTableColumnsViewPrecision do
    begin
      DataBinding.FieldName := 'Precision';
      Caption               := 'Precisión';
      Width                 := 95;
    end;

    with grdTableColumnsViewScale do
    begin
      DataBinding.FieldName := 'Scale';
      Caption               := 'Escala';
      Width                 := 70;
    end;
  end;
end;

procedure TFRBuilder.ShowParameterDialog(ADataSet : TFDMemTable; const AIsEdit : Boolean);
var
  Dialog : TParameterDialog;
begin
  Dialog := TParameterDialog.Create(Self, ADataSet, AIsEdit);
  try
    Dialog.ShowModal;
  finally
    Dialog.Free;
  end;
end;

procedure TFRBuilder.ShowColumnDialog(ADataSet : TFDMemTable; const AIsEdit : Boolean);
var
  Dialog : TParameterDialog;
begin
  Dialog := TParameterDialog.Create(Self, ADataSet, AIsEdit);
  try
    Dialog.Caption := 'Columna de Función de Tabla';
    Dialog.ShowModal;
  finally
    Dialog.Free;
  end;
end;

procedure TFRBuilder.GenerateScalarFunctionSQL;
var
  FunctionName, SchemaName, ReturnType, Body : string;
  ReturnLength: Integer;
begin
  FunctionName := Trim(edtScalarFunctionName.Text);

  if FunctionName = '' then
    begin
      Mensaje('Por favor, ingresa un nombre para la función.',
              'nombre inexistente', Advertencia);
      edtScalarFunctionName.SetFocus;
      Exit;
    end;

  SchemaName := cbScalarSchema.Text;

  if SchemaName = '' then
    SchemaName := 'dbo';

  ReturnType := cbScalarReturnType.Text;

  if ReturnType = '' then
    begin
      Mensaje('Por favor, selecciona un tipo de retorno.',
              'Selección inexistente', Advertencia);
      Exit;
    end;

  ReturnLength := StrToIntDef(edtScalarTypeLength.Text, 0);

  Body := memScalarBody.Text;

  if Body = '' then
    begin
      Mensaje('Por favor, ingresa el cuerpo de la función.',
              'Cuerpo de la función inexistente', Advertencia);
      Exit;
    end;

  // Clear builder and set properties
  FFunctionBuilder.Clear;
  FFunctionBuilder.FunctionName := FunctionName;
  FFunctionBuilder.FunctionType := ftScalar;
  FFunctionBuilder.Schema       := SchemaName;
  FFunctionBuilder.SetReturnType(ReturnType, ReturnLength);
  FFunctionBuilder.SetFunctionBody(Body);

  // Add parameters
  FScalarParamsDataSet.First;
  while not FScalarParamsDataSet.Eof do
  begin
    FFunctionBuilder.AddParameter(
      FScalarParamsDataSet.FieldByName('Name').AsString,
      FScalarParamsDataSet.FieldByName('DataType').AsString,
      pdInput,
      FScalarParamsDataSet.FieldByName('Length').AsInteger,
      FScalarParamsDataSet.FieldByName('Precision').AsInteger,
      FScalarParamsDataSet.FieldByName('Scale').AsInteger
    );
    FScalarParamsDataSet.Next;
  end;

  // Generate SQL
  memScalarSQL.Text := FFunctionBuilder.GenerateSQL;
end;

procedure TFRBuilder.GenerateTableFunctionSQL;
var
  FunctionName, SchemaName, Body : string;
begin
  FunctionName := Trim(edtTableFunctionName.Text);

  if FunctionName = '' then
    begin
      Mensaje('Por favor, ingresa un nombre para la función.',
              'nombre inexistente', Advertencia);
      edtTableFunctionName.SetFocus;
      Exit;
    end;

  SchemaName := cbTableSchema.Text;

  if SchemaName = '' then
    SchemaName := 'dbo';

  // Check if there's at least one column defined
  if FTableColumnsDataSet.IsEmpty then
    begin
      Mensaje('Debe definir al menos una columna para la tabla de retorno.',
              'columna inexistente', Advertencia);
      Exit;
    end;

  Body := memTableBody.Text;

  if Body = '' then
    begin
      Mensaje('Por favor, ingresa el cuerpo de la función.',
              'cuerpo de la función inexistente', Advertencia);
      Exit;
    end;

  // Clear builder and set properties
  FFunctionBuilder.Clear;
  FFunctionBuilder.FunctionName := FunctionName;
  FFunctionBuilder.FunctionType := ftTable;
  FFunctionBuilder.Schema       := SchemaName;
  FFunctionBuilder.SetFunctionBody(Body);

  // Add parameters
  FTableParamsDataSet.First;
  while not FTableParamsDataSet.Eof do
  begin
    FFunctionBuilder.AddParameter(
      FTableParamsDataSet.FieldByName('Name').AsString,
      FTableParamsDataSet.FieldByName('DataType').AsString,
      pdInput,
      FTableParamsDataSet.FieldByName('Length').AsInteger,
      FTableParamsDataSet.FieldByName('Precision').AsInteger,
      FTableParamsDataSet.FieldByName('Scale').AsInteger
    );
    FTableParamsDataSet.Next;
  end;

  // Add table columns
  FTableColumnsDataSet.First;
  while not FTableColumnsDataSet.Eof do
  begin
    FFunctionBuilder.AddTableColumn(
      FTableColumnsDataSet.FieldByName('Name').AsString,
      FTableColumnsDataSet.FieldByName('DataType').AsString,
      FTableColumnsDataSet.FieldByName('Length').AsInteger,
      FTableColumnsDataSet.FieldByName('Precision').AsInteger,
      FTableColumnsDataSet.FieldByName('Scale').AsInteger
    );
    FTableColumnsDataSet.Next;
  end;

  // Generate SQL
  memTableSQL.Text := FFunctionBuilder.GenerateSQL;
end;

procedure TFRBuilder.cbScalarReturnTypePropertiesChange(Sender: TObject);
var
  DataType : string;
begin
  DataType := cbScalarReturnType.Text;

  // Enable/disable length field based on data type
  edtScalarTypeLength.Enabled := (DataType = 'VARCHAR') or (DataType = 'NVARCHAR') or
                                (DataType = 'CHAR') or (DataType = 'NCHAR') or
                                (DataType = 'BINARY') or (DataType = 'VARBINARY');
end;

procedure TFRBuilder.btnScalarAddParamClick(Sender: TObject);
begin
  ShowParameterDialog(FScalarParamsDataSet, False);
end;

procedure TFRBuilder.btnScalarDeleteParamClick(Sender: TObject);
begin
  if not FScalarParamsDataSet.IsEmpty then
    begin
      if Mensaje('¿Está seguro de eliminar este parámetro?',
                 'Eliminar parámetro',Pregunta) = True then
        FScalarParamsDataSet.Delete;
    end
  else
    Mensaje('No hay parámetros para eliminar.',
            'Parámetros inexistentes', Advertencia);
end;

procedure TFRBuilder.btnScalarEditParamClick(Sender: TObject);
begin
  if not FScalarParamsDataSet.IsEmpty then
    ShowParameterDialog(FScalarParamsDataSet, True)
  else
    Mensaje('No hay parámetros para editar.',
            'Parámetros inexistentes', Advertencia);
end;

procedure TFRBuilder.btnGenerateScalarSQLClick(Sender: TObject);
begin
  GenerateScalarFunctionSQL;
end;

procedure TFRBuilder.btnCopyScalarSQLClick(Sender: TObject);
begin
  if memScalarSQL.Text <> '' then
    begin
      Clipboard.AsText := memScalarSQL.Text;
      Mensaje('SQL copiado al portapapeles.',
              'Copiado al portapapeles', Informacion);
    end;
end;

procedure TFRBuilder.btnTableAddColumnClick(Sender: TObject);
begin
  ShowColumnDialog(FTableColumnsDataSet, False);
end;

procedure TFRBuilder.btnTableAddParamClick(Sender: TObject);
begin
  ShowParameterDialog(FTableParamsDataSet, False);
end;

procedure TFRBuilder.btnTableDeleteColumnClick(Sender: TObject);
begin
  if not FTableColumnsDataSet.IsEmpty then
    begin
      if Mensaje('¿Está seguro de eliminar esta columna?',
                 'Eliminar columna',Pregunta) = True then
        FTableColumnsDataSet.Delete;
    end
  else
    Mensaje('No hay columnas para eliminar.',
            'Columnas inexistentes', Advertencia);
end;

procedure TFRBuilder.btnTableDeleteParamClick(Sender: TObject);
begin
  if not FTableParamsDataSet.IsEmpty then
    begin
      if Mensaje('¿Está seguro de eliminar este parámetro?',
                 'Eliminar parámetro',Pregunta) = True then
        FTableParamsDataSet.Delete;
    end
  else
    Mensaje('No hay parámetros para eliminar.',
            'Parámetros inexistentes', Advertencia);
end;

procedure TFRBuilder.btnTableEditColumnClick(Sender: TObject);
begin
  if not FTableColumnsDataSet.IsEmpty then
    ShowColumnDialog(FTableColumnsDataSet, True)
  else
    Mensaje('No hay columnas para editar.',
            'Columnas inexistentes', Advertencia);
end;

procedure TFRBuilder.btnTableEditParamClick(Sender: TObject);
begin
  if not FTableParamsDataSet.IsEmpty then
    ShowParameterDialog(FTableParamsDataSet, True)
  else
    Mensaje('No hay parámetros para editar.',
            'Parámetros inexistentes', Advertencia);
end;

procedure TFRBuilder.btnGenerateTableSQLClick(Sender: TObject);
begin
  GenerateTableFunctionSQL;
end;

procedure TFRBuilder.btnCopyTableSQLClick(Sender: TObject);
begin
  if memTableSQL.Text <> '' then
    begin
      Clipboard.AsText := memTableSQL.Text;
      Mensaje('SQL copiado al portapapeles.',
              'Copiado al portapapeles', Informacion);
    end;
end;

end.