COSTAGE/src-modules/module/costage/rohdaten_sos/sos_costage_unload.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<superx-unload version="4.0">
<module id="sos" version="1.2" systeminfo_id="7">SOS-Modul</module>

<parameters>
<param name="SOS_UNL_COMPLETE" defaultValue="true" description="Komplett entladen"><comment>Sollen alle Datensätze entladen werden, oder nur die geänderten?(true,false).</comment></param>
<param name="VERSION" defaultValue="13" description="Datenbank-Version"><comment>SOSPOS-Version, möglich sind 6,7,8,9,10,11,12,13. Bei HISinOne wird sie automatisch gesetzt.</comment></param>
<param name="start_stud_sem" defaultValue="19911" description="Startsemester Studierende"><comment>Ab welchem Semester sollen Studierende entladen werden? z.B. 20011 für SS 2001</comment></param>
<param name="start_pruef_sem" defaultValue="19911" description="Startsemester Prüfungen"><comment>Ab welchem Semester sollen Prüfungen entladen werden? z.B. 20021 für SS 2002</comment></param>
<param name="SOS_UNL_ANON" defaultValue="false" description="Pseudonymisierung"><comment>Matrikelnummern pseudonymisieren (true, false).  Muss bei Datenquelle HISinOne auf "false" gesetzt sein.</comment></param>
<param name="POS_PNR" defaultValue="0" ><comment>Welche Prüfungsnummern (Vor- Hauptprüfun../../../superx/WEB-INF/web.xmlgen) sollen entladen werden? Wird bei Datenquelle HISinOne nicht ausgewertet.</comment></param>
<param name="LAB_FILTER" defaultValue=" AND (lab.panerk is null or lab.panerk != 'J') " ><comment>Weiterer Filter für Einzelprüfungen. Standardmäßig werden anerkannte Prüfungen nicht entladen. Wird bei Datenquelle HISinOne nicht ausgewertet.</comment></param>
<param name="STUDENT_FILTER" defaultValue=" AND 1=1 " ><comment>Filter für Studierende, um z.B. Teststudenten nicht zu entladen (nur HISinOne).</comment></param>
<param name="STUDENT_SOSPOS_FILTER" defaultValue=" AND 1=1 " ><comment>Filter für Studierende, um z.B. Teststudenten nicht zu entladen (nur sospos/co).</comment></param>
<param name="DATUM" defaultValue="01.01.1900" description="Entladedatum"><comment>Datum ab dem entladen werden soll (bei SOS_UNL_COMPLETE=false). Wird bei Datenquelle HISinOne nicht ausgewertet.</comment></param>
<param name="STUD_IDENT" defaultValue="false" description="Sollen Name und Vorname der Studierenden entladen werden? (Die ersten vier Buchstaben des Vornamens werden immer entladen, da sie für die Hochschulstatistik benötigt werden)"><comment> Wenn ja, dann ist der Wert "true", wenn nein, dann ist er "false"</comment></param>
<param name="PRUEFER_NAME" defaultValue="false" description="Sollen Name/Vorname der Prüfer entladen werden?"><comment> Wenn ja, dann ist der Wert "true", wenn nein, dann ist es "false". Wird bei Datenquelle HISinOne nicht ausgewertet.</comment></param>
<param name="DIPL_THEMA" defaultValue="false" description="Soll das Thema der Abschlussarbeit entladen werden?"><comment> Wenn ja, dann ist der Wert "true", wenn nein, dann ist es "false". Wird bei Datenquelle HISinOne nicht ausgewertet.</comment></param>
<param name="PERSONATTRIBUTE_IDS" defaultValue="0" description="Sollen Attribute einer Person entladen werden? Wenn Personenattribute entladen werden sollen, dann personattributetype_id durch Komma getrennt eingeben"><comment>Wird bei Datenquelle HISinOne ausgewertet.</comment></param>
<param name="stu_prot_maxid" defaultValue="0" description="Letzte Protokoll-ID"><comment>Letzte Protokollid beim inkrementellen Laden, wird automatisch gesetzt, bitte nicht ändern. Gilt nur für HISinOne-STU als Quellsystem</comment></param>
<param name="stu_updated_at" defaultValue="1900-01-01" description="Letzter entladener Datensatz"><comment>Letzter entladener Datensatz beim inkrementellen Laden, wird automatisch gesetzt, bitte nicht ändern. Gilt nur für HISinOne-STU als Quellsystem</comment></param>
<param name="exa_prot_maxid" defaultValue="0" description="Letzte Protokoll-ID"><comment>Letzte Protokollid beim inkrementellen Laden, wird automatisch gesetzt, bitte nicht ändern. Gilt nur für HISinOne-EXA als Quellsystem</comment></param>
<param name="exa_updated_at" defaultValue="1900-01-01" description="Letzter entladener Datensatz"><comment>Letzter entladener Datensatz beim inkrementellen Laden, wird automatisch gesetzt, bitte nicht ändern. Gilt nur für HISinOne-EXA als Quellsystem</comment></param>
<param name="sos_pord_pltxt1" defaultValue="null::char(1)" description="Soll das Feld sos_pord.pltxt1 entladen werden?"><comment> Wenn ja, dann ist der Wert "pltxt1", wenn nein, dann ist es null::char(1).</comment></param>
<param name="sos_pord_pltxt2" defaultValue="null::char(1)" description="Soll das Feld sos_pord.pltxt2 entladen werden?"><comment> Wenn ja, dann ist der Wert "pltxt2", wenn nein, dann ist es null::char(1).</comment></param>
<param name="sos_pord_pltxt3" defaultValue="null::char(1)" description="Soll das Feld sos_pord.pltxt3 entladen werden?"><comment> Wenn ja, dann ist der Wert "pltxt3", wenn nein, dann ist es null::char(1).</comment></param>
<param name="sos_pord_pltxt4" defaultValue="null::char(1)" description="Soll das Feld sos_pord.pltxt4 entladen werden?"><comment> Wenn ja, dann ist der Wert "pltxt4", wenn nein, dann ist es null::char(1).</comment></param>
</parameters>
<sourcesystems>
<sourcesystem name="sospos" description="SOSPOS-GX Datenbank" />
<sourcesystem name="hisinone" description="HIS1 Datenbank" default="true"/>
<sourcesystem name="co" description="CampusOnline-Datenbank" />

</sourcesystems>

<!--
<unload-job id="preparation1" extraction-table="" extraction-script="" transfer-unload-file="" >
<comment> wichtige Konstanten aus SOS entladen, z.B. HISSOS-Version.</comment>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[
execute procedure sp_mtknr_ldsg("$SOS_UNL_ANON");

]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[
select sp_mtknr_ldsg('$SOS_UNL_ANON');

]]>
</extraction-sql>

</unload-job>
-->
<unload-job id="preparation1" extraction-table="" extraction-script="" transfer-unload-file="" >
<comment> wichtige Konstanten aus SOS entladen, z.B. HISSOS-Version.</comment>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[

create temp table tmp_mtknr_ldsg(mtknr integer);
-- alle mtknr aus der Tabelle sos in die Tabelle mtknr_ldsg einfügen
--Welche Matrikelnummern sind neu?
insert into tmp_mtknr_ldsg
select S.mtknr from sos S left outer join mtknr_ldsg L
on (L.mtknr=S.mtknr)
where L.mtknr is null
and S.mtknr is not null
	  ;

--Nur die neuen Matrikelnummern hinzufügen
	   insert into mtknr_ldsg(mtknr)
	   select  distinct mtknr from tmp_mtknr_ldsg
	   where '$SOS_UNL_ANON' = 'true';

	   insert into mtknr_ldsg(mtknr,mtknr_ldsg)
	   select  distinct mtknr,mtknr from tmp_mtknr_ldsg
	   where '$SOS_UNL_ANON' != 'true';



drop table tmp_mtknr_ldsg;

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
DROP TABLE IF EXISTS tmp_xdummy;
create table tmp_xdummy
(
c char(10)
);
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
create table tmp_xdummy
(
c char(10)
);
]]>
</extraction-sql>
</unload-job>
<unload-job id="preparation2" extraction-table="" extraction-script="" database="" transfer-unload-file="" >
<comment> wichtige Konstanten aus SOS entladen, z.B. HISSOS-Version.</comment>
<!-- Ab der INFORMIX IDS 117 entfällt die database-Spezifika: -->
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[
-- DROP TABLE IF EXISTS superx_sos;
create table superx_sos (mtknr integer, mtknr_ldsg integer);

]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[
create table superx_sos (mtknr integer, mtknr_ldsg integer);

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
DROP TABLE IF EXISTS superx_sos;
create table superx_sos (id integer,
mtknr_ldsg integer,
semester_astat varchar(20),
semester_country_astat varchar(20),
person_id integer,
semester_postcode varchar(50),
semester_country_lid integer ,
erhssembrd integer,
discontinuationsemester integer,
study_before_university_lid integer,
study_before_country_lid integer,
study_before_place_of_study char(10),
study_before_country_of_study char(10),
k_study_interruption_type_id integer,
k_study_interruption_type_astat char(10),
personinfo_country_id integer,
second_nationality_country_lid integer,
second_nationality_astat char(10),
orgrole_valid_from date,
orgrole_valid_to date,
person_k_gender_id integer,
person_birthdate date,
person_birthcity varchar(255)
);

insert into tmp_xdummy values('1');

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[

create table superx_sos (mtknr integer, mtknr_ldsg integer);

insert into tmp_xdummy values('1');

]]>
</extraction-sql>
</unload-job>
<unload-job id="preparation3" extraction-table="" extraction-script="" transfer-unload-file="" >
<comment> PNR Konstanten aus POS entladen</comment>
<!-- Ab der INFORMIX IDS 117 entfällt die database-Spezifika: -->
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[
create table tmp_hskonst (pnr integer);

]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[
DROP TABLE IF EXISTS tmp_hskonst;
create table tmp_hskonst (pnr integer);

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[

DROP TABLE IF EXISTS tmp_course_of_study;
CREATE TABLE tmp_course_of_study (
    id integer NOT NULL,
    lid integer NOT NULL,
    degree_lid integer,
    degree_id integer,
    subject_lid integer,
    subject_id integer,
    major_field_of_study_lid integer,
    major_field_of_study_id integer,
    course_specialization_lid integer,
    course_specialization_id integer,
    k_subject_indicator_id integer,
    k_examinationversion_id integer,
    k_place_of_studies_id integer,
    k_enrollment_id integer,
    k_type_of_study_id integer,
    k_form_of_studies_id integer,
    part_of_studies integer NOT NULL,
    valid_from date,
    valid_to date,
    k_language_id integer NOT NULL,
    shorttext character varying,
    defaulttext character varying NOT NULL,
    longtext character varying,
    orgunit_lid integer,
    orgunit_id integer,
    regular_number_of_semesters integer,
    uniquename character varying,
    from_term_year integer,
    from_term_type_id integer,
    to_term_year integer,
    to_term_type_id integer,
    admission_to_study_id integer,
    is_admission_to_study integer,
    is_course_of_study_start integer,
    k_course_of_study_type_id integer NOT NULL,
    termcategory integer NOT NULL,
    teachingunit_orgunit_lid integer,
    teachingunit_orgunit_id integer,
    k_field_of_study_id integer,
    examination_office_no character varying,
    is_historized smallint
);
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
create table tmp_hskonst (unikey char(10),anzahl integer,max_anzahl smallint);

]]>
</extraction-sql>
</unload-job>
<unload-job id="preparation4" extraction-table="" extraction-script="" transfer-unload-file="" >
<comment> PNR Konstanten aus POS entladen</comment>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[
insert into tmp_hskonst
select vpnr from hskonst
union
select hpnr from hskonst
union
select sonstpnr1 from hskonst
union
select sonstpnr2 from hskonst
union
select sonstpnr3 from hskonst;

]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[
insert into tmp_hskonst
select vpnr from hskonst;
insert into tmp_hskonst
select hpnr from hskonst;
insert into tmp_hskonst
select sonstpnr1 from hskonst;
insert into tmp_hskonst
select sonstpnr2 from hskonst;
insert into tmp_hskonst
select sonstpnr3 from hskonst;

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[


insert into tmp_course_of_study( id,
       lid,
       degree_lid,
       subject_lid,
       major_field_of_study_lid,
       course_specialization_lid,
       k_subject_indicator_id,
       k_examinationversion_id,
       k_place_of_studies_id,
       k_enrollment_id,
       k_type_of_study_id,
       k_form_of_studies_id,
       part_of_studies,
       valid_from,
       valid_to,
       k_language_id,
       shorttext,
       defaulttext,
       longtext,
       orgunit_lid,
       regular_number_of_semesters,
       uniquename,
       from_term_year,
       from_term_type_id,
       to_term_year,
       to_term_type_id,
       admission_to_study_id,
       is_admission_to_study,
       is_course_of_study_start,
       k_course_of_study_type_id,
       termcategory,
       teachingunit_orgunit_lid,
       k_field_of_study_id,
       examination_office_no,
       is_historized)
SELECT id,
       lid,
       degree_lid,
       subject_lid,
       major_field_of_study_lid,
       course_specialization_lid,
       k_subject_indicator_id,
       k_examinationversion_id,
       k_place_of_studies_id,
       k_enrollment_id,
       k_type_of_study_id,
       k_form_of_studies_id,
       part_of_studies,
       valid_from,
       valid_to,
       k_language_id,
       shorttext,
       defaulttext,
       longtext,
       orgunit_lid,
       regular_number_of_semesters,
       uniquename,
       from_term_year,
       from_term_type_id,
       to_term_year,
       to_term_type_id,
       admission_to_study_id,
       is_admission_to_study,
       is_course_of_study_start,
       k_course_of_study_type_id,
       termcategory,
       teachingunit_orgunit_lid,
       k_field_of_study_id,
       examination_office_no,
       0 --is_historized
FROM course_of_study;
--ermitteln der historisierten IDs
--degree
update tmp_course_of_study set degree_id=(select D.id from degree D
where D.lid=tmp_course_of_study.degree_lid
and (D.valid_from <= tmp_course_of_study.valid_from
or D.valid_from is null
or ( D.valid_from is null and tmp_course_of_study.valid_from is null)
)
and (D.valid_to >= tmp_course_of_study.valid_to
or D.valid_to is null
or ( D.valid_from is null and tmp_course_of_study.valid_from is null)
)
);
--wenn degree nicht ermittelt werden kann, dann ohne Historisierung
update tmp_course_of_study set degree_id=(select min(D.id) from degree D
where D.lid=tmp_course_of_study.degree_lid
)
where degree_id is null
;
--subject
update tmp_course_of_study set subject_id=(select D.id from subject D
where D.lid=tmp_course_of_study.subject_lid
and (D.valid_from <= tmp_course_of_study.valid_from
or D.valid_from is null
or ( D.valid_from is null and tmp_course_of_study.valid_from is null)
)
and (D.valid_to >= tmp_course_of_study.valid_to
or D.valid_to is null
or ( D.valid_from is null and tmp_course_of_study.valid_from is null)
)
);
--wenn subject nicht ermittelt werden kann, dann ohne Historisierung
update tmp_course_of_study set subject_id=(select min(D.id) from subject D
where D.lid=tmp_course_of_study.subject_lid
)
where subject_id is null
;
--major_field_of_study
update tmp_course_of_study set major_field_of_study_id=(select D.id from major_field_of_study D
where D.lid=tmp_course_of_study.major_field_of_study_lid
and (D.valid_from <= tmp_course_of_study.valid_from
or D.valid_from is null
or ( D.valid_from is null and tmp_course_of_study.valid_from is null)
)
and (D.valid_to >= tmp_course_of_study.valid_to
or D.valid_to is null
or ( D.valid_from is null and tmp_course_of_study.valid_from is null)
)
);
--course_specialization_lid
update tmp_course_of_study set course_specialization_id=(select D.id from course_specialization D
where D.lid=tmp_course_of_study.course_specialization_lid
and (D.valid_from <= tmp_course_of_study.valid_from
or D.valid_from is null
or ( D.valid_from is null and tmp_course_of_study.valid_from is null)
)
and (D.valid_to >= tmp_course_of_study.valid_to
or D.valid_to is null
or ( D.valid_from is null and tmp_course_of_study.valid_from is null)
)
);
--orgunit
update tmp_course_of_study set orgunit_id=(select D.id from orgunit D
where D.lid=tmp_course_of_study.orgunit_lid
and (D.valid_from <= tmp_course_of_study.valid_from
or D.valid_from is null
or ( D.valid_from is null and tmp_course_of_study.valid_from is null)
)
and (D.valid_to >= tmp_course_of_study.valid_to
or D.valid_to is null
or ( D.valid_from is null and tmp_course_of_study.valid_from is null)
)
);
--wenn Studiengang heute gültig ist und orgunit historisiert, nimmt er den aktuellen FB
update tmp_course_of_study set orgunit_id=(select D.id from orgunit D
where D.lid=tmp_course_of_study.orgunit_lid
and current_date between D.valid_from and D.valid_to)
where current_date between valid_from and valid_to
and orgunit_id is null;


--teachingunit_orgunit_lid

update tmp_course_of_study set teachingunit_orgunit_id=(select D.id from orgunit D
where D.lid=tmp_course_of_study.teachingunit_orgunit_lid
and (D.valid_from <= tmp_course_of_study.valid_from
or D.valid_from is null
or ( D.valid_from is null and tmp_course_of_study.valid_from is null)
)
and (D.valid_to >= tmp_course_of_study.valid_to
or D.valid_to is null
or ( D.valid_from is null and tmp_course_of_study.valid_from is null)
)
)
where teachingunit_orgunit_lid is not null;

--wenn Studiengang heute gültig ist und orgunit historisiert, nimmt er aktuelle LE
update tmp_course_of_study set teachingunit_orgunit_id=(select D.id from orgunit D
where D.lid=tmp_course_of_study.teachingunit_orgunit_lid
and current_date between D.valid_from and D.valid_to)
where current_date between valid_from and valid_to
and teachingunit_orgunit_id is null;


--k_field_of_study
update tmp_course_of_study set k_field_of_study_id=(select S.k_field_of_study_id
from subject S
where S.id=tmp_course_of_study.subject_id)
where k_field_of_study_id is null;
--hochprojizieren auf Fächergruppe
update tmp_course_of_study set k_field_of_study_id=(select K.parent_id
from k_field_of_study K
where K.id=tmp_course_of_study.k_field_of_study_id);

--is_historized=1 wenn es mehrere Studiengänge pro LID gibt
update tmp_course_of_study set is_historized=1
where 1 < (select count(*) from course_of_study C
where C.lid=tmp_course_of_study.lid);

create index i_tc1 on tmp_course_of_study(lid);

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
insert into tmp_hskonst (unikey,anzahl )
select A.unikey,count(*) from costage_st_studien_aggr A
group by 1;

update tmp_hskonst set max_anzahl=1
where anzahl=(select max(T.anzahl) from tmp_hskonst T);



]]>
</extraction-sql>
</unload-job>




<unload-job id="preparation5" extraction-table="" extraction-script="" database="" transfer-unload-file="" >
<comment> wichtige Konstanten aus SOS entladen, z.B. HISSOS-Version.</comment>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[
insert into superx_sos(mtknr, mtknr_ldsg)
SELECT  DISTINCT S.mtknr,M.mtknr_ldsg
from sos S,mtknr_ldsg M
 where S.mtknr=M.mtknr
 and (fehlerkz not in ("F", "V")
	or fehlerkz is null)
$STUDENT_SOSPOS_FILTER
 and   (
 --Entweder
 "$SOS_UNL_COMPLETE"='true'
 --oder DATLAE
 or ((datlae >= date("$DATUM")
	 OR ruebeudat >= date("$DATUM")
	 OR exmdat >= date("$DATUM"))
	)
	--oder pro
or (S.mtknr in (select mtknr
FROM    pro
WHERE   datum >= date("$DATUM")
-- keine Berücksichtigung von archivierten Daten
and fktkz not in ("ARC", "REA", "NER", "AAE"))
)
--oder pprot
or (S.mtknr in (select
 DISTINCT mtknr
FROM    pprot
WHERE   datlae >= date("$DATUM")) )

);
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[
insert into superx_sos(mtknr, mtknr_ldsg)
SELECT  DISTINCT S.mtknr,M.mtknr_ldsg
from sos S,mtknr_ldsg M
 where S.mtknr=M.mtknr
 AND (fehlerkz not in ('F', 'V')
	or fehlerkz is null)
$STUDENT_SOSPOS_FILTER
 and   (
 --Entweder
 '"$SOS_UNL_COMPLETE"'='"true"'
 --oder DATLAE
 or ((datlae >= date('"$DATUM"')
	 OR ruebeudat >= date('"$DATUM"')
	 OR exmdat >= date('"$DATUM"'))
	)
	--oder pro
or (S.mtknr in (select mtknr
FROM    pro
WHERE   datum >= date('"$DATUM"')
-- keine Berücksichtigung von archivierten Daten
and fktkz not in ('ARC', 'REA', 'NER', 'AAE'))
)
--oder pprot
or (S.mtknr in (select
 DISTINCT mtknr
FROM    pprot
WHERE   datlae >= date('"$DATUM"')) )

)


 ;

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
INSERT INTO superx_sos(
  id,
  mtknr_ldsg,
  person_id,
  person_birthdate,
  person_birthcity,
  person_k_gender_id
)
SELECT DISTINCT
  S.id,
  S.registrationnumber,
  S.person_id,
  P.birthdate,
  substring(P.birthcity from 1 for 255),
  P.k_gender_id
FROM
  student S,
  person P
WHERE
  P.id = S.person_id
  AND S.registrationnumber IS NOT NULL
  $STUDENT_FILTER
  AND '$SOS_UNL_ANON' != 'true'
  AND ((S.updated_at > '$stu_updated_at') OR (S.updated_at IS NULL AND '$stu_updated_at' = '1900-01-01'))
  --keine vorläufigen Studierenden #118453
  --nur Rolle "Student" (hiskey_id=5)
  AND 0 < (
    SELECT
      count(*)
    FROM
      orgrole O,
      role R
    WHERE
      R.id = O.role_id
      AND S.person_id = O.person_id
      AND R.hiskey_id IN (5, 8)
    );
  --Promovierende 81
  --Gasthörer 8

-- Ermittlung semesterwohnsitz
-- alle Studierenden id-s aus Tabelle student
-- die Postleitzahl der Hinterlegten Adresse des Studierendens (-> welcher Adresstype(n) ist richtig? Ein Studierenden kann verschiedene Adressarten hinterlegen...)
-- und die country_lid ueber die der Staat ermittelt werden kann (superx_sos.country_lid->country.country_lid)
UPDATE
  superx_sos
SET
  semester_postcode = addr.postcode,
  semester_country_lid = addr.country_lid
FROM
  address AS addr
  LEFT JOIN address_k_notificationcategory adnocat ON addr.id = adnocat.address_id
  LEFT JOIN k_notificationcategory knocat ON (adnocat.k_notificationcategory_id = knocat.id AND knocat.hiskey_id = 2), -- hiskey_id=2 -> STU
  person prs,
  k_addresstag atag
WHERE
  superx_sos.person_id = prs.id and addr.person_id=prs.id
  AND addr.eaddresstype_id IS NULL -- -> address.addresstype = 'Postaddress'
  AND atag.id = addr.k_addresstag_id
  AND atag.hiskey_id = 2 --semesterwohnsitz
;


-- Semesterwohnsitz = Heimatwohnsitz falls Semesterwohnsitz nicht gesetzt ist
UPDATE
  superx_sos
SET
  semester_postcode = substring(addr.postcode FOR 50),
  semester_country_lid = addr.country_lid
FROM
  address addr
  LEFT JOIN address_k_notificationcategory adnocat ON addr.id = adnocat.address_id
  LEFT JOIN k_notificationcategory knocat ON adnocat.k_notificationcategory_id = knocat.id AND knocat.hiskey_id = 2, -- hiskey_id=2 -> STU
  person prs,
  k_addresstag atag
WHERE
  superx_sos.person_id = prs.id
  AND addr.person_id = prs.id
  AND addr.eaddresstype_id IS NULL -- -> address.addresstype = 'Postaddress'
  AND atag.id = addr.k_addresstag_id
  -- Ab hier Anpassungen
  AND atag.hiskey_id = 1 --heimatwohnsitz
  AND semester_postcode IS NULL
  AND semester_country_lid IS NULL
;

-- für jeden Studierenden mit Postleitzahl den astat-Schlüssel des Landkreises aus k_postcode holen
create index i_tmp_k_postcode1 on k_postcode(postcode,astat);
create index i_tmp_ss1 on superx_sos(semester_postcode); 

UPDATE
  superx_sos
SET
  semester_astat = (
    SELECT
      k_postcode.astat
    FROM
      k_postcode
    WHERE
      superx_sos.semester_postcode = k_postcode.postcode
    LIMIT 1
  );

drop index i_tmp_k_postcode1;
drop index i_tmp_ss1;


-- Astat-Schlüssel aus Country
UPDATE
  superx_sos
SET
  semester_country_astat = (
    SELECT
      country.astat
    FROM
      country
    WHERE
      superx_sos.semester_country_lid = country.lid
      AND current_date BETWEEN valid_from AND valid_to
    LIMIT 1
  );

CREATE index i_ts1 ON superx_sos(mtknr_ldsg);
CREATE index i_ts2 ON superx_sos(person_id);

--Erstes Studium (erhssembrd etc.) ermitteln
UPDATE
  superx_sos
SET
  erhssembrd = to_number(('' || STUBE.first_term_year || TETY.termnumber),'99999'),
  discontinuationsemester = STUBE.discontinuationsemester,
  study_before_university_lid = STUBE.university_lid,
  study_before_country_lid = STUBE.country_lid,
  k_study_interruption_type_id = STUBE.k_study_interruption_type_id
FROM
  term_type TETY,
  study_before STUBE
WHERE
  STUBE.person_id = superx_sos.person_id
  AND STUBE.first_term_type_id = TETY.id;

UPDATE
  superx_sos
SET
  study_before_place_of_study = (
    SELECT
      UNI.astat
    FROM
      university UNI
    WHERE
      UNI.lid = superx_sos.study_before_university_lid
  )
WHERE
  study_before_university_lid IS NOT NULL
;

UPDATE
  superx_sos
SET
  study_before_country_of_study = (
    SELECT
      CNT.astat
    FROM
      country CNT
    WHERE
      CNT.lid = superx_sos.study_before_country_lid
  )
WHERE
  study_before_country_lid IS NOT NULL
;

UPDATE
  superx_sos
SET
  k_study_interruption_type_astat = (
    SELECT
      STINTY.astat
    FROM
      k_study_interruption_type STINTY
    WHERE
      STINTY.id = superx_sos.k_study_interruption_type_id
  )
WHERE
  k_study_interruption_type_id IS NOT NULL
;

UPDATE
  superx_sos
SET
  second_nationality_country_lid = prsinf.second_nationality_country_lid,
  personinfo_country_id = cnt.id
FROM
  personinfo prsinf
  LEFT OUTER JOIN country cnt ON cnt.lid = prsinf.country_lid AND current_date between cnt.valid_from and cnt.valid_to
WHERE
  prsinf.person_id = superx_sos.person_id
;

UPDATE
  superx_sos
SET
  second_nationality_astat = (
    SELECT
      cnt.astat
    FROM
      country cnt
    WHERE
      cnt.lid = superx_sos.second_nationality_country_lid
      AND current_date BETWEEN cnt.valid_from AND cnt.valid_to
  )
WHERE
  second_nationality_country_lid IS NOT NULL
;

UPDATE
  superx_sos
SET
  orgrole_valid_from = OrgR.valid_from,
  orgrole_valid_to = OrgR.valid_to
FROM
  orgrole OrgR
WHERE
  OrgR.person_id = superx_sos.person_id
  AND OrgR.role_id = 5
;

CREATE INDEX tmp_i_ts99 ON superx_sos(id);

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
insert into superx_sos(mtknr, mtknr_ldsg)
SELECT  DISTINCT val(S.matrikelnummer),val(S.matrikelnummer)
from costage_st_studierendenstammdaten S
--where S.semester >= $start_stud_sem

 ;

]]>
</extraction-sql>
</unload-job>

<!--<unload-job id="preparation" extraction-table="" extraction-script="preparation.sql" transfer-unload-file=""   database="" version="">
<comment> Geänderte Matrikelnummern</comment>
</unload-job>-->
<unload-job id="konstanten" extraction-table="" extraction-script="" transfer-unload-file="unl/konstanten.unl" >
<comment> wichtige Konstanten aus SOS entladen, z.B. HISSOS-Version.</comment>

<extraction-sql sourcesystem="sospos" database="INFORMIX" version="">
<![CDATA[

select 21,"" || trunc(substring(dbversnr from 1 for 2)),"SOS-Version" from hskonst
 union
 select 22,"" || $start_stud_sem,"Start_SOS_Semester" from hskonst
union
  select 23,"" || $start_pruef_sem,"Start_POS_Semester" from hskonst
 union
select 24,"" || vpnr,"sos_pruef_vdpnr" from hskonst
 union
select 25,"" || hpnr,"sos_pruef_hdpnr" from hskonst
 union
select 26,"" || sonstpnr1,"sos_einz_pruef_pnr1" from hskonst
 union
select 27,"" || sonstpnr2,"sos_einz_pruef_pnr2" from hskonst
 union
select 28,"" || sonstpnr3,"sos_einz_pruef_pnr3" from hskonst
 union
select 30,"1",beschr from k_s_var where beschr="Semester 5-stellig" and wert1='J'
union
select 31,"0",beschr from k_s_var where beschr="Semester 5-stellig" and wert1 !='J'
union
select 32,"1","sos_unload_complete" from hskonst
where "$SOS_UNL_COMPLETE"="true"
union
select 32,"0","sos_unload_complete" from hskonst
where "$SOS_UNL_COMPLETE"!="true"
union
select 33,"5","SOS_Quellsystem" from hskonst
union
select 34,"0","SOS_Trimester" from hskonst
;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos" database="POSTGRES" version="">
<![CDATA[

select 21,'' || trunc(to_number(dbversnr,'99')),'SOS-Version' from hskonst
 union
 select 22,'' || $start_stud_sem,'Start_SOS_Semester' from hskonst
union
  select 23,'' || $start_pruef_sem,'Start_POS_Semester' from hskonst
 union
select 24,'' || vpnr,'sos_pruef_vdpnr' from hskonst
 union
select 25,'' || hpnr,'sos_pruef_hdpnr' from hskonst
 union
select 26,'' || sonstpnr1,'sos_einz_pruef_pnr^1' from hskonst
 union
select 27,'' || sonstpnr2,'sos_einz_pruef_pnr2' from hskonst
 union
select 28,'' || sonstpnr3,'sos_einz_pruef_pnr3' from hskonst
 union
select 30,'1',beschr from k_s_var where beschr='Semester 5-stellig' and wert1='J'
union
select 31,'0',beschr from k_s_var where beschr='Semester 5-stellig' and wert1 <>'J'
union
select 32,'1','sos_unload_complete' from hskonst
where '$SOS_UNL_COMPLETE'='true'
union
select 32,'0','sos_unload_complete' from hskonst
where '$SOS_UNL_COMPLETE'!='true'
union
select 33,'5','SOS_Quellsystem' from hskonst
union
select 34,'0','SOS_Trimester' from hskonst
;
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone" database="" version="">
<![CDATA[

select 21,'' || 2,'SOS-Version' as version from tmp_xdummy
 union
 select 22,'' || $start_stud_sem,'Start_SOS_Semester' from tmp_xdummy
union
  select 23,'' || $start_pruef_sem,'Start_POS_Semester' from tmp_xdummy
 union
select 32,'1','sos_unload_complete' from tmp_xdummy
where '$SOS_UNL_COMPLETE'='true'
and $stu_prot_maxid=0
union
select 32,'0','sos_unload_complete' from tmp_xdummy
where '$SOS_UNL_COMPLETE'!='true'
or $stu_prot_maxid>0
union
select 33,'6','SOS_Quellsystem' from tmp_xdummy
union
select 34,'0','SOS_Trimester' from tmp_xdummy
where 0=(SELECT count(*)
FROM k_period_usage K,period_usage U,period P,term_type T
where K.id=U.k_period_usage_id
and K.hiskey_id=7 --Semesterzeitraum
and U.period_id=P.id
and T.id=P.term_type_id
and T.termcategory=3 --Trimester
)
union
select 34,'1','SOS_Trimester' from tmp_xdummy
where 0< (SELECT count(*)
FROM k_period_usage K,period_usage U,period P,term_type T
where K.id=U.k_period_usage_id
and K.hiskey_id=7 --Semesterzeitraum
and U.period_id=P.id
and T.id=P.term_type_id
and T.termcategory=3 --Trimester
)
;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co" database="" version="">
<![CDATA[

select 21,'' || 2,'SOS-Version' as version from tmp_xdummy
 union
 select 22,'' || $start_stud_sem,'Start_SOS_Semester' from tmp_xdummy
union
  select 23,'' || $start_pruef_sem,'Start_POS_Semester' from tmp_xdummy
 union
select 32,'1','sos_unload_complete' from tmp_xdummy
where '$SOS_UNL_COMPLETE'='true'
union
select 32,'0','sos_unload_complete' from tmp_xdummy
where '$SOS_UNL_COMPLETE'!='true'
union
select 33,'15','SOS_Quellsystem' from tmp_xdummy
union
select 34,'0','SOS_Trimester' from tmp_xdummy
;
]]>
</extraction-sql>
</unload-job>

<unload-job id="sos_studenten" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_studenten.unl" >
<comment><comment>Studi-Sätze aus SOS. Die KFZ-Kennzeichen werden erst in SuperX umgeschlüsselt.</comment></comment>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="5">
<![CDATA[

SELECT
superx_sos.mtknr_ldsg mtknr,        {matrikel_nr}
gebdat, {d_geburt}
gebort, {geburtsort}
k_geschl.astat geschl,  {geschlecht}
exmdat, {d_exmatr}
status, {kz_rueck_beur_ein}
semester, {sem_rueck_beur_ein}
poplz, {plz}
poort, {ort}
immdat, {d_immatr}
beugrund as gdbu,
exmgrund as gdex,
staat,
k_ikfz.bland bland,     {bundesland}
hssem, {hs_sem_zahl}
urlsem,{url_sem_zahl}
hmkfzkz,                {Kennz. Heimatkfz}
hmkfz,                  {Heimatkfz}
semkfzkz,               {Kennz. Semesterkfz}
semkfz,                 {Semesterkfz}
hzbart,                  {Art der Hochschulzugangsberechtigung}
hzbjahr,
hzbkfzkz,
hzbkfz,
hzbdatum,
null::char(1) as hzbnote ,
hssemgewicht,
null::char(1) as urlsemgewicht ,
erhskfz,
erhsart,
erhssembrd,
erstsemhs,
sperrart1,
sperrart2,
staatkez,
ersthzbkfz,
ersthzbkfzkz,
ersthzbart,
NULL::char(1) AS second_nationality,
NULL::char(1) AS practicalsemester,
NULL::char(1) AS kollegsemester,
NULL::char(1) AS job,
NULL::char(1) AS studyrelatedjob,
NULL::char(1) AS studyrelatedinternship,
NULL::char(1) AS interruptiontype,
NULL::char(1) AS study_before_place_of_study,
NULL::char(1) AS study_before_country_of_study,
NULL::date AS org_role_valid_from,
NULL::date AS org_role_valid_to,
NULL::char(1) AS sema,
NULL::char(1) AS gebasoll,
NULL::char(1) AS geba,
NULL::char(1) AS geba_sws,
NULL::integer as ersthzbjahr,
NULL::integer as ersthzbnote
FROM sos
, superx_sos
, outer k_geschl
, outer k_ikfz

WHERE sos.mtknr = superx_sos.mtknr
AND sos.geschl = k_geschl.geschl
AND sos.hmkfz = k_ikfz.ikfz
--and sos.semester >= $start_stud_sem;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="6,7,8,9,10,11,12,13">
<![CDATA[

SELECT
superx_sos.mtknr_ldsg mtknr,        {matrikel_nr}
gebdat, {d_geburt}
gebort, {geburtsort}
k_geschl.astat geschl,  {geschlecht}
exmdat, {d_exmatr}
status, {kz_rueck_beur_ein}
semester, {sem_rueck_beur_ein}
poplz, {plz}
poort, {ort}
immdat, {d_immatr}
beugrund as gdbu,
exmgrund as gdex,
staat,
k_ikfz.bland bland,     {bundesland}
hssem, {hs_sem_zahl}
urlsem,{url_sem_zahl}
hmkfzkz,                {Kennz. Heimatkfz}
hmkfz,                  {Heimatkfz}
semkfzkz,               {Kennz. Semesterkfz}
semkfz,                 {Semesterkfz}
hzbart,                  {Art der Hochschulzugangsberechtigung}
hzbjahr,
hzbkfzkz,
hzbkfz,
hzbdatum,
null::char(1) as hzbnote ,
hssemgewicht,
urlsemgewicht ,
erhskfz,
erhsart,
erhssembrd,
erstsemhs,
sperrart1,
sperrart2,
staatkez,
ersthzbkfz,
ersthzbkfzkz,
ersthzbart,
NULL::char(1) AS second_nationality,
praxsem AS practicalsemester,
kolsem AS kollegsemester,
NULL::char(1) AS discontinuationsemester ,
NULL::char(1) AS studyrelatedjob ,
NULL::char(1) AS studyrelatedinternship,
NULL::char(1) AS interruptiontype,
NULL::char(1) AS study_before_place_of_study,
NULL::char(1) AS study_before_country_of_study,
NULL::date AS org_role_valid_from,
NULL::date AS org_role_valid_to,
sema,
gebasoll,
geba,
geba_sws,
ersthzbjahr,
ersthzbnote
FROM sos
, superx_sos
, outer k_geschl
, outer k_ikfz

WHERE sos.mtknr = superx_sos.mtknr
AND sos.geschl = k_geschl.geschl
AND sos.hmkfz = k_ikfz.ikfz
--and sos.semester >= $start_stud_sem;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="6,7,8,9,10,11,12,13">
<![CDATA[

select superx_sos.mtknr_ldsg,
extract(day from gebdat)::varchar(2) || '.' || extract(month from gebdat)::varchar(2) || '.' || extract(year from gebdat)::varchar(4),
gebort,
k_geschl.astat as geschl,
extract(day from exmdat)::varchar(2) || '.' || extract(month from exmdat)::varchar(2) || '.' || extract(year from exmdat)::varchar(4),
status,
semester,
poplz,
poort,
extract(day from immdat)::varchar(2) || '.' || extract(month from immdat)::varchar(2) || '.' || extract(year from immdat)::varchar(4),
 beugrund as gdbu,
exmgrund as gdex,
staat,
null::char(1) as bland,
hssem,
urlsem,
hmkfzkz,
hmkfz,
semkfzkz,
semkfz,
hzbart,
hzbjahr,
hzbkfzkz,
hzbkfz,
extract(day from hzbdatum)::varchar(2) || '.' || extract(month from hzbdatum)::varchar(2) || '.' || extract(year from hzbdatum)::varchar(4),
null::char(1) as hzbnote ,
hssemgewicht,
null::char(1) as urlsemgewicht,
erhskfz,
erhsart,
erhssembrd,
erstsemhs,
sperrart1,
sperrart2,
staatkez,
ersthzbkfz,
ersthzbkfzkz ,
ersthzbart,
NULL::char(1) AS second_nationality,
praxsem AS practicalsemester,
kolsem AS kollegsemester,
NULL::char(1) AS discontinuationsemester ,
NULL::char(1) AS studyrelatedjob ,
NULL::char(1) AS studyrelatedinternship,
NULL::char(1) AS interruptiontype,
NULL::char(1) AS study_before_place_of_study,
NULL::char(1) AS study_before_country_of_study,
NULL::date AS org_role_valid_from,
NULL::date AS org_role_valid_to,
sema,
gebasoll,
geba,
geba_sws,
ersthzbjahr,
ersthzbnote
FROM     superx_sos,sos
left outer join k_geschl on  (sos.geschl = k_geschl.geschl)
where
sos.mtknr = superx_sos.mtknr
and (fehlerkz not in ('F', 'V') or fehlerkz is null)
--and sos.semester >= $start_stud_sem
;

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[

SELECT DISTINCT
  S.mtknr_ldsg,
  S.person_birthdate,
  S.person_birthcity,                                                                                         --gebort,
  G.astat AS geschl,
  CASE WHEN RRT.k_statement_of_fact_id IS NOT NULL THEN RD.disenrollment_date END AS exmdat,                  --exmdat
  U.k_studystatus_id,                                                                                         --status
  '' || U.term_year || TT.termnumber,                                                                         --semester, TODO muss auf SuperX-Seite auf max(degree_program_progress) gesetzt werden
  null::char(1),                                                                                              --poplz,
  null::char(1),                                                                                              --poort,
  U.enrollmentdate,                                                                                           --immdat 10
  null::char(1),                                                                                              -- beugrund as gdbu,
  (SELECT STMT.uniquename FROM k_statement_of_fact STMT WHERE RRT.k_statement_of_fact_id = STMT.id) AS gdex,  -- #118735
  S.personinfo_country_id AS staat,
  null::char(1) AS bland,
  round(U.universitysemester,0)::int,                                                                         --hssem, TODO muss ermittelt werden
  U.leavesemester::int,                                                                                       --urlsem,
  U.home_country_lid,                                                                                         --hmkfzkz, Heimatwohnsitz 17,
  U.home_district_lid,                                                                                        --hmkfz,
  S.semester_country_astat,                                                                                   --semkfzkz,
  S.semester_astat,                                                                                           --semkfz
  --wird aus sos_hzb ermittelt:
  null::char(1),                                                                                              --hzbart,
  null::char(1),                                                                                              --hzbjahr,
  null::char(1),                                                                                              --hzbkfzkz,
  null::char(1),                                                                                              --hzbkfz,
  null::char(1),                                                                                              --extract(day from hzbdatum)::varchar(2) || '.' || extract(month from hzbdatum)::varchar(2) || '.' || extract(year from hzbdatum)::varchar(4),
  null::char(1),                                                                                              --hzbnote ,
  --TODO:
  null::char(1),                                                                                              --hssemgewicht,
  null::char(1) as urlsemgewicht,
  null::char(1),                                                                                              --erhskfz,
  null::char(1),                                                                                              --erhsart,
  S.erhssembrd,
  null::char(1),                                                                                              --erstsemhs
  null::char(1),                                                                                              --sperrart1,
  null::char(1),                                                                                              --sperrart2,
  null::char(1),                                                                                              --staatkez,
  null::char(1),                                                                                              --ersthzbkfz,
  null::char(1),                                                                                              --ersthzbkfzkz
  null::char(1),                                                                                              --ersthzbart
  S.second_nationality_astat,
  U.practicalsemester::int,
  U.kollegsemester::int,
  S.discontinuationsemester,
  U.study_related_job,
  U.study_related_internship,
  S.k_study_interruption_type_astat,
  S.study_before_place_of_study,
  S.study_before_country_of_study,
  S.orgrole_valid_from,
  S.orgrole_valid_to,
  NULL::char(1) AS sema,
  NULL::char(1) AS gebasoll,
  NULL::char(1) AS geba,
  NULL::char(1) AS geba_sws,
  NULL::integer as ersthzbjahr,
  NULL::integer as ersthzbnote
FROM
  k_gender G,
  (student U
  LEFT OUTER JOIN request_for_disenrollment RD ON (RD.id = U.request_for_disenrollment_id)
  LEFT OUTER JOIN request_base RB ON (RB.id = RD.id AND 0 < (
    SELECT
      count(*)
    FROM
      k_status
    WHERE
      k_status.id = RB.approval_k_status_id
      AND k_status.hiskey_id = 4001
      AND k_status.uniquename='G'
  ))
  LEFT OUTER JOIN reasonable_request_type RRT ON RB.reasonable_request_type_id = RRT.id
  LEFT OUTER JOIN term_type TT ON TT.id = U.term_type_id
  ),
  superx_sos S
WHERE
  S.person_k_gender_id = G.id
  AND U.id = S.id
  AND (U.term_year * 10 + TT.termnumber >= $start_stud_sem)
;


]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[

select superx_sos.mtknr_ldsg,
d_geburt as gebdat,
'',--gebort,
 geschlecht,
d_exmatr as exmdat,
null::integer as status,
semester_max as semester,
null::integer ,--poplz,
null::integer ,--poort,
date(aufnahmedatum) as immdat,
null::integer ,--beugrund as gdbu,
null::char(1) as gdex,
ca12_staat,
null::integer as bland,
null::char(1) ,--hssem,
null::char(1) ,--urlsem,
null::char(1) as hmkfzkz,
null::char(1) as hmkfz,
null::char(1) as semkfzkz,
null::char(1) as semkfz,
null::char(1) as hzbart,
null::char(1) as hzbjahr,
null::char(1) as hzbkfzkz,
null::char(1) as hzbkfz,
null::char(1) as hzbdatum,
null::char(1) as hzbnote ,
null::integer ,--hssemgewicht,
null::integer as urlsemgewicht,
null::char(1) as  erhskfz,
null::integer ,--erhsart,
null::char(1) as erhssembrd,
null::char(1) as erstsemhs,
null::integer ,--sperrart1,
null::integer ,--sperrart2,
null::integer ,--staatkez,
null::integer ,--ersthzbkfz,
null::integer ,--ersthzbkfzkz ,
null::integer,--ersthzbart
second_nationality,
null::integer,-- practicalsemester,
null::integer,-- kollegsemester,
null::integer,-- discontinuation_sem_zahl,
null::integer,-- studyrelatedjob,
null::integer,-- studyrelatedinternship,
null::integer,-- interruptiontype,
null::char(1) as erhskfz,-- study_before_place_of_study,
null::integer, -- study_before_country_of_study
null::integer, --date AS org_role_valid_from,
null::integer, -- date AS org_role_valid_to
null::integer AS sema,
null::integer AS gebasoll,
null::integer AS geba,
null::integer AS geba_sws,
null::integer AS ersthzbjahr,
null::integer AS ersthzbnote
FROM     superx_sos,costage_st_studierendenstammdaten
where
val(costage_st_studierendenstammdaten.matrikelnummer) = superx_sos.mtknr
and semester_max >= $start_stud_sem
;

]]>
</extraction-sql>
</unload-job>

<unload-job id="sos_hzb" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_hzb.unl" >

<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[

select superx_sos.mtknr_ldsg,
hzbart,
hzbjahr,
hzbkfzkz,
hzbkfz,
extract(day from hzbdatum)::varchar(2) || '.' || extract(month from hzbdatum)::varchar(2) || '.' || extract(year from hzbdatum)::varchar(4),
hzbnote,
null:: char(255), --ersthzbart,
null:: smallint, --ersthzbjahr,
null:: varchar(255), --ersthzbkfzkz,
null:: varchar(255),--ersthzbkzf,
null:: date, --ersthzbdate,
null:: char(10) --ersthzbnote
FROM     superx_sos,sos
where
sos.mtknr = superx_sos.mtknr
and (fehlerkz not in ('F', 'V') or fehlerkz is null)

;

]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[

select superx_sos.mtknr_ldsg,
hzbart,
hzbjahr,
hzbkfzkz,
hzbkfz,
day(hzbdatum)::varchar(2) || '.' || month(hzbdatum)::varchar(2) || '.' || year(hzbdatum)::varchar(4),
hzbnote,
null:: char(255), --ersthzbart,
null:: smallint, --ersthzbjahr,
null:: varchar(255), --ersthzbkfzkz,
null:: varchar(255),--ersthzbkzf,
null:: date, --ersthzbdate,
null:: char(10) --ersthzbnote
FROM     superx_sos,sos
where
sos.mtknr = superx_sos.mtknr
and (fehlerkz not in ('F', 'V') or fehlerkz is null)

;

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[

select distinct O.mtknr_ldsg,
H.entrance_qualification_type_id,--.hzbart,
extract(year from E.date_of_work)::smallint,--hzbjahr,
(select C.astat from country C
where C.lid=I.country_lid
and E.date_of_work between C.valid_from and C.valid_to) as hzbkfzkz,
(select D.astat from district D
where D.lid=I.district_lid
and E.date_of_work between D.valid_from and D.valid_to) as hzbfz,
extract(day from E.date_of_work)::varchar(2) || '.' || extract(month from E.date_of_work)::varchar(2) || '.' || extract(year from E.date_of_work)::varchar(4),
I.foreign_grade, --hzbnote,
null:: char(255), --ersthzbart,
null:: smallint, --ersthzbjahr,
null:: varchar(255), --ersthzbkfzkz,
null:: varchar(255),--ersthzbkzf,
null:: date, --ersthzbdate,
null:: char(10) --ersthzbnote
FROM superx_sos O, student S, person P, examplan E, unit U, k_elementtype Y,
entrance_qualification H,
examimport I
where
S.id=O.id
and P.id=S.person_id
and P.id=E.person_id
and H.examplan_id=E.id
and I.examplan_id=E.id
and U.id=E.unit_id
and U.k_elementtype_id=Y.id
and Y.hiskey_id=7 --nur HZB
;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="POSTGRES" version="">
<![CDATA[


select * from xdummy where 1=0
;


]]>
</extraction-sql>
</unload-job>
<unload-job id="sos_faecher" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_faecher.unl" >
<comment>stg-Sätze aus sos</comment>

<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="5">
<![CDATA[
SELECT
superx_sos.mtknr_ldsg, {matrikel_nr}
abschl,{ch35_ang_abschluss}
stg, {ch30_fach}
vert, {ch39_vertief}
schwp,                  {schwerpunkt}
kzfa,{kz_fach}
fb,
pversion,               {pversion}
stg.semester, {sem_rueck_beur_ein}
stg.stgnr[1,1], {studiengang_nr}
stg.stgnr[2,2], {fach_nr}
status, {kz_rueck_beur_ein}
beugrund as gdbu,
endegrd as gdex,
stg.stgsem,{fach_sem_zahl}
stg.hrst,                {Hörerstatus}
stg.klinsem,{klinische Semester}
stg.hssem,
stuart,
stutyp,
stufrm,
stort,
ruebeudat,
semgewicht,
stggewicht,
stgsemgewicht,
null::char(1) as hssemgewicht,
null::char(1) as urlsemgewicht,
kohsem,
lfdnr,
endedat ,
anfdat ,
lepsem,
NULL::char(1), -- district.astat nur h1
NULL::char(1),  -- country.astat nur h1
null::int, --Art der Promotion
null::char(1), --field_of_study
null::char(1) as field_of_study,
null::Char(10),--primaerfach,
null::Char(10) --unikey
FROM stg
, superx_sos
WHERE stg.mtknr = superx_sos.mtknr
and (lfdnr=0 or lfdnr is null)
AND stg.semester >= $start_stud_sem          {ab hier werden Daten ausgewertet}
;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="6,7,8,9,10,11,12,13">
<![CDATA[
SELECT
superx_sos.mtknr_ldsg, {matrikel_nr}
abschl,{ch35_ang_abschluss}
stg, {ch30_fach}
vert, {ch39_vertief}
schwp,                  {schwerpunkt}
kzfa,{kz_fach}
fb,
pversion,               {pversion}
stg.semester, {sem_rueck_beur_ein}
stg.stgnr[1,1], {studiengang_nr}
stg.stgnr[2,2], {fach_nr}
status, {kz_rueck_beur_ein}
beugrund as gdbu,
endegrd as gdex,
stg.stgsem,{fach_sem_zahl}
stg.hrst,                {Hörerstatus}
stg.klinsem,{klinische Semester}
stg.hssem,
stuart,
stutyp,
stufrm,
stort,
ruebeudat,
semgewicht,
stggewicht,
stgsemgewicht,
hssemgewicht,
urlsemgewicht,
kohsem,
lfdnr,
endedat ,
anfdat ,
lepsem,
NULL::char(1), -- district.astat nur h1
NULL::char(1),  -- country.astat nur h1
null::int, --Art der Promotion
null::char(1) as field_of_study,
null::Char(10),--primaerfach,
null::Char(10) --unikey
FROM stg
, superx_sos
WHERE stg.mtknr = superx_sos.mtknr
and (lfdnr=0 or lfdnr is null)
AND stg.semester >= $start_stud_sem          {ab hier werden Daten ausgewertet}
;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="6,7,8,9,10,11,12,13">
<![CDATA[
SELECT
S.mtknr_ldsg,
abschl,
stg,
vert,
schwp,
kzfa,
fb,
pversion,
F.semester,
substr(F.stgnr,1,1),
substr(F.stgnr,length(F.stgnr),1),
F.status,
F.beugrund as gdbu,
F.endegrd as gdex,
F.stgsem,
F.hrst,
F.klinsem,
F.hssem,
stuart,
stutyp,
stufrm,
stort,
extract(day from F.ruebeudat)::varchar(2) || '.' || extract(month from F.ruebeudat)::varchar(2) || '.' || extract(year from F.ruebeudat)::varchar(4),
semgewicht,
stggewicht,
stgsemgewicht,
null::char(1) as hssemgewicht,
null::char(1) as urlsemgewicht,
kohsem,
lfdnr,
extract(day from F.endedat)::varchar(2) || '.' || extract(month from F.endedat)::varchar(2) || '.' || extract(year from F.endedat)::varchar(4),
extract(day from F.anfdat)::varchar(2) || '.' || extract(month from F.anfdat)::varchar(2) || '.' || extract(year from F.anfdat)::varchar(4),
lepsem,
NULL::char(1), -- district.astat nur h1
NULL::char(1),  -- country.astat nur h1
null::int, --Art der Promotion
null::char(1) as field_of_study,
null::Char(10),--primaerfach,
null::Char(10) --unikey

FROM stg F, superx_sos S
WHERE F.mtknr = S.mtknr
and (lfdnr=0 or lfdnr is null)
AND F.semester >= $start_stud_sem
;
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
SELECT DISTINCT
  S.mtknr_ldsg,
  C.degree_id,--abschl
  C.subject_id,--stg,
  C.major_field_of_study_id, --vert,
  C.course_specialization_id, --schwp,
  C.k_subject_indicator_id,--kzfa,
  null::char(1),--fb,
  C.k_examinationversion_id,--pversion,
  '' || P.term_year || T.termnumber,--F.semester,
  DP.studynumber, --substr(F.stgnr,1,1),
  DP.subjectnumber,--substr(F.stgnr,length(F.stgnr),1),
  DP.k_studystatus_id, --F.status,
  DP.k_reason_of_leave_id, --Beurlaubungsgrund
DP.k_reason_of_finishing_id, --Exmatrikulationsgrund
trunc(DP.studysemester),--F.stgsem,
DP.k_studentstatus_id, --F.hrst,
trunc(DP.clinical_semester),--F.klinsem,
trunc(U.universitysemester),--F.hssem,
C.k_type_of_study_id ,--stuart,
C.k_enrollment_id,--stutyp,
C.k_form_of_studies_id,--stufrm,
C.k_place_of_studies_id,--stort,
extract(day from DP.reregistration_date)::varchar(2) || '.' || extract(month from DP.reregistration_date)::varchar(2) || '.' || extract(year from DP.reregistration_date)::varchar(4), --ruebeudat
DP.part_time_percentage, --semgewicht,
null::char(1),--stggewicht,
null::char(1),--stgsemgewicht,
null::char(1) as urlsemgewicht,
null::char(1) as hssemgewicht,
null::char(1),--kohsem,
0, --lfdnr,
extract(day from DP.finished)::varchar(2) || '.' || extract(month from DP.finished)::varchar(2) || '.' || extract(year from DP.finished)::varchar(4) ,--endedat
extract(day from DP.startdate)::varchar(2) || '.' || extract(month from DP.startdate)::varchar(2) || '.' || extract(year from DP.startdate)::varchar(4), --anfdat
null::char(1),--lepsem
D.dastat, --district.astat
D.castat, --country.astat
-- DIS.astat, --district.astat
-- CNT.astat,  --country.astat
D.k_type_of_doctorate_id --Art der Promotion
,SUB.fosid, --field_of_study
null::Char(10),--primaerfach,
null::Char(10) --unikey
FROM  period P,
term_type T,
degree_program_progress DP,
-- degree_program D,
(select DegP.*, DIS.astat as dastat, CNT.astat as castat from
degree_program DegP
left outer join district DIS on DIS.id = DegP.final_exam_district_id
left outer join country CNT on CNT.lid = DegP.final_exam_country_lid
where CNT.valid_from <= current_date and CNT.valid_to >= current_date and DegP.belongs_to='STUDENT') D,
superx_sos S,
student U,
tmp_course_of_study C,
(select tmpSUB.*, tmpFOS.id as fosid
from subject as tmpSUB
left outer join k_field_of_study as tmpFOS
on tmpSUB.k_field_of_study_id = tmpFOS.id) SUB
-- district DIS,
-- country CNT
WHERE T.id=P.term_type_id
and D.id=DP.degree_program_id
and DP.course_of_study_id=C.id
and DP.period_id=P.id
and S.person_id = U.person_id
and S.person_id = D.person_id
and U.id=S.id
and SUB.id = C.subject_id
-- and DIS.id = D.final_exam_district_id
-- and CNT.id = D.final_exam_country_lid
-- and CNT.valid_from <= current_date and CNT.valid_to >= current_date
AND to_number('' || P.term_year || T.termnumber,'99999')  >= $start_stud_sem
;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
SELECT
S.mtknr_ldsg,
G.abschluss,
G.stg,
'' ,--vert,
'' ,--schwp,
G.fachkennzeichen,
'' ,--fb,
val(G.pversion),
F.semester,
F.studiengang_nr,
F.fach_nr,
F.kz_rueck_beur_ein AS status,
null::char(1) ,--F.beugrund as gdbu,
null::char(1) ,--F.endegrd as gdex,
F.fachsemester::integer,
F.hrst,
null::integer as klinsem,
F.hssem,
'' ,--stuart,
'' ,--stutyp,
G.stufrm,
'' ,--stort,
F.ruebeudat,
null::char(1) ,--semgewicht,
null::char(1) ,--stggewicht,
null::char(1) ,--stgsemgewicht,
null::char(1) as hssemgewicht,
null::char(1) as urlsemgewicht,
null::char(1) ,--kohsem,
null::char(1) ,--lfdnr,
F.endedat,
F.anfdat,
null::char(1), --lepsem
null::char(1),-- -- district.astat nur h1
null::char(1),--  -- country.astat nur h1
null::char(1) , --Art der Promotion
null::char(1) as field_of_study,
primaerflag as primaerfach,
unikey ,
null::numeric(9,6) ,-- individual_number_of_semesters
F.st_studium_nr as degree_program_id 
FROM costage_st_studiengaenge G, costage_st_studien_aggr F, superx_sos S
WHERE F.matrikelnummer = S.mtknr
and G.st_studiengang_nr=F.st_studiengang_nr
and F.statustyp is not null
and F.fachsemester is not null
and F.kz_rueck_beur_ein is not null
AND F.semester >= $start_stud_sem
;
]]>
</extraction-sql>
</unload-job>
<unload-job id="preparation_sos_pruefungen" extraction-table="" extraction-script="" transfer-unload-file="" >
<comment> wichtige Konstanten aus SOS entladen, z.B. HISSOS-Version.</comment>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
DROP TABLE IF EXISTS tmp_lab;

CREATE TABLE tmp_lab(
  student_id INTEGER,
  mtknr_ldsg INTEGER,
  examplan_id INTEGER,
  date_of_work DATE,
  term_year INTEGER,
  termnumber INTEGER,
  term_type_id INTEGER,
  term_segment INTEGER,
  default_examrelation_id INTEGER,
  unit_id INTEGER,
  examrelation_id INTEGER,
  k_remark_on_exam_id INTEGER,
  k_examform_id INTEGER,
  cancelation SMALLINT,
  person_id INTEGER,
  official_statistics INTEGER,
  grade DECIMAL(9,5),
  degree_program_id INTEGER,
  type_of_doctorate_id INTEGER,
  type_of_doctorate_astat INTEGER,
  degree_program_progress_id INTEGER,
  degree_program_progress_studynumber INTEGER,
  degree_program_progress_subjectnumber INTEGER,
  degree_program_progress_studysemester INTEGER,
  studysemester_acknowledgement_id INTEGER,
  studysemester_acknowledgement_semester_overall DECIMAL(19,6) ,
  studysemester_acknowledgement_former_degree_program DECIMAL(19,6) ,
  studysemester_acknowledgement_practice_semester DECIMAL(19,6) ,
  studysemester_acknowledgement_semester_abroad DECIMAL(19,6) ,
  course_of_study_id INTEGER,
  examrelation_k_workstatus_id INTEGER,
  examrelation_malus DECIMAL(9,5),
  examrelation_bonus DECIMAL(9,5),
  examrelation_parent_examplan_id INTEGER,
  panerk CHAR(10),
  type_of_grading SMALLINT
);

INSERT INTO tmp_lab(
  student_id,
  mtknr_ldsg,
  examplan_id,
  date_of_work,
  term_year,
  termnumber,
  term_type_id,
  term_segment,
  default_examrelation_id ,
  unit_id,
  k_remark_on_exam_id,
  k_examform_id,
  cancelation,
  person_id
)
SELECT
  S.id,
  O.mtknr_ldsg,
  E.id as examplan_id,
  E.date_of_work,
  E.term_year,
  T.termnumber,
  T.id,
  E.term_segment,
  E.default_examrelation_id ,
  E.unit_id,
  E.k_remark_on_exam_id,
  E.k_examform_id,
  E.cancelation,
  S.person_id
FROM
  superx_sos O,
  student S,
  examplan E,
  term_type T,
  unit U
WHERE
  S.person_id = E.person_id
  AND S.id = O.id
  AND T.id = E.term_type_id
  AND U.id = E.unit_id
  AND (
    U.uniquename != 'AP-EXT'
    OR U.uniquename IS NULL
  ) --ext.Pruefungnen ausschliessen
  AND 0 = (
    SELECT
      count(*)
    FROM
      k_elementtype K
    WHERE
      K.id = U.k_elementtype_id
      AND K.hiskey_id = 7
  ) --keine HZB-Leistungen
  AND (
    E.updated_at > '${exa_updated_at}'
    OR (
      E.updated_at IS NULL
      AND '${exa_updated_at}' = '1900-01-01')
    )
    AND (to_number('' || E.term_year || T.termnumber,'99999') ) >= $start_pruef_sem
;

UPDATE
  tmp_lab
SET
  examrelation_id = default_examrelation_id
WHERE
  examrelation_id IS NULL
;

UPDATE
  tmp_lab
SET
  examrelation_k_workstatus_id = R.k_workstatus_id,
  examrelation_malus = R.malus,
  examrelation_bonus = R.bonus,
  examrelation_parent_examplan_id = R.parent_examplan_id
FROM
  examrelation R
WHERE
  R.id = tmp_lab.examrelation_id
;

UPDATE
  tmp_lab
SET
  type_of_grading = gt.type_of_grading
FROM
  examplan exp,
  unitrelation unr,
  unit u,
  grading_type gt
WHERE
  exp.id = tmp_lab.examplan_id
  AND exp.unit_id = u.id
  AND u.default_unitrelation_id = unr.id
  AND unr.grading_type_id = gt.id
; 

UPDATE
  tmp_lab
SET
  official_statistics = (
    SELECT
      official_statistics
    FROM
      unit U
    WHERE
      U.id = tmp_lab.unit_id
    )
;

UPDATE
  tmp_lab
SET
  official_statistics = 3
WHERE EXISTS (
  SELECT
    unit_id
  FROM
    examination X
  WHERE 
    X.unit_id = tmp_lab.unit_id
    AND k_examination_type_id IN (
      SELECT
        id
      FROM
        k_examination_type
      WHERE
        hiskey_id = 99
      )
    )
;

UPDATE
  tmp_lab
SET
  grade = (
    SELECT
      R.grade
    FROM
      examresult R
    WHERE
      R.examrelation_id = tmp_lab.examrelation_id
  )
;

--Studienverlauf ermitteln
UPDATE
  tmp_lab
SET
  degree_program_progress_id = DP.id,
  degree_program_progress_studynumber = DP.studynumber,
  degree_program_progress_subjectnumber = DP.subjectnumber,
  degree_program_progress_studysemester = DP.studysemester,
  degree_program_id = D.id,
  course_of_study_id = C.id,
  studysemester_acknowledgement_id = DP.studysemester_acknowledgement_id,
  type_of_doctorate_id = D.k_type_of_doctorate_id
FROM
  degree_program D,
  degree_program_progress DP,
  period P,
  unit_studies US,
  tmp_course_of_study C
WHERE
  D.id = DP.degree_program_id
  AND P.id = DP.period_id
  AND C.lid = US.course_of_study_lid
  AND DP.course_of_study_id = C.id
  AND (
    tmp_lab.date_of_work BETWEEN C.valid_from AND C.valid_to
    OR tmp_lab.date_of_work IS NULL
    OR C.is_historized = 0
    OR (
      C.valid_from IS NULL
      AND tmp_lab.date_of_work <= C.valid_to
    )
    OR (
      C.valid_to IS NULL
      AND tmp_lab.date_of_work >= C.valid_from
    )
  )
  AND tmp_lab.unit_id = US.unit_id
  AND tmp_lab.person_id = D.person_id
  AND tmp_lab.term_type_id = P.term_type_id
  AND tmp_lab.term_year = P.term_year
;

--evt. früheren Studienverlauf ermitteln
UPDATE
  tmp_lab
SET
  degree_program_progress_id = DP.id,
  degree_program_progress_studynumber = DP.studynumber,
  degree_program_progress_subjectnumber = DP.subjectnumber,
  degree_program_progress_studysemester = DP.studysemester,
  degree_program_id = D.id,
  course_of_study_id = C.id,
  studysemester_acknowledgement_id = DP.studysemester_acknowledgement_id,
  type_of_doctorate_id = D.k_type_of_doctorate_id
FROM
  degree_program D,
  degree_program_progress DP ,
  tmp_course_of_study C
WHERE
  D.id = DP.degree_program_id
  AND DP.id = (
    SELECT
      DP.id
    FROM
      degree_program D,
      degree_program_progress DP
    WHERE
      tmp_lab.person_id = D.person_id
      AND DP.degree_program_id = D.id
      AND DP.course_of_study_id IN (
        SELECT
          cos.id
        FROM
          unit_studies us,
          course_of_study cos
        WHERE
          us.unit_id = tmp_lab.unit_id
          AND us.course_of_study_lid = cos.lid
          AND (
            tmp_lab.date_of_work BETWEEN cos.valid_from AND cos.valid_to
            OR (
              tmp_lab.date_of_work IS NULL
                AND (
                  SELECT
                    startdate
                  FROM
                    period P,
                    period_usage PU,
                    k_period_usage KPU
                  WHERE
                    KPU.hiskey_id = 7
                    AND PU.k_period_usage_id = KPU.id
                    AND PU.period_id = P.id
                    AND P.term_year = tmp_lab.term_year
                    AND P.term_type_id = tmp_lab.term_type_id
                  ) BETWEEN cos.valid_from AND cos.valid_to
                )
              )
        )
    ORDER BY
      enddate desc
    LIMIT
      1
    )
    AND C.id = DP.course_of_study_id
    AND tmp_lab.course_of_study_id IS NULL
;

-- zusätzlich schauen nach Sätzen mit abgelaufener Gültigkeit, dabei den aktuellsten Gültigkeitszeitraum wählen
UPDATE
  tmp_lab
SET
  degree_program_progress_id = DP.id,
  degree_program_progress_studynumber = DP.studynumber,
  degree_program_progress_subjectnumber = DP.subjectnumber,
  degree_program_progress_studysemester = DP.studysemester,
  degree_program_id = D.id,
  course_of_study_id = C.id,
  studysemester_acknowledgement_id = DP.studysemester_acknowledgement_id,
  type_of_doctorate_id = D.k_type_of_doctorate_id
FROM
  degree_program D,
  degree_program_progress DP ,
  tmp_course_of_study C
WHERE
  D.id = DP.degree_program_id
  AND DP.id = (
    SELECT
      DP.id
    FROM
      degree_program D,
      degree_program_progress DP
    WHERE
      tmp_lab.person_id = D.person_id
      AND DP.degree_program_id = D.id
      AND DP.course_of_study_id IN (
        SELECT
          cos.id from unit_studies us,
          course_of_study cos
        WHERE
          us.unit_id = tmp_lab.unit_id
          AND us.course_of_study_lid = cos.lid
        )
    ORDER BY 
      enddate DESC
    LIMIT
      1
    )
    AND C.id = DP.course_of_study_id
    AND tmp_lab.course_of_study_id IS NULL
;

-- kein Studienverlauf vorhanden, sehen ob ein Studiengang passt
UPDATE
  tmp_lab
SET
  course_of_study_id = (
    SELECT
      cos.id
    FROM
      unit_studies us,
      course_of_study cos
    WHERE
      us.unit_id = tmp_lab.unit_id
      AND us.course_of_study_lid = cos.lid
      AND (
        tmp_lab.date_of_work BETWEEN cos.valid_from AND cos.valid_to
        OR tmp_lab.date_of_work IS NULL)
    limit 1
)
WHERE
  course_of_study_id IS NULL
  AND 0 = (
    SELECT
      count(*)
    FROM
      unit u,
      k_elementtype k
    WHERE
      u.id = tmp_lab.unit_id
      AND u.k_elementtype_id = k.id
      AND k.hiskey_id NOT IN (2,3)
    )
;

-- Sonderbehandlung Umrechnung Punkte bei Staatsexamen Jura in Noten
UPDATE
  tmp_lab
SET
 grade =
  CASE
    WHEN grade BETWEEN 14   AND 18    THEN 1
    WHEN grade BETWEEN 11.5 AND 13.99 THEN 2
    WHEN grade BETWEEN  9   AND 11.49 THEN 7
    WHEN grade BETWEEN  6.5 AND  8.99 THEN 3
    WHEN grade BETWEEN  4   AND  6.49 THEN 4
    WHEN grade BETWEEN  0   AND  3.99 THEN 5
  ELSE
    grade
  END
WHERE
  course_of_study_id IN (
    SELECT
      cos.id
   FROM
     course_of_study cos,
     subject s,
     degree d
   WHERE
     cos.subject_lid = s.lid
     AND cos.degree_lid = d.lid
     AND coalesce(d.astat_bund, d.astat_land) IN ('08','09') -- Staatsexamen
     AND coalesce(s.astat_bund, s.astat_land) = '0135' -- Jura (Rechtswissenschaft)
  )
  AND type_of_grading IS NULL OR type_of_grading = 1 -- unbekannt oder Punkte
;

UPDATE
  tmp_lab
SET
  type_of_doctorate_astat = (
    SELECT
      to_number(D.astat,'99999')
    FROM
      k_type_of_doctorate D
    WHERE
      D.id = tmp_lab.type_of_doctorate_id
    )
WHERE
  type_of_doctorate_id IS NOT NULL
;

--Anerkennung
UPDATE
  tmp_lab
SET
  studysemester_acknowledgement_semester_overall = S.semester_overall,
  studysemester_acknowledgement_former_degree_program = S.former_degree_program,
  studysemester_acknowledgement_practice_semester = S.practice_semester,
  studysemester_acknowledgement_semester_abroad = S.semester_abroad
FROM
  studysemester_acknowledgement S
WHERE
  S.id = tmp_lab.studysemester_acknowledgement_id
;

UPDATE
  tmp_lab
SET
  panerk = 'J'
WHERE
  examplan_id IN (
    SELECT
      examplan_id
    FROM
      accreditation
    )
;

CREATE index i_tl1 ON tmp_lab(student_id);

]]>
</extraction-sql>
</unload-job>

<unload-job id="sos_pord_to_stg" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_pord_to_stg.unl" >
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
SELECT distinct
 pord.stg,
 pord.vert,
 pord.abschl,
 pord.kzfa,
 null::char(1),--tid_stg,
 null::char(1),--sto,
 pord.pversion,
 pord.schwp,
 pord.pnr ,
 pord.pordnr,
 pord.pdtxt,
 pord.pnr,
 pord.modulart,
 null::char(1) --stutyp
FROM pord
;
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="POSTGRES" version="">
<![CDATA[

 SELECT distinct
 C.subject_id,--stg,
 C.major_field_of_study_id, --vert,
 C.degree_id,--abschl,
 C.k_subject_indicator_id,--kzfa,
 null::char(1),--tid_stg,
 C.k_place_of_studies_id,--stort,
 C.k_examinationversion_id,--pversion,
 C.course_specialization_id,--schwp,
 U.official_statistics ,
 U.id,
 substring(U.defaulttext from 1 for 255),
 U.elementnr,
 U.k_elementtype_id,
 C.k_enrollment_id --stutyp
 FROM unit_studies US,
    tmp_course_of_study C,
   unit U
    WHERE U.id=US.unit_id
     and C.lid=US.course_of_study_lid

;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>

<unload-job id="sos_pruefungenext" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_pruefungenext.unl" >
<comment>Externe Abschlussprüfungen</comment>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[
-- Externe Abschlussprüfungen
SELECT S.mtknr_ldsg AS matrikel_nr,
null::integer AS studentexternal_id,
CASE WHEN E.stgnr ~ '^[0-9]*$' THEN to_number(substring(E.stgnr from 1 for 1),'99')
ELSE NULL::int END AS studiengang_nr,
CASE WHEN E.stgnr ~ '^[0-9]*$' THEN to_number(substring(E.stgnr from 2 for 1),'9')
ELSE NULL::int END AS fach_nr,
E.abschl AS ang_abschl,
E.stgsem AS fachsem_zahl,
E.semester AS p_sem,
extract(day from E.lzabdat)::varchar(2) || '.' || extract(month from E.lzabdat)::varchar(2) || '.' || extract(year from E.lzabdat)::varchar(4) AS d_abg_pruefung,
extract(month from E.lzabdat)::integer AS p_monat,
extract(year from E.lzabdat)::integer AS p_jahr,
E.stg AS fach,
CASE WHEN E.pnote ~ '^[0-9]*$' THEN
substring(replace(replace(E.pnote,',',''),'.','') from 1 for 1) || '.' || substring(replace(replace(E.pnote,',',''),'.','') from 2 for 2)
ELSE NULL END,
E.pstatus,
E.stufrm as p_art,
E.hskfzkz,
E.hskfz,
K.astat AS hs,
E.hsart,
null::char(1), -- country astat wird in trans_sos_pruefungenext.sql ermittelt
null::int as examplan_id
from stgext E, superx_sos S, sos O left outer join  k_ikfzha K
on (K.ikfzha=trim(O.erhskfz) || trim(O.erhsart))
WHERE E.mtknr = S.mtknr
and E.mtknr=O.mtknr
and E.extart in ('AP')
;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[

SELECT S.mtknr_ldsg AS matrikel_nr,
null::integer AS studentexternal_id,
substring(E.stgnr from 1 for 1) AS studiengang_nr,
substring(E.stgnr from 2 for 1) AS fach_nr,
E.abschl AS ang_abschl,
E.stgsem AS fachsem_zahl,
E.semester AS p_sem,
E.lzabdat AS d_abg_pruefung,
month(E.lzabdat) AS p_monat,
year(E.lzabdat) AS p_jahr,
E.stg AS fach,
CASE WHEN E.pnote MATCHES '[0-9][0-9][0-9]' THEN
substring(replace(replace(E.pnote,',',''),'.','') from 1 for 1) || '.' || substring(replace(replace(E.pnote,',',''),'.','') from 2 for 2)
ELSE NULL::char(1) END,
E.pstatus,
E.stufrm as p_art,
E.hskfzkz,
E.hskfz,
K.astat AS hs,
E.hsart,
null::char(1), -- country astat wird in trans_sos_pruefungenext.sql ermittelt
null::int as examplan_id
from stgext E, superx_sos S, sos O left outer join  k_ikfzha K
on (K.ikfzha=(trim(O.erhskfz) || trim(O.erhsart)))
WHERE E.mtknr = S.mtknr
and E.mtknr=O.mtknr
and E.extart in ('AP') -- Externe Abschlussprüfungen
;
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
-- Externe Abschlussprüfungen
SELECT SS.mtknr_ldsg AS matrikel_nr
,SE.id AS studentexternal_id
--, 'AP' AS extart -- Abschlussprüfungen
,DP.studynumber AS studiengang_nr
,DP.subjectnumber AS fach_nr
,DE.astat_land AS ang_abschl
,DP.number_of_studysemester::INT AS fachsem_zahl
, '' || EP.term_year || TT.termnumber AS p_sem
,EP.date_of_work AS d_abg_pruefung
,EXTRACT(MONTH FROM EP.date_of_work)::int AS p_monat
,EXTRACT(YEAR FROM EP.date_of_work)::int AS p_jahr
,SU.astat_land AS fach
,EI.foreign_grade AS p_note
,KWS.id AS p_status
--,KEF.uniquename AS p_art
, D.k_form_of_studies_id as p_art
, CASE WHEN C.uniquename = 'D' THEN 'I' ELSE 'A' END AS hskfzkz
, CASE WHEN C.uniquename = 'D' THEN UNI.vehicle_registration_plate ELSE C.uniquename END AS hskfz
,UNI.astat AS hs
,UNI.universitytype AS hsart
,C.astat as country_astat
,EP.id as examplan_id
FROM person P
JOIN student S ON S.person_id = P.id AND S.registrationnumber IS NOT NULL
JOIN superx_sos SS on SS.id=S.id
JOIN examplan EP ON EP.person_id = P.id
JOIN unit U ON U.id = EP.unit_id
JOIN examimport EI ON EP.id = EI.examplan_id
JOIN degree_program_before D ON D.examimport_id = EI.id
JOIN studentexternal SE ON SE.id = D.studentexternal_id
JOIN degree_program_progress_before DP ON DP.degree_program_before_id = D.id
JOIN degree DE ON DE.lid = D.degree_lid AND now() BETWEEN DE.valid_from AND DE.valid_to
JOIN examrelation ER ON EP.default_examrelation_id = ER.id
JOIN subject SU ON SU.lid = DP.subject_lid AND now() BETWEEN SU.valid_from AND SU.valid_to
LEFT JOIN term_type TT ON EP.term_type_id = TT.id
--left join university UNI on EI.university_lid = UNI.lid and now() between UNI.valid_from and UNI.valid_to
LEFT JOIN university UNI ON SE.university_lid = UNI.lid AND now() BETWEEN UNI.valid_from AND UNI.valid_to
LEFT JOIN country C ON C.lid = SE.country_lid
LEFT JOIN k_workstatus KWS ON KWS.id = ER.k_workstatus_id
LEFT JOIN k_examform KEF ON KEF.id = EP.k_examform_id
WHERE U.uniquename = 'AP-EXT'
ORDER BY matrikel_nr,studiengang_nr,fach_nr
;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>

<unload-job id="sos_pruefungen" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_pruefungen.unl" >
<comment>Verzeichnis der Prüfungen.</comment>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[
SELECT
superx_sos.mtknr_ldsg, {matrikel_nr}
stgnr[1,1], {studiengang_nr}
stgnr[2,2], {fach_nr}
abschl, {ch35_ang_abschluss}
psem, {sem_der_pruefung}
pdatum, {d_abg_pruefung}
stg, {ch30_fach}
vert, {ch39_vertief}
schwp,                  {schwerpunkt}
kzfa, {kzfa}
pnote, {haupt_pruef_note}
vken1, {lief_amtl_statist}
null::char(7), --pruefungsamt_nr
lab.pnr,   {pnr}
pversion, {pversion}
pstatus,{pstatus ist char(2)}
stgsem                  {fach_sem_zahl} ,
part,
labnr,
pversuch,
ppruef1,
ppruef2,
malus,
bonus,
pordnr,
psws,
null::char(1), --relation_id nur bei HIS1
pvermerk,
prueck,
ptermin,
pform,
null::char(1), --anger. fs insg.
null::char(1), --berufspraktische taetigkeit
null::char(1), --aus auslandsstudium
null::char(1), --aus anderem stg an einer deutschen hs
null::char(1), -- amtl. Schl. Art der Promotion
panerk,
pstatkennz,
ppunkte,
null::CHAR(1), --stuart
null::CHAR(1),  --stufrm
null::CHAR(1)  --stutyp
FROM lab
, superx_sos
WHERE lab.mtknr = superx_sos.mtknr
AND (lab.pstatus is null or lab.pstatus != "SO")
$LAB_FILTER
AND lab.prueck = 0         { ab 8.99 }
AND lab.psem >= $start_pruef_sem        {ab hier werden Daten ausgewertet}
and
((lab.pnr in ($POS_PNR) or "0"="$POS_PNR")
or lab.pnr in
 (
select distinct pnr from tmp_hskonst
)
)
;

]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[
SELECT
S.mtknr_ldsg,
substr(stgnr,1,1),
substr(stgnr,length(stgnr),1),
abschl,
psem,
extract(day from pdatum)::varchar(2) || '.' || extract(month from pdatum)::varchar(2) || '.' || extract(year from pdatum)::varchar(4),
stg,
vert,
schwp,
kzfa,
pnote,
vken1,
null::char(7), --pruefungsamt_nr
lab.pnr,
pversion,
pstatus,
stgsem ,
part,
labnr,
pversuch,
ppruef1,
ppruef2,
malus,
bonus,
pordnr,
psws,
null::char(1), --relation_id nur bei HIS1
pvermerk,
prueck,
ptermin, --term_segment
pform,
null::char(1), --anger. fs insg.
null::char(1), --berufspraktische taetigkeit
null::char(1), --aus auslandsstudium
null::char(1), --aus anderem stg an einer deutschen hs
null::char(1), -- amtl. Schl. Art der Promotion
panerk,
pstatkennz,
ppunkte,
null::CHAR(1), --stuart
null::CHAR(1),  --stufrm
null::CHAR(1)  --stutyp
FROM lab , superx_sos S
WHERE lab.mtknr = S.mtknr
$LAB_FILTER
AND (lab.pstatus is null or lab.pstatus != 'SO')
AND lab.psem >= $start_pruef_sem
and
((lab.pnr in ($POS_PNR) or '"0"'='"$POS_PNR"')
or lab.pnr in
 (
select distinct pnr from tmp_hskonst
)
)
;

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[

   SELECT distinct
    L.mtknr_ldsg,
degree_program_progress_studynumber,--substr(stgnr,1,1),
degree_program_progress_subjectnumber,--substr(stgnr,length(stgnr),1),
'' || C.degree_id,--abschl,
'' || L.term_year || L.termnumber,--psem,
extract(day from L.date_of_work)::varchar(2) || '.' || extract(month from L.date_of_work)::varchar(2) || '.' || extract(year from L.date_of_work)::varchar(4),
'' || C.subject_id,--stg,
'' || C.major_field_of_study_id, --vert,
'' || C.course_specialization_id,--schwp,
'' || C.k_subject_indicator_id,--kzfa,
substring('' || L.grade from 1 for 1) || coalesce(substring('' || L.grade from 3 for 2),'') ,--pnote,  TODO: examvaluation.grade
null::char(1),--vken1,
c.examination_office_no, --pruefungsamt
L.official_statistics, --lab.pnr,
'' || C.k_examinationversion_id,--pversion,
L.examrelation_k_workstatus_id,--pstatus,
L.degree_program_progress_studysemester,--stgsem , provisorisch s. Ticket https://hiszilla.his.de/hiszilla/show_bug.cgi?id=88788#c4
(select X.k_examination_type_id from examination X where X.unit_id=L.unit_id),--part,
L.examplan_id,--labnr,
null::char(1),--pversuch,
null::char(1),--ppruef1,
null::char(1),--ppruef2,
L.examrelation_malus,
L.examrelation_bonus,
L.unit_id,--pordnr,
null::char(1),--psws
L.examrelation_parent_examplan_id,
L.k_remark_on_exam_id,
L.cancelation ,
L.term_segment,--ptermin
L.k_examform_id, --pform
trunc(L.studysemester_acknowledgement_semester_overall)::integer, --anger. fs insg.
trunc(L.studysemester_acknowledgement_practice_semester)::integer, -- berufspraktische taetigkeit
trunc(L.studysemester_acknowledgement_semester_abroad)::integer, -- aus Auslandsstudium
trunc(L.studysemester_acknowledgement_former_degree_program)::integer, --aus anderem stg an einer deutschen hs
L.type_of_doctorate_astat, -- amtl. Schl. Art der Promotion
L.panerk,
null::integer, --pstatkennz
null::integer, --ppunkte
C.k_type_of_study_id, --stuart
C.k_form_of_studies_id,  --stufrm 
C.k_enrollment_id --stutyp
FROM tmp_lab L left outer join tmp_course_of_study C
on (C.id=L.course_of_study_id)
;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
SELECT
P.matrikelnummer,
P.studiengang_nr,
P.fach_nr,
G.abschluss,
P.semester,
P.leistungsdatum,
G.stg,
null::integer as vert,
null::integer as schwp,
G.fachkennzeichen,
round(P.note::decimal(15,4),2) as note,
null::integer as vken1,
null::char(7), --pruefungsamt_nr
P.pnr,
val(G.pversion),
P.leistungsstatus_map_kb as pstatus,
P.fachsemester ,
null::char(7) as part,
P.leistung_nr,
null::integer as pversuch,
null::char(7)as ppruef1,
null::char(7) as ppruef2,
null::char(7) as malus,
P.credits as bonus,
stp_sp_nr as pordnr,
null::integer as psws,
null::char(1), --relation_id nur bei HIS1
null::integer as pvermerk,
null::integer as prueck,
null::integer as ptermin, --term_segment
null::integer as pform,
null::char(1), --anger. fs insg.
null::char(1), --berufspraktische taetigkeit
null::char(1), --aus auslandsstudium
null::char(1), --aus anderem stg an einer deutschen hs
null::char(1), -- amtl. Schl. Art der Promotion
P.anerkannt_flag as panerk,
null::integer as pstatkennz,
null::integer as ppunkte,
null::CHAR(1), --stuart
G.stufrm,
null::CHAR(1),  --stutyp
st_studium_nr as degree_program_id,
null::char(1) as k_elementtype_id,
null::char(1) as  ut_top_unit_id,
null::char(1) as ut_top_k_elementtype_id,
null::char(1) as child_ut_top_unit_id,
null::char(1) as child_ut_top_unit_stat,
null::char(1) as k_unit_purpose_id
FROM costage_st_pruef_aggr P, costage_st_studiengaenge G
where G.st_studiengang_nr=P.st_studiengang_nr
AND P.semester >= $start_pruef_sem
;


]]>
</extraction-sql>
</unload-job>

<unload-job id="sos_lab_astat_attributes" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_lab_astat_attributes.unl" >
<comment>zusätzliche Merkmale für amtliche Prüfungsstatistik</comment>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[

select
null::integer AS labnr, -- Pruefungsnummer: labnr
null::integer AS st_abr_id, --Auslandsaufenthalte: stay_abroad.id
null::integer AS sourcesystem, -- Quellsystem
null::integer AS st_abr_country_astat, -- Staat des Auslandsaufenthaltes: country.astat
null::smallint AS st_abr_month, -- Dauer Auslandsaufenthalt in Monaten: stay_abroad.number_of_month
null::integer AS st_abr_type, -- Typ des Auslandsaufenthaltes: stay_abroad.stayabroad_type
null::integer AS st_abr_program, -- Mobilitätsprogramm: k_mobility_program.mobility_program
null::integer AS matrikel_nr,
null::integer AS sem_der_pruefung,
null::integer as d_abg_pruefung --Prüfungsdatum
from hskonst where 1=0

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="POSTGRES" version="">
<![CDATA[

   SELECT distinct

    --zuerst vor/Hauptprüfungen mit Fach/Abschluss etc. , weil eindeutig
L.examplan_id,
STAB.id,
CNT.astat, -- astat Land 1
STAB.number_of_month, -- Monate 1
SATY.astat, -- astat Art 1
MOPRO.astat, -- astat Mobilitätsprogramm 1
L.mtknr_ldsg,
'' || L.term_year || L.termnumber,--psem,
extract(day from L.date_of_work)::varchar(2) || '.' || extract(month from L.date_of_work)::varchar(2) || '.' || extract(year from L.date_of_work)::varchar(4)
 FROM unit_studies US,
    tmp_course_of_study C,
    (degree_program_progress as DPtmp
    left outer join studysemester_acknowledgement as SACKtmp
    on DPtmp.studysemester_acknowledgement_id = SACKtmp.id) as DP,
degree_program D,
period P,
    (tmp_lab as L
    join stayabroad_examplan as STABEX on L.examplan_id = STABEX.examplan_id
    join stay_abroad as STAB on STAB.id = STABEX.stay_abroad_id
    left outer join country as CNT on CNT.lid = STAB.country_lid
    left outer join k_stayabroad_type as SATY on SATY.id = STAB.k_stayabroad_type_id
    left outer join k_mobility_program as MOPRO on MOPRO.id = STAB.k_mobility_program_id) ,
   unit U ,
    examrelation R
    left outer join examresult N on (N.examrelation_id=R.id)
    WHERE U.id=US.unit_id
     and C.lid=US.course_of_study_lid
     and L.unit_id=U.id
     and L.examrelation_id=R.id
     and D.id=DP.degree_program_id
and DP.course_of_study_id=C.id
and DP.period_id=P.id
 and P.term_type_id=L.term_type_id
 and P.term_year=L.term_year
     and L.person_id=D.person_id
--and (C.valid_from <= DP.startdate
--or C.valid_from <= DP.enddate
--or (DP.enddate is null and DP.startdate is null))
and U.official_statistics in (1,2)
AND (to_number('' || L.term_year || L.termnumber,'99999') ) >= $start_pruef_sem
;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select
*
from tmp_xdummy where 1=0
]]>
</extraction-sql>
</unload-job>




<unload-job id="sos_stud_loe" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_stud_loe.unl" >
<comment> falls Studenten gelöscht wurden, werden diese durch die obigen Proz. in
 SuperX nicht berührt</comment>
<extraction-sql sourcesystem="sospos"  database="ACCESS" version="">
<![CDATA[SELECT  distinctrow mtknr
FROM    pro
WHERE  fktkz = 'LOE' ;

]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[

SELECT  distinct mtknr_ldsg
FROM    mtknr_ldsg, pro left outer join sos on (pro.mtknr=sos.mtknr)
WHERE  pro.mtknr=mtknr_ldsg.mtknr
and pro.datum >= date('$DATUM')
and fktkz = 'LOE'
and sos.mtknr is null;
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
SELECT * FROM student WHERE 1=0;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>

<unload-job id="sos_faecher_ext" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_faecher_ext.unl" >
<comment>Vorheriges Studium und Zweitstudiengänge</comment>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
select
S.mtknr_ldsg, E.extart, E.semester, E.hskfzkz, E.hskfz,
K.astat, E.hsart, substring(E.stgnr from 1 for 1),
substring(E.stgnr from 2 for 1), E.abschl,
E.stg, E.stgsem
,null::char(1), -- country astat wird in trans_sos_faecher_ext.sql ermittelt
E.stufrm
from stgext E, superx_sos S, sos O left outer join  k_ikfzha K
on (K.ikfzha=trim(O.erhskfz) || trim(O.erhsart))
WHERE E.mtknr = O.mtknr
and E.mtknr=S.mtknr
and E.extart in ('ZW','VS');

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
    <![CDATA[
-- AP (Abschlussprüfungen extern) fehlen hier. Werden gesondert behandelt!
SELECT SS.mtknr_ldsg AS matrikel_nr
, CASE WHEN 0 < (
   SELECT COUNT(1)
   FROM student S2, person PS
   JOIN degree_program D2 ON D2.person_id = PS.id
   JOIN degree_program_progress DP2 ON DP2.degree_program_id = D2.id
   JOIN period P ON P.id = DP2.period_id AND P.term_year=DP.term_year
   JOIN term_type TT2 ON P.term_type_id = TT2.id AND TT2.termnumber=TT.termnumber
   WHERE S2.registrationnumber = S.registrationnumber AND S2.person_id = PS.id
) THEN 'ZW' ELSE 'VS' END AS extart -- VS = Vorsemester an anderer Hochschule ZW = Zweithochschule in diesem Semester
,  case when DP.term_year not between 1900 and 2999 then null else '' || DP.term_year || TT.termnumber end AS sem_rueck_beur_ein
, CASE WHEN C.uniquename = 'D' THEN 'I' ELSE 'A' END AS hskfzkz
, CASE WHEN C.uniquename = 'D' THEN U.vehicle_registration_plate ELSE C.uniquename END AS hskfz
, U.astat AS hs
, U.universitytype AS hsart
,case when DP.studynumber >9 then 1 else DP.studynumber end AS studiengang_nr
,DP.subjectnumber AS fach_nr
,DE.astat_land AS ang_abschl
,SU.astat_land AS fach
,DP.number_of_studysemester::INT AS fachsem_zahl
,C.astat AS country_astat
,D.k_form_of_studies_id
FROM studentexternal SE
JOIN student S ON SE.person_id = S.person_id AND S.registrationnumber IS NOT NULL
JOIN superx_sos SS on SS.id=S.id
JOIN degree_program_before D ON D.studentexternal_id = SE.id
JOIN degree_program_progress_before DP ON DP.degree_program_before_id = D.id
JOIN subject SU ON SU.lid = DP.subject_lid AND now() BETWEEN SU.valid_from AND SU.valid_to
JOIN degree DE ON DE.lid = D.degree_lid AND now() BETWEEN DE.valid_from AND DE.valid_to
LEFT JOIN k_studystatus KSS ON KSS.id=DP.k_studystatus_id
LEFT JOIN k_type_of_study KTS ON KTS.id=DP.id
LEFT JOIN k_enrollment KEN ON KEN.id = DP.k_enrollment_id
LEFT JOIN term_type TT ON DP.term_type_id = TT.id
LEFT JOIN university U ON SE.university_lid = U.lid AND now() BETWEEN U.valid_from AND U.valid_to
LEFT JOIN country C ON C.lid = SE.country_lid

;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>

<unload-job id="sos_faecher_kontrolle" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_faecher_kontrolle.unl" >
<comment></comment>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[
select stg.semester,"" || round(count(*),0) from sos, stg
where sos.mtknr = stg.mtknr
and stg.stgnr = '11'
AND stg.semester >= $start_stud_sem
group by stg.semester
order by stg.semester;

]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="ACCESS" version="">
<![CDATA[
select stg.semester,count(*) from sos, stg
where sos.mtknr = stg.mtknr
and stg.stgnr = '11'
group by stg.semester
order by stg.semester;

]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[
select stg.semester,'' || round(count(*),0) from sos, stg
where sos.mtknr = stg.mtknr
and stg.stgnr = '11'
AND stg.semester >= $start_stud_sem
group by stg.semester
order by stg.semester;


]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="POSTGRES" version="">
<![CDATA[
select '' || P.term_year || T.termnumber,'' || round(count(*),0)
    FROM  period P,
term_type  T,
degree_program_progress DP,
degree_program D
WHERE T.id=P.term_type_id
and D.id=DP.degree_program_id
AND to_number('' || P.term_year || T.termnumber,'99999')  >= $start_stud_sem
and DP.startdate=date(P.startdate)
and DP.enddate=date(P.enddate)
group by 1
;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
<unload-job id="sos_pruefungen_kontrolle" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_pruefungen_kontrolle.unl" >
<comment></comment>
<extraction-sql sourcesystem="sospos"  database="ACCESS" version="">
<![CDATA[
select 'lab',lab.psem,count(*) from lab, sos S
WHERE lab.mtknr = S.mtknr
AND (lab.panerk is null or lab.panerk <> 'J')
--AND lab.prueck = 0
AND (S.fehlerkz not in ('F', 'V') or S.fehlerkz is null)
group by lab.psem
;

]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[
select 'lab',lab.psem,"" || round(count(*),0) from lab, sos S
WHERE lab.mtknr = S.mtknr
AND (lab.pstatus is null or lab.pstatus != "SO")
$LAB_FILTER
--AND lab.prueck = 0
AND (S.fehlerkz not in ("F", "V") or S.fehlerkz is null)
AND lab.psem >= $start_pruef_sem
and lab.pnr in (select distinct pnr from tmp_hskonst)
group by 1,2
;

]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[
select 'lab',lab.psem,count(*) from lab, sos S
WHERE lab.mtknr = S.mtknr
$LAB_FILTER
--AND lab.prueck = 0
AND (S.fehlerkz not in ('F', 'V') or S.fehlerkz is null)
AND lab.psem >= $start_pruef_sem
and lab.pnr in (select distinct pnr from tmp_hskonst)
group by lab.psem
;


]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[

SELECT 'lab'::char(10),'' || L.term_year || L.termnumber,--psem,
    count(*)
FROM tmp_lab L,
   unit U
  where L.unit_id=U.id
--and U.official_statistics in (1,2)
AND (to_number('' || L.term_year || L.termnumber,'99999') ) >= $start_pruef_sem
group by 1,2
;


]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>

<unload-job id="sos_anschri" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_anschri.unl" >
<comment> Anschriften aus SOS</comment>
<extraction-sql sourcesystem="sospos"  database="ACCESS" version="">
<![CDATA[
SELECT identnr,
       superx_sos.mtknr_ldsg,
       bewnr,
       anschrkz,
       kfz,
       plz,
       ort,
       anzuord,
       anwt,
      zusaort
FROM anschri, superx_sos
where superx_sos.mtknr=anschri.mtknr;

]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[
SELECT identnr,
       superx_sos.mtknr_ldsg,
       bewnr,
       anschrkz,
       kfz,
       plz,
       ort,
       anzuord,
       anwt,
      zusaort
FROM anschri, superx_sos
WHERE anschri.mtknr = superx_sos.mtknr;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[

SELECT identnr,
       superx_sos.mtknr_ldsg,
       bewnr,
       anschrkz,
       kfz,
       plz,
       ort,
       anzuord,
       anwt,
      zusaort
FROM anschri, superx_sos
WHERE anschri.mtknr = superx_sos.mtknr;
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
    SELECT * from tmp_xdummy
where 1=0;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
<unload-job id="sos_parstg" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_parstg.unl" >
<comment> Stichtage für Studiengänge aus POS</comment>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[
SELECT abschl,
       stg,
       vert,
       schwp,
       kzfa,
       pversion,
       psem,
       ptermin,
       folgesem,
       pmaxvg,
       pmaxvh,
       vpfri,
       hpfri,
       exmmeld,
       beumeld,
       pmaxfrnbs,
       pmaxfrnbvd,
       pmaxfrbevd,
       pmaxfrnbhd,
       pmaxfrbehd,
       pnotgrenzw,
       kap,
       tit,
       huel,
       freivers,
       psemfr,
       pdatkenn,
       abtitelhm,
       abtitelhw,
       abtitelvm,
       abtitelvw,
       mspgen,
       potext,
       melostg,
       semsetza,
       semsetzn,
       termintext,
       panfang,
       pende,
       rmfrist,
       sivabschl,
       sivstg,
       sivvert,
       sivschwp,
       sivkzfa,
       sivpversion,
       sivverw,
       pspanfang,
       pspende
FROM parstg
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="ACCESS" version="">
<![CDATA[SELECT abschl,
       stg,
       vert,
       schwp,
       kzfa,
       pversion,
       psem,
       ptermin,
       folgesem,
       pmaxvg,
       pmaxvh,
       vpfri,
       hpfri,
       exmmeld,
       beumeld,
       pmaxfrnbs,
       pmaxfrnbvd,
       pmaxfrbevd,
       pmaxfrnbhd,
       pmaxfrbehd,
       pnotgrenzw,
       kap,
       tit,
       huel,
       freivers,
       psemfr,
       pdatkenn,
       abtitelhm,
       abtitelhw,
       abtitelvm,
       abtitelvw,
       mspgen,
       potext,
       melostg,
       semsetza,
       semsetzn,
       termintext,
       format([panfang],'dd.mm.yyyy'),
       format([pende],'dd.mm.yyyy'),
       format([rmfrist],'dd.mm.yyyy'),
       sivabschl,
       sivstg,
       sivvert,
       sivschwp,
       sivkzfa,
       sivpversion,
       sivverw,
       format([pspanfang],'dd.mm.yyyy'),
       format([pspende],'dd.mm.yyyy')
FROM parstg
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[
SELECT abschl,
       stg,
       vert,
       schwp,
       kzfa,
       pversion,
       psem,
       ptermin,
       folgesem,
       pmaxvg,
       pmaxvh,
       vpfri,
       hpfri,
       exmmeld,
       beumeld,
       pmaxfrnbs,
       pmaxfrnbvd,
       pmaxfrbevd,
       pmaxfrnbhd,
       pmaxfrbehd,
       pnotgrenzw,
       kap,
       tit,
       huel,
       freivers,
       psemfr,
       pdatkenn,
       abtitelhm,
       abtitelhw,
       abtitelvm,
       abtitelvw,
       mspgen,
       potext,
       melostg,
       semsetza,
       semsetzn,
       termintext,
       panfang,
       pende,
       rmfrist,
       sivabschl,
       sivstg,
       sivvert,
       sivschwp,
       sivkzfa,
       sivpversion,
       sivverw,
       pspanfang,
       pspende
FROM parstg;

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
    SELECT * from tmp_xdummy
where 1=0;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>

<unload-job id="sos_hsnr" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_hsnr.unl" >
<comment>SuperX-Hochschulnr.</comment>
<extraction-sql sourcesystem="sospos"  database="ACCESS" version="">
<![CDATA[
   SELECT distinctrow hsnr, bland, hsbez FROM hskonst;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[
SELECT distinct hsnr, bland, hsbez FROM hskonst;
   ]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[
SELECT distinct hsnr, bland, hsbez FROM hskonst;
   ]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
SELECT DISTINCT ou.astat,SUBSTRING(kp.astat FROM 1 FOR 2),ou.defaulttext
FROM ( -- Höchste aktive Konfigurationaquelle mit aktivem Schlüssel
       -- core.psv.self.own_university
       SELECT cv.parameter_value AS orgunit_obj_guid,
              cs.uniquename AS confsrc_uniquename -- Zur Information
         FROM confparameter cp
              JOIN confvalue cv ON cp.id=cv.confparameter_id
              JOIN confsrc cs ON cv.confsrc_id=cs.id
        WHERE cp.confkey='core.psv.self.own_university' AND
              cp.active=1 AND
              cs.active=1
        ORDER BY cs.priority DESC
        LIMIT 1
     ) i
     JOIN orgunitobj ouo ON i.orgunit_obj_guid=ouo.obj_guid
     JOIN orgunit ou ON ouo.id=ou.lid
     JOIN address a ON ou.lid=a.orgunit_lid
     JOIN k_postcode kp USING(postcode)
WHERE CURRENT_DATE BETWEEN ou.valid_from AND ou.valid_to AND
     a.addresstype='Postaddress' ;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select unikey,null::char(1) as  bland,
null::char(1) as hsbez,
null::char(1) as hsort,
null::char(1) as hsstrasse,
null::char(1) as hsplz,
null::char(1) as hspostfach
from tmp_hskonst
where max_anzahl=1;
]]>
</extraction-sql>
</unload-job>

<unload-job id="semester" extraction-table="" extraction-script="" transfer-unload-file="unl/semester.unl" >
<comment>SuperX-semester</comment>
<extraction-sql sourcesystem="sospos"  database="ACCESS" version="">
<![CDATA[
   SELECT distinctrow aktsem,aktsem, format([sembg],'dd.mm.yyyy'),format([semende],'dd.mm.yyyy'),format([stistat],'dd.mm.yyyy')
FROM sossys where aktsem is not null;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="">
<![CDATA[
SELECT distinct aktsem,aktsem, sembg,semende,stistat
FROM sossys where aktsem is not null;
   ]]>
</extraction-sql>


<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="">
<![CDATA[
SELECT distinct aktsem,aktsem,
   extract(day from sembg)::varchar(2) || '.' || extract(month from sembg)::varchar(2) || '.' || extract(year from sembg)::varchar(4),
   extract(day from semende)::varchar(2) || '.' || extract(month from semende)::varchar(2) || '.' || extract(year from semende)::varchar(4),
   extract(day from stistat)::varchar(2) || '.' || extract(month from stistat)::varchar(2) || '.' || extract(year from stistat)::varchar(4)
FROM sossys where aktsem is not null;
   ]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
SELECT distinct '' || P.term_year || T.termnumber,'' || P.term_year || T.termnumber, date(P.startdate),date(P.enddate),date(P.startdate)+85 --Mitte des semesters
FROM k_period_usage K,period_usage U,period P,term_type T
where K.id=U.k_period_usage_id
and K.hiskey_id=7 --Semesterzeitraum
and U.period_id=P.id
and T.id=P.term_type_id
-- Semester nur entladen wenn es keine Trimester gibt
and T.termcategory=2 --Semester
and 0=(select count(*) from k_period_usage K,period_usage U,period P,term_type T
where K.id=U.k_period_usage_id
and K.hiskey_id=7 --Semesterzeitraum
and U.period_id=P.id
and T.id=P.term_type_id
and T.termcategory=3)
union
--Trimester werden entladen wenn es mind. eines gibt
SELECT distinct '' || P.term_year || T.termnumber,'' || P.term_year || T.termnumber, date(P.startdate),date(P.enddate),date(P.startdate)+85 --Mitte des semesters
FROM k_period_usage K,period_usage U,period P,term_type T
where K.id=U.k_period_usage_id
and K.hiskey_id=7 --Semesterzeitraum
and U.period_id=P.id
and T.id=P.term_type_id
and T.termcategory=3 --Trimester
and 0<(select count(*) from k_period_usage K,period_usage U,period P,term_type T
where K.id=U.k_period_usage_id
and K.hiskey_id=7 --Semesterzeitraum
and U.period_id=P.id
and T.id=P.term_type_id
and T.termcategory=3)
;
   ]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[

SELECT distinct semester_tid,
semester_bezeichnung, 
date(semester_anfang) as sem_beginn,
date(semester_ende) as semende,
date(semester_anfang)+60 as stistat
FROM costage_st_semester 
where semester_tid >= $start_stud_sem
;

]]>
</extraction-sql>
</unload-job>



<unload-job id="cif" extraction-table="" extraction-script="" transfer-unload-file="unl/cif.unl" >
<comment>cif-Schlüssel</comment>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="5,6,7">
<![CDATA[
SELECT
    12,
0,
   '' || astat,
   ktxt,
   dtxt,
   ltxt,
null::char(1),
null::char(1),
null::char(1),
null::char(1),
null::char(1)
   FROM k_akfz
   WHERE akfz is not null
   and aikz="A"
   and astat is not null

union
  SELECT
9010,
-1,
   '' || vpnr,"VD","Vorprüfung","Vorprüfung",
'' || vpnr,
null::char(1),
null::char(1),
null::char(1),
null::char(1)
FROM hskonst
union
SELECT
   9010,
-1,
   '' || hpnr,"HD","Hauptprüfung","Hauptprüfung",
'' || hpnr,
null::char(1),
null::char(1),
null::char(1),
null::char(1)
FROM hskonst

union
SELECT
   9003,
0,
   astat,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),
null::char(1),
null::char(1),
null::char(1)
   FROM k_geschl
   WHERE astat is not null
 union
SELECT
   617,
-1,
   '' || semgewicht,
   ktxt,
   dtxt,
   ltxt,
'' || semgewicht,
null::char(1),
null::char(1) ,
null::char(1),
null::char(1)
   FROM k_semgewicht

 union
SELECT
   631,
-1,
   '' || pnr,
   ktxt,
   dtxt,
   ltxt,
'' ||  pnr,
null::char(1),
null::char(1) ,
null::char(1),
null::char(1)
   FROM k_pnr
   where pnr is not null
  union
SELECT
   632,
-1,
   '' || refpvers,
   ktxt,
   dtxt,
   ltxt,
'' ||  pvers,
null::char(1),
null::char(1) ,
null::char(1),
sprache
   FROM k_pvers
   where refpvers is not null;


]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="8,9,10,11,12,13">
<![CDATA[
SELECT
    12,
0,
   '' || astat,
   ktxt,
   dtxt,
   ltxt,
null::char(1),
null::char(1),
null::char(1),
null::char(1),
null::char(1)
   FROM k_akfz
   WHERE akfz is not null
   and astat is not null
   and aikz="A"
   and (sprache ="D" or sprache is null)
union
  SELECT
9010,
-1,
   '' || vpnr,"VD","Vorprüfung","Vorprüfung",
'' || vpnr,
null::char(1),
null::char(1),
null::char(1),
null::char(1)
FROM hskonst
union
SELECT
   9010,
-1,
   '' || hpnr,"HD","Hauptprüfung","Hauptprüfung",
'' || hpnr,
null::char(1),
null::char(1),
null::char(1),
null::char(1)
FROM hskonst

union
SELECT
   9003,
0,
   astat,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),
null::char(1),
null::char(1),
null::char(1)
   FROM k_geschl
   WHERE astat is not null
 union
SELECT
   617,
-1,
   '' || semgewicht,
   ktxt,
   dtxt,
   ltxt,
'' || semgewicht,
null::char(1),
null::char(1) ,
null::char(1),
null::char(1)
   FROM k_semgewicht

 union
SELECT
   631,
-1,
   '' || pnr,
   ktxt,
   dtxt,
   ltxt,
'' ||  pnr,
null::char(1),
null::char(1) ,
null::char(1),
null::char(1)
   FROM k_pnr
   where pnr is not null
   union
SELECT
   632,
-1,
   '' || refpvers,
   ktxt,
   dtxt,
   ltxt,
'' ||  pvers,
null::char(1),
null::char(1) ,
null::char(1),
sprache
   FROM k_pvers
   where refpvers is not null;


]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="5,6,7">
<![CDATA[
SELECT
    12,
0,
   '' || astat,
   ktxt,
   dtxt,
   ltxt,
null::char(1),
null::char(1),
null::char(1),
null::char(1),
null::char(1)
   FROM k_akfz
   WHERE akfz is not null
   and astat is not null
   and aikz='A'

union
SELECT
   9010,
-1,
   '' || vpnr,'VD','Vorprüfung','Vorprüfung',
'' || vpnr,
null::char(1),
null::char(1),
null::char(1),
null::char(1)
FROM hskonst
union
SELECT
   9010,
   -1,
   '' || hpnr,'HD','Hauptprüfung','Hauptprüfung',
   '' || hpnr,
   null::char(1),
   null::char(1),
   null::char(1),
   null::char(1)
FROM hskonst

union
SELECT
   9003,
   0,
   astat,
   ktxt,
   dtxt,
   ltxt,
   astat,
   null::char(1),
   null::char(1),
   null::char(1),
   null::char(1)
   FROM k_geschl
   WHERE astat is not null
 union
SELECT
   617,
   -1,
   '' || semgewicht,
   ktxt,
   dtxt,
   ltxt,
   '' || semgewicht,
   null::char(1),
   null::char(1) ,
   null::char(1),
   null::char(1)
   FROM k_semgewicht

 union
SELECT
   631,
   -1,
   '' || pnr,
   ktxt,
   dtxt,
   ltxt,
   '' ||  pnr,
   null::char(1),
   null::char(1) ,
   null::char(1),
   null::char(1)
   FROM k_pnr
   where pnr is not null
  union
SELECT
   632,
-1,
   '' || refpvers,
   ktxt,
   dtxt,
   ltxt,
'' ||  pvers,
null::char(1),
null::char(1) ,
null::char(1),
sprache
   FROM k_pvers
   where refpvers is not null;


]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="8,9,10,11,12,13">
<![CDATA[
SELECT
    12,
0,
   '' || astat,
   ktxt,
   dtxt,
   ltxt,
null::char(1),
null::char(1),
null::char(1),
null::char(1),
null::char(1)
   FROM k_akfz
   WHERE akfz is not null
   and astat is not null
   and aikz='A'
   and (sprache ='D' or sprache is null)
union
SELECT
   9010,
-1,
   '' || vpnr,'VD','Vorprüfung','Vorprüfung',
'' || vpnr,
null::char(1),
null::char(1),
null::char(1),
null::char(1)
FROM hskonst
union
SELECT
   9010,
   -1,
   '' || hpnr,'HD','Hauptprüfung','Hauptprüfung',
   '' || hpnr,
   null::char(1),
   null::char(1),
   null::char(1),
   null::char(1)
FROM hskonst

union
SELECT
   9003,
   0,
   astat,
   ktxt,
   dtxt,
   ltxt,
   astat,
   null::char(1),
   null::char(1),
   null::char(1),
   null::char(1)
   FROM k_geschl
   WHERE astat is not null
 union
SELECT
   617,
   -1,
   '' || semgewicht,
   ktxt,
   dtxt,
   ltxt,
   '' || semgewicht,
   null::char(1),
   null::char(1) ,
   null::char(1),
   null::char(1)
   FROM k_semgewicht

 union
SELECT
   631,
   -1,
   '' || pnr,
   ktxt,
   dtxt,
   ltxt,
   '' ||  pnr,
   null::char(1),
   null::char(1) ,
   null::char(1),
   null::char(1)
   FROM k_pnr
   where pnr is not null
  union
SELECT
   632,
-1,
   '' || refpvers,
   ktxt,
   dtxt,
   ltxt,
'' ||  pvers,
null::char(1),
null::char(1) ,
null::char(1),
sprache
   FROM k_pvers
   where refpvers is not null;


]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="POSTGRES" version="">
<![CDATA[
SELECT
   12,
0,
   substring('' || astat from 1 for 10),--astat,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring('' || astat from 1 for 10), --astat
null::char(1),--parent
null::char(1),--sortc1
null::char(1),--bund_apnr
substring('' || k_language_id from 1 for 3) --sprache,
   FROM country --k_akfz
   --cif-Schlüssel derzeit noch nicht historisiert:
   where (current_date >= valid_from
   or valid_from is null)
   and (current_date <= valid_to
   or valid_to is null)

union
SELECT
    9010,
 -1,
   '2','VD','Vorprüfung',
   'Vorprüfung',
 null::char(1) , --astat
 null::char(1), --parent
 null::char(1), --sortc1
 null::char(1), --bund_apnr
 null::char(1) --sprache
FROM tmp_xdummy
union
SELECT
   9010,
-1,
   '1','HD','Hauptprüfung',
   'Hauptprüfung',
null::char(1) , --astat
null::char(1), --parent
null::char(1), --sortc1
null::char(1), --bund_apnr
null::char(1) --sprache
FROM tmp_xdummy
union
SELECT
   9010,
-1,
   '3','AA','Abschlussarbeit',
   'Abschlussarbeit',
null::char(1) , --astat
null::char(1), --parent
null::char(1), --sortc1
null::char(1), --bund_apnr
null::char(1) --sprache
FROM tmp_xdummy
union
SELECT
   9003,
   0,
   substring('' || astat from 1 for 10),--astat,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
  substring('' || astat from 1 for 10),--astat,
    null::char(1),
   null::char(1),
   null::char(1),
   null::char(1)
   FROM k_gender
   WHERE astat is not null
  union
SELECT
   631,
   -1,
   '' || id,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
   null::char(1) , --astat
   null::char(1),
   '' || sortorder ,--sortc1
   null::char(1),
   substring('' || k_language_id from 1 for 3)--sprache
   FROM k_examination_type
  union
SELECT
   632,
-1,
   '' || id,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
'' || hiskey_id , --astat
null::char(1), --parent
uniquename,
null::char(1),--bund_apnr
substring('' || k_language_id from 1 for 3)--sprache
   FROM  k_examinationversion;


]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
SELECT distinct 
   632,
   -1,
   val(po_stp_stp_version_kb),
   po_stp_stp_version_kb,
   po_stp_stp_version_kb,
   po_stp_stp_version_kb,
   null , --astat
   null,
   '' ,--sortc1
   null,
   '' --sprache
   FROM costage_st_studien_spoversionen
   union
   select 9003,
   -1,
   apnr,
   kurz,
   druck,
   druck,
    null , --astat
   null,
   '' ,--sortc1
   null,
   '' --sprache
   from cif
   where key=9003
   and apnr != -999990
  
   
]]>
</extraction-sql>
</unload-job>
<unload-job id="cifx" extraction-table="" extraction-script="" transfer-unload-file="unl/cifx.unl" >
<comment>Schlüsseltabelle cifx</comment>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[



    SELECT
    --zuerst gemeinsame Schluessel von SOS, POS und ZUL
 --die gleichen selects muessen auch in der zul_unload.xml sein!!!

   35,
-1,
   refabint,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),--parent
refabint,--sortc1 wird später uniquename
null::char(1),
sprache,
null::char(1), --gültig von
null::char(1), --gültig bis
refabint, --sourcesystem_id
null::char(1), --hiskey_id
aikz,  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_abint
   WHERE refabint is not null and refabint != '' and refabint != ''
   and (sprache='D' or sprache is null)
    union
SELECT
   30,
-1,
   refstg,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),--parent
refstg, --sortc1  wird später uniquename
null::char(1),--bund_apnr
sprache,
null::char(1), --gültig von
null::char(1), --gültig bis
refstg , --sourcesystem_id
null::char(1), --hiskey_id
fb,  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_stg
   WHERE refstg is not null
      and (sprache='D' or sprache is null)
       and trim (refstg) !=''
union
SELECT
   39,
-1,
   refvert,
   ktxt,
   dtxt,
   ltxt,
null::char(1),
null::char(1),
vert,
null::char(1),
sprache,
null::char(1), --gültig von
null::char(1), --gültig bis
refvert , --sourcesystem_id
null::char(1), --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_vert
        WHERE refvert is not null
      and (sprache='D' or sprache is null)
       and trim (refvert) !=''

   union
SELECT
   41,
0,
   schwp,
   ktxt,
   dtxt,
   ltxt,
null::char(1),
null::char(1),
schwp,
null::char(1),
sprache ,
null::char(1), --gültig von
null::char(1), --gültig bis
schwp, --sourcesystem_id
null::char(1), --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder

   FROM k_schwp
   WHERE schwp is not null
   and  trim(schwp) != ''
   union
   SELECT
   601,
-1,
   hzbart,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),
hzbart ,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
hzbart , --sourcesystem_id
null::char(1), --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_hzbart
   union
   SELECT
   612,
-1,
   stufrm,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),
stufrm ,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
stufrm , --sourcesystem_id
null::char(1), --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_stufrm
   union
   SELECT
   614,
-1,
   kzfa,
   ktxt,
   dtxt,
   ltxt,
   his_kzfa as astat,
null::char(1) as parent, --refkzfa,
kzfa ,
null::char(1),
sprache,
null::char(1), --gültig von
null::char(1), --gültig bis
kzfa , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_kzfa
   where (sprache='D' or sprache is null)
   union
   SELECT
   613,
-1,
   hrst,
   ktxt,
   dtxt,
   ltxt,
astat,
his_hrst,
hrst ,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
hrst, --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_hrst
   union
   SELECT
   616,
-1,
   stuart,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),
stuart ,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
stuart , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_stuart
   union
   SELECT
   620,
-1,
   astfr,
   ktxt,
   dtxt,
   ltxt,
null::char(1),
null::char(1),
astfr ,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
astfr , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_astfr
   where astfr is not null
   and trim(astfr)!=''
   union
   SELECT
   621,
-1,
   astgrp,
   ktxt,
   dtxt,
   ltxt,
null::char(1),
null::char(1),
astgrp ,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
astgrp , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_astgrp
   where astgrp is not null
   and trim(astgrp)!=''
   union
   SELECT
   618,
-1,
   abext,
   ktxt,
   dtxt,
   ltxt,
astat,
astat,
abext ,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
abext , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_abext
   union
   SELECT
   	622,
	-1,
   	refpstatus,
   	ktxt,
   	dtxt,
   	ltxt,
	null::char(1),
	null::char(1),
	refpstatus ,
	null::char(1),
	null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
refpstatus , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_pstatus
   where aikz='A'
   and (sprache='D' or sprache is null)

   union

   SELECT
   40,
-1,
   stutyp,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),
stutyp ,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
stutyp , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_stutyp
union
SELECT
   11,
-1,
   ikfz,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),
ikfz,
bland,
null::char(1) ,
null::char(1), --gültig von
null::char(1), --gültig bis
ikfz , --sourcesystem_id
null::char(1) , --hiskey_id
aikz,  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_ikfz
   WHERE astat is not null
   --and aikz ='A'
 union
SELECT
   12,
0,
   akfz,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),
akfz,--uniqename
erdteil,
null::char(1) ,
null::char(1), --gültig von
null::char(1), --gültig bis
akfz , --sourcesystem_id
null::char(1) , --hiskey_id
egmitgl,  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_akfz
   WHERE akfz is not null
   and (sprache ='D' or sprache is null)
   and aikz='A'
   union
SELECT
   12,
0,
   akfz,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),
akfz,--bei staaten ist astat=uniqename
erdteil,
null::char(1) ,
null::char(1), --gültig von
'01.01.2009', --gültig bis
akfz , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_akfz
   WHERE akfz is not null
   and (sprache ='D' or sprache is null)
   and aikz='I'
    union
SELECT
   8,
0,
   bland,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),
bland,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
bland , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_bland
   WHERE bland is not null
   union
   SELECT
   9011,
0,
   ppruefer,
   kname,
   nachname  ,
  nachname || ', '|| vorname ,
null::char(1),
null::char(1),
ppruefer,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
ppruefer , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_ppruef
   WHERE ppruefer is not null
   and '$PRUEFER_NAME'='true'
   union
   SELECT
   305,
0,
   sperre,
   ktxt,
   dtxt  ,
  ltxt ,
sos_sperre1::char(10),
sos_sperre2::char(10),
sperre,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
sperre , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_sperre
   WHERE sperre is not null
   and aikz='A'
   union
SELECT
   9001,
0,
   status,
   ktxt,
   dtxt,
   ltxt ,
astat,
null::char(1),
status,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
status , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_status
   WHERE status is not null
   and aikz='A'
    union
SELECT
   9013,
0,
   modulart,
   ktxt,
   dtxt  ,
  ltxt ,
null::char(1),
null::char(1),
modulart,
null::char(1),
sprache,
null::char(1), --gültig von
null::char(1), --gültig bis
modulart , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_modulart
   WHERE modulart is not null
   and aikz='A'
   union

   SELECT
   90,
-1,
   reffb,
   ktxt,
   dtxt,
   ltxt,
null::char(1),
null::char(1),
fb ,
null::char(1),
sprache,
null::char(1), --gültig von
null::char(1), --gültig bis
reffb , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_fb
   where aikz='A'
   and (sprache ='D' or sprache is null)
 union
   SELECT
   	9012,
	-1,
   	stort,
   	ktxt,
   	dtxt,
   	ltxt,
	astat,
	null::char(1),
	stort ,
	null::char(1),
	null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
stort , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_stort
    where aikz='A'

   union
   SELECT
   619,
-1,
   lehreinh,
   ktxt,
   dtxt,
   ltxt,
null::char(1),
null::char(1),
lehreinh ,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
lehreinh , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_le
   where lehreinh is not null
   and trim(lehreinh)!=''
   union
   SELECT
   27,
-1,
   gdbu,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),
gdbu ,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
gdbu , --sourcesystem_id
his_gdbu , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_gdbu
   where gdbu is not null
   --and aikz='A'
   and trim(gdbu)!=''
   union
   SELECT
   62,
-1,
   gdex,
   ktxt,
   dtxt,
   ltxt,
astat,
null::char(1),
gdex ,
null::char(1),
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
gdex , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_gdex
   where gdex is not null
   --and aikz='A'
   and trim(gdex)!=''
   union
       SELECT
   624,
-1,
   pvermerk,
   ktxt,
   dtxt  ,
  ltxt ,
astat,
null::char(1) ,
pvermerk,
null::char(1) ,
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
pvermerk , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_pverme
   WHERE pvermerk is not null
   and aikz='A'
   and trim(pvermerk) != ''
union
       SELECT
   9002,
-1,
   part,
   ktxt,
   dtxt  ,
  ltxt ,
astat,
null::char(1) ,
part,
null::char(1) ,
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
part , --sourcesystem_id
prfgkz , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_part
   WHERE part is not null
union
       SELECT
   618,
-1,
   abext,
   ktxt,
   dtxt  ,
  ltxt ,
astat,
null::char(1) ,
abext,
null::char(1) ,
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
abext , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_abext
   WHERE abext is not null
union
       SELECT
   623,
-1,
   art,
   substring(dtxt from 1 for 10),
   dtxt  ,
  artmind ,
astat,
null::char(1) ,
art,
null::char(1) ,
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
art , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1) ,  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_minder
   WHERE art is not null
   and aikz='A'
union
       SELECT
   9014,
-1,
   refpform,
   substring(dtxt from 1 for 10),
   dtxt  ,
  null::char(1) ,
null::char(1),
null::char(1) ,
null::char(1),
null::char(1) ,
null::char(1),
null::char(1), --gültig von
null::char(1), --gültig bis
refpform , --sourcesystem_id
null::char(1) , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
null::integer as sortorder
   FROM k_pform
   WHERE refpform is not null
   and aikz='A'
   ;

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[

   SELECT
   35,
-1,
   ('' || id)::varchar(255) as id,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring(astat_land from 1 for 10),--astat,
null::char(1),--parent
uniquename,
substring(astat_bund from 1 for 10), --bund_apnr
substring('' || k_language_id from 1 for 3), --sprache,
valid_from, --gueltig von
valid_to, --gueltig bis
id , --sourcesystem_id
'' || hiskey_id,
null::char(1),  --struktur_c
lid::char(255) as lid,
null::char(255) as parent_lid,
sortorder
   FROM degree
   where (hiskey_id !=2 or hiskey_id is null) --keine externen Abschlüsse
    union
SELECT 30,
-1,
   '' || S.id,
substring(S.shorttext from 1 for 10),
substring(S.defaulttext from 1 for 100),
substring(S.longtext from 1 for 150),
substring(S.astat_land from 1 for 10) as astat,
null::char(1),--parent
substring(S.uniquename from 1 for 10), --sortc1
S.astat_bund ,--bund_apnr
substring('' || S.k_language_id from 1 for 3),--sprache,
S.valid_from, --gueltig von
S.valid_to, --gueltig bis
S.id , --sourcesystem_id
min('' || F.uniquename) as astgrp, --hiskey_id
min('' || C.orgunit_id), --struktur_c ist FB, keine Duplikate erlaubt
S.lid::char(255) as lid,
null::char(255) as parent_lid,
S.sortorder
   FROM subject S, tmp_course_of_study C left outer join k_field_of_study F on
(F.id=C.k_field_of_study_id)
where S.id=C.subject_id
and S.hiskey_id=1 --nur interne Fächer
group by 1,2,3,4,5,6,7,9,10,11,12,13,14

union
SELECT
--Vertiefung
   39,
-1,
   '' || id,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
null::char(1) as astat,
null::char(1),--parent
uniquename,
null::char(1) ,--bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
valid_from, --gueltig von
valid_to, --gueltig bis
id , --sourcesystem_id
null::char(1), --hiskey_id
null::char(1),  --struktur_c
lid::char(255) as lid,
null::char(255) as parent_lid,
sortorder
   FROM major_field_of_study

union
--HZB-Art
   SELECT
   601,
-1,
   '' || id,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring('' || astat from 1 for 10),--astat,
null::char(1),--parent
uniquename,
null::char(1), --bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
valid_from, --gueltig von
valid_to, --gueltig bis
id , --sourcesystem_id
null::char(1), --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
   FROM entrance_qualification_type
    union
    SELECT
    612,
 -1,
   '' || id, --stufrm
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring('' || astat from 1 for 10),--astat,
null::char(1),--parent
uniquename,
null::char(1), --bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
null::date, --gueltig von
null::date, --gueltig bis
id , --sourcesystem_id
'' || hiskey_id,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
    FROM k_form_of_studies
   union
   --kzfa:
   SELECT
   614,
-1,
   '' || id,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
   '' || hiskey_id, --astat
null::char(1),--parent
uniquename,
null::char(1), --bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
date('01.01.1900'), --gueltig von
date('01.01.2900'), --gueltig bis
id , --sourcesystem_id
'' || hiskey_id,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
FROM k_subject_indicator
   union
   SELECT
    613,
 -1,
   '' || id, -- hrst,
substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring(astat from 1 for 10), -- astat,
null::char(1), --parent
uniquename,
 null::char(1) ,--bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
date('01.01.1900'), --gueltig von
date('01.01.2900'), --gueltig bis
id , --sourcesystem_id
'' || hiskey_id, -- his_hrst,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
 FROM k_studentstatus
    union
       -- stuart:
    SELECT
    616,
-1,
   '' || id,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
 substring('' || astat from 1 for 10),--astat,
null::char(1),--parent
uniquename,
null::char(1), --bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
null::date, --gueltig von
null::date, --gueltig bis
id , --sourcesystem_id
null::char(1)|| hiskey_id,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
    FROM k_type_of_study
    union
       -- k_astgrp:
 SELECT
     621,
 -1,
    '' || id,
    substring(shorttext from 1 for 10),
    substring(defaulttext from 1 for 100),
    substring(longtext from 1 for 150),
  substring('' || astat from 1 for 10),--astat,
 '',--parent
 uniquename,
 '', --bund_apnr
 substring('' || k_language_id from 1 for 3),--sprache,
 valid_from, --gueltig von
 valid_to, --gueltig bis
 id , --sourcesystem_id
 ''|| hiskey_id,
 '' ,  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
     FROM k_field_of_study
     where hiskey_id=4
    union
       -- pvermerk:
    SELECT
    624,
-1,
   '' || id,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
null::char(1),--substring('' || astat from 1 for 10),--astat,
null::char(1),--parent
uniquename,
null::char(1), --bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
null::date, --gueltig von
null::date, --gueltig bis
id , --sourcesystem_id
'' || hiskey_id,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
    FROM k_remark_on_exam
    union
   -- stutyp,
    SELECT
    40,
 -1,
     '' || id,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring('' || astat from 1 for 10),--astat,
null::char(1),--parent
uniquename,
null::char(1), --bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
null::date, --gueltig von
null::date, --gueltig bis
id , --sourcesystem_id
'' || hiskey_id,
null::char(1) ,  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
    FROM k_enrollment
 union
 SELECT
    11,
 -1,
   '' || id, -- ikfz,
substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring(astat from 1 for 10), -- astat,
null::char(1), --parent
uniquename,
substring(astat from 1 for 2), -- (bund_apnr) hier StBa-Key für Bundesland aus astat,
substring('' || k_language_id from 1 for 3),--sprache,
valid_from, --gueltig von
valid_to, --gueltig bis
id , --sourcesystem_id
''|| lid , --hiskey_id
'I'  ,  --struktur_c
lid::char(255) as lid,
null::char(255) as parent_lid,
sortorder
FROM district
where valid_to < current_date
union
 SELECT
    11,
 -1,
   '' || id, -- ikfz,
substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring(astat from 1 for 10), -- astat,
null::char(1), --parent
uniquename,
substring(astat from 1 for 2), -- (bund_apnr) hier StBa-Key für Bundesland aus astat,
substring('' || k_language_id from 1 for 3),--sprache,
valid_from, --gueltig von
valid_to, --gueltig bis
id , --sourcesystem_id
''|| lid , --hiskey_id
'A' ,  --struktur_c
lid::char(255) as lid,
null::char(255) as parent_lid,
sortorder
FROM district
where (valid_to >= current_date or valid_to is null)
 union
SELECT
   12,
0,
   '' || id,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring('' || astat from 1 for 10),--astat,
null::char(1),--parent
substring('' || uniquename from 1 for 10), --sortc1
substring('' || continent from 1 for 10), -- erdteil
substring('' || k_language_id from 1 for 3),--sprache,
valid_from, --gueltig von
valid_to, --gueltig bis
id , --sourcesystem_id
'' || lid, --hiskey_id
'I',  --struktur_c
lid::char(255) as lid,
null::char(255) as parent_lid,
sortorder
   FROM country
   where valid_to < current_date
   union
SELECT
   12,
0,
   '' || id,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring('' || astat from 1 for 10),--astat,
null::char(1),--parent
substring('' || uniquename from 1 for 10), --sortc1
substring('' || continent from 1 for 10), -- erdteil
substring('' || k_language_id from 1 for 3),--sprache,
valid_from, --gueltig von
valid_to, --gueltig bis
id , --sourcesystem_id
'' || lid, --hiskey_id
'A' ,  --struktur_c
lid::char(255) as lid,
null::char(255) as parent_lid,
sortorder
   FROM country
   where (valid_to >= current_date or valid_to is null)
  union
    SELECT
    8,
 -1,
     uniquename,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring('' || astat from 1 for 10),--astat,
null::char(1),--parent
uniquename,
null::char(1), --bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
null::date, --gueltig von
null::date, --gueltig bis
id , --sourcesystem_id
'' ,--hiskey_id,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
    FROM k_federal_state
    WHERE uniquename  not in ('99','BO') --ohne Ausland und Berlin Ost
   union
SELECT
    9001,
 0,
   '' || id, -- status,
substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring(astat from 1 for 10), -- astat,
null::char(1), --parent
uniquename,
 null::char(1) ,--bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
date('01.01.1900'), --gueltig von
date('01.01.2900'), --gueltig bis
id , --sourcesystem_id
'' || hiskey_id, -- his_hrst,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
    FROM k_studystatus
     union
SELECT
   9013,
 0,
   '' || id, -- modulart,
substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
null::char(1) , -- astat,
null::char(1), --parent
substring(uniquename from 1 for 10),--uniquename
 null::char(1) ,--bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
date('01.01.1900'), --gueltig von
date('01.01.2900'), --gueltig bis
id , --sourcesystem_id
'' || hiskey_id , --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
FROM k_elementtype
union
   SELECT
   90,
-1,
   '' || O.id,
   substring(O.shorttext from 1 for 10),
   substring(O.defaulttext from 1 for 100),
   substring(O.longtext from 1 for 150),
substring(O.astat from 1 for 10),--astat,
substring('' || O.parent_lid from 1 for 3),--parent
O.uniquename,
null::char(1), --bund_apnr
substring('' || O.k_language_id from 1 for 3),--sprache,
O.valid_from, --gueltig von
O.valid_to, --gueltig bis
O.id, --sourcesystem_id
'' || T.hiskey_id,
null::char(1),  --struktur_c
O.lid::char(255) as lid,
O.parent_lid::char(255) as parent_lid,
O.sortorder
   FROM orgunit O,k_orgunittype T
   where O.k_orgunittype_id=T.id
   and T.hiskey_id=4 --Fachbereich
union
   SELECT
   619,
-1,
   '' || O.id,
   substring(O.shorttext from 1 for 10),
   substring(O.defaulttext from 1 for 100),
   substring(O.longtext from 1 for 150),
substring(O.astat from 1 for 10),--astat,
substring('' || O.parent_lid from 1 for 3),--parent
substring(O.uniquename from 1 for 10), --sortc1
null::char(1), --bund_apnr
substring('' || O.k_language_id from 1 for 3),--sprache,
O.valid_from, --gueltig von
O.valid_to, --gueltig bis
O.id, --sourcesystem_id
'' || T.hiskey_id,
null::char(1),  --struktur_c
O.lid::char(255) as lid,
O.parent_lid::char(255) as parent_lid,
O.sortorder
   FROM orgunit O,k_orgunittype T
   where O.k_orgunittype_id=T.id
   and T.hiskey_id=7 --Lehreinheit
 union
 --Standorte
   SELECT
   	9012,
	-1,
    '' || id,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring(astat from 1 for 10), --astat,
null::char(1),--parent
uniquename,
substring('' || hiskey_id from 1 for 10), --bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
date('01.01.1900'), --gueltig von
date('01.01.2900'), --gueltig bis
id, --sourcesystem_id
null::char(1), --hiskey_id
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
   FROM k_place_of_studies
   union
   --pstatus
   SELECT
   	622,
	-1,
   '' || id,
   substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
	null::char(1),
null::char(1),--parent
uniquename,
null::char(1), --bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
date('01.01.1900'), --gueltig von
date('01.01.2900'), --gueltig bis
id, --sourcesystem_id
'' || hiskey_id,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
   FROM k_workstatus

 union
  --Beurlaubungsgründe
SELECT
    27,
 0,
   '' || id, -- gdbu,
substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
substring(astat from 1 for 10), -- astat,
null::char(1), --parent
uniquename,
 null::char(1) ,--bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
valid_from, --gueltig von
valid_to, --gueltig bis
id , --sourcesystem_id
null::char(1) , -- hiskey,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
    FROM k_reason_of_leave

union

SELECT -- Exmatrikulationsgründe
  62,
  0,
  '' || S.id, -- gdbu,
  substring(S.shorttext from 1 for 10),
  substring(S.defaulttext from 1 for 100),
  substring(S.longtext from 1 for 150),
  substring(S.astat from 1 for 10), -- astat,
  '', --parent
  S.uniquename,
  substring(S.astat from 1 for 10), --bund_apnr
  substring('' || S.k_language_id from 1 for 3),--sprache,
  S.valid_from, --gueltig von
  S.valid_to, --gueltig bis
  S.id , --sourcesystem_id
  '' || S.hiskey_id, -- hiskey,
  '',  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
FROM k_reason_of_finishing S

union

SELECT
  9002,
  0,
  '' || id, -- ,
  substring(shorttext from 1 for 10),
  substring(defaulttext from 1 for 100),
  substring(longtext from 1 for 150),
  null::char(1),-- astat,
  null::char(1), --parent
  uniquename,
  null::char(1) ,--bund_apnr
  substring('' || k_language_id from 1 for 3),--sprache,
  date('01.01.1900'), --gueltig von
  date('01.01.2900'), --gueltig bis
  id , --sourcesystem_id
  '' || hiskey_id , -- hiskey,
  null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
FROM k_examination_type

union

SELECT
    9014,
 0,
   '' || id, -- ,
substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
null::char(1),-- astat,
null::char(1), --parent
uniquename,
 null::char(1) ,--bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
date('01.01.1900'), --gueltig von
date('01.01.2900'), --gueltig bis
id , --sourcesystem_id
'' || hiskey_id , -- hiskey,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
    FROM k_examform

    union
SELECT
    41,
 0,
   '' || id, -- ,
substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
null::char(1),-- astat,
null::char(1), --parent
uniquename,
 null::char(1) ,--bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
date('01.01.1900'), --gueltig von
date('01.01.2900'), --gueltig bis
id , --sourcesystem_id
'' || hiskey_id , -- hiskey,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
    FROM course_specialization

    union

    SELECT
    9005,
 0,
   '' || id, -- ,
substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
null::char(1),-- astat,
null::char(1), --parent
uniquename,
 null::char(1) ,--bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
date('01.01.1900'), --gueltig von
date('01.01.2900'), --gueltig bis
id , --sourcesystem_id
'' || hiskey_id , -- hiskey,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
    FROM k_accreditationtype

    union

     SELECT
    9006,
 0,
   '' || id, -- ,
substring(shorttext from 1 for 10),
   substring(defaulttext from 1 for 100),
   substring(longtext from 1 for 150),
 astat,
null::char(1), --parent
uniquename,
astat_guest_auditor ,--bund_apnr
substring('' || k_language_id from 1 for 3),--sprache,
date('01.01.1900'), --gueltig von
date('01.01.2900'), --gueltig bis
id , --sourcesystem_id
'' || hiskey_id , -- hiskey,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
sortorder
    FROM k_field_of_study

    union

     SELECT DISTINCT
    9008,
 0,
   '' || examination_office_no, -- ,
substring(examination_office_no::varchar from 1 for 10),
   substring(examination_office_no::varchar from 1 for 100),
   substring(examination_office_no::varchar from 1 for 150),
 '',
null::char(1), --parent
examination_office_no, --uniquename
'' ,--bund_apnr
'',--sprache,
date('01.01.1900'), --gueltig von
date('01.01.2900'), --gueltig bis
examination_office_no::int  , --sourcesystem_id
'' , -- hiskey,
null::char(1),  --struktur_c
null::char(255) as lid,
null::char(255) as parent_lid,
0
    FROM tmp_course_of_study
        ;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[


    SELECT
    --zuerst gemeinsame Schluessel von SOS, POS und ZUL
 --die gleichen selects muessen auch in der zul_unload.xml sein!!!

   35,
-1,
   abint,
   abint,--ktxt,
   dtxt,
   ltxt,
astat,
null as parent,
abint,--sortc1 wird später uniquename
' ',
null as sprache,
null::date as gueltig_von,
null::date  as gueltig_bis,
abint, --sourcesystem_id
' ', --hiskey_id
aikz, --struktur_c
null as lid,
null as parent_lid,
null as sortorder
   FROM k_abint
   WHERE abint is not null

    union
SELECT
   30,
-1,
   apnr,
   kurz,
   druck,
   lang_1,
astat,
null as parent,
apnr, --sortc1  wird später uniquename
null as bund_apnr,
null as sprache,
null::date  gueltig_von,
null::date  gueltig_bis,
apnr , --sourcesystem_id
' ', --hiskey_id
struktur_c as fb,
null as lid,
null as parent_lid,
null as sortorder
   FROM cifx where key=30

 union
    SELECT distinct 
    612,
 -1,
    studienform_statistik_code,
    studienform_statistik_code as ktxt,
    studienform_name,
    studienform_name,
 studienform_statistik_code as astat,
 '',
 studienform_statistik_code ,
 '',
 '',
null::date  as gueltig_von,
null::date  as gueltig_bis,
 studienform_statistik_code , --sourcesystem_id
 '', --hiskey_id
 '' , --struktur_c
null as lid,
null as parent_lid,
null as sortorder
    FROM costage_st_studien
   union
   SELECT distinct 
   613,
-1,
   hoererstatus_kb,
   hoererstatus_kb as ktxt,
   hoererstatus_name,
   hoererstatus_name,
   (case when hoererstatus_kb='G' then '4'
   when hoererstatus_kb ='O' then '1'
   when hoererstatus_kb in ('W','Z') then '2'
   else '' end) as astat,
'' as his_hrst,
hoererstatus_kb ,
' ',
' ',
null::date  as gueltig_von,
null::date  as gueltig_bis,
hoererstatus_kb, --sourcesystem_id
' ' , --hiskey_id
' ' , --struktur_c
null as lid,
null as parent_lid,
null as sortorder
   FROM costage_st_hoererstatus
union
SELECT distinct 
   614,
-1,
   fachkennzeichen,
   fachkennzeichen,--ktxt,
   fachkennzeichen,
   fachkennzeichen,
null::char(10),
null as parent,
fachkennzeichen,--sortc1 wird später uniquename
' ',
null as sprache,
null::date  as gueltig_von,
null::date  as gueltig_bis,
fachkennzeichen, --sourcesystem_id
' ', --hiskey_id
'A', --struktur_c
null as lid,
null as parent_lid,
null as sortorder
   FROM costage_st_studiengaenge
   WHERE fachkennzeichen is not null
   and trim(fachkennzeichen)!=''
 union
       SELECT distinct 
   	 622,
	 -1,
   	 leistungsstatus_map_kb as pstatus,
   	leistungsstatus_map_kb as ktxt,
   	leistungsstatus_map_kb as dtxt,
   	leistungsstatus_map_kb as ltxt,
	 '',
	'',
	leistungsstatus_map_kb ,
	 '',
	 '',
null::date ,-- gültig von,
null::date, -- gültig bis,
leistungsstatus_map_kb , --sourcesystem_id
 '' , --hiskey_id
 '' , --struktur_c
null as lid,
null as parent_lid,
null as sortorder
 FROM costage_st_pruef_aggr
 union
 SELECT
    12,
 0,
    statistik_code,
    kurzbezeichnung as ktxt,
    name,
    name,
 statistik_code as astat,
 '',
 statistik_code as akfz,--uniqename
 '' as erdteil,
 '' ,
null::date  as gueltig_von,
null::date as gueltig_bis,
 statistik_code, --sourcesystem_id
 '' , --hiskey_id
 '' ,--egmitgl struktur_c
null as lid,
null as parent_lid,
null as sortorder
    FROM costage_st_laender
    WHERE statistik_code is not null
   union
 SELECT
    8,
 0,
R.statistik_code as bland,
R.statistik_code as ktxt,
R.name as  dtxt,
R.name as ltxt,
R.statistik_code as astat,
 '',
R.statistik_code as bland,
 '',
 '',
null::date  as gueltig_von,
null::date  as gueltig_bis,
R.statistik_code , --sourcesystem_id
 '' , --hiskey_id
 '', --struktur_c
null as lid,
null as parent_lid,
null as sortorder
from costage_st_land_regionen R, costage_st_laender L
where L.st_land_nr=R.st_land_nr
and L.statistik_code='000'
and R.statistik_code is not null
    union
SELECT
   9001,
0,
   '1',--status,
   'Erstein.' as ktxt,
   'Ersteinschreibung' as dtxt,
   'Ersteinschreibung' as ltxt ,
'1',
' ',
'1',--status,
' ',
' ',
null::date  as gueltig_von,
null::date  as gueltig_bis,
'1', --sourcesystem_id
' ' , --hiskey_id
' ' , --struktur_c
null as lid,
null as parent_lid,
null as sortorder
   FROM xdummy
 union
 SELECT
   9001,
0,
   '2',--status,
   'Neuein.' as ktxt,
   'Neueinschreibung' as dtxt,
   'Neueinschreibung' as ltxt ,
'2',
' ',
'2',--status,
' ',
' ',
null::date as gueltig_von,
null::date as gueltig_bis,
'2', --sourcesystem_id
' ' , --hiskey_id
' ' , --struktur_c
null as lid,
null as parent_lid,
null as sortorder
   FROM xdummy
 union
 SELECT
   9001,
0,
   '3',--status,
   'Rückm.' as ktxt,
   'Rückmeldung' as dtxt,
   'Rückmeldung' as ltxt ,
'3',
' ',
'3',--status,
' ',
' ',
null::date  as gueltig_von,
null::date  as gueltig_bis,
'3', --sourcesystem_id
' ' , --hiskey_id
' ' , --struktur_c
null as lid,
null as parent_lid,
null as sortorder
   FROM xdummy
 union
 SELECT
   9001,
0,
   '4',--status,
   'Beurl.' as ktxt,
   'Beurlaubung' as dtxt,
   'Beurlaubung' as ltxt ,
'4',
' ',
'4',--status,
' ',
' ',
null::date  as gueltig_von,
null::date  as gueltig_bis,
'4', --sourcesystem_id
' ' , --hiskey_id
' ' , --struktur_c
null as lid,
null as parent_lid,
null as sortorder
   FROM xdummy
 union
 SELECT
   9001,
0,
   '5',--status,
   'Exmatr.' as ktxt,
   'Exmatrikulation' as dtxt,
   'Exmatrikulation' as ltxt ,
'5',
' ',
'5',--status,
' ',
' ',
null::date  as gueltig_von,
null::date  as gueltig_bis,
'5', --sourcesystem_id
' ' , --hiskey_id
' ' , --struktur_c
null as lid,
null as parent_lid,
null as sortorder
   FROM xdummy
;

]]>
</extraction-sql>
</unload-job>
<unload-job id="k_pvers" extraction-table="" extraction-script="" transfer-unload-file="unl/k_pvers.unl" database="" version="">
<comment>PO-Versionen aus SOS, werden im GANG-Modul gelesen. </comment>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
SELECT pvers,
       aikz,
       ktxt,
       dtxt,
       ltxt,
       sprache,
       refpvers FROM k_pvers
       where refpvers is not null;
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
    SELECT * from tmp_xdummy
where 1=0;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
<unload-job id="k_stg" extraction-table="" extraction-script="" transfer-unload-file="unl/k_stg.unl" database="" version="">
<comment>Fächer aus SOS. </comment>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
SELECT refstg,
       aikz,
       ktxt,
       dtxt,
       ltxt,
       astat,
       fb,
       astfr,
       astgrp,
       zulplaugr,
       kzfaarray,
       sortkz1,
       sprache,
       refstg
FROM k_stg
where refstg is not null
      and (sprache='D' or sprache is null)
       and trim (refstg) !='';
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
SELECT  * --wird oben bei cifx entladen, und in trans_k_stg.sql gefüllt
FROM subject S
where 1=0;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
SELECT apnr,
       'A' as aikz,
       kurz,
       druck,
       lang_1,
       astat,
       struktur_c as fb,
null as astfr,
null as astgrp,
null as zulplaugr,
null as kzfaarray,
null as sortkz1,
null as sprache,
apnr --refstg
FROM  cifx where key=30
    ;
]]>
</extraction-sql>
</unload-job>
<unload-job id="k_stgext" extraction-table="" extraction-script="" transfer-unload-file="unl/k_stgext.unl" database="" version="">
<comment>Externe Studienfächer aus SOS. </comment>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
SELECT stgext,
       aikz,
       ktxt,
       dtxt,
       ltxt,
       astat,
       astfr,
       astgrp FROM k_stgext;
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
    SELECT * from tmp_xdummy
where 1=0;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
<!--
<unload-job id="k_abext" extraction-table="" extraction-script="" transfer-unload-file="unl/k_abext.unl" database="" version="">
<comment>Externe Studienabschlüsse aus SOS. </comment>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
SELECT abext,
       aikz,
       ktxt,
       dtxt,
       ltxt,
       astat,
       mag_laa
FROM k_abext;
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
    SELECT * from tmp_xdummy
where 1=0;

]]>
</extraction-sql>
</unload-job>-->
<unload-job id="k_abstgv" extraction-table="" extraction-script="" transfer-unload-file="unl/k_abstgv.unl" database="" version="">
<comment>Studiengänge aus SOS. </comment>
<extraction-sql sourcesystem="sospos"  database="" version="5">
<![CDATA[
SELECT abstgv,
       aikz,
       ktxt,
       dtxt,
       ltxt,
       pversion,
       frist1,
       frist2,
       frist3,
       frist3_alt,
       frist4,
       astat1,
       astat2,
       astgrp,
       prfgamt,
       vglgrp,
       fb,
       stutyp,
       kzfa,
       immsemkz,
       kzfaarray,
       stort,
       lehreinh,
       stkkurs1,
       stkkurs2,
       stkkurs3,
       prax1fsem,
       prax2fsem,
       abschl,
       stg,
       vert,
       schwp,
       stuart,
       stufrm,
       abstitel,
       abstgvnr,
       null::char(1) as efh,
       null::char(1) as regelstz,
       null::char(1) as email_part,
       null::char(1) as login_part,
       null::char(1) as sem_gueltigbis,
       guthaben_ects
       FROM k_abstgv;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="" version="6,7,8,9,10,11,12,13">
<![CDATA[
SELECT  abstgv,
       aikz,
       ktxt,
       dtxt,
       ltxt,
       pversion,
       frist1,
       frist2,
       frist3,
       frist3_alt,
       frist4,
       astat1,
       astat2,
       astgrp,
       prfgamt,
       vglgrp,
       fb,
       stutyp,
       kzfa,
       immsemkz,
       kzfaarray,
       stort,
       lehreinh,
       stkkurs1,
       stkkurs2,
       stkkurs3,
       prax1fsem,
       prax2fsem,
       abschl,
       stg,
       vert,
       schwp,
       stuart,
       stufrm,
       abstitel,
       abstgvnr,
       efh,
       regelstz,
        email_part,
       login_part,
       sem_gueltigbis,
       guthaben_ects
       FROM k_abstgv;
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
SELECT substring(C.uniquename from 1 for 10) ,-- abstgv,
   'A',--    aikz,
   substring(C.shorttext from 1 for 10),
   substring(C.defaulttext from 1 for 25),
   substring(C.longtext from 1 for 150),
   C.k_examinationversion_id,--    pversion,
   null::char(1),--    frist1,
   null::char(1),--    frist2,
   null::char(1),--    frist3,
   null::char(1),--    frist3_alt,
   null::char(1),--    frist4,
   null::char(1),--        astat1,
   null::char(1),--        astat2,
   null::char(1),--        astgrp,
    null::char(1),--       prfgamt,
   null::char(1),--        vglgrp,
    C.orgunit_id,--       fb,
    C.k_enrollment_id,--   stutyp,
    C.k_subject_indicator_id,--   kzfa,
    null::char(1),--    immsemkz,
    null::char(1),--    kzfaarray,
    C.k_place_of_studies_id,--   stort,
    C.teachingunit_orgunit_id,--  lehreinh,
    null::char(1),--    stkkurs1,
    null::char(1),--    stkkurs2,
    null::char(1),--    stkkurs3,
    null::char(1),--    prax1fsem,
    null::char(1),--    prax2fsem,
    C.degree_id,--   abschl,
     C.subject_id,--  stg,
     C.major_field_of_study_id,--  vert,
     C.course_specialization_id,--  schwp,
    null::char(1),--    stuart,
     C.k_form_of_studies_id,--  stufrm,
     null::char(1),--   abstitel,
     C.id,--  abstgvnr,
     null::char(1),--   efh,
     C.regular_number_of_semesters,--  regelstz,
     null::char(1),--    email_part,
     null::char(1),--   login_part,
     '' || C.to_term_year || T.termnumber, --  sem_gueltigbis
     part_of_studies
       FROM tmp_course_of_study C
       left outer join term_type  T on (C.to_term_type_id=T.id);
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="6,7,8,9,10,11,12,13">
<![CDATA[
SELECT  substring(G.studiengangs_identifikator from 1 for 10) ,--abstgv,
       'A' as aikz,
       '' ,--ktxt,
       substring(G.studiengangs_bezeichnung from 1 for 25) as dtxt,
       substring(G.studiengangs_bezeichnung from 1 for 255) as ltxt,
       val(G.pversion),
       null::integer ,--frist1,
       null::integer ,--frist2,
       null::integer ,--frist3,
       null::integer ,--frist3_alt,
       null::integer ,--frist4,
       null::integer,--astat1,
       null::integer,--astat2,
       null::integer,--astgrp,
       null::integer, --prfgamt,
       null::integer,--vglgrp,
       K.struktur_c as fb,
       null::integer,--stutyp,
       G.fachkennzeichen as kzfa,
       null::integer,--immsemkz,
       null::integer,--kzfaarray,
       null::integer,--stort,
       '', -- lehreinh,
       null::integer,--stkkurs1,
       null::integer,--stkkurs2,
       null::integer,--stkkurs3,
       null::integer,--prax1fsem,
       null::integer,--prax2fsem,
       abschluss,
       stg,
       null::integer,--vert,
       null::integer,--schwp,
       null::integer,--stuart,
       null::integer,--stufrm,
       null::integer,--abstitel,
       st_studiengang_nr as abstgvnr,
       null::integer,--efh,
       G.rsz, --regelstz,
       null::integer,-- email_part,
       null::integer,--login_part,
       null::date as sem_gueltigbis,
       null::integer -- ects
       FROM costage_st_studiengaenge G, cifx K
       where K.key=30
       and K.apnr=G.stg
       ;
]]>
</extraction-sql>
</unload-job>

<!--
<unload-job id="sos_stat" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_stat.unl" >
<comment><comment>Statistiktabelle zur Lieferung ans STALA</comment></comment>

<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="6,7,8,9,10,11,12,13">
<![CDATA[

SELECT ef001,
       ef002,
       ef003,
       ef004,
       ef005,
       superx_sos.mtknr_ldsg,
       ef007,
       ef008a,
       ef008b,
       ef009,
       ef010a,
       ef010b,
       ef011a,
       ef011b,
       ef012,
       ef013,
       ef014,
       ef015,
       ef016,
       ef017,
       ef018,
       ef019,
       ef020,
       ef021,
       ef022,
       ef023,
       ef024,
       ef025,
       ef026,
       ef027,
       ef028,
       ef029,
       ef030,
       ef031,
       ef032,
       ef033,
       ef034,
       ef035,
       ef036,
       ef037,
       ef038,
       ef039,
       ef040a,
       ef040b,
       ef040c,
       ef041,
       ef042,
       ef043,
       ef044,
       ef045,
       ef046,
       ef047,
       ef048,
       ef049,
       ef050,
       ef051,
       ef052,
       ef053,
       ef054,
       ef055a,
       ef055b,
       ef055c,
       ef056,
       ef057,
       ef058,
       ef059,
       ef060,
       ef061,
       ef062,
       ef063,
       ef064,
       ef065,
       ef066,
       ef067,
       ef068,
       ef069,
       ef070,
       ef071,
       ef072,
       ef073,
       ef074,
       ef075,
       ef076,
       ef077,
       ef078,
       ef079,
       ef080,
       ef081,
       ef082,
       ef083,
       ef084,
       ef085,
       ef086,
       ef087,
       ef088,
       ef089,
       ef090,
       ef091,
       ef092,
       ef093,
       ef094,
       ef095,
       ef096,
       ef097,
       ef098,
       ef099,
       ef100,
       ef101,
       ef102,
       ef103,
       ef104,
       ef105,
       ef106,
       ef107,
       ef108,
       ef109,
       ef110,
       ef111u1,
       ef111u2,
       ef112,
       ef113,
       ef114,
       ef115,
       ef116,
       ef117,
       ef118,
       ef119,
       ef120,
       ef121,
       ef122,
       ef123,
       ef124,
       ef125,
       ef126,
       ef127,
       ef128,
       ef129,
       ef130,
       ef131a,
       ef131b,
       ef132,
       ef133,
       ef134,
       ef135,
       ef136,
       ef137,
       ef138,
       ef139,
       ef140,
       ef141,
       ef142,
       ef143,
       ef144,
       ef145,
       ef146,
       ef147a,
       ef147b,
       ef148,
       ef149,
       ef150,
       ef151,
       ef152
FROM stat_neu , superx_sos
WHERE stat_neu.ef006 = superx_sos.mtknr
;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="6,7,8,9,10,11,12,13">
<![CDATA[

SELECT ef001,
       ef002,
       ef003,
       ef004,
       ef005,
       superx_sos.mtknr_ldsg,
       ef007,
       ef008a,
       ef008b,
       ef009,
       ef010a,
       ef010b,
       ef011a,
       ef011b,
       ef012,
       ef013,
       ef014,
       ef015,
       ef016,
       ef017,
       ef018,
       ef019,
       ef020,
       ef021,
       ef022,
       ef023,
       ef024,
       ef025,
       ef026,
       ef027,
       ef028,
       ef029,
       ef030,
       ef031,
       ef032,
       ef033,
       ef034,
       ef035,
       ef036,
       ef037,
       ef038,
       ef039,
       ef040a,
       ef040b,
       ef040c,
       ef041,
       ef042,
       ef043,
       ef044,
       ef045,
       ef046,
       ef047,
       ef048,
       ef049,
       ef050,
       ef051,
       ef052,
       ef053,
       ef054,
       ef055a,
       ef055b,
       ef055c,
       ef056,
       ef057,
       ef058,
       ef059,
       ef060,
       ef061,
       ef062,
       ef063,
       ef064,
       ef065,
       ef066,
       ef067,
       ef068,
       ef069,
       ef070,
       ef071,
       ef072,
       ef073,
       ef074,
       ef075,
       ef076,
       ef077,
       ef078,
       ef079,
       ef080,
       ef081,
       ef082,
       ef083,
       ef084,
       ef085,
       ef086,
       ef087,
       ef088,
       ef089,
       ef090,
       ef091,
       ef092,
       ef093,
       ef094,
       ef095,
       ef096,
       ef097,
       ef098,
       ef099,
       ef100,
       ef101,
       ef102,
       ef103,
       ef104,
       ef105,
       ef106,
       ef107,
       ef108,
       ef109,
       ef110,
       ef111u1,
       ef111u2,
       ef112,
       ef113,
       ef114,
       ef115,
       ef116,
       ef117,
       ef118,
       ef119,
       ef120,
       ef121,
       ef122,
       ef123,
       ef124,
       ef125,
       ef126,
       ef127,
       ef128,
       ef129,
       ef130,
       ef131a,
       ef131b,
       ef132,
       ef133,
       ef134,
       ef135,
       ef136,
       ef137,
       ef138,
       ef139,
       ef140,
       ef141,
       ef142,
       ef143,
       ef144,
       ef145,
       ef146,
       ef147a,
       ef147b,
       ef148,
       ef149,
       ef150,
       ef151,
       ef152
FROM stat_neu , superx_sos
WHERE to_number(stat_neu.ef006,'999999999') = superx_sos.mtknr
;
]]>
</extraction-sql>
</unload-job>-->
<unload-job id="sos_pord" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_pord.unl" >
<comment><comment>Pruefungsordnungsdaten</comment></comment>

<extraction-sql sourcesystem="sospos"  database="" version="6,7,8,9,10,11,12,13">
<![CDATA[

SELECT abschl,
       stg,
       vert,
       schwp,
       kzfa,
       pversion,
       pnr,
       pabschn,
       pteil,
       pdum,
       pausw1,
       pausw2,
       pausw3,
       pktxt,
       pdtxt,
       null::char(1), --wg. Umbrüchen erstmal auskommentiert : pltxt1,
       null::char(1), --wg. Umbrüchen erstmal auskommentiert : pltxt2,
       null::char(1), --wg. Umbrüchen erstmal auskommentiert : pltxt3,
       null::char(1), --wg. Umbrüchen erstmal auskommentiert : pltxt4,
       geldat,
       ppflicht,
       pform,
       part,
       pdauer,
       partngb,
       pfsem,
       psws,
       pminsem,
       phoesem,
       pmaxvbe,
       pmaxver,
       pzuver,
       pmaxrueck,
       pwfrist,
       pfrist1,
       pfrist2,
       pfristr,
       pnhstat3,
       paenddat,
       pnrvl1,
       pnrvl2,
       pnrvl3,
       pnrvl4,
       pnrvl5,
       pvken1,
       pvken2,
       pvken3,
       pvken4,
       pvken5,
       psort1,
       psort2,
       psort3,
       pnra,
       petgp,
       pmerg,
       pbedv,
       pbedg,
       pbedw,
       vordipl,
       pfnrex,
       pbetrag,
       panmkenn,
       freivers,
       pbetragz1,
       pbetragz2,
       pordnr,
       bonus,
       malus,
       bogverb,
       bogempf,
       mogverb,
       mogempf,
       pnotpkt,
       fb,
       nacharb,
       meldekz,
       sivabschl,
       sivstg,
       sivvert,
       sivschwp,
       sivkzfa,
       sivpversion,
       zmadauer,
       null::char(1), --wg. Umbrüchen erstmal auskommentiert :beleg,
       null::char(1), --wg. Umbrüchen erstmal auskommentiert :diplkz,
       bonus_bei_nb,
       steuer_wvl,
       bendauer,
       disdauer,
       diszmadauer,
       instnr,
       beschkat,
       labgewicht,
       standbearb,
       modulturnus,
       praesenzzeit,
       selbstzeit,
       workload,
       modulart,
       modulcode,
       moduldauer,
       zmamoduldauer,
       verart,
       max_teilnehmer,
       null::char(1) --schriftlich
FROM pord;

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
   SELECT
null::char(1),--C.degree_id,--abschl,
null::char(1),--C.subject_id,--stg,
null::char(1),--C.major_field_of_study_id, --vert,
null::char(1),--C.course_specialization_id,--schwp,
null::char(1),--C.k_subject_indicator_id,--kzfa,
null::char(1),--C.k_examinationversion_id,--pversion,
 U.official_statistics,  --pnr
 null::char(1),--pabschn,
 null::char(1),--pteil,
 null::char(1),--pdum,
 null::char(1),--pausw1,
 null::char(1),--pausw2,
 null::char(1),--pausw3,
 U.elementnr,--pktxt,
 substring(U.defaulttext from 1 for 255),--pdtxt,
 null::char(1), --wg. Umbrüchen erstmal auskommentiert : pltxt1,
 null::char(1), --wg. Umbrüchen erstmal auskommentiert : pltxt2,
 null::char(1), --wg. Umbrüchen erstmal auskommentiert : pltxt3,
 null::char(1), --wg. Umbrüchen erstmal auskommentiert : pltxt4,
 null::char(1),--geldat,
 null::char(1),--ppflicht,
 E.k_examform_id,--pform,
 E.k_examination_type_id,--part,
 null::char(1),--pdauer,
 null::char(1),--partngb,
R.recommended_semester::integer,--pfsem,
 null::char(1),--psws,
 null::char(1),--pminsem,
 null::char(1),--phoesem,
 null::char(1),--pmaxvbe,
 null::char(1),--pmaxver,
 null::char(1),--pzuver,
 null::char(1),--pmaxrueck,
 null::char(1),--pwfrist,
 null::char(1),--pfrist1,
 null::char(1),--pfrist2,
 null::char(1),--pfristr,
 null::char(1),--pnhstat3,
 null::char(1),--paenddat,
 null::char(1),--pnrvl1,
 null::char(1),--pnrvl2,
 null::char(1),--pnrvl3,
 null::char(1),--pnrvl4,
 null::char(1),--pnrvl5,
 null::char(1),--pvken1,
 null::char(1),--pvken2,
 null::char(1),--pvken3,
 null::char(1),--pvken4,
 null::char(1),--pvken5,
 null::char(1),--psort1,
 null::char(1),--psort2,
 null::char(1),--psort3,
 null::char(1),--pnra,
 null::char(1),--petgp,
 null::char(1),--pmerg,
 null::char(1),--pbedv,
 null::char(1),--pbedg,
 null::char(1),--pbedw,
 null::char(1),--vordipl,
 null::char(1),--pfnrex,
 null::char(1),--pbetrag,
 null::char(1),--panmkenn,
 null::char(1),--freivers,
 null::char(1),--pbetragz1,
 null::char(1),--pbetragz2,
 U.id,--pordnr,
R.bonus,--bonus,
 null::char(1),--malus,
 null::char(1),--bogverb,
 null::char(1),--bogempf,
 null::char(1),--mogverb,
 null::char(1),--mogempf,
 null::char(1),--pnotpkt,
 null::char(1),--fb,
 null::char(1),--nacharb,
  substring('' || U.official_statistics from 1 for 1),--meldekz,
 null::char(1),--sivabschl,
 null::char(1),--sivstg,
 null::char(1),--sivvert,
 null::char(1),--sivschwp,
 null::char(1),--sivkzfa,
 null::char(1),--sivpversion,
 null::char(1),--zmadauer,
       null::char(1), --wg. Umbrüchen erstmal auskommentiert :beleg,
       null::char(1), --wg. Umbrüchen erstmal auskommentiert :diplkz,
 null::char(1),--bonus_bei_nb,
 null::char(1),--steuer_wvl,
 null::char(1),--bendauer,
 null::char(1),--disdauer,
 null::char(1),--diszmadauer,
 null::char(1),--instnr,
 null::char(1),--beschkat,
 null::char(1),--labgewicht,
 null::char(1),--standbearb,
 null::char(1),--modulturnus,
 null::char(1),--praesenzzeit,
 null::char(1),--selbstzeit,
 null::char(1),--workload,
 U.k_elementtype_id,--modulart,
 null::char(1),--modulcode,
 null::char(1),--moduldauer,
 null::char(1),--zmamoduldauer,
 null::char(1),--verart,
 null::char(1), --max_teilnehmer
 E.exam_written
 FROM
   unitrelation R, unit U left outer join examination E
   on (E.unit_id=U.id)
   where R.id=U.default_unitrelation_id
    ;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[

select * from k_stg where 1=0;

]]>
</extraction-sql>
</unload-job>
<unload-job id="sos_dipl" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_dipl.unl" >
<extraction-sql sourcesystem="sospos"  database="" version="6,7,8,9,10,11,12,13">
<![CDATA[

SELECT superx_sos.mtknr_ldsg,
       abschl,
       stg,
       vert,
       schwp,
       kzfa,
       pnr,
       psem,
       pversuch,
       prueck,
       pversion,
       antrdat,
       meldat,
       beabeg,
       dauer,
       verlkz,
       abdat,
       tabdat,
       pnoteges,
       zeudat,
       labnr,
       case when '$DIPL_THEMA'='true' then substring(thema from 1 for 255) else null::char(10) end as thema,
       case when '$PRUEFER_NAME'='true' then betreu1 else null::char(10) end as betreu1,
       case when '$PRUEFER_NAME'='true' then betreu2 else null::char(10) end as betreu2
FROM dipl, superx_sos
WHERE dipl.mtknr = superx_sos.mtknr
AND dipl.psem >= $start_pruef_sem
;

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
    SELECT L.mtknr_ldsg,
null::char(1),--abschl,
null::char(1),--stg,
null::char(1),--vert,
null::char(1),--schwp,
null::char(1),--kzfa,
null::char(1),--pnr,
'' || L.term_year || L.termnumber,--psem,
null::char(1),--pversuch,
null::char(1),--prueck,
null::char(1),--pversion,
W.date_of_application,--antrdat,
null::char(1),--meldat,
null::char(1),--beabeg,
null::char(1),--dauer,
null::char(1),--verlkz,
null::char(1),--abdat,
null::char(1),--tabdat,
null::char(1),--pnoteges,
null::char(1),--zeudat,
L.examplan_id, --labnr
case when '$DIPL_THEMA'='true' then substring(W.title from 1 for 255) else null::char(10) end as thema,
null::char(1), --betreu1
null::char(1) --betreu2
FROM
    tmp_lab L,
    exam_written W
    where W.examplan_id=L.examplan_id
   AND (to_number('' || L.term_year || L.termnumber,'99999') ) >= $start_pruef_sem
;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
<unload-job id="sos_minder" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_minder.unl" >
<extraction-sql sourcesystem="sospos"  database="" version="6,7,8,9,10,11,12,13">
<![CDATA[

SELECT superx_sos.mtknr_ldsg,
       art,
       grund,
       vonsem,
       bissem,
       bonus,
       betrag,
 --      bemerkung,
       gewicht,
       hskfzkz,
       hskfz,
       hsart,
       lfdnr,
       bewnr,
--       herkunft,
       antr_genehmigt,
       antr_datum
FROM minder, superx_sos
WHERE minder.mtknr = superx_sos.mtknr
AND (minder.vonsem >= $start_stud_sem  or minder.vonsem is null)
;

]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
    SELECT * from tmp_xdummy
where 1=0;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
<unload-job id="sos_stud_d" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_stud_d.unl" >
<extraction-sql sourcesystem="sospos"  database="" version="6,7,8,9,10,11,12,13">
<![CDATA[

select
 distinct S.mtknr_ldsg,
 R.identnr,
 I.name,
 I.vorname,
 T.tel,
 T.artkz,
 T.anschrkz,
 O.res13,
 null::integer -- person_id
FROM identroll R, sos O, superx_sos S, ident I left outer join telefon T
on (T.identnr=I.identnr)
WHERE R.verbindung_integer = S.mtknr
and O.mtknr=S.mtknr
and I.identnr=R.identnr
and R.rolle='S'
and '$STUD_IDENT'='true';



]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
    <![CDATA[
-- detaillierte Personendaten
select
S.mtknr_ldsg,
U.id,--identnr (student id)
P.surname, --name
COALESCE(P.firstname,P.surname), --vorname,
'',--tel,
'',--artkz,
'',--anschrkz,
'', -- O.res13
S.person_id --(person_id
FROM student U, superx_sos S, person P, term_type TT
where
U.term_year * 10 + TT.termnumber >= $start_stud_sem
and P.id=U.person_id
and U.id=S.id
and S.person_id=P.id
and U.term_type_id = TT.id
and '$STUD_IDENT'='true'
UNION

-- einfache Personendaten
-- Beispiel 11200321^20^^Wern^^^^^
 select
S.mtknr_ldsg,
U.id, --identnr (student id)
'', --name
SUBSTRING(COALESCE(P.firstname,P.surname) FROM 1 FOR 4), --vorname,
'',--tel,
'',--artkz,
'',--anschrkz,
'', -- O.res13
S.person_id --(person_id
FROM student U, superx_sos S, person P, term_type TT
where
U.term_year * 10 + TT.termnumber >= $start_stud_sem
and P.id=U.person_id
and U.id=S.id
and S.person_id=P.id
and U.term_type_id = TT.id
and '$STUD_IDENT'='false'
;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select
 distinct S.mtknr_ldsg,
 S.mtknr_ldsg,
 O.familienname,
 O.vorname,
 '',--T.tel,
 '',--T.artkz,
 '',--T.anschrkz,
 '',--O.res13,
 O.nr -- person_id
FROM costage_st_personen O, superx_sos S
where
val(O.matrikelnummer)=S.mtknr
and '$STUD_IDENT'='true';
]]>
</extraction-sql>
</unload-job>
<unload-job id="sos_pords" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_pords.unl" >
<extraction-sql sourcesystem="sospos"  database="" version="6,7,8,9,10,11,12,13">
<![CDATA[

SELECT pordnr,
       pktxt,
       pdtxt,
       pltxt1,
       pordsnr,
       sprache
FROM pords


]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
    SELECT * from tmp_xdummy
where 1=0;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
<unload-job id="sos_porg" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_porg.unl" >
<extraction-sql sourcesystem="sospos"  database="" version="6,7,8,9,10,11,12,13">
<![CDATA[

SELECT porgnr,
pordnr,
abschl,
       stg,
       vert,
       schwp,
       kzfa,
       pversion,
       angeboten,
pdauer,
ppruefer,
zweitpruefer,
psem,
pnr
from  porg


]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
    SELECT * from tmp_xdummy
where 1=0;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
<unload-job id="sos_labzuord" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_labzuord.unl" >
<extraction-sql sourcesystem="sospos"  database="INFORMIX" version="6,7,8,9,10,11,12,13">
<![CDATA[
select
superx_sos.mtknr_ldsg,
labzuord.labnr,
labzuord.artzuordnung,
labzuord.pordnrzu,
labzuord.labnrzu,
labzuord.bonus,
labzuord.malus
FROM labzuord,lab,
 superx_sos
WHERE lab.mtknr = superx_sos.mtknr
and labzuord.mtknr = superx_sos.mtknr
and labzuord.labnr=lab.labnr
AND (lab.pstatus is null or lab.pstatus != 'SO')
$LAB_FILTER
AND lab.prueck = 0
AND lab.psem >= $start_pruef_sem
and
((lab.pnr in ($POS_PNR) or "0"="$POS_PNR")
or lab.pnr in
 (
select distinct pnr from tmp_hskonst
)
)


]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="POSTGRES" version="6,7,8,9,10,11,12,13">
<![CDATA[
select
superx_sos.mtknr_ldsg,
labzuord.labnr,
labzuord.artzuordnung,
labzuord.pordnrzu,
labzuord.labnrzu,
labzuord.bonus,
labzuord.malus
FROM labzuord,lab,
 superx_sos
WHERE lab.mtknr = superx_sos.mtknr
and labzuord.mtknr = superx_sos.mtknr
and labzuord.labnr=lab.labnr
AND (lab.pstatus is null or lab.pstatus != 'SO')
$LAB_FILTER
AND lab.prueck = 0
AND lab.psem >= $start_pruef_sem
and
((lab.pnr in ($POS_PNR) or '"0"'='"$POS_PNR"')
or lab.pnr in
 (
select distinct pnr from tmp_hskonst
)
)


]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
    select
L.mtknr_ldsg,
L.examplan_id as labnr,
K.uniquename as artzuordnung,
null::integer as  pordnrzu,
R.parent_examplan_id as labnrzu,
R.bonus,
R.malus
 FROM
tmp_lab L, examrelation R, k_unitrelationtype K
WHERE
L.examplan_id = R.child_examplan_id
and K.id=R.k_unitrelationtype_id
AND (to_number('' || L.term_year || L.termnumber,'99999') ) >= $start_pruef_sem



]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
<unload-job id="sos_pnrzuord" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_pnrzuord.unl" >
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
select
       lfdnr,
       artzuord,
       pordnr,
       pordnrzu,
       bonus,
       malus,
       bez,
       bonus_bei_nb,
       ppflicht,
       freivsem,
       semester
FROM pnrzuord


]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
    select
null::smallint as lfdnr,--R.sortorder
K.uniquename as artzuord,
R.child_unit_id as pordnr,
R.parent_unit_id as pordnrzu,
R.bonus,
R.malus,
null::char(1) as bez,
null::char(1) as bonus_bei_nb,
null::char(1) as ppflicht,
R.firsttrial_semester as freivsem,
R.recommended_semester::integer as semester
FROM unitrelation R, k_unitrelationtype K
where K.id=R.k_unitrelationtype_id

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>

<unload-job id="sos_gewichtungsvariante" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_gewichtungsvariante.unl" >
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
select 'nix' FROM pnrzuord where 1=0
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
   SELECT id,
       defaulttext
FROM student_weighting_variant;

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>

<unload-job id="sos_gewichtungregel_filter" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_gewichtungregel_filter.unl" >
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
select 'nix' FROM pnrzuord where 1=0
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
  SELECT k_student_weighting_filter_type_id,
       filter_value,
       student_weighting_rule_id FROM student_weighting_filter;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>

<unload-job id="sos_gewichtungregel" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_gewichtungregel.unl" >
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
select 'nix' FROM pnrzuord where 1=0
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
 -- die _list Felder bleiben leer, werden später im ETL gefüllt
  SELECT id,
       shorttext,
       student_weighting_variant_id,
       sortorder,
       weight,
       k_student_weighting_weight_usage_type_id,
       k_student_weighting_action_type_id,
       weighting_ident_operator_id,
       ''::char(1) as weighting_ident_list,
       new_weighting_ident,
       degree_counter_operator_id,
         ''::char(1) as degree_counter_list,
       new_degree_counter,
       subject_counter_operator_id,
         ''::char(1) as  subject_counter_list,
       new_subject_counter,
       subject_count_operator_id,
         ''::char(1) as subject_count_list,
       degree_count_operator_id,
         ''::char(1) as degree_count_list,
       ects_operator_id,
         ''::char(1) as ects_list,
       newects,
       teaching_unit_operator_id,
         ''::char(1) as teachning_unit_list,
       ''::char(1) as new_teachning_unit,
       department_operator_id,
         ''::char(1) as department_list,
       new_department,
       subject_operator_id,
         ''::char(1) as subject_list,
       new_subject,
       degree_operator_id,
         ''::char(1) as  degree_list,
       new_degree,
       subject_indicator_operator_id,
         ''::char(1) as subject_indicator_operator_list,
       new_subject_indicator,
       type_of_study_operator_id,
         ''::char(1) as type_of_study_operator_list,
       new_type_of_study,
       form_of_study_operator_id,
         ''::char(1) as form_of_study_list,
       new_form_of_study
FROM student_weighting_rule

]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
 <unload-job id="finalize1" extraction-table="" extraction-script="" transfer-unload-file=""  database="" version="">
<comment>Beendigung</comment>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
drop table superx_sos;
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
drop table superx_sos;
drop table tmp_xdummy;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
drop table superx_sos;
drop table tmp_xdummy;
]]>
</extraction-sql>
</unload-job>
<unload-job id="finalize2" extraction-table="" extraction-script="" transfer-unload-file=""  database="" version="">
<comment>Beendigung</comment>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
drop table tmp_hskonst;
]]>
</extraction-sql>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[


drop table tmp_course_of_study;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
drop table tmp_hskonst;
]]>
</extraction-sql>
</unload-job>

<unload-job id="personattribute" extraction-table="" extraction-script="" transfer-unload-file="unl/personattribute.unl" >
<comment>Personenattribute</comment>
<extraction-sql sourcesystem="hisinone"  database="" version="">
select
P.id,
P.person_id,
S.registrationnumber,
10 as systeminfo_id,
P.personattributetype_id,
coalesce(P.attributevalue, (select attributevalue from personattribute_value_list pav where pav.id=P.personattribute_value_list_id) ) attributevalue,
P.valid_from,
P.valid_to,
'' ,--semester_von
'' --semester_bis
from personattribute P, student S where S.person_id= P.person_id and P.personattributetype_id in ($PERSONATTRIBUTE_IDS) order by person_id;
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
<unload-job id="personattributetype" extraction-table="" extraction-script="" transfer-unload-file="unl/personattributetype.unl" >
<comment>Typ der Personattributen</comment>
<extraction-sql sourcesystem="hisinone"  database="" version="">
select
id,
fieldname
from personattributetype where '$PERSONATTRIBUTE_IDS' != '0';
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
<unload-job id="personattribute_value_list" extraction-table="" extraction-script="" transfer-unload-file="unl/personattribute_value_list.unl" >
<comment>Einzelne Ausprägungen der Personenattribute</comment>
<extraction-sql sourcesystem="hisinone"  database="" version="">
select
personattributetype_id,
attributevalue,
shorttext,
defaulttext,
longtext
from personattribute_value_list where '$PERSONATTRIBUTE_IDS' != '0';
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>

<unload-job id="stu_update_prot" extraction-table="" extraction-script="" transfer-unload-file="unl/stu_update_prot.unl" >
<comment>Letzter entladener Protokollsatz (STU)</comment>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
SELECT 7::integer,'stu'::char(40), cast(extract(epoch from (select max(updated_at)))as integer), max(updated_at) from student;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
<unload-job id="exa_update_prot" extraction-table="" extraction-script="" transfer-unload-file="unl/exa_update_prot.unl" >
<comment>Letzter entladener Protokollsatz (EXA)</comment>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
SELECT 7::integer,'exa'::char(40), cast(extract(epoch from (select max(updated_at)))as integer), max(updated_at) from examplan;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>


<unload-job id="sos_accredited_ects" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_accredited_ects.unl" >
<comment>Summierte ECTS-Punkte</comment>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
select
TL.mtknr_ldsg,
AE.examplan_id,
AE.abroad_ects,
AE.professional_experience_ects,
AE.total_accredited_ects,
'' || TL.term_year || TL.termnumber, --psem
extract(day from TL.date_of_work)::varchar(2) || '.' || extract(month from TL.date_of_work)::varchar(2) || '.' || extract(year from TL.date_of_work)::varchar(4) --Prüfungsdatum
from accredited_ects AE, tmp_lab TL where AE.examplan_id = TL.examplan_id;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
select
*,
null::integer AS sem_der_pruefung, --psem
null::integer as d_abg_pruefung --Prüfungsdatum
from k_stg where 1=0;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>

<unload-job id="finalize_sos_pruefungen" extraction-table="" extraction-script="" transfer-unload-file="" >
<comment> </comment>
<extraction-sql sourcesystem="hisinone"  database="" version="">

drop table IF EXISTS  tmp_lab;
</extraction-sql>
</unload-job>



<unload-job id="sos_pord_orgeinheit" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_pord_orgeinheit.unl" >
<comment></comment>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
SELECT U.unit_id as pordnr,
       6 as sourcesystem,
       O.id as institution,
       U.valid_from,
       U.valid_to,
       R.uniquename as art,
       O.sortorder
FROM hisinone.orgunit O, hisinone.unit_orgunit U left outer join hisinone.k_unit_orgunit_relation R
on (R.id=U.k_unit_orgunit_relation_id)
where O.lid=U.orgunit_lid
 ;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
<unload-job id="sos_pordnr_pnr" extraction-table="" extraction-script="" transfer-unload-file="unl/sos_pordnr_pnr.unl" >
<comment></comment>
<extraction-sql sourcesystem="hisinone"  database="" version="">
<![CDATA[
SELECT U.unit_id as pordnr,
       6 as sourcesystem,
       O.id as institution,
       U.valid_from,
       U.valid_to,
       R.uniquename as art,
       O.sortorder
FROM hisinone.orgunit O, hisinone.unit_orgunit U left outer join hisinone.k_unit_orgunit_relation R
on (R.id=U.k_unit_orgunit_relation_id)
where O.lid=U.orgunit_lid
 ;
]]>
</extraction-sql>
<extraction-sql sourcesystem="sospos"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
<extraction-sql sourcesystem="co"  database="" version="">
<![CDATA[
select * from k_stg where 1=0;
]]>
</extraction-sql>
</unload-job>
</superx-unload>