Ignore:
Timestamp:
22/12/06 06:14:28 (13 years ago)
Author:
ko23
Message:

Establish MDIP xqueries

File:
1 edited

Legend:

Unmodified
Added
Removed
  • TI07-MOLES/trunk/MDIP/XQueries/MDIP2MOLES.xquery

    r1886 r1917  
     1(: Version for one DIF per dgMetadata instance :) 
     2(: Note algoritm for creating non-pre-existing organisations :) 
     3 (: dgPersons are not created as one can't tell automatically which are people and which are orgs, and orgs are simpler :)   
     4 
    15declare default element namespace 'http://ndg.nerc.ac.uk/moles'; 
    2  
    3 for $DE in collection('/db/ndg_B_metadata')/dgMetadata/dgMetadataRecord[exists(dgDataEntity)] 
     6declare namespace xsi='http://www.w3.org/2001/XMLSchema-instance';  
     7declare namespace mdip='http://www.dassh.ac.uk'; 
     8declare namespace gco='http://www.isotc211.org/2005/gco'; 
     9declare namespace f='http://ndg.nerc.ac.uk/moles/localfunctions'; 
     10declare variable $input_collection as xs:string {'TargetCollection'}; 
     11declare variable $unknown_vocab_id as xs:string {'http://vocab.ndg.nerc.ac.uk/null'}; 
     12declare variable $ndg_data_provider_vocab as xs:string {'http://vocab.ndg.nerc.ac.uk/N010'}; 
     13 
     14declare variable $ISO_639-2_ns as xs:string{'UKGemini_Langauge_Categories'}; 
     15declare variable $ISO_3166_ns as xs:string{'UKGemini_Land_Area_Categories'}; 
     16declare variable $iso_topic_list as xs:string {'http://www.isotc211.org/2005/resources/Codelist/gmxCodelists.xml#MD_TopicCategoryCode'}; 
     17 
     18declare variable $input_repository as xs:string {'Input_Repository_Code'}; 
     19declare variable $input_repository_local as xs:string {'Input_Repository_LocalID'}; 
     20declare variable $input_DatasetIdentifier as xs:string {'Input_DatasetIdentifier'}; 
     21 
     22declare variable $gcmd_science_valids as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/gcmd_parameters.html'}; 
     23declare variable $gcmd_project_valids as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/projects.html'}; 
     24declare variable $gcmd_location_valids as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/locations.html'}; 
     25declare variable $gcmd_paleotemporal_valids as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/paleotemporal.html'}; 
     26declare variable $gcmd_iso_topic_list as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/iso_topic_list.html'}; 
     27declare variable $cf_standard_names as xs:string {'http://www.cgd.ucar.edu/cms/eaton/cf-metadata/standard_name.html'}; 
     28 
     29 
     30declare function f:fix-coord($e as element()) as element()  
     31(: Parse a non-decimal co-ordinate element,  parse to see if it's possible to convert to  
     32    a decimal co-ordinate, and do so, else return the rubbish provided :) 
     33{ 
     34if ($e castable as xs:decimal) then   
     35        $e 
     36else 
     37        let $value := substring(data($e), 1, string-length($e)-1) 
     38        let $point := lower-case(data($e)) 
     39        return 
     40        if ($value  castable as xs:decimal) then   
     41                if (ends-with($point, 'n')) then 
     42                        element {name($e)} {$value}  
     43                else if (ends-with($point, 's')) then 
     44                        element {name($e)} {concat('-', $value)}  
     45                else if (ends-with($point, 'e')) then 
     46                        element {name($e)} {$value}  
     47                else if (ends-with($point, 'w')) then 
     48                        element {name($e)} {concat('-', $value)}  
     49                else $e 
     50        else  $e 
     51} ; 
     52 
     53for $MDIP in collection($input_collection)/mdip:Metadata[mdip:DatasetIdentifier=$input_DatasetIdentifier] 
    454return 
    5 element Metadata { 
    6         element Title {}, 
    7         element Language{}, 
    8         element Abstract {}, 
    9         for $isoTopic in $DE/dgStructuredKeyword[dgValidTermID/ParentListID='']  
    10         return element TopicCategory {}, 
    11         for $subject in $DE/dgDataEntity/dgParameterSummary/dgStdParameterMeasured[dgValidTermID/ParentListID=''] 
    12         return element Subject {}, 
    13         element Date { 
    14                 element DatasetStartDate {}, 
    15                 element DatasetEndDate {} 
    16         } 
    17 } 
     55element dgMetadata { 
     56        element dgMetadataRecord { 
     57                element dgMetadataID { 
     58                        element schemeIdentifier {'NDG-B0'}, 
     59                        element repositoryIdentifier {$input_repository}, 
     60                        element localIdentifier {string($MDIP/mdip:DatasetIdentifier)} 
     61                }, 
     62                element dgMetadataDescription { 
     63                        element metadataDescriptionID { 
     64                                element schemeIdentifier {'NDG-B0'}, 
     65                                element repositoryIdentifier {$input_repository}, 
     66                                element localIdentifier {concat('generated_desc-', string($MDIP/mdip:DatasetIdentifier))} 
     67                        }, 
     68                        element metadataDescriptionLastUpdated {current-date()}                 , 
     69                        element abstract { 
     70                                element abstractText {string($MDIP/mdip:Summary)} 
     71                        } 
     72                }, 
     73                element name {string($MDIP/mdip:Entry_Title)}, 
     74                element abbreviation {string($MDIP/mdip:Entry_Title)}, 
     75                element dgDataEntity { 
     76                        element dgDataSetType {''}, 
     77                        element dgDataSummary { 
     78                                for $parameter in $MDIP/mdip:Parameters 
     79                                return 
     80                                        element dgParameterSummary { 
     81                                                element dgParameterValue { 
     82                                                        element dgValueDataParameter { 
     83                                                                element Value {''}, 
     84                                                                element dgStandardUnit { 
     85                                                                        element dgValidTerm {'dummy'}, 
     86                                                                        element dgValidTermID { 
     87                                                                                element ParentListID {$unknown_vocab_id}, 
     88                                                                                element TermID {escape-uri('dummy unit', true())} 
     89                                                                        } 
     90                                                                } 
     91                                                        } 
     92                                                }, 
     93                                                element dgStdParameterMeasured { 
     94                                                        element dgValidTerm { 
     95                                                                concat (string($parameter/mdip:Category), ' > ', string($parameter/mdip:Topic), ' > ', string($parameter/mdip:Term)), 
     96                                                                if (exists($parameter/mdip:Variable)) then 
     97                                                                        concat(' > ', string($parameter/mdip:Variable)) 
     98                                                                else (), 
     99                                                                if (exists($parameter/mdip:Detailed_Variable)) then 
     100                                                                        concat(' > ', string($parameter/mdip:Detailed_Variable)) 
     101                                                                else () 
     102                                                        }, 
     103                                                                element dgValidTermID { 
     104                                                                        element ParentListID {$gcmd_science_valids}, 
     105                                                                        element TermID {escape-uri($parameter/mdip:Category, true())} 
     106                                                                } 
     107                                                }, 
     108                                                element ParameterName { 
     109                                                        concat (string($parameter/mdip:Category), ' > ', string($parameter/mdip:Topic), ' > ', string($parameter/mdip:Term)), 
     110                                                        if (exists($parameter/mdip:Variable)) then 
     111                                                                concat(' > ', string($parameter/mdip:Variable)) 
     112                                                        else (), 
     113                                                        if (exists($parameter/mdip:Detailed_Variable)) then 
     114                                                                concat(' > ', string($parameter/mdip:Detailed_Variable)) 
     115                                                        else () 
     116                                                }, 
     117                                                element ParameterAbbreviation { 
     118                                                        concat (string($parameter/mdip:Category), ' > ', string($parameter/mdip:Topic), ' > ', string($parameter/mdip:Term)), 
     119                                                        if (exists($parameter/mdip:Variable)) then 
     120                                                                concat(' > ', string($parameter/mdip:Variable)) 
     121                                                        else (), 
     122                                                        if (exists($parameter/mdip:Detailed_Variable)) then 
     123                                                                concat(' > ', string($parameter/mdip:Detailed_Variable)) 
     124                                                        else () 
     125                                                } 
     126                                        }, 
     127                                if (exists($MDIP/mdip:Spatial_Coverage) or exists($MDIP/mdip:Paleo_Temporal_Coverage) or exists($MDIP/mdip:Location) or exists($MDIP/mdip:Temporal_Coverage)) then 
     128                                        element dgDataCoverage { 
     129                                                if (exists($MDIP/mdip:Spatial_Coverage)  or exists($MDIP/mdip:Location))  then 
     130                                                        element dgSpatialCoverage { 
     131                                                                for $boundingbox in $MDIP/mdip:Spatial_Coverage[exists(mdip:Northernmost_Latitude) 
     132                                                                                                                and exists(mdip:Southernmost_Latitude) 
     133                                                                                                                and exists(mdip:Easternmost_Longitude) 
     134                                                                                                                and exists(mdip:Westernmost_Longitude)] 
     135                                                                return 
     136                                                                        element BoundingBox { 
     137                                                                                element LimitNorth {data(f:fix-coord($boundingbox/mdip:Northernmost_Latitude))}, 
     138                                                                                element LimitSouth {data(f:fix-coord($boundingbox/mdip:Southernmost_Latitude))}, 
     139                                                                                element LimitWest {data(f:fix-coord($boundingbox/mdip:Westernmost_Longitude))}, 
     140                                                                                element LimitEast {data(f:fix-coord($boundingbox/mdip:Easternmost_Longitude))} 
     141                                                                        }, 
     142                                                                for $location in $MDIP/mdip:Location 
     143                                                                return 
     144                                                                        element dgArea { 
     145                                                                                element dgValidTerm {string($location)}, 
     146                                                                                element dgValidTermID { 
     147                                                                                        element ParentListID {$gcmd_location_valids}, 
     148                                                                                        element TermID {escape-uri($location, true())} 
     149                                                                                } 
     150                                                                        } 
     151                                                        } 
     152                                                else (), 
     153                                                if (exists($MDIP/mdip:Temporal_Coverage/mdip:Start_Date) or exists($MDIP/mdip:Paleo_Temporal_Coverage/mdip:Paleo_Start_Date) or exists($MDIP/mdip:Chronostratigraphic_Unit)) then 
     154                                                        element dgTemporalCoverage { 
     155                                                                for $temporalcoverage in $MDIP/mdip:Temporal_Coverage[exists(mdip:Start_Date)] 
     156                                                                return 
     157                                                                        element DateRange { 
     158                                                                                element DateRangeStart {string($temporalcoverage/mdip:Start_Date)}, 
     159                                                                                element DateRangeEnd {string($temporalcoverage/mdip:Stop_Date)} 
     160                                                                        }, 
     161                                                                for $paleotemporalcoverage in $MDIP/mdip:Paleo_Temporal_Coverage[exists(mdip:Paleo_Start_Date)] 
     162                                                                return 
     163                                                                        element DateRange { 
     164                                                                                element DateRangeStart {string($paleotemporalcoverage/mdip:Paleo_Start_Date)}, 
     165                                                                                element DateRangeEnd {string($paleotemporalcoverage/mdip:Paleo_Stop_Date)} 
     166                                                                        }, 
     167                                                                for $chronostratigraphic in $MDIP/mdip:Chronostratigraphic_Unit 
     168                                                                return 
     169                                                                        element dgChronostratigraphicTerm { 
     170                                                                                element dgValidTerm {string($chronostratigraphic)}, 
     171                                                                                element dgValidTermID { 
     172                                                                                        element ParentListID {$gcmd_paleotemporal_valids}, 
     173                                                                                        element TermID {escape-uri($chronostratigraphic, true())} 
     174                                                                                } 
     175                                                                        } 
     176                                                        } 
     177                                                else () 
     178                                        } 
     179                                else () 
     180                        }, 
     181                        element dgDataRoles { 
     182                                if (exists($MDIP/mdip:Data_Set_Citation/mdip:Dataset_Creator)) then 
     183                                        element dgDataCreator { 
     184                                                element dgMetadataID { 
     185                                                        element schemeIdentifier {'NDG-B0'}, 
     186                                                        element repositoryIdentifier {$input_repository}, 
     187                                                        element localIdentifier {concat('generated_creator-', string($MDIP/mdip:DatasetIdentifier))} 
     188                                                }, 
     189                                                element roleName {'Data Creator'}, 
     190                                                element abbreviation {'Creator'}, 
     191                                                for $creatorID in $MDIP/mdip:Data_Set_Citation/mdip:Dataset_Creator 
     192                                                return 
     193                                                element dgRoleHolder { 
     194                                                        element dgOrganisationID { 
     195                                                                element schemeIdentifier {'NDG-B0'}, 
     196                                                                element repositoryIdentifier {$input_repository}, 
     197                                                                element localIdentifier  {escape-uri(concat('generated_orgcit-', string($creatorID)), true())} 
     198                                                        }, 
     199                                                element startDate {current-date()} 
     200                                                } 
     201                                        } 
     202                                else if (exists($MDIP/mdip:Originating_Center)) then 
     203                                        element dgDataCreator { 
     204                                                element dgMetadataID { 
     205                                                        element schemeIdentifier {'NDG-B0'}, 
     206                                                        element repositoryIdentifier {$input_repository}, 
     207                                                        element localIdentifier {concat('generated_creator-', string($MDIP/mdip:DatasetIdentifier))} 
     208                                                }, 
     209                                                element roleName {'Data Creator'}, 
     210                                                element abbreviation {'Creator'}, 
     211                                                for $creatorID in $MDIP/mdip:Originating_Center 
     212                                                return 
     213                                                element dgRoleHolder { 
     214                                                        element dgOrganisationID { 
     215                                                                element schemeIdentifier {'NDG-B0'}, 
     216                                                                element repositoryIdentifier {$input_repository}, 
     217                                                                element localIdentifier  {escape-uri(concat('generated_orgcit-', string($creatorID)), true())} 
     218                                                        }, 
     219                                                element startDate {current-date()} 
     220                                                } 
     221                                        } 
     222                                else (), 
     223                                element dgDataCurator { 
     224                                        element dgMetadataID { 
     225                                                element schemeIdentifier {'NDG-B0'}, 
     226                                                element repositoryIdentifier {$input_repository}, 
     227                                                element localIdentifier {concat('generated_curator-', string($MDIP/mdip:DatasetIdentifier))} 
     228                                        }, 
     229                                        element roleName {'Data Curator'}, 
     230                                        element abbreviation {'Curator'}, 
     231                                        element dgRoleHolder { 
     232                                                element dgOrganisationID { 
     233                                                        element schemeIdentifier {'NDG-B0'}, 
     234                                                        element repositoryIdentifier {$input_repository}, 
     235                                                        element localIdentifier {$input_repository_local} 
     236                                                }, 
     237                                        element startDate {current-date()} 
     238                                        } 
     239                                } 
     240                        } 
     241                }, 
     242                element dgStructuredKeyword { 
     243                        element dgValidTerm {'d2b converted record'}, 
     244                        element dgValidTermID { 
     245                                element ParentListID {$unknown_vocab_id}, 
     246                                element TermID {'d2b'} 
     247                        } 
     248                }, 
     249                for $structuredKeywords in $MDIP/mdip:Keywords 
     250                return  
     251                        element dgStructuredKeyword { 
     252                                element dgValidTerm {$structuredKeywords}, 
     253                                element dgValidTermID { 
     254                                        element ParentListID {$unknown_vocab_id}, 
     255                                        element TermID {escape-uri($structuredKeywords, true())} 
     256                                } 
     257                        }, 
     258                for $structuredKeywords in $MDIP/mdip:ISO_Topic_Category 
     259                return  
     260                        element dgStructuredKeyword { 
     261                                element dgValidTerm {string($structuredKeywords)}, 
     262                                element dgValidTermID { 
     263                                        element ParentListID {$gcmd_iso_topic_list}, 
     264                                        element TermID {escape-uri($structuredKeywords, true())} 
     265                                } 
     266                        }, 
     267                if (exists($MDIP/mdip:DIF_Creation_Date) or exists($MDIP/mdip:Last_DIF_Revision_Date)) then  
     268                        element dgMetadataProvenance { 
     269                                if (exists($MDIP/mdip:DIF_Creation_Date)) then 
     270                                        element RecordCreation { 
     271                                                element CreatedDate { 
     272                                                        if (string($MDIP/mdip:DIF_Creation_Date) castable as xs:date) then  
     273                                                                string($MDIP/mdip:DIF_Creation_Date) cast as xs:date 
     274                                                        else (current-date()) 
     275                                                }, 
     276                                        element CreatedBy {$input_repository} 
     277                                        } 
     278                                else  
     279                                        element RecordCreation { 
     280                                                element CreatedDate {current-date()}, 
     281                                                element CreatedBy {'MOLES Import'} 
     282                                        }, 
     283                                if (exists($MDIP/mdip:Last_DIF_Revision_Date)) then 
     284                                        element RecordUpdate { 
     285                                                element UpdateDate { 
     286                                                        if (string($MDIP/mdip:Last_DIF_Revision_Date) castable as xs:dateTime) then  
     287                                                                string($MDIP/mdip:Last_DIF_Revision_Date) cast as xs:dateTime 
     288                                                        else (current-dateTime()) 
     289                                                }, 
     290                                                element UpdatedBy {$input_repository} 
     291                                        } 
     292                                else () 
     293                        } 
     294                else () 
     295        } (: </dgMetadataRecord>:), 
     296        for $creator in distinct-values($MDIP/(mdip:Data_Set_Citation/mdip:Dataset_Creator | mdip:Originating_Center)) 
     297        return 
     298                element dgOrganisation { 
     299                        element dgMetadataID { 
     300                                element schemeIdentifier {'NDG-B0'}, 
     301                                element repositoryIdentifier {$input_repository}, 
     302                                element localIdentifier {escape-uri(concat('generated_orgcit-', string($creator)), true())} 
     303                        }, 
     304                        element name {string($creator)}, 
     305                        element abbreviation {string($creator)}, 
     306                        element contactDetails {''} 
     307                } 
     308} (:    </dgMetadata> :) 
Note: See TracChangeset for help on using the changeset viewer.