Dumped on 2018-11-12
| F-Key | Name | Type | Description |
|---|---|---|---|
| sha1 | sha1 | PRIMARY KEY | |
| sha1_git | sha1_git | NOT NULL | |
| sha256 | sha256 | NOT NULL | |
| blake2s256 | blake2s256 | ||
| length | bigint | NOT NULL | |
| ctime | timestamp with time zone | NOT NULL DEFAULT now() | |
| status | content_status | NOT NULL DEFAULT 'visible'::content_status | |
| object_id | bigserial | NOT NULL |
| F-Key | Name | Type | Description |
|---|---|---|---|
| version | integer | PRIMARY KEY | |
| release | timestamp with time zone | ||
| description | text |
| F-Key | Name | Type | Description |
|---|---|---|---|
| id | sha1_git | PRIMARY KEY | |
| dir_entries | bigint[] | ||
| file_entries | bigint[] | ||
| rev_entries | bigint[] | ||
| object_id | bigserial | NOT NULL |
| F-Key | Name | Type | Description |
|---|---|---|---|
| id | bigserial | PRIMARY KEY | |
| target | sha1_git | ||
| name | unix_path | ||
| perms | file_perms |
| F-Key | Name | Type | Description |
|---|---|---|---|
| id | bigserial | PRIMARY KEY | |
| target | sha1_git | ||
| name | unix_path | ||
| perms | file_perms |
| F-Key | Name | Type | Description |
|---|---|---|---|
| id | bigserial | PRIMARY KEY | |
| target | sha1_git | ||
| name | unix_path | ||
| perms | file_perms |
| F-Key | Name | Type | Description |
|---|---|---|---|
| id | bigserial | PRIMARY KEY | |
| origin.id | origin | bigint | |
| date | timestamp with time zone | NOT NULL | |
| status | boolean | ||
| result | jsonb | ||
| stdout | text | ||
| stderr | text | ||
| duration | interval |
Metadata provider information
| F-Key | Name | Type | Description |
|---|---|---|---|
| id | serial |
PRIMARY KEY
Provider's identifier |
|
| provider_name | text |
NOT NULL
Provider's name |
|
| provider_type | text | NOT NULL | |
| provider_url | text |
Provider's url |
|
| metadata | jsonb |
Other metadata about provider |
Tables referencing this one via Foreign Key Constraints:
metadata_provider_provider_name_provider_url_idx provider_name, provider_url| F-Key | Name | Type | Description |
|---|---|---|---|
| object_type | text | PRIMARY KEY | |
| value | bigint | ||
| last_update | timestamp with time zone | ||
| single_update | boolean |
| F-Key | Name | Type | Description |
|---|---|---|---|
| line | serial | PRIMARY KEY | |
| object_type | text | NOT NULL | |
| identifier | text | NOT NULL | |
| bucket_start | bytea | ||
| bucket_end | bytea | ||
| value | bigint | ||
| last_update | timestamp with time zone |
| F-Key | Name | Type | Description |
|---|---|---|---|
| id | bigserial | PRIMARY KEY | |
| type | text | ||
| url | text | NOT NULL |
Tables referencing this one via Foreign Key Constraints:
origin_type_url_idx type, urlkeeps all metadata found concerning an origin
| F-Key | Name | Type | Description |
|---|---|---|---|
| id | bigserial |
PRIMARY KEY
the origin_metadata object's id |
|
| origin.id | origin_id | bigint |
NOT NULL
the origin id for which the metadata was found |
| discovery_date | timestamp with time zone |
NOT NULL
the date of retrieval |
|
| metadata_provider.id | provider_id | bigint |
NOT NULL
the metadata provider: github, openhub, deposit, etc. |
| tool.id | tool_id | bigint |
NOT NULL
the tool used for extracting metadata: lister-github, etc. |
| metadata | jsonb |
NOT NULL
metadata in json format but with original terms |
| F-Key | Name | Type | Description |
|---|---|---|---|
| origin.id | origin | bigint |
PRIMARY KEY
Visited origin |
| visit | bigint |
PRIMARY KEY
Sequential visit number for the origin |
|
| date | timestamp with time zone |
NOT NULL
Visit timestamp |
|
| status | origin_visit_status |
NOT NULL
Visit result |
|
| metadata | jsonb |
Origin metadata at visit time |
|
| snapshot.object_id | snapshot_id | bigint |
Origin snapshot at visit time |
| F-Key | Name | Type | Description |
|---|---|---|---|
| id | bigserial | PRIMARY KEY | |
| name | bytea | ||
| bytea | |||
| fullname | bytea | NOT NULL |
Tables referencing this one via Foreign Key Constraints:
person_email_idx email person_name_idx name| F-Key | Name | Type | Description |
|---|---|---|---|
| id | sha1_git | PRIMARY KEY | |
| target | sha1_git | ||
| date | timestamp with time zone | ||
| date_offset | smallint | ||
| name | bytea | ||
| comment | bytea | ||
| person.id | author | bigint | |
| synthetic | boolean | NOT NULL DEFAULT false | |
| object_id | bigserial | NOT NULL | |
| target_type | object_type | NOT NULL | |
| date_neg_utc_offset | boolean |
| F-Key | Name | Type | Description |
|---|---|---|---|
| id | sha1_git | PRIMARY KEY | |
| date | timestamp with time zone | ||
| date_offset | smallint | ||
| committer_date | timestamp with time zone | ||
| committer_date_offset | smallint | ||
| type | revision_type | NOT NULL | |
| directory | sha1_git | ||
| message | bytea | ||
| person.id | author | bigint | |
| person.id | committer | bigint | |
| synthetic | boolean | NOT NULL DEFAULT false | |
| metadata | jsonb | ||
| object_id | bigserial | NOT NULL | |
| date_neg_utc_offset | boolean | ||
| committer_date_neg_utc_offset | boolean |
Tables referencing this one via Foreign Key Constraints:
revision_directory_idx directory| F-Key | Name | Type | Description |
|---|---|---|---|
| revision.id | id | sha1_git | PRIMARY KEY |
| parent_id | sha1_git | ||
| parent_rank | integer | PRIMARY KEY |
| F-Key | Name | Type | Description |
|---|---|---|---|
| sha1 | sha1 | UNIQUE#1 | |
| sha1_git | sha1_git | UNIQUE#1 | |
| sha256 | sha256 | UNIQUE#1 | |
| blake2s256 | blake2s256 | ||
| length | bigint | NOT NULL | |
| ctime | timestamp with time zone | NOT NULL DEFAULT now() | |
| status | content_status | NOT NULL DEFAULT 'absent'::content_status | |
| reason | text | NOT NULL | |
| origin.id | origin | bigint | |
| object_id | bigserial | NOT NULL |
| F-Key | Name | Type | Description |
|---|---|---|---|
| object_id | bigserial | PRIMARY KEY | |
| id | sha1_git |
Tables referencing this one via Foreign Key Constraints:
| F-Key | Name | Type | Description |
|---|---|---|---|
| object_id | bigserial | PRIMARY KEY | |
| name | bytea | NOT NULL | |
| target | bytea | ||
| target_type | snapshot_target |
| Name | Constraint |
|---|---|
| snapshot_branch_target_check | CHECK (((target_type IS NULL) = (target IS NULL))) |
| snapshot_target_check | CHECK (((target_type <> ALL (ARRAY['content'::snapshot_target, 'directory'::snapshot_target, 'revision'::snapshot_target, 'release'::snapshot_target, 'snapshot'::snapshot_target])) OR (length(target) = 20))) |
Tables referencing this one via Foreign Key Constraints:
| F-Key | Name | Type | Description |
|---|---|---|---|
| snapshot.object_id | snapshot_id | bigint | PRIMARY KEY |
| snapshot_branch.object_id | branch_id | bigint | PRIMARY KEY |
Tool information
| F-Key | Name | Type | Description |
|---|---|---|---|
| id | serial |
PRIMARY KEY
Tool identifier |
|
| name | text | NOT NULL | |
| version | text |
NOT NULL
Tool version |
|
| configuration | jsonb |
Tool configuration: command line, flags, etc... |
Tables referencing this one via Foreign Key Constraints:
pg_armor
pg_armor
cash_dist
pg_crypt
date_dist
pg_dearmor
pg_decrypt
pg_decrypt_iv
pg_digest
pg_digest
pg_encrypt
pg_encrypt_iv
float4_dist
float8_dist
gbt_bit_compress
gbt_bit_consistent
gbt_bit_penalty
gbt_bit_picksplit
gbt_bit_same
gbt_bit_union
gbt_bpchar_compress
gbt_bpchar_consistent
gbt_bytea_compress
gbt_bytea_consistent
gbt_bytea_penalty
gbt_bytea_picksplit
gbt_bytea_same
gbt_bytea_union
gbt_cash_compress
gbt_cash_consistent
gbt_cash_distance
gbt_cash_fetch
gbt_cash_penalty
gbt_cash_picksplit
gbt_cash_same
gbt_cash_union
gbt_date_compress
gbt_date_consistent
gbt_date_distance
gbt_date_fetch
gbt_date_penalty
gbt_date_picksplit
gbt_date_same
gbt_date_union
gbt_decompress
gbt_enum_compress
gbt_enum_consistent
gbt_enum_fetch
gbt_enum_penalty
gbt_enum_picksplit
gbt_enum_same
gbt_enum_union
gbt_float4_compress
gbt_float4_consistent
gbt_float4_distance
gbt_float4_fetch
gbt_float4_penalty
gbt_float4_picksplit
gbt_float4_same
gbt_float4_union
gbt_float8_compress
gbt_float8_consistent
gbt_float8_distance
gbt_float8_fetch
gbt_float8_penalty
gbt_float8_picksplit
gbt_float8_same
gbt_float8_union
gbt_inet_compress
gbt_inet_consistent
gbt_inet_penalty
gbt_inet_picksplit
gbt_inet_same
gbt_inet_union
gbt_int2_compress
gbt_int2_consistent
gbt_int2_distance
gbt_int2_fetch
gbt_int2_penalty
gbt_int2_picksplit
gbt_int2_same
gbt_int2_union
gbt_int4_compress
gbt_int4_consistent
gbt_int4_distance
gbt_int4_fetch
gbt_int4_penalty
gbt_int4_picksplit
gbt_int4_same
gbt_int4_union
gbt_int8_compress
gbt_int8_consistent
gbt_int8_distance
gbt_int8_fetch
gbt_int8_penalty
gbt_int8_picksplit
gbt_int8_same
gbt_int8_union
gbt_intv_compress
gbt_intv_consistent
gbt_intv_decompress
gbt_intv_distance
gbt_intv_fetch
gbt_intv_penalty
gbt_intv_picksplit
gbt_intv_same
gbt_intv_union
gbt_macad8_compress
gbt_macad8_consistent
gbt_macad8_fetch
gbt_macad8_penalty
gbt_macad8_picksplit
gbt_macad8_same
gbt_macad8_union
gbt_macad_compress
gbt_macad_consistent
gbt_macad_fetch
gbt_macad_penalty
gbt_macad_picksplit
gbt_macad_same
gbt_macad_union
gbt_numeric_compress
gbt_numeric_consistent
gbt_numeric_penalty
gbt_numeric_picksplit
gbt_numeric_same
gbt_numeric_union
gbt_oid_compress
gbt_oid_consistent
gbt_oid_distance
gbt_oid_fetch
gbt_oid_penalty
gbt_oid_picksplit
gbt_oid_same
gbt_oid_union
gbt_text_compress
gbt_text_consistent
gbt_text_penalty
gbt_text_picksplit
gbt_text_same
gbt_text_union
gbt_time_compress
gbt_time_consistent
gbt_time_distance
gbt_time_fetch
gbt_time_penalty
gbt_time_picksplit
gbt_time_same
gbt_time_union
gbt_timetz_compress
gbt_timetz_consistent
gbt_ts_compress
gbt_ts_consistent
gbt_ts_distance
gbt_ts_fetch
gbt_ts_penalty
gbt_ts_picksplit
gbt_ts_same
gbt_ts_union
gbt_tstz_compress
gbt_tstz_consistent
gbt_tstz_distance
gbt_uuid_compress
gbt_uuid_consistent
gbt_uuid_fetch
gbt_uuid_penalty
gbt_uuid_picksplit
gbt_uuid_same
gbt_uuid_union
gbt_var_decompress
gbt_var_fetch
gbtreekey_in
gbtreekey_out
gbtreekey_in
gbtreekey_out
gbtreekey_in
gbtreekey_out
gbtreekey_in
gbtreekey_out
gbtreekey_in
gbtreekey_out
pg_random_bytes
pg_random_uuid
pg_gen_salt
pg_gen_salt_rounds
Compute SHA1 hash as text
select encode(digest($1, 'sha1'), 'hex')
pg_hmac
pg_hmac
int2_dist
int4_dist
int8_dist
interval_dist
begin
perform pg_notify('new_content', json_build_object(
'sha1', encode(new.sha1, 'hex'),
'sha1_git', encode(new.sha1_git, 'hex'),
'sha256', encode(new.sha256, 'hex'),
'blake2s256', encode(new.blake2s256, 'hex')
)::text);
return null;
end;
begin
perform pg_notify('new_directory', json_build_object('id', encode(new.id, 'hex'))::text);
return null;
end;
begin
perform pg_notify('new_origin', json_build_object('id', new.id)::text);
return null;
end;
begin
perform pg_notify('new_origin_visit', json_build_object(
'origin', new.origin,
'visit', new.visit
)::text);
return null;
end;
begin
perform pg_notify('new_release', json_build_object('id', encode(new.id, 'hex'))::text);
return null;
end;
begin
perform pg_notify('new_revision', json_build_object('id', encode(new.id, 'hex'))::text);
return null;
end;
begin
perform pg_notify('new_skipped_content', json_build_object(
'sha1', encode(new.sha1, 'hex'),
'sha1_git', encode(new.sha1_git, 'hex'),
'sha256', encode(new.sha256, 'hex'),
'blake2s256', encode(new.blake2s256, 'hex')
)::text);
return null;
end;
begin
perform pg_notify('new_snapshot', json_build_object('id', encode(new.id, 'hex'))::text);
return null;
end;
oid_dist
pgp_armor_headers
pgp_key_id_w
pgp_pub_decrypt_text
pgp_pub_decrypt_text
pgp_pub_decrypt_text
pgp_pub_decrypt_bytea
pgp_pub_decrypt_bytea
pgp_pub_decrypt_bytea
pgp_pub_encrypt_text
pgp_pub_encrypt_text
pgp_pub_encrypt_bytea
pgp_pub_encrypt_bytea
pgp_sym_decrypt_text
pgp_sym_decrypt_text
pgp_sym_decrypt_bytea
pgp_sym_decrypt_bytea
pgp_sym_encrypt_text
pgp_sym_encrypt_text
pgp_sym_encrypt_bytea
pgp_sym_encrypt_bytea
begin
insert into content (sha1, sha1_git, sha256, blake2s256, length, status)
select distinct sha1, sha1_git, sha256, blake2s256, length, status from tmp_content;
return;
end
declare
con content;
filters text[] := array[] :: text[]; -- AND-clauses used to filter content
q text;
begin
if sha1 is not null then
filters := filters || format('sha1 = %L', sha1);
end if;
if sha1_git is not null then
filters := filters || format('sha1_git = %L', sha1_git);
end if;
if sha256 is not null then
filters := filters || format('sha256 = %L', sha256);
end if;
if blake2s256 is not null then
filters := filters || format('blake2s256 = %L', blake2s256);
end if;
if cardinality(filters) = 0 then
return null;
else
q = format('select * from content where %s',
array_to_string(filters, ' and '));
execute q into con;
return con;
end if;
end
with recursive path as (
-- Recursively build a path from the requested content to a root
-- directory. Each iteration returns a pair (dir_id, filename) where
-- filename is relative to dir_id. Stops when no parent directory can
-- be found.
(select dir.id as dir_id, dir_entry_f.name as name, 0 as depth
from directory_entry_file as dir_entry_f
join content on content.sha1_git = dir_entry_f.target
join directory as dir on dir.file_entries @> array[dir_entry_f.id]
where content.sha1 = content_id
limit 1)
union all
(select dir.id as dir_id,
(dir_entry_d.name || '/' || path.name)::unix_path as name,
path.depth + 1
from path
join directory_entry_dir as dir_entry_d on dir_entry_d.target = path.dir_id
join directory as dir on dir.dir_entries @> array[dir_entry_d.id]
limit 1)
)
select dir_id, name from path order by depth desc limit 1;
select * from content
where object_id > min_excl and object_id <= max_incl
order by object_id;
Update existing content's columns
declare
query text;
tmp_array text[];
begin
if array_length(columns_update, 1) = 0 then
raise exception 'Please, provide the list of column names to update.';
end if;
tmp_array := array(select format('%1$s=t.%1$s', unnest) from unnest(columns_update));
query = format('update content set %s
from tmp_content t where t.sha1 = content.sha1',
array_to_string(tmp_array, ', '));
execute query;
return;
end
begin
perform swh_directory_entry_add('file');
perform swh_directory_entry_add('dir');
perform swh_directory_entry_add('rev');
insert into directory
select * from tmp_directory t
where not exists (
select 1 from directory d
where d.id = t.id);
return;
end
begin
execute format('
insert into directory_entry_%1$s (target, name, perms)
select distinct t.target, t.name, t.perms
from tmp_directory_entry_%1$s t
where not exists (
select 1
from directory_entry_%1$s i
where t.target = i.target and t.name = i.name and t.perms = i.perms)
', typ);
execute format('
with new_entries as (
select t.dir_id, array_agg(i.id) as entries
from tmp_directory_entry_%1$s t
inner join directory_entry_%1$s i
using (target, name, perms)
group by t.dir_id
)
update tmp_directory as d
set %1$s_entries = new_entries.entries
from new_entries
where d.id = new_entries.dir_id
', typ);
return;
end
begin
return query
select id from tmp_directory t
where not exists (
select 1 from directory d
where d.id = t.id);
return;
end
with recursive entries as (
select dir_id, type, target, name, perms, status, sha1, sha1_git,
sha256, length
from swh_directory_walk_one(walked_dir_id)
union all
select dir_id, type, target, (dirname || '/' || name)::unix_path as name,
perms, status, sha1, sha1_git, sha256, length
from (select (swh_directory_walk_one(dirs.target)).*, dirs.name as dirname
from (select target, name from entries where type = 'dir') as dirs) as with_parent
)
select dir_id, type, target, name, perms, status, sha1, sha1_git, sha256, length
from entries
with dir as (
select id as dir_id, dir_entries, file_entries, rev_entries
from directory
where id = walked_dir_id),
ls_d as (select dir_id, unnest(dir_entries) as entry_id from dir),
ls_f as (select dir_id, unnest(file_entries) as entry_id from dir),
ls_r as (select dir_id, unnest(rev_entries) as entry_id from dir)
(select dir_id, 'dir'::directory_entry_type as type,
e.target, e.name, e.perms, NULL::content_status,
NULL::sha1, NULL::sha1_git, NULL::sha256, NULL::bigint
from ls_d
left join directory_entry_dir e on ls_d.entry_id = e.id)
union
(select dir_id, 'file'::directory_entry_type as type,
e.target, e.name, e.perms, c.status,
c.sha1, c.sha1_git, c.sha256, c.length
from ls_f
left join directory_entry_file e on ls_f.entry_id = e.id
left join content c on e.target = c.sha1_git)
union
(select dir_id, 'rev'::directory_entry_type as type,
e.target, e.name, e.perms, NULL::content_status,
NULL::sha1, NULL::sha1_git, NULL::sha256, NULL::bigint
from ls_r
left join directory_entry_rev e on ls_r.entry_id = e.id)
order by name;
declare
end_index integer;
paths bytea default '';
path bytea;
res bytea[];
r record;
begin
end_index := array_upper(dir_or_content_path, 1);
res[1] := walked_dir_id;
for i in 1..end_index
loop
path := dir_or_content_path[i];
-- concatenate path for patching the name in the result record (if we found it)
if i = 1 then
paths = path;
else
paths := paths || '/' || path; -- concatenate paths
end if;
if i <> end_index then
select *
from swh_directory_walk_one(res[i] :: sha1_git)
where name=path
and type = 'dir'
limit 1 into r;
else
select *
from swh_directory_walk_one(res[i] :: sha1_git)
where name=path
limit 1 into r;
end if;
-- find the path
if r is null then
return null;
else
-- store the next dir to lookup the next local path from
res[i+1] := r.target;
end if;
end loop;
-- at this moment, r is the result. Patch its 'name' with the full path before returning it.
r.name := paths;
return r;
end
begin
execute format('
create temporary table tmp_%1$I
(like %1$I including defaults)
on commit drop;
alter table tmp_%1$I drop column if exists object_id;
', tblname);
return;
end
begin
execute format('
create temporary table tmp_%1$I
(like %1$I including defaults, dir_id sha1_git)
on commit drop;
alter table tmp_%1$I drop column id;
', tblname);
return;
end
create temporary table tmp_release (
like release including defaults,
author_fullname bytea,
author_name bytea,
author_email bytea
) on commit drop;
alter table tmp_release drop column author;
alter table tmp_release drop column object_id;
create temporary table tmp_revision (
like revision including defaults,
author_fullname bytea,
author_name bytea,
author_email bytea,
committer_fullname bytea,
committer_name bytea,
committer_email bytea
) on commit drop;
alter table tmp_revision drop column author;
alter table tmp_revision drop column committer;
alter table tmp_revision drop column object_id;
create temporary table tmp_snapshot_branch (
name bytea not null,
target bytea,
target_type snapshot_target
) on commit drop;
create temporary table tmp_tool (
like tool including defaults
) on commit drop;
alter table tmp_tool drop column id;
select om.id as id, origin_id, discovery_date, tool_id, om.metadata,
mp.id as provider_id, provider_name, provider_type, provider_url
from origin_metadata as om
inner join metadata_provider mp on om.provider_id = mp.id
where om.origin_id = origin
order by discovery_date desc;
select om.id as id, origin_id, discovery_date, tool_id, om.metadata,
mp.id as provider_id, provider_name, provider_type, provider_url
from origin_metadata as om
inner join metadata_provider mp on om.provider_id = mp.id
where om.origin_id = origin
and mp.provider_type = type
order by discovery_date desc;
with last_known_visit as (
select coalesce(max(visit), 0) as visit
from origin_visit
where origin = origin_id
)
insert into origin_visit (origin, date, visit, status)
values (origin_id, date, (select visit from last_known_visit) + 1, 'ongoing')
returning visit;
begin
with t as (
select distinct author_fullname as fullname, author_name as name, author_email as email from tmp_release
) insert into person (fullname, name, email)
select fullname, name, email from t
where not exists (
select 1
from person p
where t.fullname = p.fullname
);
return;
end
begin
with t as (
select author_fullname as fullname, author_name as name, author_email as email from tmp_revision
union
select committer_fullname as fullname, committer_name as name, committer_email as email from tmp_revision
) insert into person (fullname, name, email)
select distinct fullname, name, email from t
where not exists (
select 1
from person p
where t.fullname = p.fullname
);
return;
end
begin
perform swh_person_add_from_release();
insert into release (id, target, target_type, date, date_offset, date_neg_utc_offset, name, comment, author, synthetic)
select t.id, t.target, t.target_type, t.date, t.date_offset, t.date_neg_utc_offset, t.name, t.comment, a.id, t.synthetic
from tmp_release t
left join person a on a.fullname = t.author_fullname;
return;
end
with rels as (
select * from release
where object_id > min_excl and object_id <= max_incl
)
select r.id, r.target, r.target_type, r.date, r.date_offset, r.date_neg_utc_offset, r.name, r.comment,
r.synthetic, p.id as author_id, p.fullname as author_fullname, p.name as author_name, p.email as author_email, r.object_id
from rels r
left join person p on p.id = r.author
order by r.object_id;
begin
perform swh_person_add_from_revision();
insert into revision (id, date, date_offset, date_neg_utc_offset, committer_date, committer_date_offset, committer_date_neg_utc_offset, type, directory, message, author, committer, metadata, synthetic)
select t.id, t.date, t.date_offset, t.date_neg_utc_offset, t.committer_date, t.committer_date_offset, t.committer_date_neg_utc_offset, t.type, t.directory, t.message, a.id, c.id, t.metadata, t.synthetic
from tmp_revision t
left join person a on a.fullname = t.author_fullname
left join person c on c.fullname = t.committer_fullname;
return;
end
with recursive full_rev_list(id) as (
(select id from revision where id = ANY(root_revisions))
union
(select h.parent_id
from revision_history as h
join full_rev_list on h.id = full_rev_list.id)
),
rev_list as (select id from full_rev_list limit num_revs)
select rev_list.id as id,
array(select rh.parent_id::bytea
from revision_history rh
where rh.id = rev_list.id
order by rh.parent_rank
) as parent
from rev_list;
with revs as (
select * from revision
where object_id > min_excl and object_id <= max_incl
)
select r.id, r.date, r.date_offset, r.date_neg_utc_offset,
r.committer_date, r.committer_date_offset, r.committer_date_neg_utc_offset,
r.type, r.directory, r.message,
a.id, a.fullname, a.name, a.email, c.id, c.fullname, c.name, c.email, r.metadata, r.synthetic,
array(select rh.parent_id::bytea from revision_history rh where rh.id = r.id order by rh.parent_rank)
as parents, r.object_id
from revs r
left join person a on a.id = r.author
left join person c on c.id = r.committer
order by r.object_id;
with recursive full_rev_list(id) as (
(select id from revision where id = ANY(root_revisions))
union
(select h.id
from revision_history as h
join full_rev_list on h.parent_id = full_rev_list.id)
),
rev_list as (select id from full_rev_list limit num_revs)
select rev_list.id as id,
array(select rh.parent_id::bytea
from revision_history rh
where rh.id = rev_list.id
order by rh.parent_rank
) as parent
from rev_list;
select t.id, r.date, r.date_offset, r.date_neg_utc_offset,
r.committer_date, r.committer_date_offset, r.committer_date_neg_utc_offset,
r.type, r.directory, r.message,
a.id, a.fullname, a.name, a.email,
c.id, c.fullname, c.name, c.email,
r.metadata, r.synthetic, t.parents, r.object_id
from swh_revision_list(root_revisions, num_revs) as t
left join revision r on t.id = r.id
left join person a on a.id = r.author
left join person c on c.id = r.committer;
Recursively list the revision targeted directory arborescence
select dir_id, type, target, name, perms, status, sha1, sha1_git, sha256, length from swh_directory_walk((select directory from revision where id=revision_id))
begin
insert into skipped_content (sha1, sha1_git, sha256, blake2s256, length, status, reason, origin)
select distinct sha1, sha1_git, sha256, blake2s256, length, status, reason, origin
from tmp_skipped_content
where (coalesce(sha1, ''), coalesce(sha1_git, ''), coalesce(sha256, '')) in (
select coalesce(sha1, ''), coalesce(sha1_git, ''), coalesce(sha256, '')
from swh_skipped_content_missing()
);
-- TODO XXX use postgres 9.5 "UPSERT" support here, when available.
-- Specifically, using "INSERT .. ON CONFLICT IGNORE" we can avoid
-- the extra swh_content_missing() query here.
return;
end
begin
return query
select sha1, sha1_git, sha256, blake2s256 from tmp_skipped_content t
where not exists
(select 1 from skipped_content s where
s.sha1 is not distinct from t.sha1 and
s.sha1_git is not distinct from t.sha1_git and
s.sha256 is not distinct from t.sha256);
return;
end
declare
snapshot_object_id snapshot.object_id%type;
begin
select object_id from snapshot where id = snapshot_id into snapshot_object_id;
if snapshot_object_id is null then
insert into snapshot (id) values (snapshot_id) returning object_id into snapshot_object_id;
insert into snapshot_branch (name, target_type, target)
select name, target_type, target from tmp_snapshot_branch tmp
where not exists (
select 1
from snapshot_branch sb
where sb.name = tmp.name
and sb.target = tmp.target
and sb.target_type = tmp.target_type
)
on conflict do nothing;
insert into snapshot_branches (snapshot_id, branch_id)
select snapshot_object_id, sb.object_id as branch_id
from tmp_snapshot_branch tmp
join snapshot_branch sb
using (name, target, target_type)
where tmp.target is not null and tmp.target_type is not null
union
select snapshot_object_id, sb.object_id as branch_id
from tmp_snapshot_branch tmp
join snapshot_branch sb
using (name)
where tmp.target is null and tmp.target_type is null
and sb.target is null and sb.target_type is null;
end if;
update origin_visit ov
set snapshot_id = snapshot_object_id
where ov.origin=swh_snapshot_add.origin and ov.visit=swh_snapshot_add.visit;
end;
SELECT target_type, count(name) from swh_snapshot_get_by_id(swh_snapshot_count_branches.id) group by target_type;
select
swh_snapshot_get_by_id.id as snapshot_id, name, target, target_type
from snapshot_branches
inner join snapshot_branch on snapshot_branches.branch_id = snapshot_branch.object_id
where snapshot_id = (select object_id from snapshot where snapshot.id = swh_snapshot_get_by_id.id)
and (target_types is null or target_type = any(target_types))
and name >= branches_from
order by name limit branches_count
select snapshot.id from origin_visit left join snapshot on snapshot.object_id = origin_visit.snapshot_id where origin_visit.origin=origin_id and origin_visit.visit=visit_id;
select object_type as label, value as value
from object_counts
where object_type in (
'content',
'directory',
'directory_entry_dir',
'directory_entry_file',
'directory_entry_rev',
'origin',
'origin_visit',
'person',
'release',
'revision',
'revision_history',
'skipped_content',
'snapshot'
);
begin
insert into tool(name, version, configuration)
select name, version, configuration from tmp_tool tmp
on conflict(name, version, configuration) do nothing;
return query
select id, name, version, configuration
from tmp_tool join tool
using(name, version, configuration);
return;
end
begin
execute format('
insert into object_counts
(value, last_update, object_type)
values
((select count(*) from %1$I), NOW(), %1$L)
on conflict (object_type) do update set
value = excluded.value,
last_update = excluded.last_update',
object_type);
return;
end;
declare
query text;
line_to_update int;
new_value bigint;
begin
select
object_counts_bucketed.line,
format(
'select count(%I) from %I where %s',
coalesce(identifier, '*'),
object_type,
coalesce(
concat_ws(
' and ',
case when bucket_start is not null then
format('%I >= %L', identifier, bucket_start) -- lower bound condition, inclusive
end,
case when bucket_end is not null then
format('%I < %L', identifier, bucket_end) -- upper bound condition, exclusive
end
),
'true'
)
)
from object_counts_bucketed
order by coalesce(last_update, now() - '1 month'::interval) asc
limit 1
into line_to_update, query;
execute query into new_value;
update object_counts_bucketed
set value = new_value,
last_update = now()
where object_counts_bucketed.line = line_to_update;
END
begin
with to_update as (
select object_type, sum(value) as value, max(last_update) as last_update
from object_counts_bucketed ob1
where not exists (
select 1 from object_counts_bucketed ob2
where ob1.object_type = ob2.object_type
and value is null
)
group by object_type
) update object_counts
set
value = to_update.value,
last_update = to_update.last_update
from to_update
where
object_counts.object_type = to_update.object_type
and object_counts.value != to_update.value;
return null;
end
with closest_two_visits as ((
select ov, (date - visit_date) as interval
from origin_visit ov
where ov.origin = origin
and ov.date >= visit_date
order by ov.date asc
limit 1
) union (
select ov, (visit_date - date) as interval
from origin_visit ov
where ov.origin = origin
and ov.date < visit_date
order by ov.date desc
limit 1
)) select (ov).* from closest_two_visits order by interval limit 1
select *
from origin_visit
where origin=origin
order by date desc
time_dist
ts_dist
tstz_dist
Generated by PostgreSQL Autodoc