#+ DB schema - Constraints Management (mydatabase)

--------------------------------------------------------------------------------
--This code is generated with the template dbapp4.0
--Warning: Enter your changes within a <BLOCK> or <POINT> section, otherwise they will be lost.
{<POINT Name="user.comments">} {</POINT>}

--------------------------------------------------------------------------------
--Importing modules
IMPORT FGL libdbappCore
{<POINT Name="import">} {</POINT>}

--------------------------------------------------------------------------------
--Database schema
SCHEMA mydatabase

--------------------------------------------------------------------------------
--Functions

{<BLOCK Name="fct.transportistas_checkTableConstraints">}
#+ Check constraints on the "transportistas" table
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_data - a row data LIKE transportistas.*
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transportistas_checkTableConstraints(p_forUpdate, p_data)
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_data RECORD LIKE transportistas.*
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE l_errNo INTEGER
    DEFINE l_errMsg STRING
    {<POINT Name="fct.transportistas_checkTableConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transportistas_checkTableConstraints.init">} {</POINT>}

    {<POINT Name="fct.transportistas_checkTableConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transportistas_checkTableConstraints

{<BLOCK Name="fct.transacciones_master_checkTableConstraints">}
#+ Check constraints on the "transacciones_master" table
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_data - a row data LIKE transacciones_master.*
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_checkTableConstraints(p_forUpdate, p_data)
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_data RECORD LIKE transacciones_master.*
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE l_errNo INTEGER
    DEFINE l_errMsg STRING
    {<POINT Name="fct.transacciones_master_checkTableConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_master_checkTableConstraints.init">} {</POINT>}

    CALL mydatabase_dbxconstraints_transacciones_master_num_doc_checkColumnConstraints(p_data.num_doc) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_master_cod_mov_checkColumnConstraints(p_data.cod_mov) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_master_num_oc_checkColumnConstraints(p_data.num_oc) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_master_orden_compra_checkColumnConstraints(p_data.orden_compra) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_master_conduce_no_checkColumnConstraints(p_data.conduce_no) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_master_cod_sp_checkColumnConstraints(p_data.cod_sp) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_master_cod_sp_Sec_checkColumnConstraints(p_data.cod_sp_Sec) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_master_num_req_checkColumnConstraints(p_data.num_req) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_master_sec_vend_checkColumnConstraints(p_data.sec_vend) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_master_bodega_checkColumnConstraints(p_data.bodega) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_master_bodega_d_checkColumnConstraints(p_data.bodega_d) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    CALL mydatabase_dbxconstraints_transacciones_master_PK_transacciones_master_1_checkUniqueConstraint(p_forUpdate, p_data.num_doc, p_data.cod_mov, p_data.bodega) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    {<POINT Name="fct.transacciones_master_checkTableConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_checkTableConstraints

{<BLOCK Name="fct.transacciones_master_PK_transacciones_master_1_checkUniqueConstraint">}
#+ Check the primary key uniqueness constraint on the "transacciones_master"
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_key - Primary Key
#+
#+ @returnType INTEGER, STRING, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_PK_transacciones_master_1_checkUniqueConstraint(p_forUpdate, p_key)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_key
        RECORD
            transacciones_master_num_doc LIKE transacciones_master.num_doc,
            transacciones_master_cod_mov LIKE transacciones_master.cod_mov,
            transacciones_master_bodega LIKE transacciones_master.bodega
        END RECORD
    DEFINE l_key
        RECORD
            transacciones_master_num_doc LIKE transacciones_master.num_doc,
            transacciones_master_cod_mov LIKE transacciones_master.cod_mov,
            transacciones_master_bodega LIKE transacciones_master.bodega
        END RECORD
    DEFINE l_where STRING
    DEFINE l_where_num_doc STRING
    DEFINE l_where_cod_mov STRING
    DEFINE l_where_bodega STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.transacciones_master_PK_transacciones_master_1_checkUniqueConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    LET l_where_num_doc = IIF(p_key.transacciones_master_num_doc IS NULL, " OR transacciones_master.num_doc IS NULL", "")
    LET l_where_cod_mov = IIF(p_key.transacciones_master_cod_mov IS NULL, " OR transacciones_master.cod_mov IS NULL", "")
    LET l_where_bodega = IIF(p_key.transacciones_master_bodega IS NULL, " OR transacciones_master.bodega IS NULL", "")
    LET l_where = "WHERE ( transacciones_master.num_doc = ?", l_where_num_doc, " )",
                    " AND ( transacciones_master.cod_mov = ?", l_where_cod_mov, " )",
                    " AND ( transacciones_master.bodega = ?", l_where_bodega, " ) "
    LET l_sqlQuery = "SELECT COUNT(*), num_doc, cod_mov, bodega FROM transacciones_master ", l_where, " GROUP BY num_doc, cod_mov, bodega"
    {<POINT Name="fct.transacciones_master_PK_transacciones_master_1_checkUniqueConstraint.init">} {</POINT>}
    TRY
        PREPARE cur_transacciones_master_PK_transacciones_master_1_checkUniqueConstraint FROM l_sqlQuery
        EXECUTE cur_transacciones_master_PK_transacciones_master_1_checkUniqueConstraint USING p_key.* INTO l_count, l_key.*
        FREE cur_transacciones_master_PK_transacciones_master_1_checkUniqueConstraint
        IF (NOT p_forUpdate AND l_count > 0) OR (p_forUpdate AND l_count > 0 AND p_key.* != l_key.*) THEN
            CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- num_doc + cod_mov + bodega: " || ERROR_BAM_00002) RETURNING errNo, errMsg
        END IF
    CATCH
        LET errNo = ERROR_FAILURE
    END TRY
    {<POINT Name="fct.transacciones_master_PK_transacciones_master_1_checkUniqueConstraint.user">} {</POINT>}

    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_PK_transacciones_master_1_checkUniqueConstraint

{<BLOCK Name="fct.transacciones_master_num_doc_checkColumnConstraints">}
#+ Check constraints on the "transacciones_master.num_doc" column
#+
#+ @param p_num_doc - INTEGER - num_doc
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_num_doc_checkColumnConstraints(p_num_doc)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_num_doc LIKE transacciones_master.num_doc
    {<POINT Name="fct.transacciones_master_num_doc_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_master_num_doc_checkColumnConstraints.init">} {</POINT>}
    IF p_num_doc IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- num_doc: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_master_num_doc_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_num_doc_checkColumnConstraints

{<BLOCK Name="fct.transacciones_master_cod_mov_checkColumnConstraints">}
#+ Check constraints on the "transacciones_master.cod_mov" column
#+
#+ @param p_cod_mov - SMALLINT - cod_mov
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_cod_mov_checkColumnConstraints(p_cod_mov)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_mov LIKE transacciones_master.cod_mov
    {<POINT Name="fct.transacciones_master_cod_mov_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_master_cod_mov_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_mov IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_mov: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_master_cod_mov_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_cod_mov_checkColumnConstraints

{<BLOCK Name="fct.transacciones_master_num_oc_checkColumnConstraints">}
#+ Check constraints on the "transacciones_master.num_oc" column
#+
#+ @param p_num_oc - INTEGER - num_oc
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_num_oc_checkColumnConstraints(p_num_oc)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_num_oc LIKE transacciones_master.num_oc
    {<POINT Name="fct.transacciones_master_num_oc_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_master_num_oc_checkColumnConstraints.init">} {</POINT>}
    IF p_num_oc IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- num_oc: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_master_num_oc_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_num_oc_checkColumnConstraints

{<BLOCK Name="fct.transacciones_master_orden_compra_checkColumnConstraints">}
#+ Check constraints on the "transacciones_master.orden_compra" column
#+
#+ @param p_orden_compra - INTEGER - orden_compra
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_orden_compra_checkColumnConstraints(p_orden_compra)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_orden_compra LIKE transacciones_master.orden_compra
    {<POINT Name="fct.transacciones_master_orden_compra_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_master_orden_compra_checkColumnConstraints.init">} {</POINT>}
    IF p_orden_compra IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- orden_compra: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_master_orden_compra_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_orden_compra_checkColumnConstraints

{<BLOCK Name="fct.transacciones_master_conduce_no_checkColumnConstraints">}
#+ Check constraints on the "transacciones_master.conduce_no" column
#+
#+ @param p_conduce_no - CHAR(25) - conduce_no
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_conduce_no_checkColumnConstraints(p_conduce_no)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_conduce_no LIKE transacciones_master.conduce_no
    {<POINT Name="fct.transacciones_master_conduce_no_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_master_conduce_no_checkColumnConstraints.init">} {</POINT>}
    IF p_conduce_no IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- conduce_no: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_master_conduce_no_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_conduce_no_checkColumnConstraints

{<BLOCK Name="fct.transacciones_master_cod_sp_checkColumnConstraints">}
#+ Check constraints on the "transacciones_master.cod_sp" column
#+
#+ @param p_cod_sp - SMALLINT - cod_sp
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_cod_sp_checkColumnConstraints(p_cod_sp)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_sp LIKE transacciones_master.cod_sp
    {<POINT Name="fct.transacciones_master_cod_sp_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_master_cod_sp_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_sp IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_sp: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_master_cod_sp_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_cod_sp_checkColumnConstraints

{<BLOCK Name="fct.transacciones_master_cod_sp_Sec_checkColumnConstraints">}
#+ Check constraints on the "transacciones_master.cod_sp_Sec" column
#+
#+ @param p_cod_sp_Sec - INTEGER - cod_sp_Sec
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_cod_sp_Sec_checkColumnConstraints(p_cod_sp_Sec)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_sp_Sec LIKE transacciones_master.cod_sp_Sec
    {<POINT Name="fct.transacciones_master_cod_sp_Sec_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_master_cod_sp_Sec_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_sp_Sec IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_sp_Sec: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_master_cod_sp_Sec_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_cod_sp_Sec_checkColumnConstraints

{<BLOCK Name="fct.transacciones_master_num_req_checkColumnConstraints">}
#+ Check constraints on the "transacciones_master.num_req" column
#+
#+ @param p_num_req - INTEGER - num_req
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_num_req_checkColumnConstraints(p_num_req)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_num_req LIKE transacciones_master.num_req
    {<POINT Name="fct.transacciones_master_num_req_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_master_num_req_checkColumnConstraints.init">} {</POINT>}
    IF p_num_req IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- num_req: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_master_num_req_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_num_req_checkColumnConstraints

{<BLOCK Name="fct.transacciones_master_sec_vend_checkColumnConstraints">}
#+ Check constraints on the "transacciones_master.sec_vend" column
#+
#+ @param p_sec_vend - SMALLINT - sec_vend
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_sec_vend_checkColumnConstraints(p_sec_vend)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_sec_vend LIKE transacciones_master.sec_vend
    {<POINT Name="fct.transacciones_master_sec_vend_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_master_sec_vend_checkColumnConstraints.init">} {</POINT>}
    IF p_sec_vend IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- sec_vend: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_master_sec_vend_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_sec_vend_checkColumnConstraints

{<BLOCK Name="fct.transacciones_master_bodega_checkColumnConstraints">}
#+ Check constraints on the "transacciones_master.bodega" column
#+
#+ @param p_bodega - SMALLINT - bodega
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_bodega_checkColumnConstraints(p_bodega)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_bodega LIKE transacciones_master.bodega
    {<POINT Name="fct.transacciones_master_bodega_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_master_bodega_checkColumnConstraints.init">} {</POINT>}
    IF p_bodega IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- bodega: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_master_bodega_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_bodega_checkColumnConstraints

{<BLOCK Name="fct.transacciones_master_bodega_d_checkColumnConstraints">}
#+ Check constraints on the "transacciones_master.bodega_d" column
#+
#+ @param p_bodega_d - SMALLINT - bodega_d
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_bodega_d_checkColumnConstraints(p_bodega_d)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_bodega_d LIKE transacciones_master.bodega_d
    {<POINT Name="fct.transacciones_master_bodega_d_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_master_bodega_d_checkColumnConstraints.init">} {</POINT>}
    IF p_bodega_d IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- bodega_d: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_master_bodega_d_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_bodega_d_checkColumnConstraints

{<BLOCK Name="fct.transacciones_master_PK_transacciones_master_1_checkFKConstraint">}
#+ Check the Foreign Key existence constraint on the "transacciones_master"
#+
#+ @param p_data - Primary Key
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_master_PK_transacciones_master_1_checkFKConstraint(p_data)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_data
        RECORD
            transacciones_master_num_doc LIKE transacciones_master.num_doc,
            transacciones_master_cod_mov LIKE transacciones_master.cod_mov,
            transacciones_master_bodega LIKE transacciones_master.bodega
        END RECORD
    DEFINE l_where STRING
    DEFINE l_where_num_doc STRING
    DEFINE l_where_cod_mov STRING
    DEFINE l_where_bodega STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.transacciones_master_PK_transacciones_master_1_checkFKConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    IF NOT (p_data.transacciones_master_num_doc IS NULL AND p_data.transacciones_master_cod_mov IS NULL AND p_data.transacciones_master_bodega IS NULL) THEN
        LET l_where_num_doc = IIF(p_data.transacciones_master_num_doc IS NULL, " OR transacciones_master.num_doc IS NULL", "")
    LET l_where_cod_mov = IIF(p_data.transacciones_master_cod_mov IS NULL, " OR transacciones_master.cod_mov IS NULL", "")
    LET l_where_bodega = IIF(p_data.transacciones_master_bodega IS NULL, " OR transacciones_master.bodega IS NULL", "")
        LET l_where = "WHERE ( transacciones_master.num_doc = ?", l_where_num_doc, " )",
                    " AND ( transacciones_master.cod_mov = ?", l_where_cod_mov, " )",
                    " AND ( transacciones_master.bodega = ?", l_where_bodega, " ) "
        LET l_sqlQuery = "SELECT COUNT(*) FROM transacciones_master ", l_where
        {<POINT Name="fct.transacciones_master_PK_transacciones_master_1_checkFKConstraint.init">} {</POINT>}
        TRY
            PREPARE cur_transacciones_master_PK_transacciones_master_1_checkFKConstraint FROM l_sqlQuery
            EXECUTE cur_transacciones_master_PK_transacciones_master_1_checkFKConstraint USING p_data.* INTO l_count
            FREE cur_transacciones_master_PK_transacciones_master_1_checkFKConstraint
            IF (l_count == 0) THEN
                CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- num_doc + cod_mov + bodega: " || ERROR_BAM_00004) RETURNING errNo, errMsg
            END IF
        CATCH
            LET errNo = ERROR_FAILURE
        END TRY
    END IF
    {<POINT Name="fct.transacciones_master_PK_transacciones_master_1_checkFKConstraint.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_master_PK_transacciones_master_1_checkFKConstraint

{<BLOCK Name="fct.transacciones_checkTableConstraints">}
#+ Check constraints on the "transacciones" table
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_data - a row data LIKE transacciones.*
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_checkTableConstraints(p_forUpdate, p_data)
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_data RECORD LIKE transacciones.*
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE l_errNo INTEGER
    DEFINE l_errMsg STRING
    {<POINT Name="fct.transacciones_checkTableConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_checkTableConstraints.init">} {</POINT>}

    CALL mydatabase_dbxconstraints_transacciones_num_doc_checkColumnConstraints(p_data.num_doc) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_num_oc_checkColumnConstraints(p_data.num_oc) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_orden_compra_checkColumnConstraints(p_data.orden_compra) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_conduce_no_checkColumnConstraints(p_data.conduce_no) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_cod_sp_checkColumnConstraints(p_data.cod_sp) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_cod_sp_sec_checkColumnConstraints(p_data.cod_sp_sec) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_area_checkColumnConstraints(p_data.area) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_cod_n_checkColumnConstraints(p_data.cod_n) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_cod_grupo_checkColumnConstraints(p_data.cod_grupo) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_cod_tipo_checkColumnConstraints(p_data.cod_tipo) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_cod_sec_checkColumnConstraints(p_data.cod_sec) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_cantidad_1_checkColumnConstraints(p_data.cantidad_1) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_cantidad_2_checkColumnConstraints(p_data.cantidad_2) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_cod_mov_checkColumnConstraints(p_data.cod_mov) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_bodega_checkColumnConstraints(p_data.bodega) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_descripcion_bodega_checkColumnConstraints(p_data.descripcion_bodega) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_codid_checkColumnConstraints(p_data.codid) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_fecha_checkColumnConstraints(p_data.fecha) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_num_req_checkColumnConstraints(p_data.num_req) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_sec_Vend_checkColumnConstraints(p_data.sec_Vend) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_direccion_checkColumnConstraints(p_data.direccion) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_bodega_d_checkColumnConstraints(p_data.bodega_d) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_transacciones_codigo_bloque_checkColumnConstraints(p_data.codigo_bloque) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    CALL mydatabase_dbxconstraints_transacciones_IDX_existencia_1_checkUniqueConstraint(p_forUpdate, p_data.num_doc, p_data.area, p_data.codid) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    {<POINT Name="fct.transacciones_checkTableConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_checkTableConstraints

{<BLOCK Name="fct.transacciones_IDX_existencia_1_checkUniqueConstraint">}
#+ Check the primary key uniqueness constraint on the "transacciones"
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_key - Primary Key
#+
#+ @returnType INTEGER, STRING, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_IDX_existencia_1_checkUniqueConstraint(p_forUpdate, p_key)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_key
        RECORD
            transacciones_num_doc LIKE transacciones.num_doc,
            transacciones_area LIKE transacciones.area,
            transacciones_codid LIKE transacciones.codid
        END RECORD
    DEFINE l_key
        RECORD
            transacciones_num_doc LIKE transacciones.num_doc,
            transacciones_area LIKE transacciones.area,
            transacciones_codid LIKE transacciones.codid
        END RECORD
    DEFINE l_where STRING
    DEFINE l_where_num_doc STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.transacciones_IDX_existencia_1_checkUniqueConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    LET l_where_num_doc = IIF(p_key.transacciones_num_doc IS NULL, " OR transacciones.num_doc IS NULL", "")
    LET l_where = "WHERE ( transacciones.num_doc = ?", l_where_num_doc, " )",
                    " AND transacciones.area = ?",
                    " AND transacciones.codid = ? "
    LET l_sqlQuery = "SELECT COUNT(*), num_doc, area, codid FROM transacciones ", l_where, " GROUP BY num_doc, area, codid"
    {<POINT Name="fct.transacciones_IDX_existencia_1_checkUniqueConstraint.init">} {</POINT>}
    TRY
        PREPARE cur_transacciones_IDX_existencia_1_checkUniqueConstraint FROM l_sqlQuery
        EXECUTE cur_transacciones_IDX_existencia_1_checkUniqueConstraint USING p_key.* INTO l_count, l_key.*
        FREE cur_transacciones_IDX_existencia_1_checkUniqueConstraint
        IF (NOT p_forUpdate AND l_count > 0) OR (p_forUpdate AND l_count > 0 AND p_key.* != l_key.*) THEN
            CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- num_doc + area + codid: " || ERROR_BAM_00002) RETURNING errNo, errMsg
        END IF
    CATCH
        LET errNo = ERROR_FAILURE
    END TRY
    {<POINT Name="fct.transacciones_IDX_existencia_1_checkUniqueConstraint.user">} {</POINT>}

    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_IDX_existencia_1_checkUniqueConstraint

{<BLOCK Name="fct.transacciones_num_doc_checkColumnConstraints">}
#+ Check constraints on the "transacciones.num_doc" column
#+
#+ @param p_num_doc - INTEGER - num_doc
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_num_doc_checkColumnConstraints(p_num_doc)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_num_doc LIKE transacciones.num_doc
    {<POINT Name="fct.transacciones_num_doc_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_num_doc_checkColumnConstraints.init">} {</POINT>}
    IF p_num_doc IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- num_doc: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_num_doc_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_num_doc_checkColumnConstraints

{<BLOCK Name="fct.transacciones_num_oc_checkColumnConstraints">}
#+ Check constraints on the "transacciones.num_oc" column
#+
#+ @param p_num_oc - INTEGER - num_oc
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_num_oc_checkColumnConstraints(p_num_oc)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_num_oc LIKE transacciones.num_oc
    {<POINT Name="fct.transacciones_num_oc_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_num_oc_checkColumnConstraints.init">} {</POINT>}
    IF p_num_oc IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- num_oc: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_num_oc_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_num_oc_checkColumnConstraints

{<BLOCK Name="fct.transacciones_orden_compra_checkColumnConstraints">}
#+ Check constraints on the "transacciones.orden_compra" column
#+
#+ @param p_orden_compra - INTEGER - orden_compra
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_orden_compra_checkColumnConstraints(p_orden_compra)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_orden_compra LIKE transacciones.orden_compra
    {<POINT Name="fct.transacciones_orden_compra_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_orden_compra_checkColumnConstraints.init">} {</POINT>}
    IF p_orden_compra IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- orden_compra: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_orden_compra_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_orden_compra_checkColumnConstraints

{<BLOCK Name="fct.transacciones_conduce_no_checkColumnConstraints">}
#+ Check constraints on the "transacciones.conduce_no" column
#+
#+ @param p_conduce_no - CHAR(25) - conduce_no
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_conduce_no_checkColumnConstraints(p_conduce_no)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_conduce_no LIKE transacciones.conduce_no
    {<POINT Name="fct.transacciones_conduce_no_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_conduce_no_checkColumnConstraints.init">} {</POINT>}
    IF p_conduce_no IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- conduce_no: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_conduce_no_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_conduce_no_checkColumnConstraints

{<BLOCK Name="fct.transacciones_cod_sp_checkColumnConstraints">}
#+ Check constraints on the "transacciones.cod_sp" column
#+
#+ @param p_cod_sp - SMALLINT - cod_sp
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_cod_sp_checkColumnConstraints(p_cod_sp)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_sp LIKE transacciones.cod_sp
    {<POINT Name="fct.transacciones_cod_sp_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_cod_sp_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_sp IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_sp: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_cod_sp_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_cod_sp_checkColumnConstraints

{<BLOCK Name="fct.transacciones_cod_sp_sec_checkColumnConstraints">}
#+ Check constraints on the "transacciones.cod_sp_sec" column
#+
#+ @param p_cod_sp_sec - INTEGER - cod_sp_sec
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_cod_sp_sec_checkColumnConstraints(p_cod_sp_sec)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_sp_sec LIKE transacciones.cod_sp_sec
    {<POINT Name="fct.transacciones_cod_sp_sec_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_cod_sp_sec_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_sp_sec IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_sp_sec: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_cod_sp_sec_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_cod_sp_sec_checkColumnConstraints

{<BLOCK Name="fct.transacciones_area_checkColumnConstraints">}
#+ Check constraints on the "transacciones.area" column
#+
#+ @param p_area - SMALLINT - area
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_area_checkColumnConstraints(p_area)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_area LIKE transacciones.area
    {<POINT Name="fct.transacciones_area_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_area_checkColumnConstraints.init">} {</POINT>}
    IF p_area IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- area: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_area_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_area_checkColumnConstraints

{<BLOCK Name="fct.transacciones_cod_n_checkColumnConstraints">}
#+ Check constraints on the "transacciones.cod_n" column
#+
#+ @param p_cod_n - SMALLINT - cod_n
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_cod_n_checkColumnConstraints(p_cod_n)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_n LIKE transacciones.cod_n
    {<POINT Name="fct.transacciones_cod_n_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_cod_n_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_n IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_n: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_cod_n_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_cod_n_checkColumnConstraints

{<BLOCK Name="fct.transacciones_cod_grupo_checkColumnConstraints">}
#+ Check constraints on the "transacciones.cod_grupo" column
#+
#+ @param p_cod_grupo - SMALLINT - cod_grupo
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_cod_grupo_checkColumnConstraints(p_cod_grupo)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_grupo LIKE transacciones.cod_grupo
    {<POINT Name="fct.transacciones_cod_grupo_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_cod_grupo_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_grupo IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_grupo: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_cod_grupo_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_cod_grupo_checkColumnConstraints

{<BLOCK Name="fct.transacciones_cod_tipo_checkColumnConstraints">}
#+ Check constraints on the "transacciones.cod_tipo" column
#+
#+ @param p_cod_tipo - SMALLINT - cod_tipo
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_cod_tipo_checkColumnConstraints(p_cod_tipo)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_tipo LIKE transacciones.cod_tipo
    {<POINT Name="fct.transacciones_cod_tipo_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_cod_tipo_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_tipo IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_tipo: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_cod_tipo_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_cod_tipo_checkColumnConstraints

{<BLOCK Name="fct.transacciones_cod_sec_checkColumnConstraints">}
#+ Check constraints on the "transacciones.cod_sec" column
#+
#+ @param p_cod_sec - SMALLINT - cod_sec
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_cod_sec_checkColumnConstraints(p_cod_sec)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_sec LIKE transacciones.cod_sec
    {<POINT Name="fct.transacciones_cod_sec_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_cod_sec_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_sec IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_sec: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_cod_sec_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_cod_sec_checkColumnConstraints

{<BLOCK Name="fct.transacciones_cantidad_1_checkColumnConstraints">}
#+ Check constraints on the "transacciones.cantidad_1" column
#+
#+ @param p_cantidad_1 - DECIMAL(12,5) - cantidad_1
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_cantidad_1_checkColumnConstraints(p_cantidad_1)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cantidad_1 LIKE transacciones.cantidad_1
    {<POINT Name="fct.transacciones_cantidad_1_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_cantidad_1_checkColumnConstraints.init">} {</POINT>}
    IF p_cantidad_1 IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cantidad_1: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_cantidad_1_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_cantidad_1_checkColumnConstraints

{<BLOCK Name="fct.transacciones_cantidad_2_checkColumnConstraints">}
#+ Check constraints on the "transacciones.cantidad_2" column
#+
#+ @param p_cantidad_2 - DECIMAL(12,5) - cantidad_2
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_cantidad_2_checkColumnConstraints(p_cantidad_2)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cantidad_2 LIKE transacciones.cantidad_2
    {<POINT Name="fct.transacciones_cantidad_2_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_cantidad_2_checkColumnConstraints.init">} {</POINT>}
    IF p_cantidad_2 IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cantidad_2: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_cantidad_2_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_cantidad_2_checkColumnConstraints

{<BLOCK Name="fct.transacciones_cod_mov_checkColumnConstraints">}
#+ Check constraints on the "transacciones.cod_mov" column
#+
#+ @param p_cod_mov - SMALLINT - cod_mov
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_cod_mov_checkColumnConstraints(p_cod_mov)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_mov LIKE transacciones.cod_mov
    {<POINT Name="fct.transacciones_cod_mov_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_cod_mov_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_mov IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_mov: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_cod_mov_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_cod_mov_checkColumnConstraints

{<BLOCK Name="fct.transacciones_bodega_checkColumnConstraints">}
#+ Check constraints on the "transacciones.bodega" column
#+
#+ @param p_bodega - SMALLINT - bodega
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_bodega_checkColumnConstraints(p_bodega)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_bodega LIKE transacciones.bodega
    {<POINT Name="fct.transacciones_bodega_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_bodega_checkColumnConstraints.init">} {</POINT>}
    IF p_bodega IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- bodega: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_bodega_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_bodega_checkColumnConstraints

{<BLOCK Name="fct.transacciones_descripcion_bodega_checkColumnConstraints">}
#+ Check constraints on the "transacciones.descripcion_bodega" column
#+
#+ @param p_descripcion_bodega - CHAR(30) - descripcion_bodega
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_descripcion_bodega_checkColumnConstraints(p_descripcion_bodega)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_descripcion_bodega LIKE transacciones.descripcion_bodega
    {<POINT Name="fct.transacciones_descripcion_bodega_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_descripcion_bodega_checkColumnConstraints.init">} {</POINT>}
    IF p_descripcion_bodega IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- descripcion_bodega: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_descripcion_bodega_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_descripcion_bodega_checkColumnConstraints

{<BLOCK Name="fct.transacciones_codid_checkColumnConstraints">}
#+ Check constraints on the "transacciones.codid" column
#+
#+ @param p_codid - BIGINT - codid
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_codid_checkColumnConstraints(p_codid)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_codid LIKE transacciones.codid
    {<POINT Name="fct.transacciones_codid_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_codid_checkColumnConstraints.init">} {</POINT>}
    IF p_codid IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- codid: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_codid_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_codid_checkColumnConstraints

{<BLOCK Name="fct.transacciones_fecha_checkColumnConstraints">}
#+ Check constraints on the "transacciones.fecha" column
#+
#+ @param p_fecha - DATE - fecha
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_fecha_checkColumnConstraints(p_fecha)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_fecha LIKE transacciones.fecha
    {<POINT Name="fct.transacciones_fecha_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_fecha_checkColumnConstraints.init">} {</POINT>}
    IF p_fecha IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- fecha: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_fecha_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_fecha_checkColumnConstraints

{<BLOCK Name="fct.transacciones_num_req_checkColumnConstraints">}
#+ Check constraints on the "transacciones.num_req" column
#+
#+ @param p_num_req - INTEGER - num_req
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_num_req_checkColumnConstraints(p_num_req)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_num_req LIKE transacciones.num_req
    {<POINT Name="fct.transacciones_num_req_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_num_req_checkColumnConstraints.init">} {</POINT>}
    IF p_num_req IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- num_req: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_num_req_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_num_req_checkColumnConstraints

{<BLOCK Name="fct.transacciones_sec_Vend_checkColumnConstraints">}
#+ Check constraints on the "transacciones.sec_Vend" column
#+
#+ @param p_sec_Vend - SMALLINT - sec_Vend
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_sec_Vend_checkColumnConstraints(p_sec_Vend)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_sec_Vend LIKE transacciones.sec_Vend
    {<POINT Name="fct.transacciones_sec_Vend_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_sec_Vend_checkColumnConstraints.init">} {</POINT>}
    IF p_sec_Vend IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- sec_Vend: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_sec_Vend_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_sec_Vend_checkColumnConstraints

{<BLOCK Name="fct.transacciones_direccion_checkColumnConstraints">}
#+ Check constraints on the "transacciones.direccion" column
#+
#+ @param p_direccion - CHAR(500) - direccion
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_direccion_checkColumnConstraints(p_direccion)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_direccion LIKE transacciones.direccion
    {<POINT Name="fct.transacciones_direccion_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_direccion_checkColumnConstraints.init">} {</POINT>}
    IF p_direccion IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- direccion: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_direccion_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_direccion_checkColumnConstraints

{<BLOCK Name="fct.transacciones_bodega_d_checkColumnConstraints">}
#+ Check constraints on the "transacciones.bodega_d" column
#+
#+ @param p_bodega_d - SMALLINT - bodega_d
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_bodega_d_checkColumnConstraints(p_bodega_d)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_bodega_d LIKE transacciones.bodega_d
    {<POINT Name="fct.transacciones_bodega_d_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_bodega_d_checkColumnConstraints.init">} {</POINT>}
    IF p_bodega_d IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- bodega_d: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_bodega_d_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_bodega_d_checkColumnConstraints

{<BLOCK Name="fct.transacciones_codigo_bloque_checkColumnConstraints">}
#+ Check constraints on the "transacciones.codigo_bloque" column
#+
#+ @param p_codigo_bloque - CHAR(25) - codigo_bloque
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_codigo_bloque_checkColumnConstraints(p_codigo_bloque)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_codigo_bloque LIKE transacciones.codigo_bloque
    {<POINT Name="fct.transacciones_codigo_bloque_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.transacciones_codigo_bloque_checkColumnConstraints.init">} {</POINT>}
    IF p_codigo_bloque IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- codigo_bloque: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.transacciones_codigo_bloque_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_codigo_bloque_checkColumnConstraints

{<BLOCK Name="fct.transacciones_IDX_existencia_1_checkFKConstraint">}
#+ Check the Foreign Key existence constraint on the "transacciones"
#+
#+ @param p_data - Primary Key
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_transacciones_IDX_existencia_1_checkFKConstraint(p_data)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_data
        RECORD
            transacciones_num_doc LIKE transacciones.num_doc,
            transacciones_area LIKE transacciones.area,
            transacciones_codid LIKE transacciones.codid
        END RECORD
    DEFINE l_where STRING
    DEFINE l_where_num_doc STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.transacciones_IDX_existencia_1_checkFKConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    IF NOT (p_data.transacciones_num_doc IS NULL AND p_data.transacciones_area IS NULL AND p_data.transacciones_codid IS NULL) THEN
        LET l_where_num_doc = IIF(p_data.transacciones_num_doc IS NULL, " OR transacciones.num_doc IS NULL", "")
        LET l_where = "WHERE ( transacciones.num_doc = ?", l_where_num_doc, " )",
                    " AND transacciones.area = ?",
                    " AND transacciones.codid = ? "
        LET l_sqlQuery = "SELECT COUNT(*) FROM transacciones ", l_where
        {<POINT Name="fct.transacciones_IDX_existencia_1_checkFKConstraint.init">} {</POINT>}
        TRY
            PREPARE cur_transacciones_IDX_existencia_1_checkFKConstraint FROM l_sqlQuery
            EXECUTE cur_transacciones_IDX_existencia_1_checkFKConstraint USING p_data.* INTO l_count
            FREE cur_transacciones_IDX_existencia_1_checkFKConstraint
            IF (l_count == 0) THEN
                CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- num_doc + area + codid: " || ERROR_BAM_00004) RETURNING errNo, errMsg
            END IF
        CATCH
            LET errNo = ERROR_FAILURE
        END TRY
    END IF
    {<POINT Name="fct.transacciones_IDX_existencia_1_checkFKConstraint.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.transacciones_IDX_existencia_1_checkFKConstraint

{<BLOCK Name="fct.seqreg_checkTableConstraints">}
#+ Check constraints on the "seqreg" table
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_data - a row data LIKE seqreg.*
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_seqreg_checkTableConstraints(p_forUpdate, p_data)
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_data RECORD LIKE seqreg.*
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE l_errNo INTEGER
    DEFINE l_errMsg STRING
    {<POINT Name="fct.seqreg_checkTableConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.seqreg_checkTableConstraints.init">} {</POINT>}

    CALL mydatabase_dbxconstraints_seqreg_sr_name_checkColumnConstraints(p_data.sr_name) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_seqreg_sr_last_checkColumnConstraints(p_data.sr_last) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    CALL mydatabase_dbxconstraints_seqreg_pk_seqreg_checkUniqueConstraint(p_forUpdate, p_data.sr_name) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    {<POINT Name="fct.seqreg_checkTableConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.seqreg_checkTableConstraints

{<BLOCK Name="fct.seqreg_pk_seqreg_checkUniqueConstraint">}
#+ Check the primary key uniqueness constraint on the "seqreg"
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_key - Primary Key
#+
#+ @returnType INTEGER, STRING, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_seqreg_pk_seqreg_checkUniqueConstraint(p_forUpdate, p_key)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_key
        RECORD
            seqreg_sr_name LIKE seqreg.sr_name
        END RECORD
    DEFINE l_key
        RECORD
            seqreg_sr_name LIKE seqreg.sr_name
        END RECORD
    DEFINE l_where STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.seqreg_pk_seqreg_checkUniqueConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    LET l_where = "WHERE seqreg.sr_name = ? "
    LET l_sqlQuery = "SELECT COUNT(*), sr_name FROM seqreg ", l_where, " GROUP BY sr_name"
    {<POINT Name="fct.seqreg_pk_seqreg_checkUniqueConstraint.init">} {</POINT>}
    TRY
        PREPARE cur_seqreg_pk_seqreg_checkUniqueConstraint FROM l_sqlQuery
        EXECUTE cur_seqreg_pk_seqreg_checkUniqueConstraint USING p_key.* INTO l_count, l_key.*
        FREE cur_seqreg_pk_seqreg_checkUniqueConstraint
        IF (NOT p_forUpdate AND l_count > 0) OR (p_forUpdate AND l_count > 0 AND p_key.* != l_key.*) THEN
            CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- sr_name: " || ERROR_BAM_00002) RETURNING errNo, errMsg
        END IF
    CATCH
        LET errNo = ERROR_FAILURE
    END TRY
    {<POINT Name="fct.seqreg_pk_seqreg_checkUniqueConstraint.user">} {</POINT>}

    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.seqreg_pk_seqreg_checkUniqueConstraint

{<BLOCK Name="fct.seqreg_sr_name_checkColumnConstraints">}
#+ Check constraints on the "seqreg.sr_name" column
#+
#+ @param p_sr_name - VARCHAR(30) - sr_name
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_seqreg_sr_name_checkColumnConstraints(p_sr_name)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_sr_name LIKE seqreg.sr_name
    {<POINT Name="fct.seqreg_sr_name_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.seqreg_sr_name_checkColumnConstraints.init">} {</POINT>}
    IF p_sr_name IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- sr_name: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.seqreg_sr_name_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.seqreg_sr_name_checkColumnConstraints

{<BLOCK Name="fct.seqreg_sr_last_checkColumnConstraints">}
#+ Check constraints on the "seqreg.sr_last" column
#+
#+ @param p_sr_last - INTEGER - sr_last
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_seqreg_sr_last_checkColumnConstraints(p_sr_last)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_sr_last LIKE seqreg.sr_last
    {<POINT Name="fct.seqreg_sr_last_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.seqreg_sr_last_checkColumnConstraints.init">} {</POINT>}
    IF p_sr_last IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- sr_last: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.seqreg_sr_last_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.seqreg_sr_last_checkColumnConstraints

{<BLOCK Name="fct.seqreg_pk_seqreg_checkFKConstraint">}
#+ Check the Foreign Key existence constraint on the "seqreg"
#+
#+ @param p_data - Primary Key
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_seqreg_pk_seqreg_checkFKConstraint(p_data)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_data
        RECORD
            seqreg_sr_name LIKE seqreg.sr_name
        END RECORD
    DEFINE l_where STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.seqreg_pk_seqreg_checkFKConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    IF NOT (p_data.seqreg_sr_name IS NULL) THEN
        LET l_where = "WHERE seqreg.sr_name = ? "
        LET l_sqlQuery = "SELECT COUNT(*) FROM seqreg ", l_where
        {<POINT Name="fct.seqreg_pk_seqreg_checkFKConstraint.init">} {</POINT>}
        TRY
            PREPARE cur_seqreg_pk_seqreg_checkFKConstraint FROM l_sqlQuery
            EXECUTE cur_seqreg_pk_seqreg_checkFKConstraint USING p_data.* INTO l_count
            FREE cur_seqreg_pk_seqreg_checkFKConstraint
            IF (l_count == 0) THEN
                CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- sr_name: " || ERROR_BAM_00004) RETURNING errNo, errMsg
            END IF
        CATCH
            LET errNo = ERROR_FAILURE
        END TRY
    END IF
    {<POINT Name="fct.seqreg_pk_seqreg_checkFKConstraint.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.seqreg_pk_seqreg_checkFKConstraint

{<BLOCK Name="fct.seg000_checkTableConstraints">}
#+ Check constraints on the "seg000" table
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_data - a row data LIKE seg000.*
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_seg000_checkTableConstraints(p_forUpdate, p_data)
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_data RECORD LIKE seg000.*
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE l_errNo INTEGER
    DEFINE l_errMsg STRING
    {<POINT Name="fct.seg000_checkTableConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.seg000_checkTableConstraints.init">} {</POINT>}

    CALL mydatabase_dbxconstraints_seg000_usuario_checkColumnConstraints(p_data.usuario) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    CALL mydatabase_dbxconstraints_seg000_IDX_seg000_1_checkUniqueConstraint(p_forUpdate, p_data.usuario) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    {<POINT Name="fct.seg000_checkTableConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.seg000_checkTableConstraints

{<BLOCK Name="fct.seg000_IDX_seg000_1_checkUniqueConstraint">}
#+ Check the primary key uniqueness constraint on the "seg000"
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_key - Primary Key
#+
#+ @returnType INTEGER, STRING, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_seg000_IDX_seg000_1_checkUniqueConstraint(p_forUpdate, p_key)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_key
        RECORD
            seg000_usuario LIKE seg000.usuario
        END RECORD
    DEFINE l_key
        RECORD
            seg000_usuario LIKE seg000.usuario
        END RECORD
    DEFINE l_where STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.seg000_IDX_seg000_1_checkUniqueConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    LET l_where = "WHERE seg000.usuario = ? "
    LET l_sqlQuery = "SELECT COUNT(*), usuario FROM seg000 ", l_where, " GROUP BY usuario"
    {<POINT Name="fct.seg000_IDX_seg000_1_checkUniqueConstraint.init">} {</POINT>}
    TRY
        PREPARE cur_seg000_IDX_seg000_1_checkUniqueConstraint FROM l_sqlQuery
        EXECUTE cur_seg000_IDX_seg000_1_checkUniqueConstraint USING p_key.* INTO l_count, l_key.*
        FREE cur_seg000_IDX_seg000_1_checkUniqueConstraint
        IF (NOT p_forUpdate AND l_count > 0) OR (p_forUpdate AND l_count > 0 AND p_key.* != l_key.*) THEN
            CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- usuario: " || ERROR_BAM_00002) RETURNING errNo, errMsg
        END IF
    CATCH
        LET errNo = ERROR_FAILURE
    END TRY
    {<POINT Name="fct.seg000_IDX_seg000_1_checkUniqueConstraint.user">} {</POINT>}

    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.seg000_IDX_seg000_1_checkUniqueConstraint

{<BLOCK Name="fct.seg000_usuario_checkColumnConstraints">}
#+ Check constraints on the "seg000.usuario" column
#+
#+ @param p_usuario - CHAR(50) - usuario
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_seg000_usuario_checkColumnConstraints(p_usuario)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_usuario LIKE seg000.usuario
    {<POINT Name="fct.seg000_usuario_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.seg000_usuario_checkColumnConstraints.init">} {</POINT>}
    IF p_usuario IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- usuario: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.seg000_usuario_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.seg000_usuario_checkColumnConstraints

{<BLOCK Name="fct.seg000_IDX_seg000_1_checkFKConstraint">}
#+ Check the Foreign Key existence constraint on the "seg000"
#+
#+ @param p_data - Primary Key
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_seg000_IDX_seg000_1_checkFKConstraint(p_data)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_data
        RECORD
            seg000_usuario LIKE seg000.usuario
        END RECORD
    DEFINE l_where STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.seg000_IDX_seg000_1_checkFKConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    IF NOT (p_data.seg000_usuario IS NULL) THEN
        LET l_where = "WHERE seg000.usuario = ? "
        LET l_sqlQuery = "SELECT COUNT(*) FROM seg000 ", l_where
        {<POINT Name="fct.seg000_IDX_seg000_1_checkFKConstraint.init">} {</POINT>}
        TRY
            PREPARE cur_seg000_IDX_seg000_1_checkFKConstraint FROM l_sqlQuery
            EXECUTE cur_seg000_IDX_seg000_1_checkFKConstraint USING p_data.* INTO l_count
            FREE cur_seg000_IDX_seg000_1_checkFKConstraint
            IF (l_count == 0) THEN
                CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- usuario: " || ERROR_BAM_00004) RETURNING errNo, errMsg
            END IF
        CATCH
            LET errNo = ERROR_FAILURE
        END TRY
    END IF
    {<POINT Name="fct.seg000_IDX_seg000_1_checkFKConstraint.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.seg000_IDX_seg000_1_checkFKConstraint

{<BLOCK Name="fct.productos_checkTableConstraints">}
#+ Check constraints on the "productos" table
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_data - a row data LIKE productos.*
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_productos_checkTableConstraints(p_forUpdate, p_data)
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_data RECORD LIKE productos.*
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE l_errNo INTEGER
    DEFINE l_errMsg STRING
    {<POINT Name="fct.productos_checkTableConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.productos_checkTableConstraints.init">} {</POINT>}

    CALL mydatabase_dbxconstraints_productos_cod_n_checkColumnConstraints(p_data.cod_n) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_productos_cod_grupo_checkColumnConstraints(p_data.cod_grupo) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_productos_cod_tipo_checkColumnConstraints(p_data.cod_tipo) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_productos_cod_sec_checkColumnConstraints(p_data.cod_sec) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_productos_descrip_esp_checkColumnConstraints(p_data.descrip_esp) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_productos_unidad_med_checkColumnConstraints(p_data.unidad_med) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    CALL mydatabase_dbxconstraints_productos_IDX_productos_1_checkUniqueConstraint(p_forUpdate, p_data.cod_grupo, p_data.cod_n, p_data.cod_sec, p_data.cod_tipo) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    {<POINT Name="fct.productos_checkTableConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.productos_checkTableConstraints

{<BLOCK Name="fct.productos_IDX_productos_1_checkUniqueConstraint">}
#+ Check the primary key uniqueness constraint on the "productos"
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_key - Primary Key
#+
#+ @returnType INTEGER, STRING, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_productos_IDX_productos_1_checkUniqueConstraint(p_forUpdate, p_key)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_key
        RECORD
            productos_cod_grupo LIKE productos.cod_grupo,
            productos_cod_n LIKE productos.cod_n,
            productos_cod_sec LIKE productos.cod_sec,
            productos_cod_tipo LIKE productos.cod_tipo
        END RECORD
    DEFINE l_key
        RECORD
            productos_cod_grupo LIKE productos.cod_grupo,
            productos_cod_n LIKE productos.cod_n,
            productos_cod_sec LIKE productos.cod_sec,
            productos_cod_tipo LIKE productos.cod_tipo
        END RECORD
    DEFINE l_where STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.productos_IDX_productos_1_checkUniqueConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    LET l_where = "WHERE productos.cod_grupo = ?",
                    " AND productos.cod_n = ?",
                    " AND productos.cod_sec = ?",
                    " AND productos.cod_tipo = ? "
    LET l_sqlQuery = "SELECT COUNT(*), cod_grupo, cod_n, cod_sec, cod_tipo FROM productos ", l_where, " GROUP BY cod_grupo, cod_n, cod_sec, cod_tipo"
    {<POINT Name="fct.productos_IDX_productos_1_checkUniqueConstraint.init">} {</POINT>}
    TRY
        PREPARE cur_productos_IDX_productos_1_checkUniqueConstraint FROM l_sqlQuery
        EXECUTE cur_productos_IDX_productos_1_checkUniqueConstraint USING p_key.* INTO l_count, l_key.*
        FREE cur_productos_IDX_productos_1_checkUniqueConstraint
        IF (NOT p_forUpdate AND l_count > 0) OR (p_forUpdate AND l_count > 0 AND p_key.* != l_key.*) THEN
            CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_grupo + cod_n + cod_sec + cod_tipo: " || ERROR_BAM_00002) RETURNING errNo, errMsg
        END IF
    CATCH
        LET errNo = ERROR_FAILURE
    END TRY
    {<POINT Name="fct.productos_IDX_productos_1_checkUniqueConstraint.user">} {</POINT>}

    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.productos_IDX_productos_1_checkUniqueConstraint

{<BLOCK Name="fct.productos_cod_n_checkColumnConstraints">}
#+ Check constraints on the "productos.cod_n" column
#+
#+ @param p_cod_n - SMALLINT - cod_n
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_productos_cod_n_checkColumnConstraints(p_cod_n)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_n LIKE productos.cod_n
    {<POINT Name="fct.productos_cod_n_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.productos_cod_n_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_n IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_n: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.productos_cod_n_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.productos_cod_n_checkColumnConstraints

{<BLOCK Name="fct.productos_cod_grupo_checkColumnConstraints">}
#+ Check constraints on the "productos.cod_grupo" column
#+
#+ @param p_cod_grupo - SMALLINT - cod_grupo
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_productos_cod_grupo_checkColumnConstraints(p_cod_grupo)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_grupo LIKE productos.cod_grupo
    {<POINT Name="fct.productos_cod_grupo_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.productos_cod_grupo_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_grupo IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_grupo: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.productos_cod_grupo_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.productos_cod_grupo_checkColumnConstraints

{<BLOCK Name="fct.productos_cod_tipo_checkColumnConstraints">}
#+ Check constraints on the "productos.cod_tipo" column
#+
#+ @param p_cod_tipo - SMALLINT - cod_tipo
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_productos_cod_tipo_checkColumnConstraints(p_cod_tipo)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_tipo LIKE productos.cod_tipo
    {<POINT Name="fct.productos_cod_tipo_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.productos_cod_tipo_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_tipo IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_tipo: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.productos_cod_tipo_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.productos_cod_tipo_checkColumnConstraints

{<BLOCK Name="fct.productos_cod_sec_checkColumnConstraints">}
#+ Check constraints on the "productos.cod_sec" column
#+
#+ @param p_cod_sec - SMALLINT - cod_sec
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_productos_cod_sec_checkColumnConstraints(p_cod_sec)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_sec LIKE productos.cod_sec
    {<POINT Name="fct.productos_cod_sec_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.productos_cod_sec_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_sec IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_sec: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.productos_cod_sec_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.productos_cod_sec_checkColumnConstraints

{<BLOCK Name="fct.productos_descrip_esp_checkColumnConstraints">}
#+ Check constraints on the "productos.descrip_esp" column
#+
#+ @param p_descrip_esp - CHAR(100) - descrip_esp
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_productos_descrip_esp_checkColumnConstraints(p_descrip_esp)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_descrip_esp LIKE productos.descrip_esp
    {<POINT Name="fct.productos_descrip_esp_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.productos_descrip_esp_checkColumnConstraints.init">} {</POINT>}
    IF p_descrip_esp IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- descrip_esp: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.productos_descrip_esp_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.productos_descrip_esp_checkColumnConstraints

{<BLOCK Name="fct.productos_unidad_med_checkColumnConstraints">}
#+ Check constraints on the "productos.unidad_med" column
#+
#+ @param p_unidad_med - CHAR(4) - unidad_med
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_productos_unidad_med_checkColumnConstraints(p_unidad_med)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_unidad_med LIKE productos.unidad_med
    {<POINT Name="fct.productos_unidad_med_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.productos_unidad_med_checkColumnConstraints.init">} {</POINT>}
    IF p_unidad_med IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- unidad_med: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.productos_unidad_med_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.productos_unidad_med_checkColumnConstraints

{<BLOCK Name="fct.productos_IDX_productos_1_checkFKConstraint">}
#+ Check the Foreign Key existence constraint on the "productos"
#+
#+ @param p_data - Primary Key
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_productos_IDX_productos_1_checkFKConstraint(p_data)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_data
        RECORD
            productos_cod_grupo LIKE productos.cod_grupo,
            productos_cod_n LIKE productos.cod_n,
            productos_cod_sec LIKE productos.cod_sec,
            productos_cod_tipo LIKE productos.cod_tipo
        END RECORD
    DEFINE l_where STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.productos_IDX_productos_1_checkFKConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    IF NOT (p_data.productos_cod_grupo IS NULL AND p_data.productos_cod_n IS NULL AND p_data.productos_cod_sec IS NULL AND p_data.productos_cod_tipo IS NULL) THEN
        LET l_where = "WHERE productos.cod_grupo = ?",
                    " AND productos.cod_n = ?",
                    " AND productos.cod_sec = ?",
                    " AND productos.cod_tipo = ? "
        LET l_sqlQuery = "SELECT COUNT(*) FROM productos ", l_where
        {<POINT Name="fct.productos_IDX_productos_1_checkFKConstraint.init">} {</POINT>}
        TRY
            PREPARE cur_productos_IDX_productos_1_checkFKConstraint FROM l_sqlQuery
            EXECUTE cur_productos_IDX_productos_1_checkFKConstraint USING p_data.* INTO l_count
            FREE cur_productos_IDX_productos_1_checkFKConstraint
            IF (l_count == 0) THEN
                CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_grupo + cod_n + cod_sec + cod_tipo: " || ERROR_BAM_00004) RETURNING errNo, errMsg
            END IF
        CATCH
            LET errNo = ERROR_FAILURE
        END TRY
    END IF
    {<POINT Name="fct.productos_IDX_productos_1_checkFKConstraint.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.productos_IDX_productos_1_checkFKConstraint

{<BLOCK Name="fct.grupo_producto_checkTableConstraints">}
#+ Check constraints on the "grupo_producto" table
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_data - a row data LIKE grupo_producto.*
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_grupo_producto_checkTableConstraints(p_forUpdate, p_data)
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_data RECORD LIKE grupo_producto.*
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE l_errNo INTEGER
    DEFINE l_errMsg STRING
    {<POINT Name="fct.grupo_producto_checkTableConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.grupo_producto_checkTableConstraints.init">} {</POINT>}

    CALL mydatabase_dbxconstraints_grupo_producto_cod_grupo_checkColumnConstraints(p_data.cod_grupo) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_grupo_producto_descripcion_checkColumnConstraints(p_data.descripcion) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    CALL mydatabase_dbxconstraints_grupo_producto_IDX_grupo_producto_2_checkUniqueConstraint(p_forUpdate, p_data.cod_grupo) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    {<POINT Name="fct.grupo_producto_checkTableConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.grupo_producto_checkTableConstraints

{<BLOCK Name="fct.grupo_producto_IDX_grupo_producto_2_checkUniqueConstraint">}
#+ Check the primary key uniqueness constraint on the "grupo_producto"
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_key - Primary Key
#+
#+ @returnType INTEGER, STRING, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_grupo_producto_IDX_grupo_producto_2_checkUniqueConstraint(p_forUpdate, p_key)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_key
        RECORD
            grupo_producto_cod_grupo LIKE grupo_producto.cod_grupo
        END RECORD
    DEFINE l_key
        RECORD
            grupo_producto_cod_grupo LIKE grupo_producto.cod_grupo
        END RECORD
    DEFINE l_where STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.grupo_producto_IDX_grupo_producto_2_checkUniqueConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    LET l_where = "WHERE grupo_producto.cod_grupo = ? "
    LET l_sqlQuery = "SELECT COUNT(*), cod_grupo FROM grupo_producto ", l_where, " GROUP BY cod_grupo"
    {<POINT Name="fct.grupo_producto_IDX_grupo_producto_2_checkUniqueConstraint.init">} {</POINT>}
    TRY
        PREPARE cur_grupo_producto_IDX_grupo_producto_2_checkUniqueConstraint FROM l_sqlQuery
        EXECUTE cur_grupo_producto_IDX_grupo_producto_2_checkUniqueConstraint USING p_key.* INTO l_count, l_key.*
        FREE cur_grupo_producto_IDX_grupo_producto_2_checkUniqueConstraint
        IF (NOT p_forUpdate AND l_count > 0) OR (p_forUpdate AND l_count > 0 AND p_key.* != l_key.*) THEN
            CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_grupo: " || ERROR_BAM_00002) RETURNING errNo, errMsg
        END IF
    CATCH
        LET errNo = ERROR_FAILURE
    END TRY
    {<POINT Name="fct.grupo_producto_IDX_grupo_producto_2_checkUniqueConstraint.user">} {</POINT>}

    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.grupo_producto_IDX_grupo_producto_2_checkUniqueConstraint

{<BLOCK Name="fct.grupo_producto_cod_grupo_checkColumnConstraints">}
#+ Check constraints on the "grupo_producto.cod_grupo" column
#+
#+ @param p_cod_grupo - SMALLINT - cod_grupo
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_grupo_producto_cod_grupo_checkColumnConstraints(p_cod_grupo)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_grupo LIKE grupo_producto.cod_grupo
    {<POINT Name="fct.grupo_producto_cod_grupo_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.grupo_producto_cod_grupo_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_grupo IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_grupo: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.grupo_producto_cod_grupo_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.grupo_producto_cod_grupo_checkColumnConstraints

{<BLOCK Name="fct.grupo_producto_descripcion_checkColumnConstraints">}
#+ Check constraints on the "grupo_producto.descripcion" column
#+
#+ @param p_descripcion - CHAR(50) - descripcion
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_grupo_producto_descripcion_checkColumnConstraints(p_descripcion)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_descripcion LIKE grupo_producto.descripcion
    {<POINT Name="fct.grupo_producto_descripcion_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.grupo_producto_descripcion_checkColumnConstraints.init">} {</POINT>}
    IF p_descripcion IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- descripcion: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.grupo_producto_descripcion_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.grupo_producto_descripcion_checkColumnConstraints

{<BLOCK Name="fct.grupo_producto_IDX_grupo_producto_2_checkFKConstraint">}
#+ Check the Foreign Key existence constraint on the "grupo_producto"
#+
#+ @param p_data - Primary Key
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_grupo_producto_IDX_grupo_producto_2_checkFKConstraint(p_data)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_data
        RECORD
            grupo_producto_cod_grupo LIKE grupo_producto.cod_grupo
        END RECORD
    DEFINE l_where STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.grupo_producto_IDX_grupo_producto_2_checkFKConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    IF NOT (p_data.grupo_producto_cod_grupo IS NULL) THEN
        LET l_where = "WHERE grupo_producto.cod_grupo = ? "
        LET l_sqlQuery = "SELECT COUNT(*) FROM grupo_producto ", l_where
        {<POINT Name="fct.grupo_producto_IDX_grupo_producto_2_checkFKConstraint.init">} {</POINT>}
        TRY
            PREPARE cur_grupo_producto_IDX_grupo_producto_2_checkFKConstraint FROM l_sqlQuery
            EXECUTE cur_grupo_producto_IDX_grupo_producto_2_checkFKConstraint USING p_data.* INTO l_count
            FREE cur_grupo_producto_IDX_grupo_producto_2_checkFKConstraint
            IF (l_count == 0) THEN
                CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_grupo: " || ERROR_BAM_00004) RETURNING errNo, errMsg
            END IF
        CATCH
            LET errNo = ERROR_FAILURE
        END TRY
    END IF
    {<POINT Name="fct.grupo_producto_IDX_grupo_producto_2_checkFKConstraint.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.grupo_producto_IDX_grupo_producto_2_checkFKConstraint

{<BLOCK Name="fct.companias_checkTableConstraints">}
#+ Check constraints on the "companias" table
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_data - a row data LIKE companias.*
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_companias_checkTableConstraints(p_forUpdate, p_data)
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_data RECORD LIKE companias.*
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE l_errNo INTEGER
    DEFINE l_errMsg STRING
    {<POINT Name="fct.companias_checkTableConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.companias_checkTableConstraints.init">} {</POINT>}

    CALL mydatabase_dbxconstraints_companias_cod_cia_checkColumnConstraints(p_data.cod_cia) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    CALL mydatabase_dbxconstraints_companias_IDX_companias_1_checkUniqueConstraint(p_forUpdate, p_data.cod_cia) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    {<POINT Name="fct.companias_checkTableConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.companias_checkTableConstraints

{<BLOCK Name="fct.companias_IDX_companias_1_checkUniqueConstraint">}
#+ Check the primary key uniqueness constraint on the "companias"
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_key - Primary Key
#+
#+ @returnType INTEGER, STRING, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_companias_IDX_companias_1_checkUniqueConstraint(p_forUpdate, p_key)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_key
        RECORD
            companias_cod_cia LIKE companias.cod_cia
        END RECORD
    DEFINE l_key
        RECORD
            companias_cod_cia LIKE companias.cod_cia
        END RECORD
    DEFINE l_where STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.companias_IDX_companias_1_checkUniqueConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    LET l_where = "WHERE companias.cod_cia = ? "
    LET l_sqlQuery = "SELECT COUNT(*), cod_cia FROM companias ", l_where, " GROUP BY cod_cia"
    {<POINT Name="fct.companias_IDX_companias_1_checkUniqueConstraint.init">} {</POINT>}
    TRY
        PREPARE cur_companias_IDX_companias_1_checkUniqueConstraint FROM l_sqlQuery
        EXECUTE cur_companias_IDX_companias_1_checkUniqueConstraint USING p_key.* INTO l_count, l_key.*
        FREE cur_companias_IDX_companias_1_checkUniqueConstraint
        IF (NOT p_forUpdate AND l_count > 0) OR (p_forUpdate AND l_count > 0 AND p_key.* != l_key.*) THEN
            CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_cia: " || ERROR_BAM_00002) RETURNING errNo, errMsg
        END IF
    CATCH
        LET errNo = ERROR_FAILURE
    END TRY
    {<POINT Name="fct.companias_IDX_companias_1_checkUniqueConstraint.user">} {</POINT>}

    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.companias_IDX_companias_1_checkUniqueConstraint

{<BLOCK Name="fct.companias_cod_cia_checkColumnConstraints">}
#+ Check constraints on the "companias.cod_cia" column
#+
#+ @param p_cod_cia - SMALLINT - cod_cia
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_companias_cod_cia_checkColumnConstraints(p_cod_cia)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_cia LIKE companias.cod_cia
    {<POINT Name="fct.companias_cod_cia_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.companias_cod_cia_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_cia IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_cia: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.companias_cod_cia_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.companias_cod_cia_checkColumnConstraints

{<BLOCK Name="fct.companias_IDX_companias_1_checkFKConstraint">}
#+ Check the Foreign Key existence constraint on the "companias"
#+
#+ @param p_data - Primary Key
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_companias_IDX_companias_1_checkFKConstraint(p_data)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_data
        RECORD
            companias_cod_cia LIKE companias.cod_cia
        END RECORD
    DEFINE l_where STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.companias_IDX_companias_1_checkFKConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    IF NOT (p_data.companias_cod_cia IS NULL) THEN
        LET l_where = "WHERE companias.cod_cia = ? "
        LET l_sqlQuery = "SELECT COUNT(*) FROM companias ", l_where
        {<POINT Name="fct.companias_IDX_companias_1_checkFKConstraint.init">} {</POINT>}
        TRY
            PREPARE cur_companias_IDX_companias_1_checkFKConstraint FROM l_sqlQuery
            EXECUTE cur_companias_IDX_companias_1_checkFKConstraint USING p_data.* INTO l_count
            FREE cur_companias_IDX_companias_1_checkFKConstraint
            IF (l_count == 0) THEN
                CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_cia: " || ERROR_BAM_00004) RETURNING errNo, errMsg
            END IF
        CATCH
            LET errNo = ERROR_FAILURE
        END TRY
    END IF
    {<POINT Name="fct.companias_IDX_companias_1_checkFKConstraint.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.companias_IDX_companias_1_checkFKConstraint

{<BLOCK Name="fct.clase_productos_checkTableConstraints">}
#+ Check constraints on the "clase_productos" table
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_data - a row data LIKE clase_productos.*
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_clase_productos_checkTableConstraints(p_forUpdate, p_data)
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_data RECORD LIKE clase_productos.*
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE l_errNo INTEGER
    DEFINE l_errMsg STRING
    {<POINT Name="fct.clase_productos_checkTableConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.clase_productos_checkTableConstraints.init">} {</POINT>}

    CALL mydatabase_dbxconstraints_clase_productos_cod_n_checkColumnConstraints(p_data.cod_n) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg
    CALL mydatabase_dbxconstraints_clase_productos_descripcion_checkColumnConstraints(p_data.descripcion) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    CALL mydatabase_dbxconstraints_clase_productos_IDX_clase_productos_1_checkUniqueConstraint(p_forUpdate, p_data.cod_n) RETURNING l_errNo, l_errMsg
    CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, l_errNo, l_errMsg) RETURNING errNo, errMsg

    {<POINT Name="fct.clase_productos_checkTableConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.clase_productos_checkTableConstraints

{<BLOCK Name="fct.clase_productos_IDX_clase_productos_1_checkUniqueConstraint">}
#+ Check the primary key uniqueness constraint on the "clase_productos"
#+
#+ @param p_forUpdate TRUE: for 'update' SQL operation, FALSE for 'insert' SQL operation
#+ @param p_key - Primary Key
#+
#+ @returnType INTEGER, STRING, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_clase_productos_IDX_clase_productos_1_checkUniqueConstraint(p_forUpdate, p_key)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_forUpdate BOOLEAN
    DEFINE p_key
        RECORD
            clase_productos_cod_n LIKE clase_productos.cod_n
        END RECORD
    DEFINE l_key
        RECORD
            clase_productos_cod_n LIKE clase_productos.cod_n
        END RECORD
    DEFINE l_where STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.clase_productos_IDX_clase_productos_1_checkUniqueConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    LET l_where = "WHERE clase_productos.cod_n = ? "
    LET l_sqlQuery = "SELECT COUNT(*), cod_n FROM clase_productos ", l_where, " GROUP BY cod_n"
    {<POINT Name="fct.clase_productos_IDX_clase_productos_1_checkUniqueConstraint.init">} {</POINT>}
    TRY
        PREPARE cur_clase_productos_IDX_clase_productos_1_checkUniqueConstraint FROM l_sqlQuery
        EXECUTE cur_clase_productos_IDX_clase_productos_1_checkUniqueConstraint USING p_key.* INTO l_count, l_key.*
        FREE cur_clase_productos_IDX_clase_productos_1_checkUniqueConstraint
        IF (NOT p_forUpdate AND l_count > 0) OR (p_forUpdate AND l_count > 0 AND p_key.* != l_key.*) THEN
            CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_n: " || ERROR_BAM_00002) RETURNING errNo, errMsg
        END IF
    CATCH
        LET errNo = ERROR_FAILURE
    END TRY
    {<POINT Name="fct.clase_productos_IDX_clase_productos_1_checkUniqueConstraint.user">} {</POINT>}

    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.clase_productos_IDX_clase_productos_1_checkUniqueConstraint

{<BLOCK Name="fct.clase_productos_cod_n_checkColumnConstraints">}
#+ Check constraints on the "clase_productos.cod_n" column
#+
#+ @param p_cod_n - CHAR(1) - cod_n
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_clase_productos_cod_n_checkColumnConstraints(p_cod_n)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_cod_n LIKE clase_productos.cod_n
    {<POINT Name="fct.clase_productos_cod_n_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.clase_productos_cod_n_checkColumnConstraints.init">} {</POINT>}
    IF p_cod_n IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_n: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.clase_productos_cod_n_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.clase_productos_cod_n_checkColumnConstraints

{<BLOCK Name="fct.clase_productos_descripcion_checkColumnConstraints">}
#+ Check constraints on the "clase_productos.descripcion" column
#+
#+ @param p_descripcion - CHAR(50) - descripcion
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_clase_productos_descripcion_checkColumnConstraints(p_descripcion)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_descripcion LIKE clase_productos.descripcion
    {<POINT Name="fct.clase_productos_descripcion_checkColumnConstraints.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    {<POINT Name="fct.clase_productos_descripcion_checkColumnConstraints.init">} {</POINT>}
    IF p_descripcion IS NULL THEN
        CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- descripcion: " || ERROR_BAM_00001) RETURNING errNo, errMsg
    END IF
    {<POINT Name="fct.clase_productos_descripcion_checkColumnConstraints.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.clase_productos_descripcion_checkColumnConstraints

{<BLOCK Name="fct.clase_productos_IDX_clase_productos_1_checkFKConstraint">}
#+ Check the Foreign Key existence constraint on the "clase_productos"
#+
#+ @param p_data - Primary Key
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message
PUBLIC FUNCTION mydatabase_dbxconstraints_clase_productos_IDX_clase_productos_1_checkFKConstraint(p_data)
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    DEFINE p_data
        RECORD
            clase_productos_cod_n LIKE clase_productos.cod_n
        END RECORD
    DEFINE l_where STRING
    DEFINE l_sqlQuery STRING
    DEFINE l_count INTEGER
    {<POINT Name="fct.clase_productos_IDX_clase_productos_1_checkFKConstraint.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    INITIALIZE errMsg TO NULL
    IF NOT (p_data.clase_productos_cod_n IS NULL) THEN
        LET l_where = "WHERE clase_productos.cod_n = ? "
        LET l_sqlQuery = "SELECT COUNT(*) FROM clase_productos ", l_where
        {<POINT Name="fct.clase_productos_IDX_clase_productos_1_checkFKConstraint.init">} {</POINT>}
        TRY
            PREPARE cur_clase_productos_IDX_clase_productos_1_checkFKConstraint FROM l_sqlQuery
            EXECUTE cur_clase_productos_IDX_clase_productos_1_checkFKConstraint USING p_data.* INTO l_count
            FREE cur_clase_productos_IDX_clase_productos_1_checkFKConstraint
            IF (l_count == 0) THEN
                CALL libdbapp_utilBuildErrorNoAndErrorMsg(errNo, errMsg, ERROR_FAILURE, "\n- cod_n: " || ERROR_BAM_00004) RETURNING errNo, errMsg
            END IF
        CATCH
            LET errNo = ERROR_FAILURE
        END TRY
    END IF
    {<POINT Name="fct.clase_productos_IDX_clase_productos_1_checkFKConstraint.user">} {</POINT>}
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.clase_productos_IDX_clase_productos_1_checkFKConstraint

--------------------------------------------------------------------------------
--Add user functions
{<POINT Name="user.functions">} {</POINT>}