{<CODEFILE Path="dbdgii.code" Hash="javWTIEHtIq+N8lJFwImXA==" />}
#+ DB schema - Data Management (dbdgii)

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

--------------------------------------------------------------------------------
--Importing modules
IMPORT FGL libdbappCore
IMPORT FGL libdbappSql

IMPORT FGL dbdgii
IMPORT FGL dbdgii_events
IMPORT FGL dbdgii_dbxconstraints
{<POINT Name="import" Status="MODIFIED">}
{</POINT>}

--------------------------------------------------------------------------------
--Database schema
SCHEMA dbdgii

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

{<BLOCK Name="fct.empresastmp_pk_empresastmp_selectRowByKey">}
#+ Select a row identified by the primary key in the "empresastmp" table
#+
#+ @param p_key - Primary Key
#+ @param p_lock - Indicate if a lock is used in order to prevent several users editing the same rows at the same time
#+
#+ @returnType INTEGER, LIKE empresastmp.*
#+ @return     ERROR_SUCCESS|ERROR_FAILURE|ERROR_NOTFOUND, RECORD LIKE empresastmp.*
PUBLIC FUNCTION dbdgii_dbxdata_empresastmp_pk_empresastmp_selectRowByKey(p_key, p_lock)
    DEFINE p_key
        RECORD
            empresastmp_rnc LIKE empresastmp.rnc
        END RECORD
    DEFINE p_lock BOOLEAN
    DEFINE l_data RECORD LIKE empresastmp.*
    DEFINE l_supportLock BOOLEAN
    DEFINE errNo INTEGER
    {<POINT Name="fct.empresastmp_pk_empresastmp_selectRowByKey.define">} {</POINT>}

    LET errNo = ERROR_SUCCESS
    -- SQLite does not support the FOR UPDATE close in SELECT syntax
    LET l_supportLock = (UPSHIFT(fgl_db_driver_type()) != "SQT")
    {<POINT Name="fct.empresastmp_pk_empresastmp_selectRowByKey.init">} {</POINT>}
    TRY
        IF p_lock AND l_supportLock THEN
            SELECT * INTO l_data.* FROM empresastmp
                WHERE @empresastmp.rnc = p_key.empresastmp_rnc
            FOR UPDATE
        ELSE
            SELECT * INTO l_data.* FROM empresastmp
                WHERE @empresastmp.rnc = p_key.empresastmp_rnc
        END IF
        IF SQLCA.SQLCODE == NOTFOUND THEN
            LET errNo = ERROR_NOTFOUND
        END IF
    CATCH
        INITIALIZE l_data.* TO NULL
        LET errNo = ERROR_FAILURE
    END TRY
    {<POINT Name="fct.empresastmp_pk_empresastmp_selectRowByKey.afterSelect">} {</POINT>}
    RETURN errNo, l_data.*
END FUNCTION
{</BLOCK>} --fct.empresastmp_pk_empresastmp_selectRowByKey

{<BLOCK Name="fct.empresastmp_insertRowByKey" Status="MODIFIED">}
#+ Insert a row in the "empresastmp" table and return the primary key created
#+
#+ @param p_data - a row data LIKE empresastmp.*
#+
#+ @returnType - INTEGER, CHAR(11)
#+ @return - ERROR_SUCCESS|ERROR_FAILURE, empresastmp.rnc
PUBLIC FUNCTION dbdgii_dbxdata_empresastmp_insertRowByKey(p_data)
  DEFINE p_data RECORD LIKE empresastmp.*
  DEFINE errNo INTEGER
  DEFINE errMsg STRING

  LET errNo = libdbapp_begin_work()
  IF errNo == ERROR_SUCCESS THEN
    CALL dbdgii_dbxconstraints.dbdgii_dbxconstraints_empresastmp_checkTableConstraints(FALSE, p_data.*) RETURNING errNo, errMsg
    IF errNo == ERROR_SUCCESS THEN
      TRY
        INSERT INTO empresastmp VALUES (p_data.*)
      CATCH
        LET errNo = ERROR_FAILURE
      END TRY
    END IF
    IF errNo == ERROR_SUCCESS THEN
      LET errNo = libdbapp_commit_work()
    ELSE
      CALL libdbapp_rollback_work()
    END IF
  END IF
  RETURN errNo, errMsg, p_data.rnc
END FUNCTION
{</BLOCK>} --fct.empresastmp_insertRowByKey

{<BLOCK Name="fct.empresastmp_pk_empresastmp_insertRowByKey">}
#+ Insert a row in the "empresastmp" table and return the table keys
#+
#+ @param p_data - a row data LIKE empresastmp.*
#+
#+ @returnType INTEGER, STRING, CHAR(11)
#+ @return     ERROR_SUCCESS|ERROR_FAILURE, error message, empresastmp.rnc
PUBLIC FUNCTION dbdgii_dbxdata_empresastmp_pk_empresastmp_insertRowByKey(p_data)
    DEFINE p_data RECORD LIKE empresastmp.*
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    {<POINT Name="fct.empresastmp_pk_empresastmp_insertRowByKey.define">} {</POINT>}
    {<POINT Name="fct.empresastmp_pk_empresastmp_insertRowByKey.init">} {</POINT>}

    CALL dbdgii_dbxdata_empresastmp_insertRowByKey(p_data.*) RETURNING errNo, errMsg, p_data.rnc
    RETURN errNo, errMsg, p_data.rnc
END FUNCTION
{</BLOCK>} --fct.empresastmp_pk_empresastmp_insertRowByKey

{<BLOCK Name="fct.empresastmp_pk_empresastmp_updateRowByKey">}
#+ Update a row identified by the primary key in the "empresastmp" table
#+
#+ @param p_dataT0 - a row data LIKE empresastmp.*
#+ @param p_dataT1 - a row data LIKE empresastmp.*
#+
#+ @returnType INTEGER, STRING
#+ @return     ERROR_SUCCESS|ERROR_FAILURE|ERROR_CONCURRENT_ACCESS_NOTFOUND|ERROR_CONCURRENT_ACCESS_FAILURE, error message
PUBLIC FUNCTION dbdgii_dbxdata_empresastmp_pk_empresastmp_updateRowByKey(p_dataT0, p_dataT1)
    DEFINE p_dataT0 RECORD LIKE empresastmp.*
    DEFINE p_dataT1 RECORD LIKE empresastmp.*
    DEFINE l_key
        RECORD
            empresastmp_rnc LIKE empresastmp.rnc
        END RECORD
    DEFINE errNo INTEGER
    DEFINE errMsg STRING
    {<POINT Name="fct.empresastmp_pk_empresastmp_updateRowByKey.define">} {</POINT>}
    LET l_key.empresastmp_rnc = p_dataT0.rnc
    INITIALIZE errMsg TO NULL
    LET errNo = libdbapp_begin_work()
    IF errNo == ERROR_SUCCESS THEN
        {<POINT Name="fct.empresastmp_pk_empresastmp_updateRowByKey.init">} {</POINT>}
        TRY
            LET errNo = dbdgii_dbxdata_empresastmp_pk_empresastmp_checkRowByKeyWithConcurrentAccess(p_dataT0.*, TRUE)
            {<POINT Name="fct.empresastmp_pk_empresastmp_updateRowByKey.afterSelect">} {</POINT>}
            IF errNo == ERROR_SUCCESS THEN
                CALL dbdgii_dbxconstraints.dbdgii_dbxconstraints_empresastmp_checkTableConstraints(TRUE, p_dataT1.*) RETURNING errNo, errMsg
                {<POINT Name="fct.empresastmp_pk_empresastmp_updateRowByKey.beforeUpdate">} {</POINT>}
                IF errNo == ERROR_SUCCESS THEN
                 IF dbdgii_events.m_DbxDataEvent_empresastmp_BeforeUpdateRowByKey IS NOT NULL THEN
                    CALL dbdgii_events.m_DbxDataEvent_empresastmp_BeforeUpdateRowByKey(p_dataT1.*)
                        RETURNING errNo, errMsg
                END IF
                    UPDATE empresastmp
                        SET empresastmp.* = p_dataT1.*
                        WHERE @empresastmp.rnc = l_key.empresastmp_rnc
                END IF
            END IF
        CATCH
            LET errNo = ERROR_FAILURE
        END TRY
        IF dbdgii_events.m_DbxDataEvent_empresastmp_AfterUpdateRowByKey IS NOT NULL THEN
            CALL dbdgii_events.m_DbxDataEvent_empresastmp_AfterUpdateRowByKey(p_dataT1.*)
                RETURNING errNo, errMsg
        END IF
        {<POINT Name="fct.empresastmp_pk_empresastmp_updateRowByKey.afterUpdate">} {</POINT>}
        IF errNo == ERROR_SUCCESS THEN
            LET errNo = libdbapp_commit_work()
        ELSE
            CALL libdbapp_rollback_work()
        END IF
    END IF
    RETURN errNo, errMsg
END FUNCTION
{</BLOCK>} --fct.empresastmp_pk_empresastmp_updateRowByKey

{<BLOCK Name="fct.empresastmp_pk_empresastmp_deleteRowByKey">}
#+ Delete a row identified by the primary key in the "empresastmp" table
#+
#+ @param p_key - Primary Key
#+
#+ @returnType INTEGER
#+ @return     ERROR_SUCCESS|ERROR_FAILURE|ERROR_DELETE_CASCADE_ROW_USED
PUBLIC FUNCTION dbdgii_dbxdata_empresastmp_pk_empresastmp_deleteRowByKey(p_key)
    DEFINE p_key
        RECORD
            empresastmp_rnc LIKE empresastmp.rnc
        END RECORD
    DEFINE errNo INTEGER
    {<POINT Name="fct.empresastmp_pk_empresastmp_deleteRowByKey.define">} {</POINT>}

    LET errNo = libdbapp_begin_work()
    IF errNo == ERROR_SUCCESS THEN
        {<POINT Name="fct.empresastmp_pk_empresastmp_deleteRowByKey.init">} {</POINT>}
        IF dbdgii_events.m_DbxDataEvent_empresastmp_BeforeDeleteRowByKey IS NOT NULL THEN
            CALL dbdgii_events.m_DbxDataEvent_empresastmp_BeforeDeleteRowByKey(p_key.*)
                RETURNING errNo
        END IF
        TRY
            DELETE FROM empresastmp
                WHERE @empresastmp.rnc = p_key.empresastmp_rnc
        CATCH
            LET errNo = ERROR_FAILURE
        END TRY
        IF dbdgii_events.m_DbxDataEvent_empresastmp_AfterDeleteRowByKey IS NOT NULL THEN
            CALL dbdgii_events.m_DbxDataEvent_empresastmp_AfterDeleteRowByKey(p_key.*)
                RETURNING errNo
        END IF
        {<POINT Name="fct.empresastmp_pk_empresastmp_deleteRowByKey.afterDelete">} {</POINT>}
        IF errNo == ERROR_SUCCESS THEN
            LET errNo = libdbapp_commit_work()
        ELSE
            CALL libdbapp_rollback_work()
        END IF
    END IF
    RETURN errNo
END FUNCTION
{</BLOCK>} --fct.empresastmp_pk_empresastmp_deleteRowByKey

{<BLOCK Name="fct.empresastmp_pk_empresastmp_deleteRowByKeyWithConcurrentAccess">}
#+ Delete a row identified by the primary key in the "empresastmp" table if the concurrent access is success
#+
#+ @param p_dataT0 - a row data LIKE empresastmp.*
#+
#+ @returnType INTEGER
#+ @return     ERROR_SUCCESS|ERROR_FAILURE|ERROR_CONCURRENT_ACCESS_NOTFOUND|ERROR_CONCURRENT_ACCESS_FAILURE|ERROR_DELETE_CASCADE_ROW_USED
PUBLIC FUNCTION dbdgii_dbxdata_empresastmp_pk_empresastmp_deleteRowByKeyWithConcurrentAccess(p_dataT0)
    DEFINE p_dataT0 RECORD LIKE empresastmp.*
    DEFINE l_key
        RECORD
            empresastmp_rnc LIKE empresastmp.rnc
        END RECORD
    DEFINE errNo INTEGER
    {<POINT Name="fct.empresastmp_pk_empresastmp_deleteRowByKeyWithConcurrentAccess.define">} {</POINT>}

    LET l_key.empresastmp_rnc = p_dataT0.rnc
    LET errNo = libdbapp_begin_work()
    IF errNo == ERROR_SUCCESS THEN
        {<POINT Name="fct.empresastmp_pk_empresastmp_deleteRowByKeyWithConcurrentAccess.init">} {</POINT>}
        LET errNo = dbdgii_dbxdata_empresastmp_pk_empresastmp_checkRowByKeyWithConcurrentAccess(p_dataT0.*, TRUE)
        {<POINT Name="fct.empresastmp_pk_empresastmp_deleteRowByKeyWithConcurrentAccess.afterSelect">} {</POINT>}
        IF errNo == ERROR_SUCCESS THEN
            LET errNo = dbdgii_dbxdata_empresastmp_pk_empresastmp_deleteRowByKey(l_key.*)
        END IF
        {<POINT Name="fct.empresastmp_pk_empresastmp_deleteRowByKeyWithConcurrentAccess.afterDelete">} {</POINT>}
        IF errNo == ERROR_SUCCESS THEN
            LET errNo = libdbapp_commit_work()
        ELSE
            CALL libdbapp_rollback_work()
        END IF
    END IF
    RETURN errNo
END FUNCTION
{</BLOCK>} --fct.empresastmp_pk_empresastmp_deleteRowByKeyWithConcurrentAccess

{<BLOCK Name="fct.empresastmp_pk_empresastmp_checkRowByKeyWithConcurrentAccess">}
#+ Check if a row identified by the primary key in the "empresastmp" table has been modified or deleted
#+
#+ @param p_dataT0 - a row data LIKE empresastmp.*
#+ @param p_lock - Indicate if a lock is used in order to prevent several users editing the same rows at the same time
#+
#+ @returnType INTEGER
#+ @return     ERROR_SUCCESS|ERROR_FAILURE|ERROR_CONCURRENT_ACCESS_NOTFOUND|ERROR_CONCURRENT_ACCESS_FAILURE
PUBLIC FUNCTION dbdgii_dbxdata_empresastmp_pk_empresastmp_checkRowByKeyWithConcurrentAccess(p_dataT0, p_lock)
    DEFINE p_dataT0 RECORD LIKE empresastmp.*
    DEFINE l_dataT2 RECORD LIKE empresastmp.*
    DEFINE l_key
        RECORD
            empresastmp_rnc LIKE empresastmp.rnc
        END RECORD
    DEFINE p_lock BOOLEAN
    DEFINE errNo INTEGER
    DEFINE errDiff INTEGER
    {<POINT Name="fct.empresastmp_pk_empresastmp_checkRowByKeyWithConcurrentAccess.define">} {</POINT>}

    LET l_key.empresastmp_rnc = p_dataT0.rnc
    INITIALIZE l_dataT2.* TO NULL
    LET errDiff = FALSE
    {<POINT Name="fct.empresastmp_pk_empresastmp_checkRowByKeyWithConcurrentAccess.init">} {</POINT>}
    CALL dbdgii_dbxdata_empresastmp_pk_empresastmp_selectRowByKey(l_key.*, p_lock) RETURNING errNo, l_dataT2.*
    CASE errNo
        WHEN ERROR_SUCCESS
            LET errDiff = (p_dataT0.* != l_dataT2.*)
            {<POINT Name="fct.empresastmp_pk_empresastmp_checkRowByKeyWithConcurrentAccess.afterSelect">} {</POINT>}
            IF NOT errDiff THEN
                LET errNo = ERROR_SUCCESS
            ELSE
                LET errNo = ERROR_CONCURRENT_ACCESS_FAILURE
            END IF
        WHEN ERROR_NOTFOUND
            LET errNo = ERROR_CONCURRENT_ACCESS_NOTFOUND
    END CASE
    {<POINT Name="fct.empresastmp_pk_empresastmp_checkRowByKeyWithConcurrentAccess.afterCheck">} {</POINT>}
    RETURN errNo
END FUNCTION
{</BLOCK>} --fct.empresastmp_pk_empresastmp_checkRowByKeyWithConcurrentAccess

{<BLOCK Name="fct.empresastmp_setDefaultValuesFromDBSchema" Status="MODIFIED">}
#+ Set data with the default values coming from the DB schema
#+
PUBLIC FUNCTION dbdgii_dbxdata_empresastmp_setDefaultValuesFromDBSchema()
  DEFINE l_data RECORD LIKE empresastmp.*

  INITIALIZE l_data.* TO NULL
  LET l_data.rnc = ""
  LET l_data.razon_social = ""
  LET l_data.nombre_empresa = ""
  LET l_data.actividad = ""
  LET l_data.calle = ""
  LET l_data.no_local = ""
  LET l_data.sector = ""
  LET l_data.telefono = ""
  LET l_data.fecha_inicio = ""
  LET l_data.estado1 = ""
  LET l_data.estado2 = ""

  RETURN l_data.*
END FUNCTION
{</BLOCK>} --fct.empresastmp_setDefaultValuesFromDBSchema

--------------------------------------------------------------------------------
--Add user functions
{<POINT Name="user.functions" Status="MODIFIED">}
{</POINT>}
{<BLOCK Name="fct.empresastmp_deleteRowByKey" Status="LOST">}
-- #+ Delete a row identified by the primary key in the "empresastmp" table
-- #+
-- #+ @param p_key - Primary Key
-- #+
-- #+ @returnType - INTEGER
-- #+ @return - ERROR_SUCCESS|ERROR_FAILURE
-- PUBLIC FUNCTION dbdgii_dbxdata_empresastmp_deleteRowByKey(p_key)
--   DEFINE p_key
--     RECORD
--       empresastmp_rnc LIKE empresastmp.rnc
--     END RECORD
--   DEFINE errNo INTEGER
-- 
--   LET errNo = libdbapp_begin_work()
--   IF errNo == ERROR_SUCCESS THEN
--     TRY
--       DELETE FROM empresastmp
--         WHERE empresastmp.rnc = p_key.empresastmp_rnc
--     CATCH
--       LET errNo = ERROR_FAILURE
--     END TRY
--   END IF
--   IF errNo == ERROR_SUCCESS THEN
--     LET errNo = libdbapp_commit_work()
--   ELSE
--     CALL libdbapp_rollback_work()
--   END IF
-- 
--   RETURN errNo
-- END FUNCTION
{</BLOCK>}
{<BLOCK Name="fct.empresastmp_selectRowByKey" Status="LOST">}
-- #+ Select a row identified by the primary key in the "empresastmp" table
-- #+
-- #+ @param p_key - Primary Key
-- #+
-- #+ @returnType - INTEGER
-- #+ @return - ERROR_SUCCESS|ERROR_FAILURE, l_data
-- PUBLIC FUNCTION dbdgii_dbxdata_empresastmp_selectRowByKey(p_key)
--   DEFINE p_key
--     RECORD
--       empresastmp_rnc LIKE empresastmp.rnc
--     END RECORD
--   DEFINE l_data RECORD LIKE empresastmp.*
--   DEFINE errNo INTEGER
-- 
--   INITIALIZE l_data.* TO NULL
--   LET errNo = ERROR_SUCCESS
--   TRY
--     SELECT * INTO l_data.* FROM empresastmp
--     WHERE empresastmp.rnc = p_key.empresastmp_rnc
--   CATCH
--     INITIALIZE l_data.* TO NULL
--     LET errNo = ERROR_FAILURE
--   END TRY
-- 
--   RETURN errNo, l_data.*
-- END FUNCTION
{</BLOCK>}
{<BLOCK Name="fct.empresastmp_updateRowByKey" Status="LOST">}
-- #+ Update a row identified by the primary key in the "empresastmp" table
-- #+
-- #+ @param p_key - Primary Key
-- #+ @param p_dataT0 - a row data LIKE empresastmp.*
-- #+ @param p_dataT1 - a row data LIKE empresastmp.*
-- #+
-- #+ @returnType - INTEGER
-- #+ @return - ERROR_SUCCESS|ERROR_FAILURE
-- PUBLIC FUNCTION dbdgii_dbxdata_empresastmp_updateRowByKey(p_key, p_dataT0, p_dataT1)
--   DEFINE p_key
--     RECORD
--       empresastmp_rnc LIKE empresastmp.rnc
--     END RECORD
--   DEFINE p_dataT0 RECORD LIKE empresastmp.*
--   DEFINE p_dataT1 RECORD LIKE empresastmp.*
--   DEFINE l_dataT2 RECORD LIKE empresastmp.*
--   DEFINE errNo INTEGER
--   DEFINE errMsg STRING
--   DEFINE errDiff INTEGER
-- 
--   INITIALIZE l_dataT2.* TO NULL
--   INITIALIZE errMsg TO NULL
--   LET errDiff = FALSE
--   LET errNo = libdbapp_begin_work()
--   IF errNo == ERROR_SUCCESS THEN
--     TRY
--       -- Concurrent Access done with the FOR UPDATE (not supported by SQLite)
--       IF (UPSHIFT(fgl_db_driver_type()) != "SQT") THEN
--         SELECT * INTO l_dataT2.* FROM empresastmp
--           WHERE empresastmp.rnc = p_key.empresastmp_rnc
--         FOR UPDATE
--         LET errDiff = (p_dataT0.* != l_dataT2.*)
--       END IF
-- 
--       IF NOT errDiff THEN
--         CALL dbdgii_dbxconstraints.dbdgii_dbxconstraints_empresastmp_checkTableConstraints(TRUE, p_dataT1.*) RETURNING errNo, errMsg
--         IF errNo == ERROR_SUCCESS THEN
--           UPDATE empresastmp
--             SET empresastmp.* = p_dataT1.*
--             WHERE empresastmp.rnc = p_key.empresastmp_rnc
--         END IF
--       ELSE
--         LET errNo = ERROR_CONCURRENT_ACCESS_FAILURE
--       END IF
--     CATCH
--       LET errNo = ERROR_FAILURE
--     END TRY
--     IF errNo == ERROR_SUCCESS THEN
--       LET errNo = libdbapp_commit_work()
--     ELSE
--       CALL libdbapp_rollback_work()
--     END IF
--   END IF
-- 
--   RETURN errNo, errMsg
-- END FUNCTION
{</BLOCK>}