Script Completo 0.2.sql

CREATE USER UAB_GET IDENTIFIED BY taller 
DEFAULT TABLESPACE users 
TEMPORARY TABLESPACE temp 
QUOTA UNLIMITED ON users;

GRANT CREATE session TO UAB_GET; 
GRANT CREATE table TO UAB_GET; 
GRANT CREATE view TO UAB_GET; 
GRANT CREATE procedure TO UAB_GET; 
GRANT CREATE synonym TO UAB_GET;



CREATE USER APP_GESTION_UAB IDENTIFIED BY TallerBD
DEFAULT TABLESPACE users
TEMPORARY TABLESPACE temp
QUOTA UNLIMITED ON users;


GRANT CREATE session TO APP_GESTION_UAB;
GRANT CREATE procedure TO APP_GESTION_UAB;

--
-- T_ASIENTO_ID_ASIENTO  (Sequence) 
--
CREATE SEQUENCE UAB_GET.T_ASIENTO_ID_ASIENTO
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- T_ASIENTO_RUT_ID_ASIENTO_R  (Sequence) 
--
CREATE SEQUENCE UAB_GET.T_ASIENTO_RUT_ID_ASIENTO_R
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- T_BOLETO_ID_BOLETO  (Sequence) 
--
CREATE SEQUENCE UAB_GET.T_BOLETO_ID_BOLETO
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- T_CIUDAD_ID_CIUDAD  (Sequence) 
--
CREATE SEQUENCE UAB_GET.T_CIUDAD_ID_CIUDAD
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- T_DETALLE_BOL_ID_DETALLE_B  (Sequence) 
--
CREATE SEQUENCE UAB_GET.T_DETALLE_BOL_ID_DETALLE_B
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- T_DOCUMENTO_ID_DOCUMENTO  (Sequence) 
--
CREATE SEQUENCE UAB_GET.T_DOCUMENTO_ID_DOCUMENTO
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- T_FACTURA_ID_FACTURA  (Sequence) 
--
CREATE SEQUENCE UAB_GET.T_FACTURA_ID_FACTURA
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- T_FLOTA_ID_FLOTA  (Sequence) 
--
CREATE SEQUENCE UAB_GET.T_FLOTA_ID_FLOTA
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- T_HORARIO_ID_HORARIO  (Sequence) 
--
CREATE SEQUENCE UAB_GET.T_HORARIO_ID_HORARIO
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- TPAR_ESTADO_A_ID_ESTADO_AS  (Sequence) 
--
CREATE SEQUENCE UAB_GET.TPAR_ESTADO_A_ID_ESTADO_AS
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- TPAR_GENERO_ID_GENERO  (Sequence) 
--
CREATE SEQUENCE UAB_GET.TPAR_GENERO_ID_GENERO
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- TPAR_PRECIO_ID_PRECIO  (Sequence) 
--
CREATE SEQUENCE UAB_GET.TPAR_PRECIO_ID_PRECIO
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- TPAR_SUCURSAL_ID_SUCURSAL  (Sequence) 
--
CREATE SEQUENCE UAB_GET.TPAR_SUCURSAL_ID_SUCURSAL
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- TPAR_TIPO_ASI_ID_TIPO_ASIE  (Sequence) 
--
CREATE SEQUENCE UAB_GET.TPAR_TIPO_ASI_ID_TIPO_ASIE
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- TPAR_TIPO_DOC_ID_TIPO_DOCU  (Sequence) 
--
CREATE SEQUENCE UAB_GET.TPAR_TIPO_DOC_ID_TIPO_DOCU
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- TPAR_TIPO_FLO_ID_TIPO_FLOT  (Sequence) 
--
CREATE SEQUENCE UAB_GET.TPAR_TIPO_FLO_ID_TIPO_FLOT
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- TPAR_TIPO_PER_ID_TIPO_PERS  (Sequence) 
--
CREATE SEQUENCE UAB_GET.TPAR_TIPO_PER_ID_TIPO_PERS
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- TPAR_TIPO_USU_ID_TIPO_USUA  (Sequence) 
--
CREATE SEQUENCE UAB_GET.TPAR_TIPO_USU_ID_TIPO_USUA
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- T_PERSONA_ID_PERSONA  (Sequence) 
--
CREATE SEQUENCE UAB_GET.T_PERSONA_ID_PERSONA
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- T_RUTA_ID_RUTA  (Sequence) 
--
CREATE SEQUENCE UAB_GET.T_RUTA_ID_RUTA
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/


--
-- T_USUARIO_ID_USUARIO  (Sequence) 
--
CREATE SEQUENCE UAB_GET.T_USUARIO_ID_USUARIO
  START WITH 1
  MAXVALUE 9999999999999999999999999999
  MINVALUE 1
  NOCYCLE
  NOCACHE
  NOORDER
/

--
-- T_CIUDAD  (Table) 
--
--   Row count:9
CREATE TABLE UAB_GET.T_CIUDAD
(
  ID_CIUDAD       NUMBER(15)                    NOT NULL,
  NOMBRE          VARCHAR2(100 BYTE),
  APP_ID_USUARIO  NUMBER(15),
  AUD_ESTADO      NUMBER(1)                     DEFAULT 1,
  AUD_USUARIO     VARCHAR2(50 BYTE)             DEFAULT USER,
  AUD_FECHA       TIMESTAMP(6)                  DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO  DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/

COMMENT ON COLUMN UAB_GET.T_CIUDAD.AUD_FECHA IS 'Campo donde se almacena la fecha de registro del sistema'
/

COMMENT ON COLUMN UAB_GET.T_CIUDAD.FECHA_REGISTRO IS 'Campo donde se lamacena la fecha de la aplicacion'
/



--
-- T_FACTURA  (Table) 
--
--   Row count:0
CREATE TABLE UAB_GET.T_FACTURA
(
  ID_FACTURA      NUMBER(15)                    NOT NULL,
  MONTO           NUMBER(15,2),
  GLOSA           VARCHAR2(500 BYTE),
  NIT             VARCHAR2(100 BYTE),
  APP_ID_USUARIO  NUMBER(15),
  AUD_ESTADO      NUMBER(1),
  AUD_USUARIO     VARCHAR2(50 BYTE),
  AUD_FECHA       DATE,
  FECHA_REGISTRO  DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- T_HORARIO  (Table) 
--
--   Row count:44
CREATE TABLE UAB_GET.T_HORARIO
(
  ID_HORARIO      NUMBER(15)                    NOT NULL,
  HORA            VARCHAR2(15 BYTE),
  APP_ID_USUARIO  NUMBER(15),
  AUD_ESTADO      NUMBER(1)                     DEFAULT 1,
  AUD_USUARIO     VARCHAR2(50 BYTE)             DEFAULT USER,
  AUD_FECHA       TIMESTAMP(6)                  DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO  DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- TPAR_ESTADO_ASIENTO  (Table) 
--
--   Row count:3
CREATE TABLE UAB_GET.TPAR_ESTADO_ASIENTO
(
  ID_ESTADO_ASIENTO  NUMBER(15)                 NOT NULL,
  DESCRIPCION        VARCHAR2(50 BYTE),
  APP_ID_USUARIO     NUMBER(15),
  AUD_ESTADO         NUMBER(1)                  DEFAULT 1,
  AUD_USUARIO        VARCHAR2(50 BYTE)          DEFAULT USER,
  AUD_FECHA          TIMESTAMP(6)               DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO     DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- TPAR_GENERO  (Table) 
--
--   Row count:3
CREATE TABLE UAB_GET.TPAR_GENERO
(
  ID_GENERO       NUMBER(15)                    NOT NULL,
  DESCRIPCION     VARCHAR2(50 BYTE),
  APP_ID_USUARIO  NUMBER(15),
  AUD_ESTADO      NUMBER(1)                     DEFAULT 1,
  AUD_USUARIO     VARCHAR2(50 BYTE)             DEFAULT USER,
  AUD_FECHA       TIMESTAMP(6)                  DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO  DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- TPAR_PRECIO  (Table) 
--
--   Row count:17
CREATE TABLE UAB_GET.TPAR_PRECIO
(
  ID_PRECIO       NUMBER(15)                    NOT NULL,
  PRECIO          NUMBER(15,4),
  COSTO           NUMBER(15,4),
  OBSERVACIONES   VARCHAR2(500 BYTE),
  APP_ID_USUARIO  NUMBER(15),
  AUD_ESTADO      NUMBER(1)                     DEFAULT 1,
  AUD_USUARIO     VARCHAR2(50 BYTE)             DEFAULT USER,
  AUD_FECHA       TIMESTAMP(6)                  DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO  DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/

COMMENT ON TABLE UAB_GET.TPAR_PRECIO IS 'Tabla donde se almacenan los distintos precios que existen'
/



--
-- TPAR_SUCURSAL  (Table) 
--
--   Row count:11
CREATE TABLE UAB_GET.TPAR_SUCURSAL
(
  ID_SUCURSAL     NUMBER(15)                    NOT NULL,
  NOMBRE          VARCHAR2(100 BYTE),
  TELEFONO        VARCHAR2(50 BYTE),
  DIRECCION       VARCHAR2(150 BYTE),
  APP_ID_USUARIO  NUMBER(15),
  AUD_ESTADO      NUMBER(1)                     DEFAULT 1,
  AUD_USUARIO     VARCHAR2(50 BYTE)             DEFAULT USER,
  AUD_FECHA       TIMESTAMP(6)                  DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO  DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- TPAR_TIPO_ASIENTO  (Table) 
--
--   Row count:2
CREATE TABLE UAB_GET.TPAR_TIPO_ASIENTO
(
  ID_TIPO_ASIENTO  NUMBER(15)                   NOT NULL,
  DESCRIPCION      VARCHAR2(50 BYTE),
  APP_ID_USUARIO   NUMBER(15),
  AUD_ESTADO       NUMBER(1)                    DEFAULT 1,
  AUD_USUARIO      VARCHAR2(50 BYTE)            DEFAULT USER,
  AUD_FECHA        TIMESTAMP(6)                 DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO   DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- TPAR_TIPO_DOCUMENTO  (Table) 
--
--   Row count:3
CREATE TABLE UAB_GET.TPAR_TIPO_DOCUMENTO
(
  ID_TIPO_DOCUMENTO  NUMBER(15)                 NOT NULL,
  DESCRIPCION        VARCHAR2(150 BYTE),
  APP_ID_USUARIO     NUMBER(15),
  AUD_ESTADO         NUMBER(1)                  DEFAULT 1,
  AUD_USUARIO        VARCHAR2(50 BYTE)          DEFAULT USER,
  AUD_FECHA          TIMESTAMP(6)               DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO     DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- TPAR_TIPO_FLOTA  (Table) 
--
--   Row count:4
CREATE TABLE UAB_GET.TPAR_TIPO_FLOTA
(
  ID_TIPO_FLOTA   NUMBER(15)                    NOT NULL,
  DESCRIPCION     VARCHAR2(100 BYTE),
  APP_ID_USUARIO  NUMBER(15),
  AUD_ESTADO      NUMBER(1)                     DEFAULT 1,
  AUD_USUARIO     VARCHAR2(50 BYTE)             DEFAULT USER,
  AUD_FECHA       TIMESTAMP(6)                  DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO  DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- TPAR_TIPO_PERSONA  (Table) 
--
--   Row count:2
CREATE TABLE UAB_GET.TPAR_TIPO_PERSONA
(
  ID_TIPO_PERSONA  NUMBER(15)                   NOT NULL,
  DESCRIPCION      VARCHAR2(150 BYTE),
  APP_ID_USUARIO   NUMBER(15),
  AUD_ESTADO       NUMBER(1)                    DEFAULT 1,
  AUD_USUARIO      VARCHAR2(50 BYTE)            DEFAULT USER,
  AUD_FECHA        TIMESTAMP(6)                 DEFAULT SYSTIMESTAMP,
  FECHA_REGSTRO    DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- TPAR_TIPO_USUARIO  (Table) 
--
--   Row count:3
CREATE TABLE UAB_GET.TPAR_TIPO_USUARIO
(
  ID_TIPO_USUARIO  NUMBER(15)                   NOT NULL,
  DESCRIPCION      VARCHAR2(150 BYTE),
  APP_ID_USUARIO   NUMBER(15),
  AUD_ESTADO       NUMBER(1)                    DEFAULT 1,
  AUD_USUARIO      VARCHAR2(50 BYTE)            DEFAULT USER,
  AUD_FECHA        TIMESTAMP(6)                 DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO   DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- T_PERSONA  (Table) 
--
--  Dependencies: 
--   TPAR_GENERO (Table)
--   TPAR_TIPO_PERSONA (Table)
--
--   Row count:16
CREATE TABLE UAB_GET.T_PERSONA
(
  ID_PERSONA        NUMBER(15)                  NOT NULL,
  ID_TIPO_PERSONA   NUMBER(15),
  ID_GENERO         NUMBER(15),
  NOMBRE            VARCHAR2(100 BYTE),
  AP_PATERNO        VARCHAR2(100 BYTE),
  AP_MATERNO        VARCHAR2(100 BYTE),
  FECHA_NACIMIENTO  DATE,
  DIRECCION         VARCHAR2(150 BYTE),
  EMAIL             VARCHAR2(100 BYTE),
  APP_ID_USUARIO    NUMBER(15),
  AUD_ESTADO        NUMBER(1)                   DEFAULT 1,
  AUD_USUARIO       VARCHAR2(50 BYTE)           DEFAULT USER,
  AUD_FECHA         TIMESTAMP(6)                DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO    DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- T_USUARIO  (Table) 
--
--  Dependencies: 
--   TPAR_SUCURSAL (Table)
--   T_PERSONA (Table)
--   TPAR_TIPO_USUARIO (Table)
--
--   Row count:2
CREATE TABLE UAB_GET.T_USUARIO
(
  ID_USUARIO       NUMBER(15)                   NOT NULL,
  ID_PERSONA       NUMBER(15),
  ID_SUCURSAL      NUMBER(15),
  ID_TIPO_USUARIO  NUMBER(15),
  CLAVE            VARCHAR2(50 BYTE),
  USUARIO          VARCHAR2(50 BYTE),
  APP_ID_USUARIO   NUMBER(15),
  AUD_ESTADO       NUMBER(1)                    DEFAULT 1,
  AUD_USUARIO      VARCHAR2(50 BYTE)            DEFAULT USER,
  AUD_FECHA        TIMESTAMP(6)                 DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO   DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- PK_T_CAJERO  (Index) 
--
--  Dependencies: 
--   T_USUARIO (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_T_CAJERO ON UAB_GET.T_USUARIO
(ID_USUARIO)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_T_CIUDAD  (Index) 
--
--  Dependencies: 
--   T_CIUDAD (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_T_CIUDAD ON UAB_GET.T_CIUDAD
(ID_CIUDAD)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_T_FACTURA  (Index) 
--
--  Dependencies: 
--   T_FACTURA (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_T_FACTURA ON UAB_GET.T_FACTURA
(ID_FACTURA)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_T_HORARIO  (Index) 
--
--  Dependencies: 
--   T_HORARIO (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_T_HORARIO ON UAB_GET.T_HORARIO
(ID_HORARIO)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_TPAR_ESTADO_ASIENTO  (Index) 
--
--  Dependencies: 
--   TPAR_ESTADO_ASIENTO (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_TPAR_ESTADO_ASIENTO ON UAB_GET.TPAR_ESTADO_ASIENTO
(ID_ESTADO_ASIENTO)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_TPAR_GENERO  (Index) 
--
--  Dependencies: 
--   TPAR_GENERO (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_TPAR_GENERO ON UAB_GET.TPAR_GENERO
(ID_GENERO)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_TPAR_PRECIO  (Index) 
--
--  Dependencies: 
--   TPAR_PRECIO (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_TPAR_PRECIO ON UAB_GET.TPAR_PRECIO
(ID_PRECIO)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_TPAR_SUCURSAL  (Index) 
--
--  Dependencies: 
--   TPAR_SUCURSAL (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_TPAR_SUCURSAL ON UAB_GET.TPAR_SUCURSAL
(ID_SUCURSAL)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_TPAR_TIPO_ASIENTO  (Index) 
--
--  Dependencies: 
--   TPAR_TIPO_ASIENTO (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_TPAR_TIPO_ASIENTO ON UAB_GET.TPAR_TIPO_ASIENTO
(ID_TIPO_ASIENTO)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_TPAR_TIPO_DOCUMENTO  (Index) 
--
--  Dependencies: 
--   TPAR_TIPO_DOCUMENTO (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_TPAR_TIPO_DOCUMENTO ON UAB_GET.TPAR_TIPO_DOCUMENTO
(ID_TIPO_DOCUMENTO)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_TPAR_TIPO_FLOTA  (Index) 
--
--  Dependencies: 
--   TPAR_TIPO_FLOTA (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_TPAR_TIPO_FLOTA ON UAB_GET.TPAR_TIPO_FLOTA
(ID_TIPO_FLOTA)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_TPAR_TIPO_PERSONA  (Index) 
--
--  Dependencies: 
--   TPAR_TIPO_PERSONA (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_TPAR_TIPO_PERSONA ON UAB_GET.TPAR_TIPO_PERSONA
(ID_TIPO_PERSONA)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_TPAR_TIPO_USUARIO  (Index) 
--
--  Dependencies: 
--   TPAR_TIPO_USUARIO (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_TPAR_TIPO_USUARIO ON UAB_GET.TPAR_TIPO_USUARIO
(ID_TIPO_USUARIO)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_T_PERSONA  (Index) 
--
--  Dependencies: 
--   T_PERSONA (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_T_PERSONA ON UAB_GET.T_PERSONA
(ID_PERSONA)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- TPAR_ESTADO_A_ID_ESTADO_AS  (Trigger) 
--
--  Dependencies: 
--   TPAR_ESTADO_ASIENTO (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.TPAR_ESTADO_A_ID_ESTADO_AS 
    BEFORE INSERT 
    ON UAB_GET.TPAR_ESTADO_ASIENTO 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.TPAR_ESTADO_A_ID_ESTADO_AS.NEXTVAL 
        INTO :NEW.ID_ESTADO_ASIENTO 
        FROM DUAL; 
    END;
/


--
-- TPAR_GENERO_ID_GENERO  (Trigger) 
--
--  Dependencies: 
--   TPAR_GENERO (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.TPAR_GENERO_ID_GENERO 
    BEFORE INSERT 
    ON UAB_GET.TPAR_GENERO 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.TPAR_GENERO_ID_GENERO.NEXTVAL 
        INTO :NEW.ID_GENERO 
        FROM DUAL; 
    END;
/


--
-- TPAR_PRECIO_ID_PRECIO  (Trigger) 
--
--  Dependencies: 
--   TPAR_PRECIO (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.TPAR_PRECIO_ID_PRECIO 
    BEFORE INSERT 
    ON UAB_GET.TPAR_PRECIO 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.TPAR_PRECIO_ID_PRECIO.NEXTVAL 
        INTO :NEW.ID_PRECIO 
        FROM DUAL; 
    END;
/


--
-- TPAR_SUCURSAL_ID_SUCURSAL  (Trigger) 
--
--  Dependencies: 
--   TPAR_SUCURSAL (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.TPAR_SUCURSAL_ID_SUCURSAL 
    BEFORE INSERT 
    ON UAB_GET.TPAR_SUCURSAL 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.TPAR_SUCURSAL_ID_SUCURSAL.NEXTVAL 
        INTO :NEW.ID_SUCURSAL 
        FROM DUAL; 
    END;
/


--
-- TPAR_TIPO_ASI_ID_TIPO_ASIE  (Trigger) 
--
--  Dependencies: 
--   TPAR_TIPO_ASIENTO (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.TPAR_TIPO_ASI_ID_TIPO_ASIE 
    BEFORE INSERT 
    ON UAB_GET.TPAR_TIPO_ASIENTO 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.TPAR_TIPO_ASI_ID_TIPO_ASIE.NEXTVAL 
        INTO :NEW.ID_TIPO_ASIENTO 
        FROM DUAL; 
    END;
/


--
-- TPAR_TIPO_DOC_ID_TIPO_DOCU  (Trigger) 
--
--  Dependencies: 
--   TPAR_TIPO_DOCUMENTO (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.TPAR_TIPO_DOC_ID_TIPO_DOCU 
    BEFORE INSERT 
    ON UAB_GET.TPAR_TIPO_DOCUMENTO 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.TPAR_TIPO_DOC_ID_TIPO_DOCU.NEXTVAL 
        INTO :NEW.ID_TIPO_DOCUMENTO 
        FROM DUAL; 
    END;
/


--
-- TPAR_TIPO_FLO_ID_TIPO_FLOT  (Trigger) 
--
--  Dependencies: 
--   TPAR_TIPO_FLOTA (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.TPAR_TIPO_FLO_ID_TIPO_FLOT 
    BEFORE INSERT 
    ON UAB_GET.TPAR_TIPO_FLOTA 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.TPAR_TIPO_FLO_ID_TIPO_FLOT.NEXTVAL 
        INTO :NEW.ID_TIPO_FLOTA 
        FROM DUAL; 
    END;
/


--
-- TPAR_TIPO_PER_ID_TIPO_PERS  (Trigger) 
--
--  Dependencies: 
--   TPAR_TIPO_PERSONA (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.TPAR_TIPO_PER_ID_TIPO_PERS 
    BEFORE INSERT 
    ON UAB_GET.TPAR_TIPO_PERSONA 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.TPAR_TIPO_PER_ID_TIPO_PERS.NEXTVAL 
        INTO :NEW.ID_TIPO_PERSONA 
        FROM DUAL; 
    END;
/


--
-- TPAR_TIPO_USU_ID_TIPO_USUA  (Trigger) 
--
--  Dependencies: 
--   TPAR_TIPO_USUARIO (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.TPAR_TIPO_USU_ID_TIPO_USUA 
    BEFORE INSERT 
    ON UAB_GET.TPAR_TIPO_USUARIO 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.TPAR_TIPO_USU_ID_TIPO_USUA.NEXTVAL 
        INTO :NEW.ID_TIPO_USUARIO 
        FROM DUAL; 
    END;
/


--
-- T_CIUDAD_ID_CIUDAD  (Trigger) 
--
--  Dependencies: 
--   T_CIUDAD (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.T_CIUDAD_ID_CIUDAD 
    BEFORE INSERT 
    ON UAB_GET.T_CIUDAD 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.T_CIUDAD_ID_CIUDAD.NEXTVAL 
        INTO :NEW.ID_CIUDAD 
        FROM DUAL; 
    END;
/


--
-- T_FACTURA_ID_FACTURA  (Trigger) 
--
--  Dependencies: 
--   T_FACTURA (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.T_FACTURA_ID_FACTURA 
    BEFORE INSERT 
    ON UAB_GET.T_FACTURA 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.T_FACTURA_ID_FACTURA.NEXTVAL 
        INTO :NEW.ID_FACTURA 
        FROM DUAL; 
    END;
/


--
-- T_HORARIO_ID_HORARIO  (Trigger) 
--
--  Dependencies: 
--   T_HORARIO (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.T_HORARIO_ID_HORARIO 
    BEFORE INSERT 
    ON UAB_GET.T_HORARIO 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.T_HORARIO_ID_HORARIO.NEXTVAL 
        INTO :NEW.ID_HORARIO 
        FROM DUAL; 
    END;
/


--
-- T_PERSONA_ID_PERSONA  (Trigger) 
--
--  Dependencies: 
--   T_PERSONA (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.T_PERSONA_ID_PERSONA 
    BEFORE INSERT 
    ON UAB_GET.T_PERSONA 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.T_PERSONA_ID_PERSONA.NEXTVAL 
        INTO :NEW.ID_PERSONA 
        FROM DUAL; 
    END;
/


--
-- T_USUARIO_ID_USUARIO  (Trigger) 
--
--  Dependencies: 
--   T_USUARIO (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.T_USUARIO_ID_USUARIO 
    BEFORE INSERT 
    ON UAB_GET.T_USUARIO 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.T_USUARIO_ID_USUARIO.NEXTVAL 
        INTO :NEW.ID_USUARIO 
        FROM DUAL; 
    END;
/


--
-- T_ASIENTO  (Table) 
--
--  Dependencies: 
--   TPAR_TIPO_ASIENTO (Table)
--
--   Row count:6
CREATE TABLE UAB_GET.T_ASIENTO
(
  ID_ASIENTO       NUMBER(15)                   NOT NULL,
  ID_TIPO_ASIENTO  NUMBER(15),
  NUMERO           VARCHAR2(50 BYTE),
  APP_ID_USUARIO   NUMBER(15),
  AUD_ESTADO       NUMBER(1)                    DEFAULT 1,
  AUD_USUARIO      VARCHAR2(50 BYTE)            DEFAULT USER,
  AUD_FECHA        DATE                         DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO   DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- T_DOCUMENTO  (Table) 
--
--  Dependencies: 
--   TPAR_TIPO_DOCUMENTO (Table)
--   T_PERSONA (Table)
--
--   Row count:6
CREATE TABLE UAB_GET.T_DOCUMENTO
(
  ID_DOCUMENTO       NUMBER(15)                 NOT NULL,
  ID_PERSONA         NUMBER(15),
  ID_TIPO_DOCUMENTO  NUMBER(15),
  NUMERO_DOCUMENTO   VARCHAR2(50 BYTE),
  DESCRIPCION        VARCHAR2(150 BYTE),
  APP_ID_USUARIO     NUMBER(15),
  AUD_ESTADO         NUMBER(1)                  DEFAULT 1,
  AUD_USUARIO        VARCHAR2(50 BYTE)          DEFAULT USER,
  AUD_FECHA          TIMESTAMP(6)               DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO     DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- T_FLOTA  (Table) 
--
--  Dependencies: 
--   TPAR_TIPO_FLOTA (Table)
--
--   Row count:29
CREATE TABLE UAB_GET.T_FLOTA
(
  ID_FLOTA        NUMBER(15)                    NOT NULL,
  ID_TIPO_FLOTA   NUMBER(15),
  COLOR           VARCHAR2(50 BYTE),
  PLACA           VARCHAR2(50 BYTE),
  MODELO          VARCHAR2(50 BYTE),
  NRO_ASIENTOS    NUMBER(15),
  APP_ID_USUARIO  NUMBER(15),
  AUD_ESTADO      NUMBER(1)                     DEFAULT 1,
  AUD_USUARIO     VARCHAR2(50 BYTE)             DEFAULT USER,
  AUD_FECHA       TIMESTAMP(6)                  DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO  DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- T_RUTA  (Table) 
--
--  Dependencies: 
--   T_CIUDAD (Table)
--   T_HORARIO (Table)
--   T_FLOTA (Table)
--   TPAR_PRECIO (Table)
--
--   Row count:29
CREATE TABLE UAB_GET.T_RUTA
(
  ID_RUTA            NUMBER(15)                 NOT NULL,
  ID_CIUDAD_ORIGEN   NUMBER(15),
  ID_CIUDAD_DESTINO  NUMBER(15),
  ID_FLOTA           NUMBER(15),
  ID_HORARIO         NUMBER(15),
  ID_PRECIO          NUMBER(15,4),
  ID_CONDUCTOR       NUMBER(15),
  APP_ID_USUARIO     NUMBER(15),
  AUD_ESTADO         NUMBER(1)                  DEFAULT 1,
  AUD_USUARIO        VARCHAR2(50 BYTE)          DEFAULT USER,
  AUD_FECHA          TIMESTAMP(6)               DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO     DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- PK_T_ASIENTO  (Index) 
--
--  Dependencies: 
--   T_ASIENTO (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_T_ASIENTO ON UAB_GET.T_ASIENTO
(ID_ASIENTO)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_T_DOCUMENTO  (Index) 
--
--  Dependencies: 
--   T_DOCUMENTO (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_T_DOCUMENTO ON UAB_GET.T_DOCUMENTO
(ID_DOCUMENTO)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_T_FLOTA  (Index) 
--
--  Dependencies: 
--   T_FLOTA (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_T_FLOTA ON UAB_GET.T_FLOTA
(ID_FLOTA)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_T_RUTA  (Index) 
--
--  Dependencies: 
--   T_RUTA (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_T_RUTA ON UAB_GET.T_RUTA
(ID_RUTA)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- T_ASIENTO_ID_ASIENTO  (Trigger) 
--
--  Dependencies: 
--   T_ASIENTO (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.T_ASIENTO_ID_ASIENTO 
    BEFORE INSERT 
    ON UAB_GET.T_ASIENTO 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.T_ASIENTO_ID_ASIENTO.NEXTVAL 
        INTO :NEW.ID_ASIENTO 
        FROM DUAL; 
    END;
/


--
-- T_DOCUMENTO_ID_DOCUMENTO  (Trigger) 
--
--  Dependencies: 
--   T_DOCUMENTO (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.T_DOCUMENTO_ID_DOCUMENTO 
    BEFORE INSERT 
    ON UAB_GET.T_DOCUMENTO 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.T_DOCUMENTO_ID_DOCUMENTO.NEXTVAL 
        INTO :NEW.ID_DOCUMENTO 
        FROM DUAL; 
    END;
/


--
-- T_FLOTA_ID_FLOTA  (Trigger) 
--
--  Dependencies: 
--   T_FLOTA (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.T_FLOTA_ID_FLOTA 
    BEFORE INSERT 
    ON UAB_GET.T_FLOTA 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.T_FLOTA_ID_FLOTA.NEXTVAL 
        INTO :NEW.ID_FLOTA 
        FROM DUAL; 
    END;
/


--
-- T_RUTA_ID_RUTA  (Trigger) 
--
--  Dependencies: 
--   T_RUTA (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.T_RUTA_ID_RUTA 
    BEFORE INSERT 
    ON UAB_GET.T_RUTA 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.T_RUTA_ID_RUTA.NEXTVAL 
        INTO :NEW.ID_RUTA 
        FROM DUAL; 
    END;
/


--
-- T_ASIENTO_RUTA  (Table) 
--
--  Dependencies: 
--   T_ASIENTO (Table)
--   TPAR_ESTADO_ASIENTO (Table)
--   T_RUTA (Table)
--
--   Row count:5
CREATE TABLE UAB_GET.T_ASIENTO_RUTA
(
  ID_ASIENTO_RUTA    NUMBER(15)                 NOT NULL,
  ID_RUTA            NUMBER(15),
  ID_ASIENTO         NUMBER(15),
  ID_ESTADO_ASIENTO  NUMBER(15),
  DESCRIPCION        VARCHAR2(1000 BYTE),
  APP_ID_USUARIO     NUMBER(15),
  AUD_ESTADO         NUMBER(1)                  DEFAULT 1,
  AUD_USUARIO        VARCHAR2(50 BYTE)          DEFAULT USER,
  AUD_FECHA          TIMESTAMP(6)               DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO     DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/

COMMENT ON TABLE UAB_GET.T_ASIENTO_RUTA IS 'Esta tabla almacena datos sobre los asientos ocupados/libres en una ruta'
/



--
-- T_BOLETO  (Table) 
--
--  Dependencies: 
--   T_RUTA (Table)
--   TPAR_SUCURSAL (Table)
--   T_USUARIO (Table)
--
--   Row count:5
CREATE TABLE UAB_GET.T_BOLETO
(
  ID_BOLETO       NUMBER(15)                    NOT NULL,
  ID_USUARIO      NUMBER(15),
  ID_RUTA         NUMBER(15),
  ID_SUCURSAL     NUMBER(15),
  APP_ID_USUARIO  NUMBER(15),
  AUD_ESTADO      NUMBER(1)                     DEFAULT 1,
  AUD_USUARIO     VARCHAR2(50 BYTE)             DEFAULT USER,
  AUD_FECHA       TIMESTAMP(6)                  DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO  DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- T_DETALLE_BOLETO  (Table) 
--
--  Dependencies: 
--   T_BOLETO (Table)
--   T_ASIENTO (Table)
--   T_PERSONA (Table)
--
--   Row count:4
CREATE TABLE UAB_GET.T_DETALLE_BOLETO
(
  ID_DETALLE_BOLETO  NUMBER(15)                 NOT NULL,
  ID_BOLETO          NUMBER(15),
  ID_ASIENTO         NUMBER(15),
  ID_PERSONA         NUMBER(15),
  APP_ID_USUARIO     NUMBER(15),
  AUD_ESTADO         NUMBER(1)                  DEFAULT 1,
  AUD_USUARIO        VARCHAR2(50 BYTE)          DEFAULT USER,
  AUD_FECHA          TIMESTAMP(6)               DEFAULT SYSTIMESTAMP,
  FECHA_REGISTRO     DATE
)
TABLESPACE USERS
RESULT_CACHE (MODE DEFAULT)
PCTUSED    0
PCTFREE    10
INITRANS   1
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
LOGGING 
NOCOMPRESS 
NOCACHE
NOPARALLEL
MONITORING
/


--
-- PK_T_ASIENTO_RUTA  (Index) 
--
--  Dependencies: 
--   T_ASIENTO_RUTA (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_T_ASIENTO_RUTA ON UAB_GET.T_ASIENTO_RUTA
(ID_ASIENTO_RUTA)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_T_BOLETO  (Index) 
--
--  Dependencies: 
--   T_BOLETO (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_T_BOLETO ON UAB_GET.T_BOLETO
(ID_BOLETO)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- PK_T_DETALLE_BOLETO  (Index) 
--
--  Dependencies: 
--   T_DETALLE_BOLETO (Table)
--
CREATE UNIQUE INDEX UAB_GET.PK_T_DETALLE_BOLETO ON UAB_GET.T_DETALLE_BOLETO
(ID_DETALLE_BOLETO)
LOGGING
TABLESPACE USERS
PCTFREE    10
INITRANS   2
MAXTRANS   255
STORAGE    (
            INITIAL          64K
            NEXT             1M
            MINEXTENTS       1
            MAXEXTENTS       UNLIMITED
            PCTINCREASE      0
            BUFFER_POOL      DEFAULT
            FLASH_CACHE      DEFAULT
            CELL_FLASH_CACHE DEFAULT
           )
NOPARALLEL
/


--
-- T_ASIENTO_RUT_ID_ASIENTO_R  (Trigger) 
--
--  Dependencies: 
--   T_ASIENTO_RUTA (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.T_ASIENTO_RUT_ID_ASIENTO_R 
    BEFORE INSERT 
    ON UAB_GET.T_ASIENTO_RUTA 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.T_ASIENTO_RUT_ID_ASIENTO_R.NEXTVAL 
        INTO :NEW.ID_ASIENTO_RUTA 
        FROM DUAL; 
    END;
/


--
-- T_BOLETO_ID_BOLETO  (Trigger) 
--
--  Dependencies: 
--   T_BOLETO (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.T_BOLETO_ID_BOLETO 
    BEFORE INSERT 
    ON UAB_GET.T_BOLETO 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.T_BOLETO_ID_BOLETO.NEXTVAL 
        INTO :NEW.ID_BOLETO 
        FROM DUAL; 
    END;
/


--
-- T_DETALLE_BOL_ID_DETALLE_B  (Trigger) 
--
--  Dependencies: 
--   T_DETALLE_BOLETO (Table)
--
CREATE OR REPLACE TRIGGER UAB_GET.T_DETALLE_BOL_ID_DETALLE_B 
    BEFORE INSERT 
    ON UAB_GET.T_DETALLE_BOLETO 
    FOR EACH ROW
BEGIN 
        SELECT UAB_GET.T_DETALLE_BOL_ID_DETALLE_B.NEXTVAL 
        INTO :NEW.ID_DETALLE_BOLETO 
        FROM DUAL; 
    END;
/


-- 
-- Non Foreign Key Constraints for Table T_CIUDAD 
-- 
ALTER TABLE UAB_GET.T_CIUDAD ADD (
  CONSTRAINT PK_T_CIUDAD
  PRIMARY KEY
  (ID_CIUDAD)
  USING INDEX UAB_GET.PK_T_CIUDAD
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table T_FACTURA 
-- 
ALTER TABLE UAB_GET.T_FACTURA ADD (
  CONSTRAINT PK_T_FACTURA
  PRIMARY KEY
  (ID_FACTURA)
  USING INDEX UAB_GET.PK_T_FACTURA
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table T_HORARIO 
-- 
ALTER TABLE UAB_GET.T_HORARIO ADD (
  CONSTRAINT PK_T_HORARIO
  PRIMARY KEY
  (ID_HORARIO)
  USING INDEX UAB_GET.PK_T_HORARIO
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table TPAR_ESTADO_ASIENTO 
-- 
ALTER TABLE UAB_GET.TPAR_ESTADO_ASIENTO ADD (
  CONSTRAINT PK_TPAR_ESTADO_ASIENTO
  PRIMARY KEY
  (ID_ESTADO_ASIENTO)
  USING INDEX UAB_GET.PK_TPAR_ESTADO_ASIENTO
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table TPAR_GENERO 
-- 
ALTER TABLE UAB_GET.TPAR_GENERO ADD (
  CONSTRAINT PK_TPAR_GENERO
  PRIMARY KEY
  (ID_GENERO)
  USING INDEX UAB_GET.PK_TPAR_GENERO
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table TPAR_PRECIO 
-- 
ALTER TABLE UAB_GET.TPAR_PRECIO ADD (
  CONSTRAINT PK_TPAR_PRECIO
  PRIMARY KEY
  (ID_PRECIO)
  USING INDEX UAB_GET.PK_TPAR_PRECIO
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table TPAR_SUCURSAL 
-- 
ALTER TABLE UAB_GET.TPAR_SUCURSAL ADD (
  CONSTRAINT PK_TPAR_SUCURSAL
  PRIMARY KEY
  (ID_SUCURSAL)
  USING INDEX UAB_GET.PK_TPAR_SUCURSAL
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table TPAR_TIPO_ASIENTO 
-- 
ALTER TABLE UAB_GET.TPAR_TIPO_ASIENTO ADD (
  CONSTRAINT PK_TPAR_TIPO_ASIENTO
  PRIMARY KEY
  (ID_TIPO_ASIENTO)
  USING INDEX UAB_GET.PK_TPAR_TIPO_ASIENTO
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table TPAR_TIPO_DOCUMENTO 
-- 
ALTER TABLE UAB_GET.TPAR_TIPO_DOCUMENTO ADD (
  CONSTRAINT PK_TPAR_TIPO_DOCUMENTO
  PRIMARY KEY
  (ID_TIPO_DOCUMENTO)
  USING INDEX UAB_GET.PK_TPAR_TIPO_DOCUMENTO
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table TPAR_TIPO_FLOTA 
-- 
ALTER TABLE UAB_GET.TPAR_TIPO_FLOTA ADD (
  CONSTRAINT PK_TPAR_TIPO_FLOTA
  PRIMARY KEY
  (ID_TIPO_FLOTA)
  USING INDEX UAB_GET.PK_TPAR_TIPO_FLOTA
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table TPAR_TIPO_PERSONA 
-- 
ALTER TABLE UAB_GET.TPAR_TIPO_PERSONA ADD (
  CONSTRAINT PK_TPAR_TIPO_PERSONA
  PRIMARY KEY
  (ID_TIPO_PERSONA)
  USING INDEX UAB_GET.PK_TPAR_TIPO_PERSONA
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table TPAR_TIPO_USUARIO 
-- 
ALTER TABLE UAB_GET.TPAR_TIPO_USUARIO ADD (
  CONSTRAINT PK_TPAR_TIPO_USUARIO
  PRIMARY KEY
  (ID_TIPO_USUARIO)
  USING INDEX UAB_GET.PK_TPAR_TIPO_USUARIO
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table T_PERSONA 
-- 
ALTER TABLE UAB_GET.T_PERSONA ADD (
  CONSTRAINT PK_T_PERSONA
  PRIMARY KEY
  (ID_PERSONA)
  USING INDEX UAB_GET.PK_T_PERSONA
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table T_USUARIO 
-- 
ALTER TABLE UAB_GET.T_USUARIO ADD (
  CONSTRAINT PK_T_CAJERO
  PRIMARY KEY
  (ID_USUARIO)
  USING INDEX UAB_GET.PK_T_CAJERO
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table T_ASIENTO 
-- 
ALTER TABLE UAB_GET.T_ASIENTO ADD (
  CONSTRAINT PK_T_ASIENTO
  PRIMARY KEY
  (ID_ASIENTO)
  USING INDEX UAB_GET.PK_T_ASIENTO
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table T_DOCUMENTO 
-- 
ALTER TABLE UAB_GET.T_DOCUMENTO ADD (
  CONSTRAINT PK_T_DOCUMENTO
  PRIMARY KEY
  (ID_DOCUMENTO)
  USING INDEX UAB_GET.PK_T_DOCUMENTO
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table T_FLOTA 
-- 
ALTER TABLE UAB_GET.T_FLOTA ADD (
  CONSTRAINT PK_T_FLOTA
  PRIMARY KEY
  (ID_FLOTA)
  USING INDEX UAB_GET.PK_T_FLOTA
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table T_RUTA 
-- 
ALTER TABLE UAB_GET.T_RUTA ADD (
  CONSTRAINT PK_T_RUTA
  PRIMARY KEY
  (ID_RUTA)
  USING INDEX UAB_GET.PK_T_RUTA
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table T_ASIENTO_RUTA 
-- 
ALTER TABLE UAB_GET.T_ASIENTO_RUTA ADD (
  CONSTRAINT PK_T_ASIENTO_RUTA
  PRIMARY KEY
  (ID_ASIENTO_RUTA)
  USING INDEX UAB_GET.PK_T_ASIENTO_RUTA
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table T_BOLETO 
-- 
ALTER TABLE UAB_GET.T_BOLETO ADD (
  CONSTRAINT PK_T_BOLETO
  PRIMARY KEY
  (ID_BOLETO)
  USING INDEX UAB_GET.PK_T_BOLETO
  ENABLE VALIDATE)
/

-- 
-- Non Foreign Key Constraints for Table T_DETALLE_BOLETO 
-- 
ALTER TABLE UAB_GET.T_DETALLE_BOLETO ADD (
  CONSTRAINT PK_T_DETALLE_BOLETO
  PRIMARY KEY
  (ID_DETALLE_BOLETO)
  USING INDEX UAB_GET.PK_T_DETALLE_BOLETO
  ENABLE VALIDATE)
/

-- 
-- Foreign Key Constraints for Table T_PERSONA 
-- 
ALTER TABLE UAB_GET.T_PERSONA ADD (
  CONSTRAINT FK_PERS_GENE 
  FOREIGN KEY (ID_GENERO) 
  REFERENCES UAB_GET.TPAR_GENERO (ID_GENERO)
  ON DELETE CASCADE
  ENABLE VALIDATE,
  CONSTRAINT FK_TPAR_TIPE 
  FOREIGN KEY (ID_TIPO_PERSONA) 
  REFERENCES UAB_GET.TPAR_TIPO_PERSONA (ID_TIPO_PERSONA)
  ON DELETE CASCADE
  ENABLE VALIDATE)
/

-- 
-- Foreign Key Constraints for Table T_USUARIO 
-- 
ALTER TABLE UAB_GET.T_USUARIO ADD (
  CONSTRAINT FK_USUA_PERS 
  FOREIGN KEY (ID_PERSONA) 
  REFERENCES UAB_GET.T_PERSONA (ID_PERSONA)
  ENABLE VALIDATE,
  CONSTRAINT FK_USUA_SUCU 
  FOREIGN KEY (ID_SUCURSAL) 
  REFERENCES UAB_GET.TPAR_SUCURSAL (ID_SUCURSAL)
  ON DELETE CASCADE
  ENABLE VALIDATE,
  CONSTRAINT FK_USUA_TIUS 
  FOREIGN KEY (ID_TIPO_USUARIO) 
  REFERENCES UAB_GET.TPAR_TIPO_USUARIO (ID_TIPO_USUARIO)
  ON DELETE CASCADE
  ENABLE VALIDATE)
/

-- 
-- Foreign Key Constraints for Table T_ASIENTO 
-- 
ALTER TABLE UAB_GET.T_ASIENTO ADD (
  CONSTRAINT FK_ASIE_TIAS 
  FOREIGN KEY (ID_TIPO_ASIENTO) 
  REFERENCES UAB_GET.TPAR_TIPO_ASIENTO (ID_TIPO_ASIENTO)
  ON DELETE CASCADE
  ENABLE VALIDATE)
/

-- 
-- Foreign Key Constraints for Table T_DOCUMENTO 
-- 
ALTER TABLE UAB_GET.T_DOCUMENTO ADD (
  CONSTRAINT FK_DOCU_PERS 
  FOREIGN KEY (ID_PERSONA) 
  REFERENCES UAB_GET.T_PERSONA (ID_PERSONA)
  ON DELETE CASCADE
  ENABLE VALIDATE,
  CONSTRAINT FK_DOCU_TIDO 
  FOREIGN KEY (ID_TIPO_DOCUMENTO) 
  REFERENCES UAB_GET.TPAR_TIPO_DOCUMENTO (ID_TIPO_DOCUMENTO)
  ON DELETE CASCADE
  ENABLE VALIDATE)
/

-- 
-- Foreign Key Constraints for Table T_FLOTA 
-- 
ALTER TABLE UAB_GET.T_FLOTA ADD (
  CONSTRAINT FK_FLOT_TIFL 
  FOREIGN KEY (ID_TIPO_FLOTA) 
  REFERENCES UAB_GET.TPAR_TIPO_FLOTA (ID_TIPO_FLOTA)
  ON DELETE CASCADE
  ENABLE VALIDATE)
/

-- 
-- Foreign Key Constraints for Table T_RUTA 
-- 
ALTER TABLE UAB_GET.T_RUTA ADD (
  CONSTRAINT FK_RUTA_CIDE 
  FOREIGN KEY (ID_CIUDAD_DESTINO) 
  REFERENCES UAB_GET.T_CIUDAD (ID_CIUDAD)
  ON DELETE CASCADE
  ENABLE VALIDATE,
  CONSTRAINT FK_RUTA_CIOR 
  FOREIGN KEY (ID_CIUDAD_ORIGEN) 
  REFERENCES UAB_GET.T_CIUDAD (ID_CIUDAD)
  ON DELETE CASCADE
  ENABLE VALIDATE,
  CONSTRAINT FK_RUTA_FLOT 
  FOREIGN KEY (ID_FLOTA) 
  REFERENCES UAB_GET.T_FLOTA (ID_FLOTA)
  ON DELETE CASCADE
  ENABLE VALIDATE,
  CONSTRAINT FK_RUTA_HORA 
  FOREIGN KEY (ID_HORARIO) 
  REFERENCES UAB_GET.T_HORARIO (ID_HORARIO)
  ON DELETE CASCADE
  ENABLE VALIDATE,
  CONSTRAINT FK_T_RUTA_TPAR_PRECIO 
  FOREIGN KEY (ID_PRECIO) 
  REFERENCES UAB_GET.TPAR_PRECIO (ID_PRECIO)
  ON DELETE CASCADE
  ENABLE VALIDATE)
/

-- 
-- Foreign Key Constraints for Table T_ASIENTO_RUTA 
-- 
ALTER TABLE UAB_GET.T_ASIENTO_RUTA ADD (
  CONSTRAINT FK_ASIE_RUTA 
  FOREIGN KEY (ID_RUTA) 
  REFERENCES UAB_GET.T_RUTA (ID_RUTA)
  ON DELETE CASCADE
  ENABLE VALIDATE,
  CONSTRAINT FK_ASRU_ASIE 
  FOREIGN KEY (ID_ASIENTO) 
  REFERENCES UAB_GET.T_ASIENTO (ID_ASIENTO)
  ON DELETE CASCADE
  ENABLE VALIDATE,
  CONSTRAINT FK_ASRU_ESAS 
  FOREIGN KEY (ID_ESTADO_ASIENTO) 
  REFERENCES UAB_GET.TPAR_ESTADO_ASIENTO (ID_ESTADO_ASIENTO)
  ON DELETE CASCADE
  ENABLE VALIDATE)
/

-- 
-- Foreign Key Constraints for Table T_BOLETO 
-- 
ALTER TABLE UAB_GET.T_BOLETO ADD (
  CONSTRAINT FK_BOLE_RUTA 
  FOREIGN KEY (ID_RUTA) 
  REFERENCES UAB_GET.T_RUTA (ID_RUTA)
  ON DELETE CASCADE
  ENABLE VALIDATE,
  CONSTRAINT FK_BOLE_SUCU 
  FOREIGN KEY (ID_SUCURSAL) 
  REFERENCES UAB_GET.TPAR_SUCURSAL (ID_SUCURSAL)
  ON DELETE CASCADE
  ENABLE VALIDATE,
  CONSTRAINT FK_BOLE_USUA 
  FOREIGN KEY (ID_USUARIO) 
  REFERENCES UAB_GET.T_USUARIO (ID_USUARIO)
  ON DELETE CASCADE
  ENABLE VALIDATE)
/

-- 
-- Foreign Key Constraints for Table T_DETALLE_BOLETO 
-- 
ALTER TABLE UAB_GET.T_DETALLE_BOLETO ADD (
  CONSTRAINT FK_DEBO_ASIE 
  FOREIGN KEY (ID_ASIENTO) 
  REFERENCES UAB_GET.T_ASIENTO (ID_ASIENTO)
  ON DELETE CASCADE
  ENABLE VALIDATE,
  CONSTRAINT FK_DEBO_BOLE 
  FOREIGN KEY (ID_BOLETO) 
  REFERENCES UAB_GET.T_BOLETO (ID_BOLETO)
  ON DELETE CASCADE
  ENABLE VALIDATE,
  CONSTRAINT FK_DEBO_PERS 
  FOREIGN KEY (ID_PERSONA) 
  REFERENCES UAB_GET.T_PERSONA (ID_PERSONA)
  ON DELETE CASCADE
  ENABLE VALIDATE)
/

ALTER TABLE UAB_GET.T_ASIENTO ADD (
  CONSTRAINT FK_ASIE_TIAS 
  FOREIGN KEY (ID_TIPO_ASIENTO) 
  REFERENCES UAB_GET.TPAR_TIPO_ASIENTO (ID_TIPO_ASIENTO)
  ON DELETE CASCADE)
/

ALTER TABLE UAB_GET.T_ASIENTO_RUTA ADD (
  CONSTRAINT FK_ASIE_RUTA 
  FOREIGN KEY (ID_RUTA) 
  REFERENCES UAB_GET.T_RUTA (ID_RUTA)
  ON DELETE CASCADE,
  CONSTRAINT FK_ASRU_ASIE 
  FOREIGN KEY (ID_ASIENTO) 
  REFERENCES UAB_GET.T_ASIENTO (ID_ASIENTO)
  ON DELETE CASCADE,
  CONSTRAINT FK_ASRU_ESAS 
  FOREIGN KEY (ID_ESTADO_ASIENTO) 
  REFERENCES UAB_GET.TPAR_ESTADO_ASIENTO (ID_ESTADO_ASIENTO)
  ON DELETE CASCADE)
/

ALTER TABLE UAB_GET.T_BOLETO ADD (
  CONSTRAINT FK_BOLE_RUTA 
  FOREIGN KEY (ID_RUTA) 
  REFERENCES UAB_GET.T_RUTA (ID_RUTA)
  ON DELETE CASCADE,
  CONSTRAINT FK_BOLE_SUCU 
  FOREIGN KEY (ID_SUCURSAL) 
  REFERENCES UAB_GET.TPAR_SUCURSAL (ID_SUCURSAL)
  ON DELETE CASCADE,
  CONSTRAINT FK_BOLE_USUA 
  FOREIGN KEY (ID_USUARIO) 
  REFERENCES UAB_GET.T_USUARIO (ID_USUARIO)
  ON DELETE CASCADE)
/

ALTER TABLE UAB_GET.T_DETALLE_BOLETO ADD (
  CONSTRAINT FK_DEBO_ASIE 
  FOREIGN KEY (ID_ASIENTO) 
  REFERENCES UAB_GET.T_ASIENTO (ID_ASIENTO)
  ON DELETE CASCADE,
  CONSTRAINT FK_DEBO_BOLE 
  FOREIGN KEY (ID_BOLETO) 
  REFERENCES UAB_GET.T_BOLETO (ID_BOLETO)
  ON DELETE CASCADE,
  CONSTRAINT FK_DEBO_PERS 
  FOREIGN KEY (ID_PERSONA) 
  REFERENCES UAB_GET.T_PERSONA (ID_PERSONA)
  ON DELETE CASCADE)
/

ALTER TABLE UAB_GET.T_DOCUMENTO ADD (
  CONSTRAINT FK_DOCU_PERS 
  FOREIGN KEY (ID_PERSONA) 
  REFERENCES UAB_GET.T_PERSONA (ID_PERSONA)
  ON DELETE CASCADE,
  CONSTRAINT FK_DOCU_TIDO 
  FOREIGN KEY (ID_TIPO_DOCUMENTO) 
  REFERENCES UAB_GET.TPAR_TIPO_DOCUMENTO (ID_TIPO_DOCUMENTO)
  ON DELETE CASCADE)
/

ALTER TABLE UAB_GET.T_FLOTA ADD (
  CONSTRAINT FK_FLOT_TIFL 
  FOREIGN KEY (ID_TIPO_FLOTA) 
  REFERENCES UAB_GET.TPAR_TIPO_FLOTA (ID_TIPO_FLOTA)
  ON DELETE CASCADE)
/

ALTER TABLE UAB_GET.T_PERSONA ADD (
  CONSTRAINT FK_PERS_GENE 
  FOREIGN KEY (ID_GENERO) 
  REFERENCES UAB_GET.TPAR_GENERO (ID_GENERO)
  ON DELETE CASCADE,
  CONSTRAINT FK_TPAR_TIPE 
  FOREIGN KEY (ID_TIPO_PERSONA) 
  REFERENCES UAB_GET.TPAR_TIPO_PERSONA (ID_TIPO_PERSONA)
  ON DELETE CASCADE)
/

ALTER TABLE UAB_GET.T_RUTA ADD (
  CONSTRAINT FK_RUTA_CIDE 
  FOREIGN KEY (ID_CIUDAD_DESTINO) 
  REFERENCES UAB_GET.T_CIUDAD (ID_CIUDAD)
  ON DELETE CASCADE,
  CONSTRAINT FK_RUTA_CIOR 
  FOREIGN KEY (ID_CIUDAD_ORIGEN) 
  REFERENCES UAB_GET.T_CIUDAD (ID_CIUDAD)
  ON DELETE CASCADE,
  CONSTRAINT FK_RUTA_FLOT 
  FOREIGN KEY (ID_FLOTA) 
  REFERENCES UAB_GET.T_FLOTA (ID_FLOTA)
  ON DELETE CASCADE,
  CONSTRAINT FK_RUTA_HORA 
  FOREIGN KEY (ID_HORARIO) 
  REFERENCES UAB_GET.T_HORARIO (ID_HORARIO)
  ON DELETE CASCADE,
  CONSTRAINT FK_T_RUTA_TPAR_PRECIO 
  FOREIGN KEY (ID_PRECIO) 
  REFERENCES UAB_GET.TPAR_PRECIO (ID_PRECIO)
  ON DELETE CASCADE)
/

ALTER TABLE UAB_GET.T_USUARIO ADD (
  CONSTRAINT FK_USUA_PERS 
  FOREIGN KEY (ID_PERSONA) 
  REFERENCES UAB_GET.T_PERSONA (ID_PERSONA),
  CONSTRAINT FK_USUA_SUCU 
  FOREIGN KEY (ID_SUCURSAL) 
  REFERENCES UAB_GET.TPAR_SUCURSAL (ID_SUCURSAL)
  ON DELETE CASCADE,
  CONSTRAINT FK_USUA_TIUS 
  FOREIGN KEY (ID_TIPO_USUARIO) 
  REFERENCES UAB_GET.TPAR_TIPO_USUARIO (ID_TIPO_USUARIO)
  ON DELETE CASCADE)
/

--
-- PGET_GESTION  (Package) 
--
CREATE OR REPLACE PACKAGE UAB_GET.PGET_GESTION AS
/******************************************************************************
   NAME:       GET_GESTION
   PURPOSE:

   REVISIONS:
   Ver        Date        Author           Description
   ---------  ----------  ---------------  ------------------------------------
   1.0        23/03/2015      HENRRY       1. Created this package.
******************************************************************************/
PROCEDURE P_REGISTRAR_GENERO(
I_CREDENCIAL        IN  VARCHAR2,
I_ID_GENERO         IN UAB_GET.TPAR_GENERO.ID_GENERO%TYPE,
I_DESCRIPCION       IN UAB_GET.TPAR_GENERO.DESCRIPCION%TYPE, 
I_APP_ID_USUARIO    IN UAB_GET.TPAR_GENERO.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO        IN UAB_GET.TPAR_GENERO.AUD_ESTADO%TYPE,
I_FECHA_REGISTRO    IN UAB_GET.TPAR_GENERO.FECHA_REGISTRO%TYPE,
O_RESULTADO OUT SYS_REFCURSOR
);

PROCEDURE P_REGISTRA_DOCUMENTO(
I_CREDENCIAL           IN  VARCHAR2,
I_ID_DOCUMENTO         IN UAB_GET.T_DOCUMENTO.ID_DOCUMENTO%TYPE,
I_ID_PERSONA           IN UAB_GET.T_DOCUMENTO.ID_PERSONA%TYPE, 
I_ID_TIPO_DOCUMENTO    IN UAB_GET.T_DOCUMENTO.ID_TIPO_DOCUMENTO%TYPE,
I_NUMERO_DOCUMENTO     IN UAB_GET.T_DOCUMENTO.NUMERO_DOCUMENTO%TYPE,
I_DESCRIPCION          IN UAB_GET.T_DOCUMENTO.DESCRIPCION%TYPE,
I_APP_ID_USUARIO       IN UAB_GET.T_DOCUMENTO.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO           IN UAB_GET.T_DOCUMENTO.AUD_ESTADO%TYPE,
I_FECHA_REGISTRO       IN UAB_GET.T_DOCUMENTO.FECHA_REGISTRO%TYPE,
O_RESULTADO OUT SYS_REFCURSOR
);

PROCEDURE P_REGISTRAR_PERSONA(
I_CREDENCIAL           IN  VARCHAR2,
I_ID_PERSONA           IN UAB_GET.T_PERSONA.ID_PERSONA%TYPE, 
I_ID_TIPO_PERSONA      IN UAB_GET.T_PERSONA.ID_TIPO_PERSONA%TYPE, 
I_ID_GENERO            IN UAB_GET.T_PERSONA.ID_GENERO%TYPE,
I_NOMBRE               IN UAB_GET.T_PERSONA.NOMBRE%TYPE,
I_AP_PATERNO           IN UAB_GET.T_PERSONA.AP_PATERNO%TYPE,
I_AP_MATERNO           IN UAB_GET.T_PERSONA.AP_MATERNO%TYPE,
I_FECHA_NACIMIENTO     IN UAB_GET.T_PERSONA.FECHA_NACIMIENTO%TYPE,
I_DIRECCION            IN UAB_GET.T_PERSONA.DIRECCION%TYPE,
I_EMAIL                IN UAB_GET.T_PERSONA.EMAIL%TYPE,
I_APP_ID_USUARIO       IN UAB_GET.T_PERSONA.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO           IN UAB_GET.T_PERSONA.AUD_ESTADO%TYPE,
I_FECHA_REGISTRO       IN UAB_GET.T_PERSONA.FECHA_REGISTRO%TYPE,
O_RESULTADO OUT SYS_REFCURSOR
);

PROCEDURE P_REGISTRA_TPAR_PRECIO(
I_CREDENCIAL        IN  VARCHAR2,
I_ID_PRECIO         IN UAB_GET.TPAR_PRECIO.ID_PRECIO%TYPE,
I_PRECIO            IN UAB_GET.TPAR_PRECIO.PRECIO%TYPE, 
I_COSTO             IN UAB_GET.TPAR_PRECIO.COSTO%TYPE, 
I_OBSERVACIONES      IN UAB_GET.TPAR_PRECIO.OBSERVACIONES%TYPE, 
I_APP_ID_USUARIO    IN UAB_GET.TPAR_PRECIO.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO        IN UAB_GET.TPAR_PRECIO.AUD_ESTADO%TYPE,
I_AUD_USUARIO       IN UAB_GET.TPAR_PRECIO.AUD_USUARIO%TYPE,
I_AUD_FECHA         IN UAB_GET.TPAR_PRECIO.AUD_FECHA%TYPE,
I_FECHA_REGISTRO    IN UAB_GET.TPAR_PRECIO.FECHA_REGISTRO%TYPE,
O_RESULTADO OUT SYS_REFCURSOR
);
PROCEDURE P_REGISTRAR_BOLETO(
I_CREDENCIAL          IN  VARCHAR2,
I_ID_BOLETO           IN UAB_GET.T_BOLETO.ID_BOLETO%TYPE,
I_ID_USUARIO          IN UAB_GET.T_BOLETO.ID_USUARIO%TYPE,
I_ID_RUTA             IN UAB_GET.T_BOLETO.ID_RUTA%TYPE,
I_ID_SUCURSAL         IN UAB_GET.T_BOLETO.ID_SUCURSAL%TYPE,
I_APP_ID_USUARIO      IN UAB_GET.T_BOLETO.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO          IN UAB_GET.T_BOLETO.AUD_ESTADO%TYPE,
I_FECHA_REGISTRO      IN UAB_GET.T_BOLETO.FECHA_REGISTRO%TYPE,
O_RESULTADO OUT SYS_REFCURSOR
);
PROCEDURE P_REGISTRA_HORARIO(
I_CREDENCIAL        IN  VARCHAR2,
I_ID_HORARIO        IN UAB_GET.T_HORARIO.ID_HORARIO%TYPE,
I_HORA              IN UAB_GET.T_HORARIO.HORA%TYPE,
I_APP_ID_USUARIO    IN UAB_GET.T_HORARIO.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO        IN UAB_GET.T_HORARIO.AUD_ESTADO%TYPE,
I_AUD_USUARIO       IN UAB_GET.T_HORARIO.APP_ID_USUARIO%TYPE,
I_AUD_FECHA         IN UAB_GET.T_HORARIO.AUD_FECHA%TYPE,
I_FECHA_REGISTRO    IN UAB_GET.T_HORARIO.FECHA_REGISTRO%TYPE,
O_RESULTADO OUT SYS_REFCURSOR
);
PROCEDURE P_REGISTRA_FLOTA(
I_CREDENCIAL        IN  VARCHAR2,
I_ID_FLOTA          IN UAB_GET.T_FLOTA.ID_FLOTA%TYPE,
I_ID_TIPO_FLOTA     IN UAB_GET.T_FLOTA.ID_TIPO_FLOTA%TYPE,
I_COLOR             IN UAB_GET.T_FLOTA.COLOR%TYPE,
I_PLACA             IN UAB_GET.T_FLOTA.PLACA       %TYPE,
I_MODELO            IN UAB_GET.T_FLOTA.MODELO      %TYPE,
I_NRO_ASIENTOS      IN UAB_GET.T_FLOTA.NRO_ASIENTOS%TYPE,
I_APP_ID_USUARIO    IN UAB_GET.T_FLOTA.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO        IN UAB_GET.T_FLOTA.AUD_ESTADO%TYPE,
I_AUD_USUARIO       IN UAB_GET.T_FLOTA.AUD_USUARIO%TYPE,
I_AUD_FECHA         IN UAB_GET.T_FLOTA.AUD_FECHA%TYPE,
I_FECHA_REGISTRO    IN UAB_GET.T_FLOTA.FECHA_REGISTRO%TYPE,
O_RESULTADO OUT SYS_REFCURSOR
);


PROCEDURE P_REGISTRA_CIUDAD(
I_CREDENCIAL        IN  VARCHAR2,
I_ID_CIUDAD         IN UAB_GET.T_CIUDAD.ID_CIUDAD%TYPE,
I_NOMBRE            IN UAB_GET.T_CIUDAD.NOMBRE%TYPE,
I_APP_ID_USUARIO    IN UAB_GET.T_CIUDAD.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO        IN UAB_GET.T_CIUDAD.AUD_ESTADO%TYPE,
I_AUD_USUARIO        IN UAB_GET.T_CIUDAD.AUD_USUARIO%TYPE,
I_AUD_FECHA         IN UAB_GET.T_CIUDAD.AUD_FECHA%TYPE,
I_FECHA_REGISTRO    IN UAB_GET.T_CIUDAD.FECHA_REGISTRO%TYPE,
O_RESULTADO OUT SYS_REFCURSOR
);
PROCEDURE P_REGISTRA_SUCURSAL(
I_CREDENCIAL        IN  VARCHAR2,
I_ID_SUCURSAL         IN UAB_GET.TPAR_SUCURSAL.ID_SUCURSAL%TYPE,
I_NOMBRE              IN UAB_GET.TPAR_SUCURSAL.NOMBRE%TYPE,
I_TELEFONO            IN UAB_GET.TPAR_SUCURSAL.TELEFONO%TYPE,
I_DIRECCION           IN UAB_GET.TPAR_SUCURSAL.DIRECCION%TYPE,
I_APP_ID_USUARIO     IN UAB_GET.TPAR_SUCURSAL.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO          IN UAB_GET.TPAR_SUCURSAL.AUD_ESTADO%TYPE,
I_AUD_USUARIO         IN UAB_GET.TPAR_SUCURSAL.AUD_USUARIO%TYPE,
I_AUD_FECHA           IN UAB_GET.TPAR_SUCURSAL.AUD_FECHA%TYPE,
I_FECHA_REGISTRO      IN UAB_GET.TPAR_SUCURSAL.FECHA_REGISTRO%TYPE,
O_RESULTADO OUT SYS_REFCURSOR
); 

PROCEDURE P_REGISTRA_USUARIO(
I_CREDENCIAL        IN  VARCHAR2,
I_ID_USUARIO           IN UAB_GET.T_USUARIO.ID_USUARIO%TYPE,
I_ID_PERSONA           IN UAB_GET.T_USUARIO.ID_PERSONA%TYPE,
I_ID_SUCURSAL          IN UAB_GET.T_USUARIO.ID_SUCURSAL%TYPE,
I_ID_TIPO_USUARIO      IN UAB_GET.T_USUARIO.ID_TIPO_USUARIO%TYPE,
I_CLAVE             IN UAB_GET.T_USUARIO.CLAVE%TYPE,
I_USUARIO                 IN UAB_GET.T_USUARIO.USUARIO%TYPE,
I_APP_ID_USUARIO       IN UAB_GET.T_USUARIO.APP_ID_USUARIO %TYPE,
I_AUD_ESTADO           IN UAB_GET.T_USUARIO.AUD_ESTADO%TYPE,
I_AUD_USUARIO          IN UAB_GET.T_USUARIO.AUD_USUARIO%TYPE,
I_AUD_FECHA            IN UAB_GET.T_USUARIO.AUD_FECHA%TYPE,
I_FECHA_REGISTRO       IN UAB_GET.T_USUARIO.FECHA_REGISTRO %TYPE,
O_RESULTADO OUT SYS_REFCURSOR
);

PROCEDURE P_REGISTRAR_DETALLE_BOLETO(
I_CREDENCIAL          IN  VARCHAR2,
I_ID_DETALLE_BOLETO   IN UAB_GET.T_DETALLE_BOLETO.ID_DETALLE_BOLETO%TYPE,
I_ID_BOLETO           IN UAB_GET.T_DETALLE_BOLETO.ID_BOLETO%TYPE,
I_ID_ASIENTO          IN UAB_GET.T_DETALLE_BOLETO.ID_ASIENTO%TYPE,
I_ID_PERSONA          IN UAB_GET.T_DETALLE_BOLETO.ID_PERSONA%TYPE,
I_APP_ID_USUARIO      IN UAB_GET.T_DETALLE_BOLETO.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO          IN UAB_GET.T_DETALLE_BOLETO.AUD_ESTADO%TYPE,
I_FECHA_REGISTRO      IN UAB_GET.T_DETALLE_BOLETO.FECHA_REGISTRO%TYPE,
O_RESULTADO OUT SYS_REFCURSOR
);

PROCEDURE P_REGISTRAR_ASIENTO(
I_CREDENCIAL          IN  VARCHAR2,

I_ID_ASIENTO          IN UAB_GET.T_ASIENTO.ID_ASIENTO%TYPE,
I_ID_TIPO_ASIENTO     IN UAB_GET.T_ASIENTO.ID_TIPO_ASIENTO%TYPE,
I_NUMERO              IN UAB_GET.T_ASIENTO.NUMERO%TYPE,
I_APP_ID_USUARIO      IN UAB_GET.T_ASIENTO.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO          IN UAB_GET.T_ASIENTO.AUD_ESTADO%TYPE,
I_FECHA_REGISTRO      IN UAB_GET.T_ASIENTO.FECHA_REGISTRO%TYPE,
O_RESULTADO OUT SYS_REFCURSOR
);
PROCEDURE P_REGISTRAR_ASIENTO_RUTA(
I_CREDENCIAL          IN  VARCHAR2,

I_ID_ASIENTO_RUTA       IN UAB_GET.T_ASIENTO_RUTA.ID_ASIENTO_RUTA%TYPE,
I_ID_RUTA               IN UAB_GET.T_ASIENTO_RUTA.ID_RUTA%TYPE,
I_ID_ASIENTO            IN UAB_GET.T_ASIENTO_RUTA.ID_ASIENTO%TYPE,
I_ID_ESTADO_ASIENTO     IN UAB_GET.T_ASIENTO_RUTA.ID_ESTADO_ASIENTO%TYPE,
I_DESCRIPCION           IN UAB_GET.T_ASIENTO_RUTA.DESCRIPCION%TYPE,
I_APP_ID_USUARIO      IN UAB_GET.T_ASIENTO_RUTA.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO          IN UAB_GET.T_ASIENTO_RUTA.AUD_ESTADO%TYPE,
I_FECHA_REGISTRO      IN UAB_GET.T_ASIENTO_RUTA.FECHA_REGISTRO%TYPE,
O_RESULTADO OUT SYS_REFCURSOR
);

PROCEDURE P_REGISTRAR_RUTA(
I_CREDENCIAL          IN  VARCHAR2,
I_ID_RUTA           IN UAB_GET.T_RUTA.ID_RUTA%TYPE,
I_ID_CIUDAD_ORIGEN  IN UAB_GET.T_RUTA.ID_CIUDAD_ORIGEN%TYPE,
I_ID_CIUDAD_DESTINO IN UAB_GET.T_RUTA.ID_CIUDAD_DESTINO%TYPE,
I_ID_FLOTA          IN UAB_GET.T_RUTA.ID_FLOTA%TYPE,
I_ID_HORARIO        IN UAB_GET.T_RUTA.ID_HORARIO%TYPE,
I_ID_PRECIO         IN UAB_GET.T_RUTA.ID_PRECIO%TYPE,
I_ID_CONDUCTOR      IN UAB_GET.T_RUTA.ID_CONDUCTOR%TYPE,
I_APP_ID_USUARIO      IN UAB_GET.T_RUTA.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO          IN UAB_GET.T_RUTA.AUD_ESTADO%TYPE,
I_FECHA_REGISTRO      IN UAB_GET.T_RUTA.FECHA_REGISTRO%TYPE,
O_RESULTADO OUT SYS_REFCURSOR
);
END PGET_GESTION;
/

--
-- PGET_LISTADOS  (Package) 
--
CREATE OR REPLACE PACKAGE UAB_GET.PGET_LISTADOS AS
/******************************************************************************
   NAME:       PGET_LISTADOS
   PURPOSE:

   REVISIONS:
   Ver        Date        Author           Description
   ---------  ----------  ---------------  ------------------------------------
   1.0        23/03/2015      HENRRY       1. Created this package.
******************************************************************************/
PROCEDURE P_LISTAR_GENERO ( 
I_CREDENCIAL        IN  VARCHAR2,
I_ID_GENERO         IN UAB_GET.TPAR_GENERO.ID_GENERO%TYPE,
I_DESCRIPCION       IN UAB_GET.TPAR_GENERO.DESCRIPCION%TYPE, 
I_APP_ID_USUARIO    IN UAB_GET.TPAR_GENERO.APP_ID_USUARIO%TYPE,
I_AUD_ESTADO        IN UAB_GET.TPAR_GENERO.AUD_ESTADO%TYPE,
I_FECHA_REGISTRO    IN UAB_GET.TPAR_GENERO.FECHA_REGISTRO%TYPE,
O_LISTAR_GENERO  OUT SYS_REFCURSOR
);
PROCEDURE P_LISTAR_PERSONA ( 
    I_CREDENCIAL        IN VARCHAR2, 
    I_ID_PERSONA        IN UAB_GET.T_PERSONA.ID_PERSONA%TYPE,
    I_ID_TIPO_PERSONA   IN UAB_GET.T_PERSONA.ID_TIPO_PERSONA%TYPE,
    I_TIPO_PERSONA      IN UAB_GET.TPAR_TIPO_PERSONA.DESCRIPCION%TYPE,
    I_ID_GENERO         IN UAB_GET.T_PERSONA.ID_GENERO%TYPE,
    I_GENERO            IN UAB_GET.TPAR_GENERO.DESCRIPCION%TYPE,
    I_NOMBRE            IN UAB_GET.T_PERSONA.NOMBRE%TYPE,
    I_AP_PATERNO        IN UAB_GET.T_PERSONA.AP_PATERNO%TYPE,
    I_AP_MATERNO        IN UAB_GET.T_PERSONA.AP_MATERNO%TYPE,
    I_FECHA_NACIMIENTO  IN UAB_GET.T_PERSONA.FECHA_NACIMIENTO%TYPE,
    I_DIRECCION         IN UAB_GET.T_PERSONA.DIRECCION%TYPE,
    I_EMAIL             IN UAB_GET.T_PERSONA.EMAIL%TYPE,
    I_APP_ID_USUARIO    IN UAB_GET.T_PERSONA.APP_ID_USUARIO%TYPE,
    I_AUD_ESTADO        IN UAB_GET.T_PERSONA.AUD_ESTADO%TYPE,
    I_FECHA_REGISTRO    IN UAB_GET.T_PERSONA.FECHA_REGISTRO%TYPE,
      
  O_LISTAR_PERSONA  OUT SYS_REFCURSOR
  );
  
    PROCEDURE P_LISTAR_DOCUMENTO( 
    I_CREDENCIAL        IN VARCHAR2,
    I_ID_DOCUMENTO      IN UAB_GET.T_DOCUMENTO.ID_DOCUMENTO%TYPE,
    I_ID_PERSONA          IN UAB_GET.T_DOCUMENTO.ID_PERSONA%TYPE, 
    I_ID_TIPO_DOCUMENTO   IN UAB_GET.T_DOCUMENTO.ID_TIPO_DOCUMENTO%TYPE,
    I_TIPO_DOCUMENTO      IN UAB_GET.TPAR_TIPO_DOCUMENTO.DESCRIPCION%TYPE,
    I_NUMERO_DOCUMENTO    IN UAB_GET.T_DOCUMENTO.NUMERO_DOCUMENTO%TYPE,
    I_DESCRIPCION         IN UAB_GET.T_DOCUMENTO.DESCRIPCION%TYPE,
    I_APP_ID_USUARIO      IN UAB_GET.T_DOCUMENTO.APP_ID_USUARIO%TYPE,
    I_AUD_ESTADO          IN UAB_GET.T_DOCUMENTO.AUD_ESTADO%TYPE,
    I_FECHA_REGISTRO      IN UAB_GET.T_DOCUMENTO.FECHA_REGISTRO%TYPE,

    O_LISTAR_DOCUMENTO  OUT SYS_REFCURSOR
    ); 
 PROCEDURE P_LISTAR_BOLETO_COMPLETO(
 I_CREDENCIAL   IN VARCHAR2,
    I_ID_BOLETO          IN UAB_GET.T_BOLETO.ID_BOLETO%TYPE,
    I_ID_RUTA            IN UAB_GET.T_BOLETO.ID_RUTA%TYPE,   
    I_ID_USUARIO         IN UAB_GET.T_BOLETO.ID_USUARIO%TYPE,
    I_ID_SUCURSAL        IN UAB_GET.T_BOLETO.ID_SUCURSAL%TYPE,
    I_FECHA_REGISTRO        IN UAB_GET.T_BOLETO.FECHA_REGISTRO%TYPE,
    I_AUD_ESTADO         IN UAB_GET.T_BOLETO.AUD_ESTADO%TYPE,
    I_ID_DETALLE_BOLETO  IN UAB_GET.T_DETALLE_BOLETO.ID_DETALLE_BOLETO%TYPE,
    I_ID_ASIENTO         IN UAB_GET.T_DETALLE_BOLETO.ID_ASIENTO%TYPE,
    I_ID_PERSONA         IN UAB_GET.T_DETALLE_BOLETO.ID_PERSONA%TYPE,
    I_ID_TIPO_ASIENTO    IN UAB_GET.T_ASIENTO.ID_TIPO_ASIENTO%TYPE,
    I_NUMERO             IN UAB_GET.T_ASIENTO.NUMERO%TYPE,
    I_TIPO_ASIENTO        IN UAB_GET.TPAR_TIPO_ASIENTO.DESCRIPCION%TYPE,
 O_LISTAR_BOLETO_COMPLETO  OUT SYS_REFCURSOR          
 );   
PROCEDURE P_LISTAR_ASIENTO_COMPLETO(
 I_CREDENCIAL   IN VARCHAR2,
    I_ID_ASIENTO_RUTA      IN UAB_GET.T_ASIENTO_RUTA.ID_ASIENTO_RUTA%TYPE,
   I_ID_RUTA               IN UAB_GET.T_ASIENTO_RUTA.ID_RUTA%TYPE,
   I_ID_ESTADO_ASIENTO     IN UAB_GET.T_ASIENTO_RUTA.ID_ESTADO_ASIENTO%TYPE,
   I_ASIENTO_RUTA          IN UAB_GET.T_ASIENTO_RUTA.DESCRIPCION%TYPE,
   I_AUD_ESTADO            IN UAB_GET.T_ASIENTO_RUTA.AUD_ESTADO%TYPE,
   I_FECHA_REGISTRO        IN UAB_GET.T_ASIENTO_RUTA.FECHA_REGISTRO%TYPE,
   I_ID_ASIENTO            IN UAB_GET.T_ASIENTO_RUTA.ID_ASIENTO%TYPE,
   I_ESTADO_ASIENTO        IN UAB_GET.TPAR_ESTADO_ASIENTO.DESCRIPCION%TYPE,
   I_NUMERO                IN UAB_GET.T_ASIENTO.NUMERO%TYPE,
   I_TIPO_ASIENTO          IN UAB_GET.TPAR_TIPO_ASIENTO.DESCRIPCION%TYPE,
   I_ID_TIPO_ASIENTO       IN UAB_GET.T_ASIENTO.ID_TIPO_ASIENTO%TYPE,
 O_LISTAR_ASIENTO_COMPLETO  OUT SYS_REFCURSOR          
 ); 
 PROCEDURE P_LISTAR_RUTA_COMPLETO(
 I_CREDENCIAL   IN VARCHAR2,
I_ID_RUTA            IN UAB_GET.T_RUTA.ID_RUTA%TYPE,
I_ID_CIUDAD_ORIGEN   IN UAB_GET.T_RUTA.ID_CIUDAD_ORIGEN%TYPE,
I_ID_CIUDAD_DESTINO  IN UAB_GET.T_RUTA.ID_CIUDAD_DESTINO%TYPE,
I_ID_FLOTA           IN UAB_GET.T_RUTA.ID_FLOTA%TYPE,
I_ID_HORARIO         IN UAB_GET.T_RUTA.ID_HORARIO%TYPE,
I_ID_PRECIO          IN UAB_GET.T_RUTA.ID_PRECIO%TYPE,
I_ID_CONDUCTOR       IN UAB_GET.T_RUTA.ID_CONDUCTOR%TYPE,

I_PRECIO             IN UAB_GET.TPAR_PRECIO.PRECIO%TYPE,
I_HORA               IN UAB_GET.T_HORARIO.HORA%TYPE,
I_ID_TIPO_FLOTA      IN UAB_GET.T_FLOTA.ID_TIPO_FLOTA%TYPE,
I_PLACA              IN UAB_GET.T_FLOTA.PLACA%TYPE,
I_MODELO             IN UAB_GET.T_FLOTA.MODELO%TYPE,
I_NRO_ASIENTOS       IN UAB_GET.T_FLOTA.NRO_ASIENTOS%TYPE,
I_TIPO_FLOTA         IN UAB_GET.TPAR_TIPO_FLOTA.DESCRIPCION%TYPE,
I_AUD_ESTADO         IN UAB_GET.T_RUTA.AUD_ESTADO%TYPE,
 O_LISTAR_RUTA_COMPLETO  OUT SYS_REFCURSOR          
 ); 
 PROCEDURE P_LISTAR_CIUDAD ( 
I_CREDENCIAL        IN  VARCHAR2,
I_ID_CIUDAD         IN UAB_GET.T_CIUDAD.ID_CIUDAD%TYPE,
I_CIUDAD            IN UAB_GET.T_CIUDAD.NOMBRE%TYPE, 
I_AUD_ESTADO        IN UAB_GET.T_CIUDAD.AUD_ESTADO%TYPE,
O_LISTAR_CIUDAD  OUT SYS_REFCURSOR
);
END PGET_LISTADOS;
/

GRANT EXECUTE ON UAB_GET.PGET_GESTION TO APP_GESTION_UAB
/

GRANT EXECUTE ON UAB_GET.PGET_LISTADOS TO APP_GESTION_UAB
/

--
-- PGET_GESTION  (Package) 
--
--  Dependencies: 
--   STANDARD (Package)
--
CREATE OR REPLACE PACKAGE APP_GESTION_UAB.PGET_GESTION AS
/******************************************************************************
   NAME:       PGET_GESTION
   PURPOSE:
 
   REVISIONS:
   Ver        Date        Author           Description
   ---------  ----------  ---------------  ------------------------------------
   1.0        23/03/2015      HENRRY       1. Created this package.
******************************************************************************/

PROCEDURE P_REGISTRAR_GENERO(
I_CREDENCIAL        IN  VARCHAR2,
I_ID_GENERO         IN NUMBER,
I_DESCRIPCION       IN VARCHAR2, 
I_APP_ID_USUARIO    IN NUMBER,
I_AUD_ESTADO        IN NUMBER,
I_FECHA_REGISTRO    IN DATE,
O_RESULTADO OUT SYS_REFCURSOR
);
PROCEDURE P_REGISTRAR_PERSONA(
I_CREDENCIAL           IN  VARCHAR2,
I_ID_PERSONA           IN NUMBER, 
I_ID_TIPO_PERSONA      IN NUMBER, 
I_ID_GENERO            IN NUMBER,
I_NOMBRE               IN VARCHAR2,
I_AP_PATERNO           IN VARCHAR2,
I_AP_MATERNO           IN VARCHAR2,
I_FECHA_NACIMIENTO     IN DATE,
I_DIRECCION            IN VARCHAR2,
I_EMAIL                IN VARCHAR2,
I_APP_ID_USUARIO       IN NUMBER,
I_AUD_ESTADO           IN NUMBER,
I_FECHA_REGISTRO       IN DATE,
O_RESULTADO OUT SYS_REFCURSOR
);

PROCEDURE P_REGISTRA_DOCUMENTO(
I_CREDENCIAL           IN  VARCHAR2,
I_ID_DOCUMENTO         IN NUMBER,
I_ID_PERSONA           IN NUMBER, 
I_ID_TIPO_DOCUMENTO    IN NUMBER,
I_NUMERO_DOCUMENTO     IN VARCHAR2,
I_DESCRIPCION          IN VARCHAR2,
I_APP_ID_USUARIO       IN NUMBER,
I_AUD_ESTADO           IN NUMBER,
I_FECHA_REGISTRO       IN DATE,
O_RESULTADO OUT SYS_REFCURSOR
);
PROCEDURE P_REGISTRAR_BOLETO(
I_CREDENCIAL          IN  VARCHAR2,
I_ID_BOLETO           IN NUMBER,
I_ID_USUARIO          IN NUMBER,
I_ID_RUTA             IN NUMBER,
I_ID_SUCURSAL         IN NUMBER,
I_APP_ID_USUARIO      IN NUMBER,
I_AUD_ESTADO          IN NUMBER,
I_FECHA_REGISTRO      IN DATE,
O_RESULTADO OUT SYS_REFCURSOR
);
PROCEDURE P_REGISTRAR_ASIENTO(
I_CREDENCIAL          IN  VARCHAR2,
I_ID_ASIENTO          IN NUMBER,
I_ID_TIPO_ASIENTO     IN NUMBER,
I_NUMERO              IN VARCHAR2,
I_APP_ID_USUARIO      IN NUMBER,
I_AUD_ESTADO          IN NUMBER,
I_FECHA_REGISTRO      IN DATE,
O_RESULTADO OUT SYS_REFCURSOR
);

PROCEDURE P_REGISTRAR_DETALLE_BOLETO(
I_CREDENCIAL          IN  VARCHAR2,
I_ID_DETALLE_BOLETO   IN NUMBER,
I_ID_BOLETO           IN NUMBER,
I_ID_ASIENTO          IN NUMBER,
I_ID_PERSONA          IN NUMBER,
I_APP_ID_USUARIO      IN NUMBER,
I_AUD_ESTADO          IN NUMBER,
I_FECHA_REGISTRO      IN DATE,
O_RESULTADO OUT SYS_REFCURSOR
);

PROCEDURE P_REGISTRAR_ASIENTO_RUTA(
I_CREDENCIAL          IN  VARCHAR2,
I_ID_ASIENTO_RUTA     IN NUMBER,
I_ID_RUTA             IN NUMBER,
I_ID_ASIENTO          IN NUMBER,
I_ID_ESTADO_ASIENTO   IN NUMBER,
I_DESCRIPCION         IN VARCHAR2,
I_APP_ID_USUARIO      IN NUMBER,
I_AUD_ESTADO          IN NUMBER,
I_FECHA_REGISTRO      IN DATE,
O_RESULTADO OUT SYS_REFCURSOR
);
PROCEDURE P_REGISTRAR_RUTA(
I_CREDENCIAL          IN  VARCHAR2,
I_ID_RUTA           IN NUMBER,
I_ID_CIUDAD_ORIGEN  IN NUMBER,
I_ID_CIUDAD_DESTINO IN NUMBER,
I_ID_FLOTA          IN NUMBER,
I_ID_HORARIO        IN NUMBER,
I_ID_PRECIO         IN NUMBER,
I_ID_CONDUCTOR      IN NUMBER,
I_APP_ID_USUARIO      IN NUMBER,
I_AUD_ESTADO          IN NUMBER,
I_FECHA_REGISTRO      IN DATE,
O_RESULTADO OUT SYS_REFCURSOR
);
END PGET_GESTION;
/

--
-- PGET_LISTADOS  (Package) 
--
--  Dependencies: 
--   STANDARD (Package)
--
CREATE OR REPLACE PACKAGE APP_GESTION_UAB.PGET_LISTADOS AS
/******************************************************************************
   NAME:       PGET_LISTADOS
   PURPOSE:

   REVISIONS:
   Ver        Date        Author           Description
   ---------  ----------  ---------------  ------------------------------------
   1.0        23/03/2015      HENRRY       1. Created this package.
******************************************************************************/
PROCEDURE P_LISTAR_GENERO ( 
I_CREDENCIAL        IN  VARCHAR2,
I_ID_GENERO         IN NUMBER,
I_DESCRIPCION       IN VARCHAR2, 
I_APP_ID_USUARIO    IN NUMBER,
I_AUD_ESTADO        IN NUMBER,
I_FECHA_REGISTRO    IN DATE,
O_LISTAR_GENERO  OUT SYS_REFCURSOR
);
PROCEDURE P_LISTAR_PERSONA ( 
    I_CREDENCIAL        IN VARCHAR2, 
    I_ID_PERSONA        IN NUMBER,
    I_ID_TIPO_PERSONA   IN NUMBER,
    I_TIPO_PERSONA      IN VARCHAR2,
    I_ID_GENERO         IN NUMBER,
    I_GENERO            IN VARCHAR2,
    I_NOMBRE            IN VARCHAR2,
    I_AP_PATERNO        IN VARCHAR2,
    I_AP_MATERNO        IN VARCHAR2,
    I_FECHA_NACIMIENTO  IN DATE,
    I_DIRECCION         IN VARCHAR2,
    I_EMAIL             IN VARCHAR2,
    I_APP_ID_USUARIO    IN NUMBER,
    I_AUD_ESTADO        IN NUMBER,
    I_FECHA_REGISTRO    IN DATE,
      
  O_LISTAR_PERSONA  OUT SYS_REFCURSOR
  );
  
PROCEDURE P_LISTAR_DOCUMENTO( 
I_CREDENCIAL        IN VARCHAR2,
I_ID_DOCUMENTO      IN NUMBER,
I_ID_PERSONA          IN NUMBER, 
I_ID_TIPO_DOCUMENTO   IN NUMBER,
I_TIPO_DOCUMENTO      IN VARCHAR2,
I_NUMERO_DOCUMENTO    IN VARCHAR2,
I_DESCRIPCION         IN VARCHAR2,
I_APP_ID_USUARIO      IN NUMBER,
I_AUD_ESTADO          IN NUMBER,
I_FECHA_REGISTRO      IN DATE,

O_LISTAR_DOCUMENTO  OUT SYS_REFCURSOR
);
 PROCEDURE P_LISTAR_BOLETO_COMPLETO(
 I_CREDENCIAL   IN VARCHAR2,
    I_ID_BOLETO          IN NUMBER,
    I_ID_RUTA            IN NUMBER,   
    I_ID_USUARIO         IN NUMBER,
    I_ID_SUCURSAL        IN NUMBER,
    I_FECHA_REGISTRO     IN DATE,
    I_AUD_ESTADO         IN NUMBER,
    I_ID_DETALLE_BOLETO  IN NUMBER,
    I_ID_ASIENTO         IN NUMBER,
    I_ID_PERSONA         IN NUMBER,
    I_ID_TIPO_ASIENTO    IN NUMBER,
    I_NUMERO             IN VARCHAR2,
    I_TIPO_ASIENTO       IN VARCHAR2,
 O_LISTAR_BOLETO_COMPLETO  OUT SYS_REFCURSOR          
 );   
PROCEDURE P_LISTAR_ASIENTO_COMPLETO(
 I_CREDENCIAL   IN VARCHAR2,
   I_ID_ASIENTO_RUTA       IN NUMBER,
   I_ID_RUTA               IN NUMBER,
   I_ID_ESTADO_ASIENTO     IN NUMBER,
   I_ASIENTO_RUTA          IN VARCHAR2,
   I_AUD_ESTADO            IN NUMBER,
   I_FECHA_REGISTRO        IN DATE,
   I_ID_ASIENTO            IN NUMBER,
   I_ESTADO_ASIENTO        IN VARCHAR2,
   I_NUMERO                IN VARCHAR2,
   I_TIPO_ASIENTO          IN VARCHAR2,
   I_ID_TIPO_ASIENTO       IN NUMBER,
 O_LISTAR_ASIENTO_COMPLETO  OUT SYS_REFCURSOR          
 );
 
 PROCEDURE P_LISTAR_RUTA_COMPLETO(
 I_CREDENCIAL   IN VARCHAR2,
I_ID_RUTA            IN NUMBER,
I_ID_CIUDAD_ORIGEN   IN NUMBER,
I_ID_CIUDAD_DESTINO  IN NUMBER,
I_ID_FLOTA           IN NUMBER,
I_ID_HORARIO         IN NUMBER,
I_ID_PRECIO          IN NUMBER,
I_ID_CONDUCTOR       IN NUMBER,

I_PRECIO             IN NUMBER,
I_HORA               IN VARCHAR2,
I_ID_TIPO_FLOTA      IN NUMBER,
I_PLACA              IN VARCHAR2,
I_MODELO             IN VARCHAR2,
I_NRO_ASIENTOS       IN NUMBER,
I_TIPO_FLOTA         IN VARCHAR2,
I_AUD_ESTADO         IN NUMBER,
 O_LISTAR_RUTA_COMPLETO  OUT SYS_REFCURSOR          
 );

PROCEDURE P_LISTAR_CIUDAD ( 
I_CREDENCIAL        IN  VARCHAR2,
I_ID_CIUDAD         IN NUMBER,
I_CIUDAD            IN VARCHAR2, 
I_AUD_ESTADO        IN NUMBER,
O_LISTAR_CIUDAD  OUT SYS_REFCURSOR
);
END PGET_LISTADOS;
/












SET DEFINE OFF;
MERGE INTO UAB_GET.TPAR_ESTADO_ASIENTO A USING
 (SELECT
  1 as ID_ESTADO_ASIENTO,
  'OCUPADO' as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 05:57:20.454000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 05:57:56', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ESTADO_ASIENTO = B.ID_ESTADO_ASIENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ESTADO_ASIENTO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ESTADO_ASIENTO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_ESTADO_ASIENTO A USING
 (SELECT
  2 as ID_ESTADO_ASIENTO,
  'LIBRE' as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 05:57:39.359000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 05:58:03', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ESTADO_ASIENTO = B.ID_ESTADO_ASIENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ESTADO_ASIENTO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ESTADO_ASIENTO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_ESTADO_ASIENTO A USING
 (SELECT
  3 as ID_ESTADO_ASIENTO,
  'RESERVADO' as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 05:57:49.493000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 05:58:08', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ESTADO_ASIENTO = B.ID_ESTADO_ASIENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ESTADO_ASIENTO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ESTADO_ASIENTO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.TPAR_GENERO A USING
 (SELECT
  1 as ID_GENERO,
  'MASCULINO' as DESCRIPCION,
  21 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('24/03/2015 11:25:18.000000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/05/2015 17:26:54', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_GENERO = B.ID_GENERO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_GENERO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_GENERO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_GENERO A USING
 (SELECT
  2 as ID_GENERO,
  'FEMENINO' as DESCRIPCION,
  23 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('24/03/2015 11:14:07.000000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('03/23/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_GENERO = B.ID_GENERO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_GENERO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_GENERO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_GENERO A USING
 (SELECT
  3 as ID_GENERO,
  'OTRO' as DESCRIPCION,
  NULL as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('08/04/2015 04:04:21.629000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_GENERO = B.ID_GENERO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_GENERO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_GENERO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  1 as ID_PRECIO,
  20 as PRECIO,
  20 as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:32:21.666000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:32:20', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  2 as ID_PRECIO,
  25 as PRECIO,
  25 as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:32:29.518000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:32:20', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  3 as ID_PRECIO,
  30 as PRECIO,
  30 as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:32:31.972000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:32:20', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  4 as ID_PRECIO,
  35 as PRECIO,
  35 as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:34:57.157000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  5 as ID_PRECIO,
  40 as PRECIO,
  NULL as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:30:18.068000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  6 as ID_PRECIO,
  45 as PRECIO,
  NULL as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:30:20.844000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  7 as ID_PRECIO,
  50 as PRECIO,
  NULL as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:30:27.274000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  8 as ID_PRECIO,
  55 as PRECIO,
  NULL as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:30:28.546000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  9 as ID_PRECIO,
  60 as PRECIO,
  NULL as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:30:30.727000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  10 as ID_PRECIO,
  65 as PRECIO,
  NULL as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:30:32.029000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  11 as ID_PRECIO,
  70 as PRECIO,
  NULL as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:30:34.537000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  12 as ID_PRECIO,
  75 as PRECIO,
  NULL as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:30:36.109000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  13 as ID_PRECIO,
  80 as PRECIO,
  NULL as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:30:37.674000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  14 as ID_PRECIO,
  85 as PRECIO,
  NULL as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:30:40.338000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  15 as ID_PRECIO,
  90 as PRECIO,
  NULL as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:30:41.849000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  16 as ID_PRECIO,
  100 as PRECIO,
  NULL as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:30:43.746000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_PRECIO A USING
 (SELECT
  17 as ID_PRECIO,
  120 as PRECIO,
  NULL as COSTO,
  NULL as OBSERVACIONES,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:30:46.836000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:34:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PRECIO = B.ID_PRECIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PRECIO, PRECIO, COSTO, OBSERVACIONES, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PRECIO, B.PRECIO, B.COSTO, B.OBSERVACIONES, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.PRECIO = B.PRECIO,
  A.COSTO = B.COSTO,
  A.OBSERVACIONES = B.OBSERVACIONES,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.TPAR_SUCURSAL A USING
 (SELECT
  5 as ID_SUCURSAL,
  'COCHABAMBA' as NOMBRE,
  '2445556' as TELEFONO,
  'SN' as DIRECCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:43:55.053000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:41:19', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_SUCURSAL = B.ID_SUCURSAL)
WHEN NOT MATCHED THEN 
INSERT (
  ID_SUCURSAL, NOMBRE, TELEFONO, DIRECCION, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_SUCURSAL, B.NOMBRE, B.TELEFONO, B.DIRECCION, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.TELEFONO = B.TELEFONO,
  A.DIRECCION = B.DIRECCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_SUCURSAL A USING
 (SELECT
  6 as ID_SUCURSAL,
  'SANTA CRUZ' as NOMBRE,
  '24544447' as TELEFONO,
  'SN' as DIRECCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:44:18.702000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:41:19', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_SUCURSAL = B.ID_SUCURSAL)
WHEN NOT MATCHED THEN 
INSERT (
  ID_SUCURSAL, NOMBRE, TELEFONO, DIRECCION, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_SUCURSAL, B.NOMBRE, B.TELEFONO, B.DIRECCION, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.TELEFONO = B.TELEFONO,
  A.DIRECCION = B.DIRECCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_SUCURSAL A USING
 (SELECT
  7 as ID_SUCURSAL,
  'TARIJITA' as NOMBRE,
  '2445665' as TELEFONO,
  'SN' as DIRECCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:44:26.619000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:41:19', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_SUCURSAL = B.ID_SUCURSAL)
WHEN NOT MATCHED THEN 
INSERT (
  ID_SUCURSAL, NOMBRE, TELEFONO, DIRECCION, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_SUCURSAL, B.NOMBRE, B.TELEFONO, B.DIRECCION, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.TELEFONO = B.TELEFONO,
  A.DIRECCION = B.DIRECCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_SUCURSAL A USING
 (SELECT
  8 as ID_SUCURSAL,
  'ORURITO' as NOMBRE,
  '2114569' as TELEFONO,
  'SN' as DIRECCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:44:36.727000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:41:19', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_SUCURSAL = B.ID_SUCURSAL)
WHEN NOT MATCHED THEN 
INSERT (
  ID_SUCURSAL, NOMBRE, TELEFONO, DIRECCION, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_SUCURSAL, B.NOMBRE, B.TELEFONO, B.DIRECCION, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.TELEFONO = B.TELEFONO,
  A.DIRECCION = B.DIRECCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_SUCURSAL A USING
 (SELECT
  9 as ID_SUCURSAL,
  'TUPIZA' as NOMBRE,
  '2445697' as TELEFONO,
  'SN' as DIRECCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:44:44.083000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:41:19', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_SUCURSAL = B.ID_SUCURSAL)
WHEN NOT MATCHED THEN 
INSERT (
  ID_SUCURSAL, NOMBRE, TELEFONO, DIRECCION, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_SUCURSAL, B.NOMBRE, B.TELEFONO, B.DIRECCION, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.TELEFONO = B.TELEFONO,
  A.DIRECCION = B.DIRECCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_SUCURSAL A USING
 (SELECT
  10 as ID_SUCURSAL,
  'TRINIDAD' as NOMBRE,
  '2546887' as TELEFONO,
  'SN' as DIRECCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:44:51.015000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:41:19', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_SUCURSAL = B.ID_SUCURSAL)
WHEN NOT MATCHED THEN 
INSERT (
  ID_SUCURSAL, NOMBRE, TELEFONO, DIRECCION, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_SUCURSAL, B.NOMBRE, B.TELEFONO, B.DIRECCION, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.TELEFONO = B.TELEFONO,
  A.DIRECCION = B.DIRECCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_SUCURSAL A USING
 (SELECT
  11 as ID_SUCURSAL,
  'COBIJA' as NOMBRE,
  '2366355' as TELEFONO,
  'SN' as DIRECCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:44:54.238000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:41:19', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_SUCURSAL = B.ID_SUCURSAL)
WHEN NOT MATCHED THEN 
INSERT (
  ID_SUCURSAL, NOMBRE, TELEFONO, DIRECCION, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_SUCURSAL, B.NOMBRE, B.TELEFONO, B.DIRECCION, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.TELEFONO = B.TELEFONO,
  A.DIRECCION = B.DIRECCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_SUCURSAL A USING
 (SELECT
  12 as ID_SUCURSAL,
  'SUCRE' as NOMBRE,
  '2445874' as TELEFONO,
  'SN' as DIRECCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:45:34.299000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:41:19', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_SUCURSAL = B.ID_SUCURSAL)
WHEN NOT MATCHED THEN 
INSERT (
  ID_SUCURSAL, NOMBRE, TELEFONO, DIRECCION, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_SUCURSAL, B.NOMBRE, B.TELEFONO, B.DIRECCION, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.TELEFONO = B.TELEFONO,
  A.DIRECCION = B.DIRECCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_SUCURSAL A USING
 (SELECT
  2 as ID_SUCURSAL,
  'QUILLACOLLO' as NOMBRE,
  '2421212' as TELEFONO,
  'AV LAS AMERICAS N 256' as DIRECCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:39:35.000000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:39:35', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_SUCURSAL = B.ID_SUCURSAL)
WHEN NOT MATCHED THEN 
INSERT (
  ID_SUCURSAL, NOMBRE, TELEFONO, DIRECCION, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_SUCURSAL, B.NOMBRE, B.TELEFONO, B.DIRECCION, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.TELEFONO = B.TELEFONO,
  A.DIRECCION = B.DIRECCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_SUCURSAL A USING
 (SELECT
  3 as ID_SUCURSAL,
  'EL ALTO' as NOMBRE,
  '2734550' as TELEFONO,
  'VILLA DOLORES N 236' as DIRECCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:40:27.145000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:40:25', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_SUCURSAL = B.ID_SUCURSAL)
WHEN NOT MATCHED THEN 
INSERT (
  ID_SUCURSAL, NOMBRE, TELEFONO, DIRECCION, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_SUCURSAL, B.NOMBRE, B.TELEFONO, B.DIRECCION, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.TELEFONO = B.TELEFONO,
  A.DIRECCION = B.DIRECCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_SUCURSAL A USING
 (SELECT
  4 as ID_SUCURSAL,
  'LA PAZ' as NOMBRE,
  '2256542' as TELEFONO,
  'AV MONTES N 548' as DIRECCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:41:20.877000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:41:19', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_SUCURSAL = B.ID_SUCURSAL)
WHEN NOT MATCHED THEN 
INSERT (
  ID_SUCURSAL, NOMBRE, TELEFONO, DIRECCION, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_SUCURSAL, B.NOMBRE, B.TELEFONO, B.DIRECCION, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.TELEFONO = B.TELEFONO,
  A.DIRECCION = B.DIRECCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_SUCURSAL A USING
 (SELECT
  1 as ID_SUCURSAL,
  'MONTERO' as NOMBRE,
  '2421212' as TELEFONO,
  NULL as DIRECCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('13/05/2015 08:47:40.820000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_SUCURSAL = B.ID_SUCURSAL)
WHEN NOT MATCHED THEN 
INSERT (
  ID_SUCURSAL, NOMBRE, TELEFONO, DIRECCION, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_SUCURSAL, B.NOMBRE, B.TELEFONO, B.DIRECCION, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.TELEFONO = B.TELEFONO,
  A.DIRECCION = B.DIRECCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.TPAR_TIPO_ASIENTO A USING
 (SELECT
  1 as ID_TIPO_ASIENTO,
  'PASILLO' as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 02:14:53.000000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('05/13/2015 08:35:42', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_TIPO_ASIENTO = B.ID_TIPO_ASIENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_ASIENTO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_TIPO_ASIENTO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_TIPO_ASIENTO A USING
 (SELECT
  2 as ID_TIPO_ASIENTO,
  'VENTANA' as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 02:15:11.000000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('05/13/2015 08:35:47', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_TIPO_ASIENTO = B.ID_TIPO_ASIENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_ASIENTO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_TIPO_ASIENTO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.TPAR_TIPO_DOCUMENTO A USING
 (SELECT
  1 as ID_TIPO_DOCUMENTO,
  'C.I.' as DESCRIPCION,
  13 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('05/04/2015 08:27:30.693000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/05/2015 08:27:25', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_DOCUMENTO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_TIPO_DOCUMENTO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_TIPO_DOCUMENTO A USING
 (SELECT
  2 as ID_TIPO_DOCUMENTO,
  'N.I.T.' as DESCRIPCION,
  123 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('05/04/2015 08:28:06.875000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/05/2015 08:28:05', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_DOCUMENTO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_TIPO_DOCUMENTO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_TIPO_DOCUMENTO A USING
 (SELECT
  3 as ID_TIPO_DOCUMENTO,
  'PASAPORTE' as DESCRIPCION,
  15 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('05/04/2015 08:28:26.274000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/05/2015 08:28:24', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_DOCUMENTO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_TIPO_DOCUMENTO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;


SET DEFINE OFF;
MERGE INTO UAB_GET.TPAR_TIPO_FLOTA A USING
 (SELECT
  1 as ID_TIPO_FLOTA,
  'CAMA' as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:10:37.000000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:10:37', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_FLOTA, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_TIPO_FLOTA, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_TIPO_FLOTA A USING
 (SELECT
  2 as ID_TIPO_FLOTA,
  'SEMICAMA' as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:10:37.000000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_FLOTA, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_TIPO_FLOTA, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_TIPO_FLOTA A USING
 (SELECT
  3 as ID_TIPO_FLOTA,
  'NORMAL' as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:10:37.000000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_FLOTA, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_TIPO_FLOTA, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_TIPO_FLOTA A USING
 (SELECT
  4 as ID_TIPO_FLOTA,
  'LEITO' as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:16:28.009000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_FLOTA, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_TIPO_FLOTA, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;


SET DEFINE OFF;
MERGE INTO UAB_GET.TPAR_TIPO_PERSONA A USING
 (SELECT
  1 as ID_TIPO_PERSONA,
  'EMPLEADO' as DESCRIPCION,
  12 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('02/04/2015 01:50:54.084000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/01/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGSTRO
  FROM DUAL) B
ON (A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_PERSONA, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGSTRO)
VALUES (
  B.ID_TIPO_PERSONA, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGSTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGSTRO = B.FECHA_REGSTRO;

MERGE INTO UAB_GET.TPAR_TIPO_PERSONA A USING
 (SELECT
  2 as ID_TIPO_PERSONA,
  'CLIENTE' as DESCRIPCION,
  13 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('02/04/2015 01:51:29.003000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/02/2015 01:51:26', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGSTRO
  FROM DUAL) B
ON (A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_PERSONA, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGSTRO)
VALUES (
  B.ID_TIPO_PERSONA, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGSTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGSTRO = B.FECHA_REGSTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.TPAR_TIPO_USUARIO A USING
 (SELECT
  1 as ID_TIPO_USUARIO,
  'CAJERO' as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:42:58.106000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:42:56', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_TIPO_USUARIO = B.ID_TIPO_USUARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_USUARIO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_TIPO_USUARIO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_TIPO_USUARIO A USING
 (SELECT
  2 as ID_TIPO_USUARIO,
  'RECEPCION' as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:43:05.127000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:42:56', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_TIPO_USUARIO = B.ID_TIPO_USUARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_USUARIO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_TIPO_USUARIO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.TPAR_TIPO_USUARIO A USING
 (SELECT
  3 as ID_TIPO_USUARIO,
  'ADMINISTRADOR' as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:43:06.660000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:42:56', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_TIPO_USUARIO = B.ID_TIPO_USUARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_TIPO_USUARIO, DESCRIPCION, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_TIPO_USUARIO, B.DESCRIPCION, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  7 as ID_HORARIO,
  '10:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:06:36.074000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  8 as ID_HORARIO,
  '10:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:06:43.821000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  9 as ID_HORARIO,
  '11:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:07:02.969000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  10 as ID_HORARIO,
  '11:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:07:35.447000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  11 as ID_HORARIO,
  '11:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:07:44.437000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  12 as ID_HORARIO,
  '12:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:07:58.089000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  13 as ID_HORARIO,
  '12:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:08:04.771000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  14 as ID_HORARIO,
  '12:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:08:09.561000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  15 as ID_HORARIO,
  '13:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:08:13.541000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  16 as ID_HORARIO,
  '13:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:08:17.931000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  17 as ID_HORARIO,
  '13:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:08:49.681000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  18 as ID_HORARIO,
  '14:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:08:57.831000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  19 as ID_HORARIO,
  '14:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:09:06.335000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  20 as ID_HORARIO,
  '14:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:09:12.381000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  21 as ID_HORARIO,
  '15:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:09:19.204000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  22 as ID_HORARIO,
  '15:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:09:24.452000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  23 as ID_HORARIO,
  '15:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:09:29.097000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  24 as ID_HORARIO,
  '16:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:10:00.824000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  25 as ID_HORARIO,
  '16:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:10:06.623000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  26 as ID_HORARIO,
  '16:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:10:10.911000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  27 as ID_HORARIO,
  '17:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:10:38.724000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  28 as ID_HORARIO,
  '17:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:10:43.169000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  29 as ID_HORARIO,
  '17:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:10:46.868000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  30 as ID_HORARIO,
  '18:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:10:50.280000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  31 as ID_HORARIO,
  '18:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:11:00.836000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  32 as ID_HORARIO,
  '18:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:11:04.797000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  33 as ID_HORARIO,
  '19:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:11:13.232000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  34 as ID_HORARIO,
  '19:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:11:17.626000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  35 as ID_HORARIO,
  '19:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:11:23.202000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  36 as ID_HORARIO,
  '20:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:11:27.644000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  37 as ID_HORARIO,
  '20:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:11:32.198000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  38 as ID_HORARIO,
  '20:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:11:37.478000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  39 as ID_HORARIO,
  '21:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:11:46.701000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  40 as ID_HORARIO,
  '21:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:11:51.488000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  41 as ID_HORARIO,
  '21:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:12:02.856000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  42 as ID_HORARIO,
  '22:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:12:11.182000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  43 as ID_HORARIO,
  '22:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:12:15.956000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  44 as ID_HORARIO,
  '22:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:12:48.820000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  45 as ID_HORARIO,
  '23:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:13:01.037000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  46 as ID_HORARIO,
  '23:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:13:10.361000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  3 as ID_HORARIO,
  '09:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:27:50.171000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  4 as ID_HORARIO,
  '09:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:28:11.298000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  5 as ID_HORARIO,
  '09:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:28:27.840000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  6 as ID_HORARIO,
  '10:10' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:28:46.103000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:27:49', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  2 as ID_HORARIO,
  '08:50' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('13/05/2015 09:04:57.221000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_HORARIO A USING
 (SELECT
  1 as ID_HORARIO,
  '08:30' as HORA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('13/05/2015 09:05:22.744000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_HORARIO = B.ID_HORARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_HORARIO, HORA, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_HORARIO, B.HORA, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.HORA = B.HORA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  4 as ID_FLOTA,
  4 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'CVB-2560' as PLACA,
  '2007' as MODELO,
  38 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:17:27.718000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  5 as ID_FLOTA,
  4 as ID_TIPO_FLOTA,
  'AZUL' as COLOR,
  'LLDD-5410' as PLACA,
  '2009' as MODELO,
  40 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:18:18.963000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  6 as ID_FLOTA,
  2 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'AAS-0112' as PLACA,
  '2013' as MODELO,
  38 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:18:26.027000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  7 as ID_FLOTA,
  4 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'ASDF-2154' as PLACA,
  '2008' as MODELO,
  42 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:18:32.692000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  8 as ID_FLOTA,
  2 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'SSFE-2354' as PLACA,
  '2013' as MODELO,
  42 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:18:37.500000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  9 as ID_FLOTA,
  2 as ID_TIPO_FLOTA,
  'AZUL' as COLOR,
  'EFCS-2154' as PLACA,
  '2008' as MODELO,
  38 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:18:43.015000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  10 as ID_FLOTA,
  4 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'RFS-2145' as PLACA,
  '2013' as MODELO,
  40 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:18:47.878000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  11 as ID_FLOTA,
  4 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'ASTB-2356' as PLACA,
  '2008' as MODELO,
  40 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:18:56.739000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  12 as ID_FLOTA,
  3 as ID_TIPO_FLOTA,
  'AZUL' as COLOR,
  'TBGG-2354' as PLACA,
  '2008' as MODELO,
  44 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:20:05.042000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  13 as ID_FLOTA,
  3 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'GBRV-2365' as PLACA,
  '2013' as MODELO,
  40 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:20:13.349000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  14 as ID_FLOTA,
  4 as ID_TIPO_FLOTA,
  'AZUL' as COLOR,
  'TYBG-2589' as PLACA,
  '2008' as MODELO,
  40 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:20:30.843000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  15 as ID_FLOTA,
  2 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'TBG-2478' as PLACA,
  '2008' as MODELO,
  42 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:20:36.855000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  16 as ID_FLOTA,
  4 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'SWXX-3545' as PLACA,
  '2010' as MODELO,
  38 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:20:42.433000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  17 as ID_FLOTA,
  3 as ID_TIPO_FLOTA,
  'AZUL' as COLOR,
  'YHNH-2745' as PLACA,
  '2010' as MODELO,
  44 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:20:51.524000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  18 as ID_FLOTA,
  4 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'JUM-3125' as PLACA,
  '2010' as MODELO,
  42 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:21:19.604000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  19 as ID_FLOTA,
  2 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'IKHB-3454' as PLACA,
  '2013' as MODELO,
  43 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:21:20.849000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  20 as ID_FLOTA,
  3 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'AZZS-2233' as PLACA,
  '2010' as MODELO,
  40 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:21:25.100000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  21 as ID_FLOTA,
  4 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'FFRD-2333' as PLACA,
  '2010' as MODELO,
  38 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:21:26.126000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  22 as ID_FLOTA,
  3 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'VFRF-3455' as PLACA,
  '2009' as MODELO,
  40 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:21:27.313000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  23 as ID_FLOTA,
  2 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'GGTB-3556' as PLACA,
  '2014' as MODELO,
  44 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:21:28.953000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  24 as ID_FLOTA,
  4 as ID_TIPO_FLOTA,
  'AZUL' as COLOR,
  'DFBB-3658' as PLACA,
  '2010' as MODELO,
  42 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:21:31.118000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  25 as ID_FLOTA,
  3 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'FGHH-3669' as PLACA,
  '2008' as MODELO,
  40 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:21:32.454000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  26 as ID_FLOTA,
  4 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'YNHH-3677' as PLACA,
  '2013' as MODELO,
  38 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:21:34.173000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  27 as ID_FLOTA,
  3 as ID_TIPO_FLOTA,
  'AZUL' as COLOR,
  'UJMJ-3645' as PLACA,
  '2010' as MODELO,
  36 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:21:35.361000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  28 as ID_FLOTA,
  2 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'JJMM-3564' as PLACA,
  '2010' as MODELO,
  40 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:21:38.488000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  29 as ID_FLOTA,
  3 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'KKJH-2578' as PLACA,
  NULL as MODELO,
  41 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:21:42.762000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  30 as ID_FLOTA,
  4 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'JHGF-3544' as PLACA,
  NULL as MODELO,
  37 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:21:44.563000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  2 as ID_FLOTA,
  1 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'VXCV-2488' as PLACA,
  '2005' as MODELO,
  42 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:22:20.000000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:20', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  3 as ID_FLOTA,
  2 as ID_TIPO_FLOTA,
  'AZUL' as COLOR,
  'POP-565' as PLACA,
  '2008' as MODELO,
  40 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:23:00.899000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:22:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_FLOTA A USING
 (SELECT
  1 as ID_FLOTA,
  3 as ID_TIPO_FLOTA,
  'BLANCO' as COLOR,
  'JUU-6221' as PLACA,
  '2011' as MODELO,
  40 as NRO_ASIENTOS,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('13/05/2015 09:02:56.079000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_FLOTA = B.ID_FLOTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_FLOTA, ID_TIPO_FLOTA, COLOR, PLACA, MODELO, 
  NRO_ASIENTOS, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_FLOTA, B.ID_TIPO_FLOTA, B.COLOR, B.PLACA, B.MODELO, 
  B.NRO_ASIENTOS, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_FLOTA = B.ID_TIPO_FLOTA,
  A.COLOR = B.COLOR,
  A.PLACA = B.PLACA,
  A.MODELO = B.MODELO,
  A.NRO_ASIENTOS = B.NRO_ASIENTOS,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.T_CIUDAD A USING
 (SELECT
  1 as ID_CIUDAD,
  'COCHABAMBA' as NOMBRE,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:03:14.622000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:03:12', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_CIUDAD = B.ID_CIUDAD)
WHEN NOT MATCHED THEN 
INSERT (
  ID_CIUDAD, NOMBRE, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_CIUDAD, B.NOMBRE, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_CIUDAD A USING
 (SELECT
  2 as ID_CIUDAD,
  'LA PAZ' as NOMBRE,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:03:29.392000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:03:12', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_CIUDAD = B.ID_CIUDAD)
WHEN NOT MATCHED THEN 
INSERT (
  ID_CIUDAD, NOMBRE, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_CIUDAD, B.NOMBRE, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_CIUDAD A USING
 (SELECT
  3 as ID_CIUDAD,
  'ORURO' as NOMBRE,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:07:00.601000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:06:59', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_CIUDAD = B.ID_CIUDAD)
WHEN NOT MATCHED THEN 
INSERT (
  ID_CIUDAD, NOMBRE, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_CIUDAD, B.NOMBRE, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_CIUDAD A USING
 (SELECT
  4 as ID_CIUDAD,
  'POTOSI' as NOMBRE,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:07:11.891000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_CIUDAD = B.ID_CIUDAD)
WHEN NOT MATCHED THEN 
INSERT (
  ID_CIUDAD, NOMBRE, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_CIUDAD, B.NOMBRE, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_CIUDAD A USING
 (SELECT
  5 as ID_CIUDAD,
  'TARIJA' as NOMBRE,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:07:25.041000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_CIUDAD = B.ID_CIUDAD)
WHEN NOT MATCHED THEN 
INSERT (
  ID_CIUDAD, NOMBRE, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_CIUDAD, B.NOMBRE, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_CIUDAD A USING
 (SELECT
  6 as ID_CIUDAD,
  'SANTA CRUZ' as NOMBRE,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:07:34.704000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_CIUDAD = B.ID_CIUDAD)
WHEN NOT MATCHED THEN 
INSERT (
  ID_CIUDAD, NOMBRE, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_CIUDAD, B.NOMBRE, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_CIUDAD A USING
 (SELECT
  7 as ID_CIUDAD,
  'PANDO' as NOMBRE,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:07:51.016000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_CIUDAD = B.ID_CIUDAD)
WHEN NOT MATCHED THEN 
INSERT (
  ID_CIUDAD, NOMBRE, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_CIUDAD, B.NOMBRE, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_CIUDAD A USING
 (SELECT
  8 as ID_CIUDAD,
  'CHUQUISACA' as NOMBRE,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:07:59.800000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_CIUDAD = B.ID_CIUDAD)
WHEN NOT MATCHED THEN 
INSERT (
  ID_CIUDAD, NOMBRE, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_CIUDAD, B.NOMBRE, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_CIUDAD A USING
 (SELECT
  9 as ID_CIUDAD,
  'BENI' as NOMBRE,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:08:06.409000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_CIUDAD = B.ID_CIUDAD)
WHEN NOT MATCHED THEN 
INSERT (
  ID_CIUDAD, NOMBRE, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_CIUDAD, B.NOMBRE, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.NOMBRE = B.NOMBRE,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;



SET DEFINE OFF;
MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  9 as ID_RUTA,
  2 as ID_CIUDAD_ORIGEN,
  1 as ID_CIUDAD_DESTINO,
  2 as ID_FLOTA,
  3 as ID_HORARIO,
  1 as ID_PRECIO,
  333 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('23/04/2015 05:10:15.713000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/23/2015 17:10:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  5 as ID_RUTA,
  2 as ID_CIUDAD_ORIGEN,
  3 as ID_CIUDAD_DESTINO,
  3 as ID_FLOTA,
  4 as ID_HORARIO,
  2 as ID_PRECIO,
  666 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:36:35.444000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:36:34', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  6 as ID_RUTA,
  2 as ID_CIUDAD_ORIGEN,
  4 as ID_CIUDAD_DESTINO,
  4 as ID_FLOTA,
  5 as ID_HORARIO,
  3 as ID_PRECIO,
  777 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:37:38.069000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  7 as ID_RUTA,
  2 as ID_CIUDAD_ORIGEN,
  5 as ID_CIUDAD_DESTINO,
  5 as ID_FLOTA,
  6 as ID_HORARIO,
  4 as ID_PRECIO,
  999 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('21/04/2015 10:27:20.241000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  8 as ID_RUTA,
  2 as ID_CIUDAD_ORIGEN,
  6 as ID_CIUDAD_DESTINO,
  6 as ID_FLOTA,
  7 as ID_HORARIO,
  5 as ID_PRECIO,
  1000 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('21/04/2015 10:34:21.598000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  10 as ID_RUTA,
  2 as ID_CIUDAD_ORIGEN,
  7 as ID_CIUDAD_DESTINO,
  7 as ID_FLOTA,
  8 as ID_HORARIO,
  6 as ID_PRECIO,
  111 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:32:42.581000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  11 as ID_RUTA,
  2 as ID_CIUDAD_ORIGEN,
  8 as ID_CIUDAD_DESTINO,
  8 as ID_FLOTA,
  9 as ID_HORARIO,
  7 as ID_PRECIO,
  222 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:32:51.087000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  12 as ID_RUTA,
  2 as ID_CIUDAD_ORIGEN,
  9 as ID_CIUDAD_DESTINO,
  9 as ID_FLOTA,
  10 as ID_HORARIO,
  8 as ID_PRECIO,
  444 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:18.688000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  13 as ID_RUTA,
  1 as ID_CIUDAD_ORIGEN,
  2 as ID_CIUDAD_DESTINO,
  10 as ID_FLOTA,
  11 as ID_HORARIO,
  9 as ID_PRECIO,
  555 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:19.973000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  14 as ID_RUTA,
  1 as ID_CIUDAD_ORIGEN,
  3 as ID_CIUDAD_DESTINO,
  11 as ID_FLOTA,
  12 as ID_HORARIO,
  10 as ID_PRECIO,
  888 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:20.792000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  15 as ID_RUTA,
  1 as ID_CIUDAD_ORIGEN,
  4 as ID_CIUDAD_DESTINO,
  12 as ID_FLOTA,
  13 as ID_HORARIO,
  11 as ID_PRECIO,
  321 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:21.593000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  16 as ID_RUTA,
  1 as ID_CIUDAD_ORIGEN,
  5 as ID_CIUDAD_DESTINO,
  13 as ID_FLOTA,
  14 as ID_HORARIO,
  12 as ID_PRECIO,
  456 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:24.127000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  17 as ID_RUTA,
  1 as ID_CIUDAD_ORIGEN,
  6 as ID_CIUDAD_DESTINO,
  14 as ID_FLOTA,
  15 as ID_HORARIO,
  13 as ID_PRECIO,
  987 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:25.275000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  18 as ID_RUTA,
  6 as ID_CIUDAD_ORIGEN,
  1 as ID_CIUDAD_DESTINO,
  15 as ID_FLOTA,
  16 as ID_HORARIO,
  14 as ID_PRECIO,
  789 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:26.101000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  19 as ID_RUTA,
  6 as ID_CIUDAD_ORIGEN,
  2 as ID_CIUDAD_DESTINO,
  16 as ID_FLOTA,
  17 as ID_HORARIO,
  15 as ID_PRECIO,
  654 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:27.028000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  20 as ID_RUTA,
  6 as ID_CIUDAD_ORIGEN,
  3 as ID_CIUDAD_DESTINO,
  17 as ID_FLOTA,
  18 as ID_HORARIO,
  16 as ID_PRECIO,
  55 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:28.036000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  21 as ID_RUTA,
  6 as ID_CIUDAD_ORIGEN,
  4 as ID_CIUDAD_DESTINO,
  18 as ID_FLOTA,
  19 as ID_HORARIO,
  17 as ID_PRECIO,
  44 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:29.081000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  22 as ID_RUTA,
  6 as ID_CIUDAD_ORIGEN,
  5 as ID_CIUDAD_DESTINO,
  19 as ID_FLOTA,
  20 as ID_HORARIO,
  1 as ID_PRECIO,
  66 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:30.460000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  23 as ID_RUTA,
  6 as ID_CIUDAD_ORIGEN,
  7 as ID_CIUDAD_DESTINO,
  20 as ID_FLOTA,
  21 as ID_HORARIO,
  2 as ID_PRECIO,
  22 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:31.679000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  24 as ID_RUTA,
  6 as ID_CIUDAD_ORIGEN,
  8 as ID_CIUDAD_DESTINO,
  21 as ID_FLOTA,
  22 as ID_HORARIO,
  3 as ID_PRECIO,
  11 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:33.112000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  25 as ID_RUTA,
  6 as ID_CIUDAD_ORIGEN,
  9 as ID_CIUDAD_DESTINO,
  22 as ID_FLOTA,
  23 as ID_HORARIO,
  4 as ID_PRECIO,
  99 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:34.084000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  26 as ID_RUTA,
  3 as ID_CIUDAD_ORIGEN,
  2 as ID_CIUDAD_DESTINO,
  23 as ID_FLOTA,
  24 as ID_HORARIO,
  5 as ID_PRECIO,
  88 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:35.156000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  27 as ID_RUTA,
  3 as ID_CIUDAD_ORIGEN,
  1 as ID_CIUDAD_DESTINO,
  24 as ID_FLOTA,
  25 as ID_HORARIO,
  6 as ID_PRECIO,
  77 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:36.509000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  28 as ID_RUTA,
  3 as ID_CIUDAD_ORIGEN,
  6 as ID_CIUDAD_DESTINO,
  25 as ID_FLOTA,
  26 as ID_HORARIO,
  7 as ID_PRECIO,
  31 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:37.613000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  29 as ID_RUTA,
  4 as ID_CIUDAD_ORIGEN,
  1 as ID_CIUDAD_DESTINO,
  26 as ID_FLOTA,
  35 as ID_HORARIO,
  8 as ID_PRECIO,
  32 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:38.904000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  30 as ID_RUTA,
  4 as ID_CIUDAD_ORIGEN,
  2 as ID_CIUDAD_DESTINO,
  27 as ID_FLOTA,
  36 as ID_HORARIO,
  9 as ID_PRECIO,
  33 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:41.322000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  31 as ID_RUTA,
  4 as ID_CIUDAD_ORIGEN,
  3 as ID_CIUDAD_DESTINO,
  28 as ID_FLOTA,
  37 as ID_HORARIO,
  10 as ID_PRECIO,
  34 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:42.711000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  32 as ID_RUTA,
  4 as ID_CIUDAD_ORIGEN,
  5 as ID_CIUDAD_DESTINO,
  29 as ID_FLOTA,
  40 as ID_HORARIO,
  11 as ID_PRECIO,
  35 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:43.843000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_RUTA A USING
 (SELECT
  33 as ID_RUTA,
  4 as ID_CIUDAD_ORIGEN,
  6 as ID_CIUDAD_DESTINO,
  30 as ID_FLOTA,
  41 as ID_HORARIO,
  12 as ID_PRECIO,
  36 as ID_CONDUCTOR,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('28/04/2015 02:33:45.390000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:37:36', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_RUTA = B.ID_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_RUTA, ID_CIUDAD_ORIGEN, ID_CIUDAD_DESTINO, ID_FLOTA, ID_HORARIO, 
  ID_PRECIO, ID_CONDUCTOR, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, 
  AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_RUTA, B.ID_CIUDAD_ORIGEN, B.ID_CIUDAD_DESTINO, B.ID_FLOTA, B.ID_HORARIO, 
  B.ID_PRECIO, B.ID_CONDUCTOR, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, 
  B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_CIUDAD_ORIGEN = B.ID_CIUDAD_ORIGEN,
  A.ID_CIUDAD_DESTINO = B.ID_CIUDAD_DESTINO,
  A.ID_FLOTA = B.ID_FLOTA,
  A.ID_HORARIO = B.ID_HORARIO,
  A.ID_PRECIO = B.ID_PRECIO,
  A.ID_CONDUCTOR = B.ID_CONDUCTOR,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.T_ASIENTO A USING
 (SELECT
  6 as ID_ASIENTO,
  1 as ID_TIPO_ASIENTO,
  '30' as NUMERO,
  999 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_DATE('04/23/2015 17:02:32', 'MM/DD/YYYY HH24:MI:SS') as AUD_FECHA,
  TO_DATE('04/23/2015 17:02:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ASIENTO = B.ID_ASIENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ASIENTO, ID_TIPO_ASIENTO, NUMERO, APP_ID_USUARIO, AUD_ESTADO, 
  AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ASIENTO, B.ID_TIPO_ASIENTO, B.NUMERO, B.APP_ID_USUARIO, B.AUD_ESTADO, 
  B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_ASIENTO = B.ID_TIPO_ASIENTO,
  A.NUMERO = B.NUMERO,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_ASIENTO A USING
 (SELECT
  1 as ID_ASIENTO,
  2 as ID_TIPO_ASIENTO,
  '1' as NUMERO,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_DATE('04/20/2015 14:15:57', 'MM/DD/YYYY HH24:MI:SS') as AUD_FECHA,
  TO_DATE('04/20/2015 02:15:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ASIENTO = B.ID_ASIENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ASIENTO, ID_TIPO_ASIENTO, NUMERO, APP_ID_USUARIO, AUD_ESTADO, 
  AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ASIENTO, B.ID_TIPO_ASIENTO, B.NUMERO, B.APP_ID_USUARIO, B.AUD_ESTADO, 
  B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_ASIENTO = B.ID_TIPO_ASIENTO,
  A.NUMERO = B.NUMERO,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_ASIENTO A USING
 (SELECT
  2 as ID_ASIENTO,
  1 as ID_TIPO_ASIENTO,
  '2' as NUMERO,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_DATE('04/20/2015 14:16:10', 'MM/DD/YYYY HH24:MI:SS') as AUD_FECHA,
  TO_DATE('04/20/2015 02:15:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ASIENTO = B.ID_ASIENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ASIENTO, ID_TIPO_ASIENTO, NUMERO, APP_ID_USUARIO, AUD_ESTADO, 
  AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ASIENTO, B.ID_TIPO_ASIENTO, B.NUMERO, B.APP_ID_USUARIO, B.AUD_ESTADO, 
  B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_ASIENTO = B.ID_TIPO_ASIENTO,
  A.NUMERO = B.NUMERO,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_ASIENTO A USING
 (SELECT
  3 as ID_ASIENTO,
  1 as ID_TIPO_ASIENTO,
  '3' as NUMERO,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_DATE('04/20/2015 14:16:25', 'MM/DD/YYYY HH24:MI:SS') as AUD_FECHA,
  TO_DATE('04/20/2015 02:15:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ASIENTO = B.ID_ASIENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ASIENTO, ID_TIPO_ASIENTO, NUMERO, APP_ID_USUARIO, AUD_ESTADO, 
  AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ASIENTO, B.ID_TIPO_ASIENTO, B.NUMERO, B.APP_ID_USUARIO, B.AUD_ESTADO, 
  B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_ASIENTO = B.ID_TIPO_ASIENTO,
  A.NUMERO = B.NUMERO,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_ASIENTO A USING
 (SELECT
  4 as ID_ASIENTO,
  2 as ID_TIPO_ASIENTO,
  '4' as NUMERO,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_DATE('04/20/2015 14:16:36', 'MM/DD/YYYY HH24:MI:SS') as AUD_FECHA,
  TO_DATE('04/20/2015 02:15:55', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ASIENTO = B.ID_ASIENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ASIENTO, ID_TIPO_ASIENTO, NUMERO, APP_ID_USUARIO, AUD_ESTADO, 
  AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ASIENTO, B.ID_TIPO_ASIENTO, B.NUMERO, B.APP_ID_USUARIO, B.AUD_ESTADO, 
  B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_ASIENTO = B.ID_TIPO_ASIENTO,
  A.NUMERO = B.NUMERO,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_ASIENTO A USING
 (SELECT
  5 as ID_ASIENTO,
  2 as ID_TIPO_ASIENTO,
  '5' as NUMERO,
  555 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_DATE('04/20/2015 17:03:57', 'MM/DD/YYYY HH24:MI:SS') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ASIENTO = B.ID_ASIENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ASIENTO, ID_TIPO_ASIENTO, NUMERO, APP_ID_USUARIO, AUD_ESTADO, 
  AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ASIENTO, B.ID_TIPO_ASIENTO, B.NUMERO, B.APP_ID_USUARIO, B.AUD_ESTADO, 
  B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_ASIENTO = B.ID_TIPO_ASIENTO,
  A.NUMERO = B.NUMERO,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.T_ASIENTO_RUTA A USING
 (SELECT
  5 as ID_ASIENTO_RUTA,
  5 as ID_RUTA,
  3 as ID_ASIENTO,
  1 as ID_ESTADO_ASIENTO,
  'MOMOMOMO' as DESCRIPCION,
  999 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('23/04/2015 05:07:17.497000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/23/2015 17:07:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ASIENTO_RUTA = B.ID_ASIENTO_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ASIENTO_RUTA, ID_RUTA, ID_ASIENTO, ID_ESTADO_ASIENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ASIENTO_RUTA, B.ID_RUTA, B.ID_ASIENTO, B.ID_ESTADO_ASIENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_RUTA = B.ID_RUTA,
  A.ID_ASIENTO = B.ID_ASIENTO,
  A.ID_ESTADO_ASIENTO = B.ID_ESTADO_ASIENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_ASIENTO_RUTA A USING
 (SELECT
  1 as ID_ASIENTO_RUTA,
  5 as ID_RUTA,
  1 as ID_ASIENTO,
  1 as ID_ESTADO_ASIENTO,
  NULL as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 05:59:49.606000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 06:00:41', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ASIENTO_RUTA = B.ID_ASIENTO_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ASIENTO_RUTA, ID_RUTA, ID_ASIENTO, ID_ESTADO_ASIENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ASIENTO_RUTA, B.ID_RUTA, B.ID_ASIENTO, B.ID_ESTADO_ASIENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_RUTA = B.ID_RUTA,
  A.ID_ASIENTO = B.ID_ASIENTO,
  A.ID_ESTADO_ASIENTO = B.ID_ESTADO_ASIENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_ASIENTO_RUTA A USING
 (SELECT
  2 as ID_ASIENTO_RUTA,
  6 as ID_RUTA,
  3 as ID_ASIENTO,
  2 as ID_ESTADO_ASIENTO,
  'Sin descripcion' as DESCRIPCION,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 06:00:35.521000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 06:00:46', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ASIENTO_RUTA = B.ID_ASIENTO_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ASIENTO_RUTA, ID_RUTA, ID_ASIENTO, ID_ESTADO_ASIENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ASIENTO_RUTA, B.ID_RUTA, B.ID_ASIENTO, B.ID_ESTADO_ASIENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_RUTA = B.ID_RUTA,
  A.ID_ASIENTO = B.ID_ASIENTO,
  A.ID_ESTADO_ASIENTO = B.ID_ESTADO_ASIENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_ASIENTO_RUTA A USING
 (SELECT
  3 as ID_ASIENTO_RUTA,
  5 as ID_RUTA,
  3 as ID_ASIENTO,
  1 as ID_ESTADO_ASIENTO,
  'NO HAY DESCripcion' as DESCRIPCION,
  888 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 06:04:48.379000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ASIENTO_RUTA = B.ID_ASIENTO_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ASIENTO_RUTA, ID_RUTA, ID_ASIENTO, ID_ESTADO_ASIENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ASIENTO_RUTA, B.ID_RUTA, B.ID_ASIENTO, B.ID_ESTADO_ASIENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_RUTA = B.ID_RUTA,
  A.ID_ASIENTO = B.ID_ASIENTO,
  A.ID_ESTADO_ASIENTO = B.ID_ESTADO_ASIENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_ASIENTO_RUTA A USING
 (SELECT
  4 as ID_ASIENTO_RUTA,
  5 as ID_RUTA,
  3 as ID_ASIENTO,
  1 as ID_ESTADO_ASIENTO,
  'NOTHING DESCRIPTION' as DESCRIPCION,
  555 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('22/04/2015 02:09:38.206000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_ASIENTO_RUTA = B.ID_ASIENTO_RUTA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_ASIENTO_RUTA, ID_RUTA, ID_ASIENTO, ID_ESTADO_ASIENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_ASIENTO_RUTA, B.ID_RUTA, B.ID_ASIENTO, B.ID_ESTADO_ASIENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_RUTA = B.ID_RUTA,
  A.ID_ASIENTO = B.ID_ASIENTO,
  A.ID_ESTADO_ASIENTO = B.ID_ESTADO_ASIENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;


SET DEFINE OFF;
MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  6 as ID_PERSONA,
  1 as ID_TIPO_PERSONA,
  1 as ID_GENERO,
  'JUAN' as NOMBRE,
  'ARRASCAETA' as AP_PATERNO,
  'ARCANI' as AP_MATERNO,
  TO_DATE('04/04/1990 10:33:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_NACIMIENTO,
  'Calle 13' as DIRECCION,
  'xxx@gmail.com' as EMAIL,
  88 as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('04/04/2015 10:36:26.276000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/04/2015 10:34:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  7 as ID_PERSONA,
  1 as ID_TIPO_PERSONA,
  1 as ID_GENERO,
  'IGOR' as NOMBRE,
  'PERALTA' as AP_PATERNO,
  'SALAS' as AP_MATERNO,
  TO_DATE('04/04/1990 10:33:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_NACIMIENTO,
  'Calle 13' as DIRECCION,
  'xxx@gmail.com' as EMAIL,
  88 as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('04/04/2015 10:39:26.667000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/04/2015 10:34:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  12 as ID_PERSONA,
  NULL as ID_TIPO_PERSONA,
  NULL as ID_GENERO,
  'LOLA' as NOMBRE,
  NULL as AP_PATERNO,
  NULL as AP_MATERNO,
  NULL as FECHA_NACIMIENTO,
  NULL as DIRECCION,
  NULL as EMAIL,
  NULL as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('11/04/2015 10:43:43.812000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  13 as ID_PERSONA,
  2 as ID_TIPO_PERSONA,
  1 as ID_GENERO,
  'Joselito Vaca' as NOMBRE,
  NULL as AP_PATERNO,
  NULL as AP_MATERNO,
  NULL as FECHA_NACIMIENTO,
  NULL as DIRECCION,
  NULL as EMAIL,
  NULL as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('11/04/2015 11:00:02.539000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  1 as ID_PERSONA,
  1 as ID_TIPO_PERSONA,
  1 as ID_GENERO,
  'MICHELLE' as NOMBRE,
  'PEREZ' as AP_PATERNO,
  'GOMEZ' as AP_MATERNO,
  TO_DATE('04/15/1990 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_NACIMIENTO,
  'Z los pinos C 1' as DIRECCION,
  'juan@hotmail.com' as EMAIL,
  13 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('02/04/2015 12:00:00.000000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/02/2015 01:52:52', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  2 as ID_PERSONA,
  2 as ID_TIPO_PERSONA,
  2 as ID_GENERO,
  'SONIA' as NOMBRE,
  'BRITO' as AP_PATERNO,
  'MARA' as AP_MATERNO,
  TO_DATE('04/02/1995 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_NACIMIENTO,
  'Z/ Sopocachi C Belisario Salinas Nro 13' as DIRECCION,
  'sonia@gmail.com' as EMAIL,
  56 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('02/04/2015 01:55:06.008000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/02/2015 01:55:04', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  17 as ID_PERSONA,
  2 as ID_TIPO_PERSONA,
  2 as ID_GENERO,
  'andrea aguirre' as NOMBRE,
  NULL as AP_PATERNO,
  NULL as AP_MATERNO,
  NULL as FECHA_NACIMIENTO,
  NULL as DIRECCION,
  NULL as EMAIL,
  NULL as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('27/04/2015 05:47:54.811000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/27/2015 17:47:29', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  9 as ID_PERSONA,
  NULL as ID_TIPO_PERSONA,
  1 as ID_GENERO,
  'CARMEN' as NOMBRE,
  NULL as AP_PATERNO,
  NULL as AP_MATERNO,
  NULL as FECHA_NACIMIENTO,
  NULL as DIRECCION,
  NULL as EMAIL,
  NULL as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('05/04/2015 05:25:31.180000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  14 as ID_PERSONA,
  2 as ID_TIPO_PERSONA,
  1 as ID_GENERO,
  'Enrrique' as NOMBRE,
  NULL as AP_PATERNO,
  NULL as AP_MATERNO,
  NULL as FECHA_NACIMIENTO,
  NULL as DIRECCION,
  NULL as EMAIL,
  NULL as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('27/04/2015 05:20:24.810000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  15 as ID_PERSONA,
  2 as ID_TIPO_PERSONA,
  1 as ID_GENERO,
  'Armando' as NOMBRE,
  NULL as AP_PATERNO,
  NULL as AP_MATERNO,
  NULL as FECHA_NACIMIENTO,
  NULL as DIRECCION,
  NULL as EMAIL,
  NULL as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('27/04/2015 05:22:22.594000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  16 as ID_PERSONA,
  2 as ID_TIPO_PERSONA,
  2 as ID_GENERO,
  'Luisa ' as NOMBRE,
  NULL as AP_PATERNO,
  NULL as AP_MATERNO,
  NULL as FECHA_NACIMIENTO,
  NULL as DIRECCION,
  NULL as EMAIL,
  NULL as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('27/04/2015 05:23:02.318000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  8 as ID_PERSONA,
  NULL as ID_TIPO_PERSONA,
  1 as ID_GENERO,
  'HENRRY SALINAS' as NOMBRE,
  NULL as AP_PATERNO,
  NULL as AP_MATERNO,
  NULL as FECHA_NACIMIENTO,
  NULL as DIRECCION,
  NULL as EMAIL,
  NULL as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('04/04/2015 02:39:28.088000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  3 as ID_PERSONA,
  1 as ID_TIPO_PERSONA,
  1 as ID_GENERO,
  'LUISA' as NOMBRE,
  'LEIN' as AP_PATERNO,
  'MAMANI' as AP_MATERNO,
  NULL as FECHA_NACIMIENTO,
  'S/D' as DIRECCION,
  'luisa@gmail.com' as EMAIL,
  12 as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('03/04/2015 06:38:18.994000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  4 as ID_PERSONA,
  1 as ID_TIPO_PERSONA,
  2 as ID_GENERO,
  'MANOLA' as NOMBRE,
  'DIEZ' as AP_PATERNO,
  'VENTURA' as AP_MATERNO,
  NULL as FECHA_NACIMIENTO,
  'SN' as DIRECCION,
  'manola@otror.com
' as EMAIL,
  12 as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('03/04/2015 07:39:50.650000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/03/0015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  5 as ID_PERSONA,
  2 as ID_TIPO_PERSONA,
  2 as ID_GENERO,
  'LUCAS' as NOMBRE,
  'CARLOS' as AP_PATERNO,
  'PRIMERO' as AP_MATERNO,
  NULL as FECHA_NACIMIENTO,
  'UNA DIRECCION' as DIRECCION,
  'juan@gmail.com' as EMAIL,
  45 as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('03/04/2015 07:48:12.737000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_PERSONA A USING
 (SELECT
  11 as ID_PERSONA,
  1 as ID_TIPO_PERSONA,
  1 as ID_GENERO,
  'WILL' as NOMBRE,
  'GARCIA' as AP_PATERNO,
  'SALAS' as AP_MATERNO,
  TO_DATE('04/08/2015 16:06:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_NACIMIENTO,
  'S/N' as DIRECCION,
  'will@garcia.com' as EMAIL,
  123 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('08/04/2015 04:07:12.929000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/08/2015 16:07:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_PERSONA = B.ID_PERSONA)
WHEN NOT MATCHED THEN 
INSERT (
  ID_PERSONA, ID_TIPO_PERSONA, ID_GENERO, NOMBRE, AP_PATERNO, 
  AP_MATERNO, FECHA_NACIMIENTO, DIRECCION, EMAIL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_PERSONA, B.ID_TIPO_PERSONA, B.ID_GENERO, B.NOMBRE, B.AP_PATERNO, 
  B.AP_MATERNO, B.FECHA_NACIMIENTO, B.DIRECCION, B.EMAIL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_TIPO_PERSONA = B.ID_TIPO_PERSONA,
  A.ID_GENERO = B.ID_GENERO,
  A.NOMBRE = B.NOMBRE,
  A.AP_PATERNO = B.AP_PATERNO,
  A.AP_MATERNO = B.AP_MATERNO,
  A.FECHA_NACIMIENTO = B.FECHA_NACIMIENTO,
  A.DIRECCION = B.DIRECCION,
  A.EMAIL = B.EMAIL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.T_USUARIO A USING
 (SELECT
  2 as ID_USUARIO,
  1 as ID_PERSONA,
  3 as ID_SUCURSAL,
  1 as ID_TIPO_USUARIO,
  '123' as CLAVE,
  'juanes' as USUARIO,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:44:40.423000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:44:39', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_USUARIO = B.ID_USUARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_USUARIO, ID_PERSONA, ID_SUCURSAL, ID_TIPO_USUARIO, CLAVE, 
  USUARIO, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_USUARIO, B.ID_PERSONA, B.ID_SUCURSAL, B.ID_TIPO_USUARIO, B.CLAVE, 
  B.USUARIO, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_SUCURSAL = B.ID_SUCURSAL,
  A.ID_TIPO_USUARIO = B.ID_TIPO_USUARIO,
  A.CLAVE = B.CLAVE,
  A.USUARIO = B.USUARIO,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_USUARIO A USING
 (SELECT
  3 as ID_USUARIO,
  2 as ID_PERSONA,
  2 as ID_SUCURSAL,
  3 as ID_TIPO_USUARIO,
  '321' as CLAVE,
  'sony' as USUARIO,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:45:22.039000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:45:21', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_USUARIO = B.ID_USUARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_USUARIO, ID_PERSONA, ID_SUCURSAL, ID_TIPO_USUARIO, CLAVE, 
  USUARIO, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_USUARIO, B.ID_PERSONA, B.ID_SUCURSAL, B.ID_TIPO_USUARIO, B.CLAVE, 
  B.USUARIO, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_SUCURSAL = B.ID_SUCURSAL,
  A.ID_TIPO_USUARIO = B.ID_TIPO_USUARIO,
  A.CLAVE = B.CLAVE,
  A.USUARIO = B.USUARIO,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_USUARIO A USING
 (SELECT
  1 as ID_USUARIO,
  3 as ID_PERSONA,
  1 as ID_SUCURSAL,
  2 as ID_TIPO_USUARIO,
  '456' as CLAVE,
  'kiko' as USUARIO,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('13/05/2015 08:52:01.514000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_USUARIO = B.ID_USUARIO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_USUARIO, ID_PERSONA, ID_SUCURSAL, ID_TIPO_USUARIO, CLAVE, 
  USUARIO, APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, 
  FECHA_REGISTRO)
VALUES (
  B.ID_USUARIO, B.ID_PERSONA, B.ID_SUCURSAL, B.ID_TIPO_USUARIO, B.CLAVE, 
  B.USUARIO, B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, 
  B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_SUCURSAL = B.ID_SUCURSAL,
  A.ID_TIPO_USUARIO = B.ID_TIPO_USUARIO,
  A.CLAVE = B.CLAVE,
  A.USUARIO = B.USUARIO,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.T_BOLETO A USING
 (SELECT
  6 as ID_BOLETO,
  2 as ID_USUARIO,
  5 as ID_RUTA,
  4 as ID_SUCURSAL,
  999 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('23/04/2015 03:30:48.422000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/23/2015 15:30:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_BOLETO = B.ID_BOLETO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_BOLETO, ID_USUARIO, ID_RUTA, ID_SUCURSAL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_BOLETO, B.ID_USUARIO, B.ID_RUTA, B.ID_SUCURSAL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_USUARIO = B.ID_USUARIO,
  A.ID_RUTA = B.ID_RUTA,
  A.ID_SUCURSAL = B.ID_SUCURSAL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_BOLETO A USING
 (SELECT
  1 as ID_BOLETO,
  2 as ID_USUARIO,
  5 as ID_RUTA,
  2 as ID_SUCURSAL,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:46:32.000000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:46:32', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_BOLETO = B.ID_BOLETO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_BOLETO, ID_USUARIO, ID_RUTA, ID_SUCURSAL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_BOLETO, B.ID_USUARIO, B.ID_RUTA, B.ID_SUCURSAL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_USUARIO = B.ID_USUARIO,
  A.ID_RUTA = B.ID_RUTA,
  A.ID_SUCURSAL = B.ID_SUCURSAL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_BOLETO A USING
 (SELECT
  2 as ID_BOLETO,
  3 as ID_USUARIO,
  6 as ID_RUTA,
  4 as ID_SUCURSAL,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:47:31.369000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 01:46:32', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_BOLETO = B.ID_BOLETO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_BOLETO, ID_USUARIO, ID_RUTA, ID_SUCURSAL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_BOLETO, B.ID_USUARIO, B.ID_RUTA, B.ID_SUCURSAL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_USUARIO = B.ID_USUARIO,
  A.ID_RUTA = B.ID_RUTA,
  A.ID_SUCURSAL = B.ID_SUCURSAL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_BOLETO A USING
 (SELECT
  4 as ID_BOLETO,
  3 as ID_USUARIO,
  6 as ID_RUTA,
  4 as ID_SUCURSAL,
  888 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 01:51:01.749000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_BOLETO = B.ID_BOLETO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_BOLETO, ID_USUARIO, ID_RUTA, ID_SUCURSAL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_BOLETO, B.ID_USUARIO, B.ID_RUTA, B.ID_SUCURSAL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_USUARIO = B.ID_USUARIO,
  A.ID_RUTA = B.ID_RUTA,
  A.ID_SUCURSAL = B.ID_SUCURSAL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_BOLETO A USING
 (SELECT
  5 as ID_BOLETO,
  2 as ID_USUARIO,
  5 as ID_RUTA,
  3 as ID_SUCURSAL,
  555 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('22/04/2015 02:10:59.076000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_BOLETO = B.ID_BOLETO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_BOLETO, ID_USUARIO, ID_RUTA, ID_SUCURSAL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_BOLETO, B.ID_USUARIO, B.ID_RUTA, B.ID_SUCURSAL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_USUARIO = B.ID_USUARIO,
  A.ID_RUTA = B.ID_RUTA,
  A.ID_SUCURSAL = B.ID_SUCURSAL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_BOLETO A USING
 (SELECT
  3 as ID_BOLETO,
  1 as ID_USUARIO,
  5 as ID_RUTA,
  1 as ID_SUCURSAL,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('13/05/2015 08:54:11.720000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 00:00:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_BOLETO = B.ID_BOLETO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_BOLETO, ID_USUARIO, ID_RUTA, ID_SUCURSAL, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_BOLETO, B.ID_USUARIO, B.ID_RUTA, B.ID_SUCURSAL, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_USUARIO = B.ID_USUARIO,
  A.ID_RUTA = B.ID_RUTA,
  A.ID_SUCURSAL = B.ID_SUCURSAL,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;

SET DEFINE OFF;
MERGE INTO UAB_GET.T_DETALLE_BOLETO A USING
 (SELECT
  4 as ID_DETALLE_BOLETO,
  5 as ID_BOLETO,
  5 as ID_ASIENTO,
  3 as ID_PERSONA,
  999 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('23/04/2015 05:04:56.712000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/23/2015 17:04:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DETALLE_BOLETO = B.ID_DETALLE_BOLETO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DETALLE_BOLETO, ID_BOLETO, ID_ASIENTO, ID_PERSONA, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DETALLE_BOLETO, B.ID_BOLETO, B.ID_ASIENTO, B.ID_PERSONA, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_BOLETO = B.ID_BOLETO,
  A.ID_ASIENTO = B.ID_ASIENTO,
  A.ID_PERSONA = B.ID_PERSONA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DETALLE_BOLETO A USING
 (SELECT
  1 as ID_DETALLE_BOLETO,
  1 as ID_BOLETO,
  1 as ID_ASIENTO,
  12 as ID_PERSONA,
  500 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 02:20:28.555000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/20/2015 02:20:26', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DETALLE_BOLETO = B.ID_DETALLE_BOLETO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DETALLE_BOLETO, ID_BOLETO, ID_ASIENTO, ID_PERSONA, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DETALLE_BOLETO, B.ID_BOLETO, B.ID_ASIENTO, B.ID_PERSONA, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_BOLETO = B.ID_BOLETO,
  A.ID_ASIENTO = B.ID_ASIENTO,
  A.ID_PERSONA = B.ID_PERSONA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DETALLE_BOLETO A USING
 (SELECT
  2 as ID_DETALLE_BOLETO,
  4 as ID_BOLETO,
  1 as ID_ASIENTO,
  5 as ID_PERSONA,
  999 as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('20/04/2015 02:22:13.794000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DETALLE_BOLETO = B.ID_DETALLE_BOLETO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DETALLE_BOLETO, ID_BOLETO, ID_ASIENTO, ID_PERSONA, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DETALLE_BOLETO, B.ID_BOLETO, B.ID_ASIENTO, B.ID_PERSONA, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_BOLETO = B.ID_BOLETO,
  A.ID_ASIENTO = B.ID_ASIENTO,
  A.ID_PERSONA = B.ID_PERSONA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DETALLE_BOLETO A USING
 (SELECT
  3 as ID_DETALLE_BOLETO,
  5 as ID_BOLETO,
  5 as ID_ASIENTO,
  3 as ID_PERSONA,
  555 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('22/04/2015 02:12:03.078000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DETALLE_BOLETO = B.ID_DETALLE_BOLETO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DETALLE_BOLETO, ID_BOLETO, ID_ASIENTO, ID_PERSONA, APP_ID_USUARIO, 
  AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DETALLE_BOLETO, B.ID_BOLETO, B.ID_ASIENTO, B.ID_PERSONA, B.APP_ID_USUARIO, 
  B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_BOLETO = B.ID_BOLETO,
  A.ID_ASIENTO = B.ID_ASIENTO,
  A.ID_PERSONA = B.ID_PERSONA,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;


SET DEFINE OFF;
MERGE INTO UAB_GET.T_DOCUMENTO A USING
 (SELECT
  9 as ID_DOCUMENTO,
  13 as ID_PERSONA,
  1 as ID_TIPO_DOCUMENTO,
  NULL as NUMERO_DOCUMENTO,
  NULL as DESCRIPCION,
  NULL as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('11/04/2015 11:00:03.939000 AM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DOCUMENTO = B.ID_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DOCUMENTO, ID_PERSONA, ID_TIPO_DOCUMENTO, NUMERO_DOCUMENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DOCUMENTO, B.ID_PERSONA, B.ID_TIPO_DOCUMENTO, B.NUMERO_DOCUMENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO,
  A.NUMERO_DOCUMENTO = B.NUMERO_DOCUMENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DOCUMENTO A USING
 (SELECT
  12 as ID_DOCUMENTO,
  17 as ID_PERSONA,
  2 as ID_TIPO_DOCUMENTO,
  '65498744' as NUMERO_DOCUMENTO,
  NULL as DESCRIPCION,
  NULL as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('27/04/2015 05:47:56.132000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/27/2015 17:47:56', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DOCUMENTO = B.ID_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DOCUMENTO, ID_PERSONA, ID_TIPO_DOCUMENTO, NUMERO_DOCUMENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DOCUMENTO, B.ID_PERSONA, B.ID_TIPO_DOCUMENTO, B.NUMERO_DOCUMENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO,
  A.NUMERO_DOCUMENTO = B.NUMERO_DOCUMENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DOCUMENTO A USING
 (SELECT
  7 as ID_DOCUMENTO,
  9 as ID_PERSONA,
  1 as ID_TIPO_DOCUMENTO,
  NULL as NUMERO_DOCUMENTO,
  NULL as DESCRIPCION,
  NULL as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('05/04/2015 05:25:32.993000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DOCUMENTO = B.ID_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DOCUMENTO, ID_PERSONA, ID_TIPO_DOCUMENTO, NUMERO_DOCUMENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DOCUMENTO, B.ID_PERSONA, B.ID_TIPO_DOCUMENTO, B.NUMERO_DOCUMENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO,
  A.NUMERO_DOCUMENTO = B.NUMERO_DOCUMENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DOCUMENTO A USING
 (SELECT
  10 as ID_DOCUMENTO,
  15 as ID_PERSONA,
  1 as ID_TIPO_DOCUMENTO,
  NULL as NUMERO_DOCUMENTO,
  NULL as DESCRIPCION,
  NULL as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('27/04/2015 05:22:23.308000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DOCUMENTO = B.ID_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DOCUMENTO, ID_PERSONA, ID_TIPO_DOCUMENTO, NUMERO_DOCUMENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DOCUMENTO, B.ID_PERSONA, B.ID_TIPO_DOCUMENTO, B.NUMERO_DOCUMENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO,
  A.NUMERO_DOCUMENTO = B.NUMERO_DOCUMENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DOCUMENTO A USING
 (SELECT
  11 as ID_DOCUMENTO,
  16 as ID_PERSONA,
  2 as ID_TIPO_DOCUMENTO,
  NULL as NUMERO_DOCUMENTO,
  NULL as DESCRIPCION,
  NULL as APP_ID_USUARIO,
  NULL as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('27/04/2015 05:23:02.371000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DOCUMENTO = B.ID_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DOCUMENTO, ID_PERSONA, ID_TIPO_DOCUMENTO, NUMERO_DOCUMENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DOCUMENTO, B.ID_PERSONA, B.ID_TIPO_DOCUMENTO, B.NUMERO_DOCUMENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO,
  A.NUMERO_DOCUMENTO = B.NUMERO_DOCUMENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DOCUMENTO A USING
 (SELECT
  8 as ID_DOCUMENTO,
  2 as ID_PERSONA,
  2 as ID_TIPO_DOCUMENTO,
  '555999' as NUMERO_DOCUMENTO,
  'VISA' as DESCRIPCION,
  200 as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'APP_GESTION_UAB' as AUD_USUARIO,
  TO_TIMESTAMP('08/04/2015 04:09:01.762000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  TO_DATE('04/08/2015 16:08:00', 'MM/DD/YYYY HH24:MI:SS') as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DOCUMENTO = B.ID_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DOCUMENTO, ID_PERSONA, ID_TIPO_DOCUMENTO, NUMERO_DOCUMENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DOCUMENTO, B.ID_PERSONA, B.ID_TIPO_DOCUMENTO, B.NUMERO_DOCUMENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO,
  A.NUMERO_DOCUMENTO = B.NUMERO_DOCUMENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DOCUMENTO A USING
 (SELECT
  1 as ID_DOCUMENTO,
  1 as ID_PERSONA,
  1 as ID_TIPO_DOCUMENTO,
  '4566544' as NUMERO_DOCUMENTO,
  NULL as DESCRIPCION,
  NULL as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('13/05/2015 08:56:50.735000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DOCUMENTO = B.ID_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DOCUMENTO, ID_PERSONA, ID_TIPO_DOCUMENTO, NUMERO_DOCUMENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DOCUMENTO, B.ID_PERSONA, B.ID_TIPO_DOCUMENTO, B.NUMERO_DOCUMENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO,
  A.NUMERO_DOCUMENTO = B.NUMERO_DOCUMENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DOCUMENTO A USING
 (SELECT
  2 as ID_DOCUMENTO,
  2 as ID_PERSONA,
  1 as ID_TIPO_DOCUMENTO,
  '4152411' as NUMERO_DOCUMENTO,
  NULL as DESCRIPCION,
  NULL as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('13/05/2015 08:57:07.702000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DOCUMENTO = B.ID_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DOCUMENTO, ID_PERSONA, ID_TIPO_DOCUMENTO, NUMERO_DOCUMENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DOCUMENTO, B.ID_PERSONA, B.ID_TIPO_DOCUMENTO, B.NUMERO_DOCUMENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO,
  A.NUMERO_DOCUMENTO = B.NUMERO_DOCUMENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DOCUMENTO A USING
 (SELECT
  3 as ID_DOCUMENTO,
  3 as ID_PERSONA,
  2 as ID_TIPO_DOCUMENTO,
  '522258' as NUMERO_DOCUMENTO,
  NULL as DESCRIPCION,
  NULL as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('13/05/2015 08:57:30.149000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DOCUMENTO = B.ID_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DOCUMENTO, ID_PERSONA, ID_TIPO_DOCUMENTO, NUMERO_DOCUMENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DOCUMENTO, B.ID_PERSONA, B.ID_TIPO_DOCUMENTO, B.NUMERO_DOCUMENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO,
  A.NUMERO_DOCUMENTO = B.NUMERO_DOCUMENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DOCUMENTO A USING
 (SELECT
  4 as ID_DOCUMENTO,
  4 as ID_PERSONA,
  2 as ID_TIPO_DOCUMENTO,
  '5556998' as NUMERO_DOCUMENTO,
  NULL as DESCRIPCION,
  NULL as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('13/05/2015 08:58:16.268000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DOCUMENTO = B.ID_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DOCUMENTO, ID_PERSONA, ID_TIPO_DOCUMENTO, NUMERO_DOCUMENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DOCUMENTO, B.ID_PERSONA, B.ID_TIPO_DOCUMENTO, B.NUMERO_DOCUMENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO,
  A.NUMERO_DOCUMENTO = B.NUMERO_DOCUMENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DOCUMENTO A USING
 (SELECT
  5 as ID_DOCUMENTO,
  5 as ID_PERSONA,
  1 as ID_TIPO_DOCUMENTO,
  '4457566' as NUMERO_DOCUMENTO,
  NULL as DESCRIPCION,
  NULL as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('13/05/2015 08:58:42.723000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DOCUMENTO = B.ID_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DOCUMENTO, ID_PERSONA, ID_TIPO_DOCUMENTO, NUMERO_DOCUMENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DOCUMENTO, B.ID_PERSONA, B.ID_TIPO_DOCUMENTO, B.NUMERO_DOCUMENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO,
  A.NUMERO_DOCUMENTO = B.NUMERO_DOCUMENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

MERGE INTO UAB_GET.T_DOCUMENTO A USING
 (SELECT
  6 as ID_DOCUMENTO,
  6 as ID_PERSONA,
  2 as ID_TIPO_DOCUMENTO,
  '7988898' as NUMERO_DOCUMENTO,
  NULL as DESCRIPCION,
  NULL as APP_ID_USUARIO,
  1 as AUD_ESTADO,
  'SYSTEM' as AUD_USUARIO,
  TO_TIMESTAMP('13/05/2015 08:59:04.376000 PM','DD/MM/YYYY HH12:MI:SS.FF AM') as AUD_FECHA,
  NULL as FECHA_REGISTRO
  FROM DUAL) B
ON (A.ID_DOCUMENTO = B.ID_DOCUMENTO)
WHEN NOT MATCHED THEN 
INSERT (
  ID_DOCUMENTO, ID_PERSONA, ID_TIPO_DOCUMENTO, NUMERO_DOCUMENTO, DESCRIPCION, 
  APP_ID_USUARIO, AUD_ESTADO, AUD_USUARIO, AUD_FECHA, FECHA_REGISTRO)
VALUES (
  B.ID_DOCUMENTO, B.ID_PERSONA, B.ID_TIPO_DOCUMENTO, B.NUMERO_DOCUMENTO, B.DESCRIPCION, 
  B.APP_ID_USUARIO, B.AUD_ESTADO, B.AUD_USUARIO, B.AUD_FECHA, B.FECHA_REGISTRO)
WHEN MATCHED THEN
UPDATE SET 
  A.ID_PERSONA = B.ID_PERSONA,
  A.ID_TIPO_DOCUMENTO = B.ID_TIPO_DOCUMENTO,
  A.NUMERO_DOCUMENTO = B.NUMERO_DOCUMENTO,
  A.DESCRIPCION = B.DESCRIPCION,
  A.APP_ID_USUARIO = B.APP_ID_USUARIO,
  A.AUD_ESTADO = B.AUD_ESTADO,
  A.AUD_USUARIO = B.AUD_USUARIO,
  A.AUD_FECHA = B.AUD_FECHA,
  A.FECHA_REGISTRO = B.FECHA_REGISTRO;

COMMIT;