Index for softwareheritage-dev

Dumped on 2018-10-16

# Index of database - softwareheritage-dev

- public

- content
- dbversion
- directory
- directory_entry_dir
- directory_entry_file
- directory_entry_rev
- fetch_history
- metadata_provider
- object_counts
- object_counts_bucketed
- occurrence_history
- origin
- origin_metadata
- origin_visit
- person
- release
- revision
- revision_history
- skipped_content
- snapshot
- snapshot_branch
- snapshot_branches
- tool
- armor(bytea)
- armor(bytea, text[], text[])
- cash_dist(money, money)
- crypt(text, text)
- date_dist(date, date)
- dearmor(text)
- decrypt(bytea, bytea, text)
- decrypt_iv(bytea, bytea, bytea, text)
- digest(bytea, text)
- digest(text, text)
- encrypt(bytea, bytea, text)
- encrypt_iv(bytea, bytea, bytea, text)
- float4_dist(real, real)
- float8_dist(double precision, double precision)
- gbt_bit_compress(internal)
- gbt_bit_consistent(internal, "bit", smallint, oid, internal)
- gbt_bit_penalty(internal, internal, internal)
- gbt_bit_picksplit(internal, internal)
- gbt_bit_same(public.gbtreekey_var, public.gbtreekey_var, internal)
- gbt_bit_union(internal, internal)
- gbt_bpchar_compress(internal)
- gbt_bpchar_consistent(internal, bpchar, smallint, oid, internal)
- gbt_bytea_compress(internal)
- gbt_bytea_consistent(internal, bytea, smallint, oid, internal)
- gbt_bytea_penalty(internal, internal, internal)
- gbt_bytea_picksplit(internal, internal)
- gbt_bytea_same(public.gbtreekey_var, public.gbtreekey_var, internal)
- gbt_bytea_union(internal, internal)
- gbt_cash_compress(internal)
- gbt_cash_consistent(internal, money, smallint, oid, internal)
- gbt_cash_distance(internal, money, smallint, oid, internal)
- gbt_cash_fetch(internal)
- gbt_cash_penalty(internal, internal, internal)
- gbt_cash_picksplit(internal, internal)
- gbt_cash_same(public.gbtreekey16, public.gbtreekey16, internal)
- gbt_cash_union(internal, internal)
- gbt_date_compress(internal)
- gbt_date_consistent(internal, date, smallint, oid, internal)
- gbt_date_distance(internal, date, smallint, oid, internal)
- gbt_date_fetch(internal)
- gbt_date_penalty(internal, internal, internal)
- gbt_date_picksplit(internal, internal)
- gbt_date_same(public.gbtreekey8, public.gbtreekey8, internal)
- gbt_date_union(internal, internal)
- gbt_decompress(internal)
- gbt_enum_compress(internal)
- gbt_enum_consistent(internal, anyenum, smallint, oid, internal)
- gbt_enum_fetch(internal)
- gbt_enum_penalty(internal, internal, internal)
- gbt_enum_picksplit(internal, internal)
- gbt_enum_same(public.gbtreekey8, public.gbtreekey8, internal)
- gbt_enum_union(internal, internal)
- gbt_float4_compress(internal)
- gbt_float4_consistent(internal, real, smallint, oid, internal)
- gbt_float4_distance(internal, real, smallint, oid, internal)
- gbt_float4_fetch(internal)
- gbt_float4_penalty(internal, internal, internal)
- gbt_float4_picksplit(internal, internal)
- gbt_float4_same(public.gbtreekey8, public.gbtreekey8, internal)
- gbt_float4_union(internal, internal)
- gbt_float8_compress(internal)
- gbt_float8_consistent(internal, double precision, smallint, oid, internal)
- gbt_float8_distance(internal, double precision, smallint, oid, internal)
- gbt_float8_fetch(internal)
- gbt_float8_penalty(internal, internal, internal)
- gbt_float8_picksplit(internal, internal)
- gbt_float8_same(public.gbtreekey16, public.gbtreekey16, internal)
- gbt_float8_union(internal, internal)
- gbt_inet_compress(internal)
- gbt_inet_consistent(internal, inet, smallint, oid, internal)
- gbt_inet_penalty(internal, internal, internal)
- gbt_inet_picksplit(internal, internal)
- gbt_inet_same(public.gbtreekey16, public.gbtreekey16, internal)
- gbt_inet_union(internal, internal)
- gbt_int2_compress(internal)
- gbt_int2_consistent(internal, smallint, smallint, oid, internal)
- gbt_int2_distance(internal, smallint, smallint, oid, internal)
- gbt_int2_fetch(internal)
- gbt_int2_penalty(internal, internal, internal)
- gbt_int2_picksplit(internal, internal)
- gbt_int2_same(public.gbtreekey4, public.gbtreekey4, internal)
- gbt_int2_union(internal, internal)
- gbt_int4_compress(internal)
- gbt_int4_consistent(internal, integer, smallint, oid, internal)
- gbt_int4_distance(internal, integer, smallint, oid, internal)
- gbt_int4_fetch(internal)
- gbt_int4_penalty(internal, internal, internal)
- gbt_int4_picksplit(internal, internal)
- gbt_int4_same(public.gbtreekey8, public.gbtreekey8, internal)
- gbt_int4_union(internal, internal)
- gbt_int8_compress(internal)
- gbt_int8_consistent(internal, bigint, smallint, oid, internal)
- gbt_int8_distance(internal, bigint, smallint, oid, internal)
- gbt_int8_fetch(internal)
- gbt_int8_penalty(internal, internal, internal)
- gbt_int8_picksplit(internal, internal)
- gbt_int8_same(public.gbtreekey16, public.gbtreekey16, internal)
- gbt_int8_union(internal, internal)
- gbt_intv_compress(internal)
- gbt_intv_consistent(internal, interval, smallint, oid, internal)
- gbt_intv_decompress(internal)
- gbt_intv_distance(internal, interval, smallint, oid, internal)
- gbt_intv_fetch(internal)
- gbt_intv_penalty(internal, internal, internal)
- gbt_intv_picksplit(internal, internal)
- gbt_intv_same(public.gbtreekey32, public.gbtreekey32, internal)
- gbt_intv_union(internal, internal)
- gbt_macad8_compress(internal)
- gbt_macad8_consistent(internal, macaddr8, smallint, oid, internal)
- gbt_macad8_fetch(internal)
- gbt_macad8_penalty(internal, internal, internal)
- gbt_macad8_picksplit(internal, internal)
- gbt_macad8_same(public.gbtreekey16, public.gbtreekey16, internal)
- gbt_macad8_union(internal, internal)
- gbt_macad_compress(internal)
- gbt_macad_consistent(internal, macaddr, smallint, oid, internal)
- gbt_macad_fetch(internal)
- gbt_macad_penalty(internal, internal, internal)
- gbt_macad_picksplit(internal, internal)
- gbt_macad_same(public.gbtreekey16, public.gbtreekey16, internal)
- gbt_macad_union(internal, internal)
- gbt_numeric_compress(internal)
- gbt_numeric_consistent(internal, numeric, smallint, oid, internal)
- gbt_numeric_penalty(internal, internal, internal)
- gbt_numeric_picksplit(internal, internal)
- gbt_numeric_same(public.gbtreekey_var, public.gbtreekey_var, internal)
- gbt_numeric_union(internal, internal)
- gbt_oid_compress(internal)
- gbt_oid_consistent(internal, oid, smallint, oid, internal)
- gbt_oid_distance(internal, oid, smallint, oid, internal)
- gbt_oid_fetch(internal)
- gbt_oid_penalty(internal, internal, internal)
- gbt_oid_picksplit(internal, internal)
- gbt_oid_same(public.gbtreekey8, public.gbtreekey8, internal)
- gbt_oid_union(internal, internal)
- gbt_text_compress(internal)
- gbt_text_consistent(internal, text, smallint, oid, internal)
- gbt_text_penalty(internal, internal, internal)
- gbt_text_picksplit(internal, internal)
- gbt_text_same(public.gbtreekey_var, public.gbtreekey_var, internal)
- gbt_text_union(internal, internal)
- gbt_time_compress(internal)
- gbt_time_consistent(internal, time without time zone, smallint, oid, internal)
- gbt_time_distance(internal, time without time zone, smallint, oid, internal)
- gbt_time_fetch(internal)
- gbt_time_penalty(internal, internal, internal)
- gbt_time_picksplit(internal, internal)
- gbt_time_same(public.gbtreekey16, public.gbtreekey16, internal)
- gbt_time_union(internal, internal)
- gbt_timetz_compress(internal)
- gbt_timetz_consistent(internal, time with time zone, smallint, oid, internal)
- gbt_ts_compress(internal)
- gbt_ts_consistent(internal, timestamp without time zone, smallint, oid, internal)
- gbt_ts_distance(internal, timestamp without time zone, smallint, oid, internal)
- gbt_ts_fetch(internal)
- gbt_ts_penalty(internal, internal, internal)
- gbt_ts_picksplit(internal, internal)
- gbt_ts_same(public.gbtreekey16, public.gbtreekey16, internal)
- gbt_ts_union(internal, internal)
- gbt_tstz_compress(internal)
- gbt_tstz_consistent(internal, timestamp with time zone, smallint, oid, internal)
- gbt_tstz_distance(internal, timestamp with time zone, smallint, oid, internal)
- gbt_uuid_compress(internal)
- gbt_uuid_consistent(internal, uuid, smallint, oid, internal)
- gbt_uuid_fetch(internal)
- gbt_uuid_penalty(internal, internal, internal)
- gbt_uuid_picksplit(internal, internal)
- gbt_uuid_same(public.gbtreekey32, public.gbtreekey32, internal)
- gbt_uuid_union(internal, internal)
- gbt_var_decompress(internal)
- gbt_var_fetch(internal)
- gbtreekey16_in(cstring)
- gbtreekey16_out(public.gbtreekey16)
- gbtreekey32_in(cstring)
- gbtreekey32_out(public.gbtreekey32)
- gbtreekey4_in(cstring)
- gbtreekey4_out(public.gbtreekey4)
- gbtreekey8_in(cstring)
- gbtreekey8_out(public.gbtreekey8)
- gbtreekey_var_in(cstring)
- gbtreekey_var_out(public.gbtreekey_var)
- gen_random_bytes(integer)
- gen_random_uuid()
- gen_salt(text)
- gen_salt(text, integer)
- hash_sha1(text)
- hmac(bytea, bytea, text)
- hmac(text, text, text)
- int2_dist(smallint, smallint)
- int4_dist(integer, integer)
- int8_dist(bigint, bigint)
- interval_dist(interval, interval)
- notify_new_content()
- notify_new_directory()
- notify_new_origin()
- notify_new_origin_visit()
- notify_new_release()
- notify_new_revision()
- notify_new_skipped_content()
- oid_dist(oid, oid)
- pgp_armor_headers(value text)
- pgp_key_id(bytea)
- pgp_pub_decrypt(bytea, bytea)
- pgp_pub_decrypt(bytea, bytea, text)
- pgp_pub_decrypt(bytea, bytea, text, text)
- pgp_pub_decrypt_bytea(bytea, bytea)
- pgp_pub_decrypt_bytea(bytea, bytea, text)
- pgp_pub_decrypt_bytea(bytea, bytea, text, text)
- pgp_pub_encrypt(text, bytea)
- pgp_pub_encrypt(text, bytea, text)
- pgp_pub_encrypt_bytea(bytea, bytea)
- pgp_pub_encrypt_bytea(bytea, bytea, text)
- pgp_sym_decrypt(bytea, text)
- pgp_sym_decrypt(bytea, text, text)
- pgp_sym_decrypt_bytea(bytea, text)
- pgp_sym_decrypt_bytea(bytea, text, text)
- pgp_sym_encrypt(text, text)
- pgp_sym_encrypt(text, text, text)
- pgp_sym_encrypt_bytea(bytea, text)
- pgp_sym_encrypt_bytea(bytea, text, text)
- swh_content_add()
- swh_content_find(blake2s256 public.sha1, sha256 public.sha1_git, sha1_git public.sha256, sha1 public.blake2s256)
- swh_content_find_directory(content_id public.sha1)
- swh_content_list_by_object_id(max_incl bigint, min_excl bigint)
- swh_content_update(columns_update text[])
- swh_directory_add()
- swh_directory_entry_add(typ public.directory_entry_type)
- swh_directory_missing()
- swh_directory_walk(walked_dir_id public.sha1_git)
- swh_directory_walk_one(walked_dir_id public.sha1_git)
- swh_find_directory_entry_by_path(dir_or_content_path public.sha1_git, walked_dir_id bytea[])
- swh_mktemp(tblname regclass)
- swh_mktemp_dir_entry(tblname regclass)
- swh_mktemp_occurrence_history()
- swh_mktemp_release()
- swh_mktemp_revision()
- swh_mktemp_snapshot_branch()
- swh_mktemp_tool()
- swh_occurrence_get_by(date bigint, branch_name bytea, origin_id timestamp with time zone)
- swh_occurrence_history_add()
- swh_origin_metadata_get_by_origin(origin integer)
- swh_origin_metadata_get_by_provider_type(type integer, origin text)
- swh_origin_visit_add(date bigint, origin_id timestamp with time zone)
- swh_person_add_from_release()
- swh_person_add_from_revision()
- swh_release_add()
- swh_release_list_by_object_id(max_incl bigint, min_excl bigint)
- swh_revision_add()
- swh_revision_get_by(date bigint, branch_name bytea, origin_id timestamp with time zone)
- swh_revision_list(parents bytea[], id bigint)
- swh_revision_list_by_object_id(max_incl bigint, min_excl bigint)
- swh_revision_list_children(parents bytea[], id bigint)
- swh_revision_log(num_revs bytea[], root_revisions bigint)
- swh_revision_walk(revision_id public.sha1_git)
- swh_skipped_content_add()
- swh_skipped_content_missing()
- swh_snapshot_add(snapshot_id bigint, visit bigint, origin public.sha1_git)
- swh_snapshot_count_branches(id public.sha1_git)
- swh_snapshot_get_by_id(target_types public.sha1_git, branches_count bytea, branches_from bigint, id public.snapshot_target[])
- swh_snapshot_get_by_origin_visit(visit_id bigint, origin_id bigint)
- swh_stat_counters()
- swh_tool_add()
- swh_update_counter(object_type text)
- swh_update_counter_bucketed()
- swh_update_counters_from_buckets()
- swh_visit_find_by_date(visit_date bigint, origin timestamp with time zone)
- swh_visit_get(origin bigint)
- time_dist(time without time zone, time without time zone)
- ts_dist(timestamp without time zone, timestamp without time zone)
- tstz_dist(timestamp with time zone, timestamp with time zone)

## Table: content

content Structure
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

content_blake2s256_idx blake2s256 content_ctime_idx ctime content_sha256_idx sha256

Index - Schema public

## Table: dbversion

dbversion Structure
F-Key | Name | Type | Description
--- | --- | --- | ---
| version | integer | PRIMARY KEY
| release | timestamp with time zone |
| description | text |

Index - Schema public

## Table: directory

directory Structure
F-Key | Name | Type | Description
--- | --- | --- | ---
| id | sha1_git | PRIMARY KEY
| dir_entries | bigint[] |
| file_entries | bigint[] |
| rev_entries | bigint[] |
| object_id | bigserial | NOT NULL

directory_dir_entries_idx dir_entries directory_file_entries_idx file_entries directory_rev_entries_idx rev_entries

Index - Schema public

## Table: directory_entry_dir

directory_entry_dir Structure
F-Key | Name | Type | Description
--- | --- | --- | ---
| id | bigserial | PRIMARY KEY
| target | sha1_git |
| name | unix_path |
| perms | file_perms |

Index - Schema public

## Table: directory_entry_file

directory_entry_file Structure
F-Key | Name | Type | Description
--- | --- | --- | ---
| id | bigserial | PRIMARY KEY
| target | sha1_git |
| name | unix_path |
| perms | file_perms |

Index - Schema public

## Table: directory_entry_rev

directory_entry_rev Structure
F-Key | Name | Type | Description
--- | --- | --- | ---
| id | bigserial | PRIMARY KEY
| target | sha1_git |
| name | unix_path |
| perms | file_perms |

Index - Schema public

## Table: fetch_history

fetch_history Structure
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 |

Index - Schema public

## Table: metadata_provider

Metadata provider information

metadata_provider Structure
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:

- origin_metadata

metadata_provider_provider_name_provider_url_idx provider_name, provider_url

Index - Schema public

## Table: object_counts

object_counts Structure
F-Key | Name | Type | Description
--- | --- | --- | ---
| object_type | text | PRIMARY KEY
| value | bigint |
| last_update | timestamp with time zone |
| single_update | boolean |

Index - Schema public

## Table: object_counts_bucketed

object_counts_bucketed Structure
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 |

Index - Schema public

## Table: occurrence_history

occurrence_history Structure
F-Key | Name | Type | Description
--- | --- | --- | ---
origin.id | origin | bigint | NOT NULL
| branch | bytea | NOT NULL
| target | sha1_git | NOT NULL
| target_type | object_type | NOT NULL
| visits | bigint[] | NOT NULL
| object_id | bigserial | PRIMARY KEY
| snapshot_branch_id | bigint |

occurrence_history_origin_branch_idx origin, branch occurrence_history_target_target_type_idx target, target_type

Index - Schema public

## Table: origin

origin Structure
F-Key | Name | Type | Description
--- | --- | --- | ---
| id | bigserial | PRIMARY KEY
| type | text |
| url | text | NOT NULL

Tables referencing this one via Foreign Key Constraints:

- fetch_history

- occurrence_history

- origin_metadata

- origin_visit

- skipped_content

origin_type_url_idx type, url

Index - Schema public

## Table: origin_metadata

keeps all metadata found concerning an origin

origin_metadata Structure
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

origin_metadata_origin_id_provider_id_tool_id_idx origin_id, provider_id, tool_id

Index - Schema public

## Table: origin_visit

origin_visit Structure
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

origin_visit_date_idx date

Index - Schema public

## Table: person

person Structure
F-Key | Name | Type | Description
--- | --- | --- | ---
| id | bigserial | PRIMARY KEY
| name | bytea |
| email | bytea |
| fullname | bytea | NOT NULL

Tables referencing this one via Foreign Key Constraints:

- release

- revision

person_email_idx email person_name_idx name

Index - Schema public

## Table: release

release Structure
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 |

release_target_target_type_idx target, target_type

Index - Schema public

## Table: revision

revision Structure
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_history

revision_directory_idx directory

Index - Schema public

## Table: revision_history

revision_history Structure
F-Key | Name | Type | Description
--- | --- | --- | ---
revision.id | id | sha1_git | PRIMARY KEY
| parent_id | sha1_git |
| parent_rank | integer | PRIMARY KEY

revision_history_parent_id_idx parent_id

Index - Schema public

## Table: skipped_content

skipped_content Structure
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

skipped_content_blake2s256_idx blake2s256 skipped_content_sha1_git_idx sha1_git skipped_content_sha1_idx sha1 skipped_content_sha256_idx sha256

Index - Schema public

## Table: snapshot

snapshot Structure
F-Key | Name | Type | Description
--- | --- | --- | ---
| object_id | bigserial | PRIMARY KEY
| id | sha1_git |

Tables referencing this one via Foreign Key Constraints:

- origin_visit

- snapshot_branches

Index - Schema public

## Table: snapshot_branch

snapshot_branch Structure
F-Key | Name | Type | Description
--- | --- | --- | ---
| object_id | bigserial | PRIMARY KEY
| name | bytea | NOT NULL
| target | bytea |
| target_type | snapshot_target |

snapshot_branch Constraints
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:

- snapshot_branches

Index - Schema public

## Table: snapshot_branches

snapshot_branches Structure
F-Key | Name | Type | Description
--- | --- | --- | ---
snapshot.object_id | snapshot_id | bigint | PRIMARY KEY
snapshot_branch.object_id | branch_id | bigint | PRIMARY KEY

Index - Schema public

## Table: tool

Tool information

tool Structure
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:

- origin_metadata

Index - Schema public

## Function: armor(bytea)

### Returns: text

### Language: C

    pg_armor

## Function: armor(bytea, text[], text[])

### Returns: text

### Language: C

    pg_armor

## Function: cash_dist(money, money)

### Returns: money

### Language: C

    cash_dist

## Function: crypt(text, text)

### Returns: text

### Language: C

    pg_crypt

## Function: date_dist(date, date)

### Returns: integer

### Language: C

    date_dist

## Function: dearmor(text)

### Returns: bytea

### Language: C

    pg_dearmor

## Function: decrypt(bytea, bytea, text)

### Returns: bytea

### Language: C

    pg_decrypt

## Function: decrypt_iv(bytea, bytea, bytea, text)

### Returns: bytea

### Language: C

    pg_decrypt_iv

## Function: digest(bytea, text)

### Returns: bytea

### Language: C

    pg_digest

## Function: digest(text, text)

### Returns: bytea

### Language: C

    pg_digest

## Function: encrypt(bytea, bytea, text)

### Returns: bytea

### Language: C

    pg_encrypt

## Function: encrypt_iv(bytea, bytea, bytea, text)

### Returns: bytea

### Language: C

    pg_encrypt_iv

## Function: float4_dist(real, real)

### Returns: real

### Language: C

    float4_dist

## Function: float8_dist(double precision, double precision)

### Returns: double precision

### Language: C

    float8_dist

## Function: gbt_bit_compress(internal)

### Returns: internal

### Language: C

    gbt_bit_compress

## Function: gbt_bit_consistent(internal, "bit", smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_bit_consistent

## Function: gbt_bit_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_bit_penalty

## Function: gbt_bit_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_bit_picksplit

## Function: gbt_bit_same(public.gbtreekey_var, public.gbtreekey_var, internal)

### Returns: internal

### Language: C

    gbt_bit_same

## Function: gbt_bit_union(internal, internal)

### Returns: gbtreekey_var

### Language: C

    gbt_bit_union

## Function: gbt_bpchar_compress(internal)

### Returns: internal

### Language: C

    gbt_bpchar_compress

## Function: gbt_bpchar_consistent(internal, bpchar, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_bpchar_consistent

## Function: gbt_bytea_compress(internal)

### Returns: internal

### Language: C

    gbt_bytea_compress

## Function: gbt_bytea_consistent(internal, bytea, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_bytea_consistent

## Function: gbt_bytea_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_bytea_penalty

## Function: gbt_bytea_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_bytea_picksplit

## Function: gbt_bytea_same(public.gbtreekey_var, public.gbtreekey_var, internal)

### Returns: internal

### Language: C

    gbt_bytea_same

## Function: gbt_bytea_union(internal, internal)

### Returns: gbtreekey_var

### Language: C

    gbt_bytea_union

## Function: gbt_cash_compress(internal)

### Returns: internal

### Language: C

    gbt_cash_compress

## Function: gbt_cash_consistent(internal, money, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_cash_consistent

## Function: gbt_cash_distance(internal, money, smallint, oid, internal)

### Returns: double precision

### Language: C

    gbt_cash_distance

## Function: gbt_cash_fetch(internal)

### Returns: internal

### Language: C

    gbt_cash_fetch

## Function: gbt_cash_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_cash_penalty

## Function: gbt_cash_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_cash_picksplit

## Function: gbt_cash_same(public.gbtreekey16, public.gbtreekey16, internal)

### Returns: internal

### Language: C

    gbt_cash_same

## Function: gbt_cash_union(internal, internal)

### Returns: gbtreekey16

### Language: C

    gbt_cash_union

## Function: gbt_date_compress(internal)

### Returns: internal

### Language: C

    gbt_date_compress

## Function: gbt_date_consistent(internal, date, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_date_consistent

## Function: gbt_date_distance(internal, date, smallint, oid, internal)

### Returns: double precision

### Language: C

    gbt_date_distance

## Function: gbt_date_fetch(internal)

### Returns: internal

### Language: C

    gbt_date_fetch

## Function: gbt_date_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_date_penalty

## Function: gbt_date_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_date_picksplit

## Function: gbt_date_same(public.gbtreekey8, public.gbtreekey8, internal)

### Returns: internal

### Language: C

    gbt_date_same

## Function: gbt_date_union(internal, internal)

### Returns: gbtreekey8

### Language: C

    gbt_date_union

## Function: gbt_decompress(internal)

### Returns: internal

### Language: C

    gbt_decompress

## Function: gbt_enum_compress(internal)

### Returns: internal

### Language: C

    gbt_enum_compress

## Function: gbt_enum_consistent(internal, anyenum, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_enum_consistent

## Function: gbt_enum_fetch(internal)

### Returns: internal

### Language: C

    gbt_enum_fetch

## Function: gbt_enum_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_enum_penalty

## Function: gbt_enum_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_enum_picksplit

## Function: gbt_enum_same(public.gbtreekey8, public.gbtreekey8, internal)

### Returns: internal

### Language: C

    gbt_enum_same

## Function: gbt_enum_union(internal, internal)

### Returns: gbtreekey8

### Language: C

    gbt_enum_union

## Function: gbt_float4_compress(internal)

### Returns: internal

### Language: C

    gbt_float4_compress

## Function: gbt_float4_consistent(internal, real, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_float4_consistent

## Function: gbt_float4_distance(internal, real, smallint, oid, internal)

### Returns: double precision

### Language: C

    gbt_float4_distance

## Function: gbt_float4_fetch(internal)

### Returns: internal

### Language: C

    gbt_float4_fetch

## Function: gbt_float4_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_float4_penalty

## Function: gbt_float4_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_float4_picksplit

## Function: gbt_float4_same(public.gbtreekey8, public.gbtreekey8, internal)

### Returns: internal

### Language: C

    gbt_float4_same

## Function: gbt_float4_union(internal, internal)

### Returns: gbtreekey8

### Language: C

    gbt_float4_union

## Function: gbt_float8_compress(internal)

### Returns: internal

### Language: C

    gbt_float8_compress

## Function: gbt_float8_consistent(internal, double precision, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_float8_consistent

## Function: gbt_float8_distance(internal, double precision, smallint, oid, internal)

### Returns: double precision

### Language: C

    gbt_float8_distance

## Function: gbt_float8_fetch(internal)

### Returns: internal

### Language: C

    gbt_float8_fetch

## Function: gbt_float8_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_float8_penalty

## Function: gbt_float8_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_float8_picksplit

## Function: gbt_float8_same(public.gbtreekey16, public.gbtreekey16, internal)

### Returns: internal

### Language: C

    gbt_float8_same

## Function: gbt_float8_union(internal, internal)

### Returns: gbtreekey16

### Language: C

    gbt_float8_union

## Function: gbt_inet_compress(internal)

### Returns: internal

### Language: C

    gbt_inet_compress

## Function: gbt_inet_consistent(internal, inet, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_inet_consistent

## Function: gbt_inet_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_inet_penalty

## Function: gbt_inet_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_inet_picksplit

## Function: gbt_inet_same(public.gbtreekey16, public.gbtreekey16, internal)

### Returns: internal

### Language: C

    gbt_inet_same

## Function: gbt_inet_union(internal, internal)

### Returns: gbtreekey16

### Language: C

    gbt_inet_union

## Function: gbt_int2_compress(internal)

### Returns: internal

### Language: C

    gbt_int2_compress

## Function: gbt_int2_consistent(internal, smallint, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_int2_consistent

## Function: gbt_int2_distance(internal, smallint, smallint, oid, internal)

### Returns: double precision

### Language: C

    gbt_int2_distance

## Function: gbt_int2_fetch(internal)

### Returns: internal

### Language: C

    gbt_int2_fetch

## Function: gbt_int2_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_int2_penalty

## Function: gbt_int2_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_int2_picksplit

## Function: gbt_int2_same(public.gbtreekey4, public.gbtreekey4, internal)

### Returns: internal

### Language: C

    gbt_int2_same

## Function: gbt_int2_union(internal, internal)

### Returns: gbtreekey4

### Language: C

    gbt_int2_union

## Function: gbt_int4_compress(internal)

### Returns: internal

### Language: C

    gbt_int4_compress

## Function: gbt_int4_consistent(internal, integer, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_int4_consistent

## Function: gbt_int4_distance(internal, integer, smallint, oid, internal)

### Returns: double precision

### Language: C

    gbt_int4_distance

## Function: gbt_int4_fetch(internal)

### Returns: internal

### Language: C

    gbt_int4_fetch

## Function: gbt_int4_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_int4_penalty

## Function: gbt_int4_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_int4_picksplit

## Function: gbt_int4_same(public.gbtreekey8, public.gbtreekey8, internal)

### Returns: internal

### Language: C

    gbt_int4_same

## Function: gbt_int4_union(internal, internal)

### Returns: gbtreekey8

### Language: C

    gbt_int4_union

## Function: gbt_int8_compress(internal)

### Returns: internal

### Language: C

    gbt_int8_compress

## Function: gbt_int8_consistent(internal, bigint, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_int8_consistent

## Function: gbt_int8_distance(internal, bigint, smallint, oid, internal)

### Returns: double precision

### Language: C

    gbt_int8_distance

## Function: gbt_int8_fetch(internal)

### Returns: internal

### Language: C

    gbt_int8_fetch

## Function: gbt_int8_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_int8_penalty

## Function: gbt_int8_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_int8_picksplit

## Function: gbt_int8_same(public.gbtreekey16, public.gbtreekey16, internal)

### Returns: internal

### Language: C

    gbt_int8_same

## Function: gbt_int8_union(internal, internal)

### Returns: gbtreekey16

### Language: C

    gbt_int8_union

## Function: gbt_intv_compress(internal)

### Returns: internal

### Language: C

    gbt_intv_compress

## Function: gbt_intv_consistent(internal, interval, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_intv_consistent

## Function: gbt_intv_decompress(internal)

### Returns: internal

### Language: C

    gbt_intv_decompress

## Function: gbt_intv_distance(internal, interval, smallint, oid, internal)

### Returns: double precision

### Language: C

    gbt_intv_distance

## Function: gbt_intv_fetch(internal)

### Returns: internal

### Language: C

    gbt_intv_fetch

## Function: gbt_intv_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_intv_penalty

## Function: gbt_intv_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_intv_picksplit

## Function: gbt_intv_same(public.gbtreekey32, public.gbtreekey32, internal)

### Returns: internal

### Language: C

    gbt_intv_same

## Function: gbt_intv_union(internal, internal)

### Returns: gbtreekey32

### Language: C

    gbt_intv_union

## Function: gbt_macad8_compress(internal)

### Returns: internal

### Language: C

    gbt_macad8_compress

## Function: gbt_macad8_consistent(internal, macaddr8, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_macad8_consistent

## Function: gbt_macad8_fetch(internal)

### Returns: internal

### Language: C

    gbt_macad8_fetch

## Function: gbt_macad8_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_macad8_penalty

## Function: gbt_macad8_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_macad8_picksplit

## Function: gbt_macad8_same(public.gbtreekey16, public.gbtreekey16, internal)

### Returns: internal

### Language: C

    gbt_macad8_same

## Function: gbt_macad8_union(internal, internal)

### Returns: gbtreekey16

### Language: C

    gbt_macad8_union

## Function: gbt_macad_compress(internal)

### Returns: internal

### Language: C

    gbt_macad_compress

## Function: gbt_macad_consistent(internal, macaddr, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_macad_consistent

## Function: gbt_macad_fetch(internal)

### Returns: internal

### Language: C

    gbt_macad_fetch

## Function: gbt_macad_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_macad_penalty

## Function: gbt_macad_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_macad_picksplit

## Function: gbt_macad_same(public.gbtreekey16, public.gbtreekey16, internal)

### Returns: internal

### Language: C

    gbt_macad_same

## Function: gbt_macad_union(internal, internal)

### Returns: gbtreekey16

### Language: C

    gbt_macad_union

## Function: gbt_numeric_compress(internal)

### Returns: internal

### Language: C

    gbt_numeric_compress

## Function: gbt_numeric_consistent(internal, numeric, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_numeric_consistent

## Function: gbt_numeric_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_numeric_penalty

## Function: gbt_numeric_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_numeric_picksplit

## Function: gbt_numeric_same(public.gbtreekey_var, public.gbtreekey_var, internal)

### Returns: internal

### Language: C

    gbt_numeric_same

## Function: gbt_numeric_union(internal, internal)

### Returns: gbtreekey_var

### Language: C

    gbt_numeric_union

## Function: gbt_oid_compress(internal)

### Returns: internal

### Language: C

    gbt_oid_compress

## Function: gbt_oid_consistent(internal, oid, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_oid_consistent

## Function: gbt_oid_distance(internal, oid, smallint, oid, internal)

### Returns: double precision

### Language: C

    gbt_oid_distance

## Function: gbt_oid_fetch(internal)

### Returns: internal

### Language: C

    gbt_oid_fetch

## Function: gbt_oid_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_oid_penalty

## Function: gbt_oid_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_oid_picksplit

## Function: gbt_oid_same(public.gbtreekey8, public.gbtreekey8, internal)

### Returns: internal

### Language: C

    gbt_oid_same

## Function: gbt_oid_union(internal, internal)

### Returns: gbtreekey8

### Language: C

    gbt_oid_union

## Function: gbt_text_compress(internal)

### Returns: internal

### Language: C

    gbt_text_compress

## Function: gbt_text_consistent(internal, text, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_text_consistent

## Function: gbt_text_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_text_penalty

## Function: gbt_text_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_text_picksplit

## Function: gbt_text_same(public.gbtreekey_var, public.gbtreekey_var, internal)

### Returns: internal

### Language: C

    gbt_text_same

## Function: gbt_text_union(internal, internal)

### Returns: gbtreekey_var

### Language: C

    gbt_text_union

## Function: gbt_time_compress(internal)

### Returns: internal

### Language: C

    gbt_time_compress

## Function: gbt_time_consistent(internal, time without time zone, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_time_consistent

## Function: gbt_time_distance(internal, time without time zone, smallint, oid, internal)

### Returns: double precision

### Language: C

    gbt_time_distance

## Function: gbt_time_fetch(internal)

### Returns: internal

### Language: C

    gbt_time_fetch

## Function: gbt_time_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_time_penalty

## Function: gbt_time_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_time_picksplit

## Function: gbt_time_same(public.gbtreekey16, public.gbtreekey16, internal)

### Returns: internal

### Language: C

    gbt_time_same

## Function: gbt_time_union(internal, internal)

### Returns: gbtreekey16

### Language: C

    gbt_time_union

## Function: gbt_timetz_compress(internal)

### Returns: internal

### Language: C

    gbt_timetz_compress

## Function: gbt_timetz_consistent(internal, time with time zone, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_timetz_consistent

## Function: gbt_ts_compress(internal)

### Returns: internal

### Language: C

    gbt_ts_compress

## Function: gbt_ts_consistent(internal, timestamp without time zone, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_ts_consistent

## Function: gbt_ts_distance(internal, timestamp without time zone, smallint, oid, internal)

### Returns: double precision

### Language: C

    gbt_ts_distance

## Function: gbt_ts_fetch(internal)

### Returns: internal

### Language: C

    gbt_ts_fetch

## Function: gbt_ts_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_ts_penalty

## Function: gbt_ts_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_ts_picksplit

## Function: gbt_ts_same(public.gbtreekey16, public.gbtreekey16, internal)

### Returns: internal

### Language: C

    gbt_ts_same

## Function: gbt_ts_union(internal, internal)

### Returns: gbtreekey16

### Language: C

    gbt_ts_union

## Function: gbt_tstz_compress(internal)

### Returns: internal

### Language: C

    gbt_tstz_compress

## Function: gbt_tstz_consistent(internal, timestamp with time zone, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_tstz_consistent

## Function: gbt_tstz_distance(internal, timestamp with time zone, smallint, oid, internal)

### Returns: double precision

### Language: C

    gbt_tstz_distance

## Function: gbt_uuid_compress(internal)

### Returns: internal

### Language: C

    gbt_uuid_compress

## Function: gbt_uuid_consistent(internal, uuid, smallint, oid, internal)

### Returns: boolean

### Language: C

    gbt_uuid_consistent

## Function: gbt_uuid_fetch(internal)

### Returns: internal

### Language: C

    gbt_uuid_fetch

## Function: gbt_uuid_penalty(internal, internal, internal)

### Returns: internal

### Language: C

    gbt_uuid_penalty

## Function: gbt_uuid_picksplit(internal, internal)

### Returns: internal

### Language: C

    gbt_uuid_picksplit

## Function: gbt_uuid_same(public.gbtreekey32, public.gbtreekey32, internal)

### Returns: internal

### Language: C

    gbt_uuid_same

## Function: gbt_uuid_union(internal, internal)

### Returns: gbtreekey32

### Language: C

    gbt_uuid_union

## Function: gbt_var_decompress(internal)

### Returns: internal

### Language: C

    gbt_var_decompress

## Function: gbt_var_fetch(internal)

### Returns: internal

### Language: C

    gbt_var_fetch

## Function: gbtreekey16_in(cstring)

### Returns: gbtreekey16

### Language: C

    gbtreekey_in

## Function: gbtreekey16_out(public.gbtreekey16)

### Returns: cstring

### Language: C

    gbtreekey_out

## Function: gbtreekey32_in(cstring)

### Returns: gbtreekey32

### Language: C

    gbtreekey_in

## Function: gbtreekey32_out(public.gbtreekey32)

### Returns: cstring

### Language: C

    gbtreekey_out

## Function: gbtreekey4_in(cstring)

### Returns: gbtreekey4

### Language: C

    gbtreekey_in

## Function: gbtreekey4_out(public.gbtreekey4)

### Returns: cstring

### Language: C

    gbtreekey_out

## Function: gbtreekey8_in(cstring)

### Returns: gbtreekey8

### Language: C

    gbtreekey_in

## Function: gbtreekey8_out(public.gbtreekey8)

### Returns: cstring

### Language: C

    gbtreekey_out

## Function: gbtreekey_var_in(cstring)

### Returns: gbtreekey_var

### Language: C

    gbtreekey_in

## Function: gbtreekey_var_out(public.gbtreekey_var)

### Returns: cstring

### Language: C

    gbtreekey_out

## Function: gen_random_bytes(integer)

### Returns: bytea

### Language: C

    pg_random_bytes

## Function: gen_random_uuid()

### Returns: uuid

### Language: C

    pg_random_uuid

## Function: gen_salt(text)

### Returns: text

### Language: C

    pg_gen_salt

## Function: gen_salt(text, integer)

### Returns: text

### Language: C

    pg_gen_salt_rounds

## Function: hash_sha1(text)

### Returns: text

### Language: SQL

Compute SHA1 hash as text

       select encode(digest($1, 'sha1'), 'hex')

## Function: hmac(bytea, bytea, text)

### Returns: bytea

### Language: C

    pg_hmac

## Function: hmac(text, text, text)

### Returns: bytea

### Language: C

    pg_hmac

## Function: int2_dist(smallint, smallint)

### Returns: smallint

### Language: C

    int2_dist

## Function: int4_dist(integer, integer)

### Returns: integer

### Language: C

    int4_dist

## Function: int8_dist(bigint, bigint)

### Returns: bigint

### Language: C

    int8_dist

## Function: interval_dist(interval, interval)

### Returns: interval

### Language: C

    interval_dist

## Function: notify_new_content()

### Returns: trigger

### Language: PLPGSQL

      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;

## Function: notify_new_directory()

### Returns: trigger

### Language: PLPGSQL

      begin
        perform pg_notify('new_directory', json_build_object('id', encode(new.id, 'hex'))::text);
        return null;
      end;

## Function: notify_new_origin()

### Returns: trigger

### Language: PLPGSQL

      begin
        perform pg_notify('new_origin', json_build_object('id', new.id)::text);
        return null;
      end;

## Function: notify_new_origin_visit()

### Returns: trigger

### Language: PLPGSQL

      begin
        perform pg_notify('new_origin_visit', json_build_object(
          'origin', new.origin,
          'visit', new.visit
        )::text);
        return null;
      end;

## Function: notify_new_release()

### Returns: trigger

### Language: PLPGSQL

      begin
        perform pg_notify('new_release', json_build_object('id', encode(new.id, 'hex'))::text);
        return null;
      end;

## Function: notify_new_revision()

### Returns: trigger

### Language: PLPGSQL

      begin
        perform pg_notify('new_revision', json_build_object('id', encode(new.id, 'hex'))::text);
        return null;
      end;

## Function: notify_new_skipped_content()

### Returns: trigger

### Language: PLPGSQL

      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;

## Function: oid_dist(oid, oid)

### Returns: oid

### Language: C

    oid_dist

## Function: pgp_armor_headers(value text)

### Returns: SET OF record

### Language: C

    pgp_armor_headers

## Function: pgp_key_id(bytea)

### Returns: text

### Language: C

    pgp_key_id_w

## Function: pgp_pub_decrypt(bytea, bytea)

### Returns: text

### Language: C

    pgp_pub_decrypt_text

## Function: pgp_pub_decrypt(bytea, bytea, text)

### Returns: text

### Language: C

    pgp_pub_decrypt_text

## Function: pgp_pub_decrypt(bytea, bytea, text, text)

### Returns: text

### Language: C

    pgp_pub_decrypt_text

## Function: pgp_pub_decrypt_bytea(bytea, bytea)

### Returns: bytea

### Language: C

    pgp_pub_decrypt_bytea

## Function: pgp_pub_decrypt_bytea(bytea, bytea, text)

### Returns: bytea

### Language: C

    pgp_pub_decrypt_bytea

## Function: pgp_pub_decrypt_bytea(bytea, bytea, text, text)

### Returns: bytea

### Language: C

    pgp_pub_decrypt_bytea

## Function: pgp_pub_encrypt(text, bytea)

### Returns: bytea

### Language: C

    pgp_pub_encrypt_text

## Function: pgp_pub_encrypt(text, bytea, text)

### Returns: bytea

### Language: C

    pgp_pub_encrypt_text

## Function: pgp_pub_encrypt_bytea(bytea, bytea)

### Returns: bytea

### Language: C

    pgp_pub_encrypt_bytea

## Function: pgp_pub_encrypt_bytea(bytea, bytea, text)

### Returns: bytea

### Language: C

    pgp_pub_encrypt_bytea

## Function: pgp_sym_decrypt(bytea, text)

### Returns: text

### Language: C

    pgp_sym_decrypt_text

## Function: pgp_sym_decrypt(bytea, text, text)

### Returns: text

### Language: C

    pgp_sym_decrypt_text

## Function: pgp_sym_decrypt_bytea(bytea, text)

### Returns: bytea

### Language: C

    pgp_sym_decrypt_bytea

## Function: pgp_sym_decrypt_bytea(bytea, text, text)

### Returns: bytea

### Language: C

    pgp_sym_decrypt_bytea

## Function: pgp_sym_encrypt(text, text)

### Returns: bytea

### Language: C

    pgp_sym_encrypt_text

## Function: pgp_sym_encrypt(text, text, text)

### Returns: bytea

### Language: C

    pgp_sym_encrypt_text

## Function: pgp_sym_encrypt_bytea(bytea, text)

### Returns: bytea

### Language: C

    pgp_sym_encrypt_bytea

## Function: pgp_sym_encrypt_bytea(bytea, text, text)

### Returns: bytea

### Language: C

    pgp_sym_encrypt_bytea

## Function: swh_content_add()

### Returns: void

### Language: PLPGSQL

    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

## Function: swh_content_find(blake2s256 public.sha1, sha256 public.sha1_git, sha1_git public.sha256, sha1 public.blake2s256)

### Returns: content

### Language: PLPGSQL

    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

## Function: swh_content_find_directory(content_id public.sha1)

### Returns: content_dir

### Language: SQL

        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;

## Function: swh_content_list_by_object_id(max_incl bigint, min_excl bigint)

### Returns: SET OF content

### Language: SQL

        select * from content
        where object_id > min_excl and object_id <= max_incl
        order by object_id;

## Function: swh_content_update(columns_update text[])

### Returns: void

### Language: PLPGSQL

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

## Function: swh_directory_add()

### Returns: void

### Language: PLPGSQL

    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

## Function: swh_directory_entry_add(typ public.directory_entry_type)

### Returns: void

### Language: PLPGSQL

    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

## Function: swh_directory_missing()

### Returns: SET OF sha1_git

### Language: PLPGSQL

    begin
        return query
    	select id from tmp_directory t
    	where not exists (
    	    select 1 from directory d
    	    where d.id = t.id);
        return;
    end

## Function: swh_directory_walk(walked_dir_id public.sha1_git)

### Returns: SET OF directory_entry

### Language: SQL

        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

## Function: swh_directory_walk_one(walked_dir_id public.sha1_git)

### Returns: SET OF directory_entry

### Language: SQL

        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;

## Function: swh_find_directory_entry_by_path(dir_or_content_path public.sha1_git, walked_dir_id bytea[])

### Returns: directory_entry

### Language: PLPGSQL

    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

## Function: swh_mktemp(tblname regclass)

### Returns: void

### Language: PLPGSQL

    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

## Function: swh_mktemp_dir_entry(tblname regclass)

### Returns: void

### Language: PLPGSQL

    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

## Function: swh_mktemp_occurrence_history()

### Returns: void

### Language: SQL

        create temporary table tmp_occurrence_history(
            like occurrence_history including defaults,
            visit bigint not null
        ) on commit drop;
        alter table tmp_occurrence_history
          drop column visits,
          drop column object_id;

## Function: swh_mktemp_release()

### Returns: void

### Language: SQL

        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;

## Function: swh_mktemp_revision()

### Returns: void

### Language: SQL

        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;

## Function: swh_mktemp_snapshot_branch()

### Returns: void

### Language: SQL

      create temporary table tmp_snapshot_branch (
          name bytea not null,
          target bytea,
          target_type snapshot_target
      ) on commit drop;

## Function: swh_mktemp_tool()

### Returns: void

### Language: SQL

        create temporary table tmp_tool (
          like tool including defaults
        ) on commit drop;
        alter table tmp_tool drop column id;

## Function: swh_occurrence_get_by(date bigint, branch_name bytea, origin_id timestamp with time zone)

### Returns: SET OF occurrence_history

### Language: PLPGSQL

    declare
        filters text[] := array[] :: text[];  -- AND-clauses used to filter content
        visit_id bigint;
        q text;
    begin
        if origin_id is null then
            raise exception 'Needs an origin_id to get an occurrence.';
        end if;
        filters := filters || format('origin = %L', origin_id);
        if branch_name is not null then
            filters := filters || format('branch = %L', branch_name);
        end if;
        if date is not null then
            select visit from swh_visit_find_by_date(origin_id, date) into visit_id;
        else
            select visit from origin_visit where origin = origin_id order by origin_visit.date desc limit 1 into visit_id;
        end if;
        if visit_id is null then
            return;
        end if;
        filters := filters || format('%L = any(visits)', visit_id);

        q = format('select * from occurrence_history where %s',
                   array_to_string(filters, ' and '));
        return query execute q;
    end

## Function: swh_occurrence_history_add()

### Returns: void

### Language: PLPGSQL

    declare
      origin_id origin.id%type;
    begin
      -- Create or update occurrence_history
      with occurrence_history_id_visit as (
        select tmp_occurrence_history.*, object_id, visits from tmp_occurrence_history
        left join occurrence_history using(origin, branch, target, target_type)
      ),
      occurrences_to_update as (
        select object_id, visit from occurrence_history_id_visit where object_id is not null
      ),
      update_occurrences as (
        update occurrence_history
        set visits = array(select unnest(occurrence_history.visits) as e
                            union
                           select occurrences_to_update.visit as e
                           order by e)
        from occurrences_to_update
        where occurrence_history.object_id = occurrences_to_update.object_id
      )
      insert into occurrence_history (origin, branch, target, target_type, visits)
        select origin, branch, target, target_type, ARRAY[visit]
          from occurrence_history_id_visit
          where object_id is null;
      return;
    end

## Function: swh_origin_metadata_get_by_origin(origin integer)

### Returns: SET OF origin_metadata_signature

### Language: SQL

        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;

## Function: swh_origin_metadata_get_by_provider_type(type integer, origin text)

### Returns: SET OF origin_metadata_signature

### Language: SQL

        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;

## Function: swh_origin_visit_add(date bigint, origin_id timestamp with time zone)

### Returns: bigint

### Language: SQL

      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;

## Function: swh_person_add_from_release()

### Returns: void

### Language: PLPGSQL

    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

## Function: swh_person_add_from_revision()

### Returns: void

### Language: PLPGSQL

    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

## Function: swh_release_add()

### Returns: void

### Language: PLPGSQL

    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

## Function: swh_release_list_by_object_id(max_incl bigint, min_excl bigint)

### Returns: SET OF release_entry

### Language: SQL

        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;

## Function: swh_revision_add()

### Returns: void

### Language: PLPGSQL

    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

## Function: swh_revision_get_by(date bigint, branch_name bytea, origin_id timestamp with time zone)

### Returns: SET OF revision_entry

### Language: SQL

        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 swh_occurrence_get_by(origin_id, branch_name, date) as occ
        inner join revision r on occ.target = r.id
        left join person a on a.id = r.author
        left join person c on c.id = r.committer;

## Function: swh_revision_list(parents bytea[], id bigint)

### Returns: SET OF record

### Language: SQL

        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;

## Function: swh_revision_list_by_object_id(max_incl bigint, min_excl bigint)

### Returns: SET OF revision_entry

### Language: SQL

        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;

## Function: swh_revision_list_children(parents bytea[], id bigint)

### Returns: SET OF record

### Language: SQL

        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;

## Function: swh_revision_log(num_revs bytea[], root_revisions bigint)

### Returns: SET OF revision_entry

### Language: SQL

        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;

## Function: swh_revision_walk(revision_id public.sha1_git)

### Returns: SET OF directory_entry

### Language: SQL

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))

## Function: swh_skipped_content_add()

### Returns: void

### Language: PLPGSQL

    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

## Function: swh_skipped_content_missing()

### Returns: SET OF content_signature

### Language: PLPGSQL

    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

## Function: swh_snapshot_add(snapshot_id bigint, visit bigint, origin public.sha1_git)

### Returns: void

### Language: PLPGSQL

    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;

## Function: swh_snapshot_count_branches(id public.sha1_git)

### Returns: SET OF snapshot_size

### Language: SQL

      SELECT target_type, count(name)
      from swh_snapshot_get_by_id(swh_snapshot_count_branches.id)
      group by target_type;

## Function: swh_snapshot_get_by_id(target_types public.sha1_git, branches_count bytea, branches_from bigint, id public.snapshot_target[])

### Returns: SET OF snapshot_result

### Language: SQL

      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

## Function: swh_snapshot_get_by_origin_visit(visit_id bigint, origin_id bigint)

### Returns: sha1_git

### Language: SQL

      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;

## Function: swh_stat_counters()

### Returns: SET OF counter

### Language: SQL

        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',
            'occurrence_history',
            'origin',
            'origin_visit',
            'person',
            'release',
            'revision',
            'revision_history',
            'skipped_content',
            'snapshot'
        );

## Function: swh_tool_add()

### Returns: SET OF tool

### Language: PLPGSQL

    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

## Function: swh_update_counter(object_type text)

### Returns: void

### Language: PLPGSQL

    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;

## Function: swh_update_counter_bucketed()

### Returns: void

### Language: PLPGSQL

    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

## Function: swh_update_counters_from_buckets()

### Returns: trigger

### Language: PLPGSQL

    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

## Function: swh_visit_find_by_date(visit_date bigint, origin timestamp with time zone)

### Returns: origin_visit

### Language: SQL

      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

## Function: swh_visit_get(origin bigint)

### Returns: origin_visit

### Language: SQL

        select *
        from origin_visit
        where origin=origin
        order by date desc

## Function: time_dist(time without time zone, time without time zone)

### Returns: interval

### Language: C

    time_dist

## Function: ts_dist(timestamp without time zone, timestamp without time zone)

### Returns: interval

### Language: C

    ts_dist

## Function: tstz_dist(timestamp with time zone, timestamp with time zone)

### Returns: interval

### Language: C

    tstz_dist

Generated by PostgreSQL Autodoc

W3C HTML 4.01 Strict