
SET LOCAL search_path to @extschema@;

-- initialize the faker engine
-- usage: SELECT faker.faker(ARRAY('fr_FR','ja_JP'))
CREATE OR REPLACE FUNCTION faker(
  locales TEXT[]
)
RETURNS BOOLEAN
AS $$
  from faker import Faker
  GD['Faker'] = Faker(locales)
  return True
$$
  LANGUAGE plpython3u
;

--
-- initialize the faker engine with one or zero locale
-- usage:
--  - SELECT faker.faker()
--  - SELECT faker.faker('de_DE')
--
CREATE OR REPLACE FUNCTION faker(
  locale TEXT DEFAULT 'en_US'
)
RETURNS BOOLEAN
AS $$
  from faker import Faker
  GD['Faker'] = Faker(locale)
  return True
$$
  LANGUAGE plpython3u
;

CREATE OR REPLACE FUNCTION autoinit()
RETURNS BOOLEAN
AS $$
  test = """
    SELECT
      pg_catalog.current_setting('faker.autoinit', True)::BOOLEAN AS autoinit,
      pg_catalog.current_setting('faker.locales', True) AS locales,
      pg_catalog.current_setting('faker.seed', True) AS seed
    ;
  """
  settings = plpy.execute(test)
  if settings[0]['autoinit'] is not None and not settings[0]['autoinit'] :
    plpy.warning(
      "faker is not initialized.",
      hint="Use SELECT @extschema@.faker(); first or set faker.autoinit to True."
    )
    return False

  from faker import Faker
  if settings[0]['locales'] is None :
    GD['Faker'] = Faker()
  else:
    GD['Faker'] = Faker([l.strip() for l in settings[0]['locales'].split(',')])

  if settings[0]['seed'] is not None:
    GD['Faker'].seed_instance(settings[0]['seed'])

  return True
$$
  LANGUAGE plpython3u
;


--
-- Seeding the generator
-- https://github.com/joke2k/faker#seeding-the-generator
--
CREATE OR REPLACE FUNCTION seed(
  seed TEXT
)
RETURNS BOOLEAN
AS $$
  try:
    GD['Faker'].seed_instance(seed)
  except KeyError:
    plpy.warning(
      "faker is not initialized.",
      hint='Use SELECT @extschema@.faker(); first.'
    )
    return False
  return True
$$
  LANGUAGE plpython3u
;

CREATE OR REPLACE FUNCTION seed(
  seed INTEGER
)
RETURNS BOOLEAN
AS $$
  try:
    GD['Faker'].seed_instance(seed)
  except KeyError:
    plpy.warning(
      "faker is not initialized.",
      hint='Use SELECT @extschema@.faker(); first.'
    )
    return False
  return True
$$
  LANGUAGE plpython3u
;



-- Provider : faker.providers.address
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/__init__.py


CREATE OR REPLACE FUNCTION city_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_suffix'):
  plpy.warning(
    "the `city_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_suffix'):
  plpy.warning(
    "the `city_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix'):
  plpy.warning(
    "the `street_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix'):
  plpy.warning(
    "the `street_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION building_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_number'):
  plpy.warning(
    "the `building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_number'):
  plpy.warning(
    "the `building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_address'):
  plpy.warning(
    "the `street_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_address'):
  plpy.warning(
    "the `street_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'address'):
  plpy.warning(
    "the `address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'address'):
  plpy.warning(
    "the `address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION country() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'country'):
  plpy.warning(
    "the `country` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].country()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_country() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'country'):
  plpy.warning(
    "the `country` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.country()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION country_code("representation" TEXT = 'alpha-2' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'country_code'):
  plpy.warning(
    "the `country_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].country_code(representation
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_country_code("representation" TEXT = 'alpha-2' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'country_code'):
  plpy.warning(
    "the `country_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.country_code(representation)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.cs_CZ
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/cs_CZ/__init__.py


CREATE OR REPLACE FUNCTION street_suffix_short() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_short'):
  plpy.warning(
    "the `street_suffix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_suffix_short()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_suffix_short() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_short'):
  plpy.warning(
    "the `street_suffix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_suffix_short()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_suffix_long() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_long'):
  plpy.warning(
    "the `street_suffix_long` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_suffix_long()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_suffix_long() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_long'):
  plpy.warning(
    "the `street_suffix_long` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_suffix_long()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_with_postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_with_postcode'):
  plpy.warning(
    "the `city_with_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_with_postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_with_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_with_postcode'):
  plpy.warning(
    "the `city_with_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_with_postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.da_DK
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/da_DK/__init__.py


CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.de
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/de/__init__.py




-- Provider : faker.providers.address.de_AT
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/de_AT/__init__.py


CREATE OR REPLACE FUNCTION street_suffix_short() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_short'):
  plpy.warning(
    "the `street_suffix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_suffix_short()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_suffix_short() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_short'):
  plpy.warning(
    "the `street_suffix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_suffix_short()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_suffix_long() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_long'):
  plpy.warning(
    "the `street_suffix_long` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_suffix_long()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_suffix_long() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_long'):
  plpy.warning(
    "the `street_suffix_long` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_suffix_long()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_with_postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_with_postcode'):
  plpy.warning(
    "the `city_with_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_with_postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_with_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_with_postcode'):
  plpy.warning(
    "the `city_with_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_with_postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.de_DE
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/de_DE/__init__.py


CREATE OR REPLACE FUNCTION street_suffix_short() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_short'):
  plpy.warning(
    "the `street_suffix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_suffix_short()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_suffix_short() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_short'):
  plpy.warning(
    "the `street_suffix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_suffix_short()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_suffix_long() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_long'):
  plpy.warning(
    "the `street_suffix_long` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_suffix_long()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_suffix_long() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_long'):
  plpy.warning(
    "the `street_suffix_long` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_suffix_long()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_with_postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_with_postcode'):
  plpy.warning(
    "the `city_with_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_with_postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_with_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_with_postcode'):
  plpy.warning(
    "the `city_with_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_with_postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.el_GR
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/el_GR/__init__.py


CREATE OR REPLACE FUNCTION line_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'line_address'):
  plpy.warning(
    "the `line_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].line_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_line_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'line_address'):
  plpy.warning(
    "the `line_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.line_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_prefix_short() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix_short'):
  plpy.warning(
    "the `street_prefix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix_short()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix_short() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix_short'):
  plpy.warning(
    "the `street_prefix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix_short()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_prefix_long() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix_long'):
  plpy.warning(
    "the `street_prefix_long` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix_long()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix_long() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix_long'):
  plpy.warning(
    "the `street_prefix_long` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix_long()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street'):
  plpy.warning(
    "the `street` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street'):
  plpy.warning(
    "the `street` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION region() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'region'):
  plpy.warning(
    "the `region` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].region()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_region() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'region'):
  plpy.warning(
    "the `region` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.region()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.en
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/en/__init__.py




-- Provider : faker.providers.address.en_AU
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/en_AU/__init__.py


CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION secondary_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].secondary_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_secondary_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.secondary_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state_abbr() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state_abbr()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state_abbr() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state_abbr()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.en_CA
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/en_CA/__init__.py


CREATE OR REPLACE FUNCTION province() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].province()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_province() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.province()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION province_abbr() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province_abbr'):
  plpy.warning(
    "the `province_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].province_abbr()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_province_abbr() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province_abbr'):
  plpy.warning(
    "the `province_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.province_abbr()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION secondary_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].secondary_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_secondary_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.secondary_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postal_code_letter() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postal_code_letter'):
  plpy.warning(
    "the `postal_code_letter` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postal_code_letter()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postal_code_letter() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postal_code_letter'):
  plpy.warning(
    "the `postal_code_letter` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postal_code_letter()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postcode_in_province("province_abbr" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode_in_province'):
  plpy.warning(
    "the `postcode_in_province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode_in_province(province_abbr
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode_in_province("province_abbr" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode_in_province'):
  plpy.warning(
    "the `postcode_in_province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode_in_province(province_abbr)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postalcode_in_province("province_abbr" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postalcode_in_province'):
  plpy.warning(
    "the `postalcode_in_province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postalcode_in_province(province_abbr
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postalcode_in_province("province_abbr" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postalcode_in_province'):
  plpy.warning(
    "the `postalcode_in_province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postalcode_in_province(province_abbr)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postalcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postalcode'):
  plpy.warning(
    "the `postalcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postalcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postalcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postalcode'):
  plpy.warning(
    "the `postalcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postalcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.en_GB
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/en_GB/__init__.py


CREATE OR REPLACE FUNCTION postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION secondary_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].secondary_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_secondary_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.secondary_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION county() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'county'):
  plpy.warning(
    "the `county` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].county()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_county() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'county'):
  plpy.warning(
    "the `county` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.county()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.en_IE
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/en_IE/__init__.py


CREATE OR REPLACE FUNCTION postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION county() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'county'):
  plpy.warning(
    "the `county` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].county()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_county() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'county'):
  plpy.warning(
    "the `county` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.county()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.en_IN
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/en_IN/__init__.py


CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.en_NZ
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/en_NZ/__init__.py


CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION te_reo_part() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'te_reo_part'):
  plpy.warning(
    "the `te_reo_part` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].te_reo_part()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_te_reo_part() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'te_reo_part'):
  plpy.warning(
    "the `te_reo_part` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.te_reo_part()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION te_reo_first() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'te_reo_first'):
  plpy.warning(
    "the `te_reo_first` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].te_reo_first()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_te_reo_first() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'te_reo_first'):
  plpy.warning(
    "the `te_reo_first` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.te_reo_first()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION te_reo_ending() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'te_reo_ending'):
  plpy.warning(
    "the `te_reo_ending` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].te_reo_ending()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_te_reo_ending() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'te_reo_ending'):
  plpy.warning(
    "the `te_reo_ending` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.te_reo_ending()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_suffix'):
  plpy.warning(
    "the `city_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_suffix'):
  plpy.warning(
    "the `city_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION rd_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'rd_number'):
  plpy.warning(
    "the `rd_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].rd_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_rd_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'rd_number'):
  plpy.warning(
    "the `rd_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.rd_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION secondary_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].secondary_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_secondary_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.secondary_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.en_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/en_PH/__init__.py


CREATE OR REPLACE FUNCTION metro_manila_postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'metro_manila_postcode'):
  plpy.warning(
    "the `metro_manila_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].metro_manila_postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_metro_manila_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'metro_manila_postcode'):
  plpy.warning(
    "the `metro_manila_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.metro_manila_postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION luzon_province_postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'luzon_province_postcode'):
  plpy.warning(
    "the `luzon_province_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].luzon_province_postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_luzon_province_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'luzon_province_postcode'):
  plpy.warning(
    "the `luzon_province_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.luzon_province_postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION visayas_province_postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'visayas_province_postcode'):
  plpy.warning(
    "the `visayas_province_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].visayas_province_postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_visayas_province_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'visayas_province_postcode'):
  plpy.warning(
    "the `visayas_province_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.visayas_province_postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION mindanao_province_postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mindanao_province_postcode'):
  plpy.warning(
    "the `mindanao_province_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].mindanao_province_postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_mindanao_province_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mindanao_province_postcode'):
  plpy.warning(
    "the `mindanao_province_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.mindanao_province_postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION luzon_province() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'luzon_province'):
  plpy.warning(
    "the `luzon_province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].luzon_province()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_luzon_province() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'luzon_province'):
  plpy.warning(
    "the `luzon_province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.luzon_province()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION visayas_province() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'visayas_province'):
  plpy.warning(
    "the `visayas_province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].visayas_province()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_visayas_province() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'visayas_province'):
  plpy.warning(
    "the `visayas_province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.visayas_province()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION mindanao_province() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mindanao_province'):
  plpy.warning(
    "the `mindanao_province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].mindanao_province()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_mindanao_province() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mindanao_province'):
  plpy.warning(
    "the `mindanao_province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.mindanao_province()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION province() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].province()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_province() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.province()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION standalone_building_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'standalone_building_number'):
  plpy.warning(
    "the `standalone_building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].standalone_building_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_standalone_building_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'standalone_building_number'):
  plpy.warning(
    "the `standalone_building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.standalone_building_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION partitioned_building_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'partitioned_building_number'):
  plpy.warning(
    "the `partitioned_building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].partitioned_building_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_partitioned_building_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'partitioned_building_number'):
  plpy.warning(
    "the `partitioned_building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.partitioned_building_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION building_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_number'):
  plpy.warning(
    "the `building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_number'):
  plpy.warning(
    "the `building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ordinal_street_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ordinal_street_number'):
  plpy.warning(
    "the `ordinal_street_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ordinal_street_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ordinal_street_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ordinal_street_number'):
  plpy.warning(
    "the `ordinal_street_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ordinal_street_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION floor_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'floor_number'):
  plpy.warning(
    "the `floor_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].floor_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_floor_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'floor_number'):
  plpy.warning(
    "the `floor_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.floor_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ordinal_floor_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ordinal_floor_number'):
  plpy.warning(
    "the `ordinal_floor_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ordinal_floor_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ordinal_floor_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ordinal_floor_number'):
  plpy.warning(
    "the `ordinal_floor_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ordinal_floor_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION floor_unit_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'floor_unit_number'):
  plpy.warning(
    "the `floor_unit_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].floor_unit_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_floor_unit_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'floor_unit_number'):
  plpy.warning(
    "the `floor_unit_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.floor_unit_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION building_unit_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_unit_number'):
  plpy.warning(
    "the `building_unit_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_unit_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_unit_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_unit_number'):
  plpy.warning(
    "the `building_unit_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_unit_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION building_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_name'):
  plpy.warning(
    "the `building_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_name'):
  plpy.warning(
    "the `building_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION building_name_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_name_suffix'):
  plpy.warning(
    "the `building_name_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_name_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_name_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_name_suffix'):
  plpy.warning(
    "the `building_name_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_name_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION subdivision_block_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'subdivision_block_number'):
  plpy.warning(
    "the `subdivision_block_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].subdivision_block_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_subdivision_block_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'subdivision_block_number'):
  plpy.warning(
    "the `subdivision_block_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.subdivision_block_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION subdivision_lot_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'subdivision_lot_number'):
  plpy.warning(
    "the `subdivision_lot_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].subdivision_lot_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_subdivision_lot_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'subdivision_lot_number'):
  plpy.warning(
    "the `subdivision_lot_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.subdivision_lot_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION subdivision_unit_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'subdivision_unit_number'):
  plpy.warning(
    "the `subdivision_unit_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].subdivision_unit_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_subdivision_unit_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'subdivision_unit_number'):
  plpy.warning(
    "the `subdivision_unit_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.subdivision_unit_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION subdivision_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'subdivision_name'):
  plpy.warning(
    "the `subdivision_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].subdivision_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_subdivision_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'subdivision_name'):
  plpy.warning(
    "the `subdivision_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.subdivision_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION subdivision_name_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'subdivision_name_suffix'):
  plpy.warning(
    "the `subdivision_name_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].subdivision_name_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_subdivision_name_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'subdivision_name_suffix'):
  plpy.warning(
    "the `subdivision_name_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.subdivision_name_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION metro_manila_lgu() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'metro_manila_lgu'):
  plpy.warning(
    "the `metro_manila_lgu` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].metro_manila_lgu()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_metro_manila_lgu() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'metro_manila_lgu'):
  plpy.warning(
    "the `metro_manila_lgu` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.metro_manila_lgu()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION province_lgu() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province_lgu'):
  plpy.warning(
    "the `province_lgu` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].province_lgu()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_province_lgu() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province_lgu'):
  plpy.warning(
    "the `province_lgu` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.province_lgu()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION metro_manila_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'metro_manila_address'):
  plpy.warning(
    "the `metro_manila_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].metro_manila_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_metro_manila_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'metro_manila_address'):
  plpy.warning(
    "the `metro_manila_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.metro_manila_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION luzon_province_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'luzon_province_address'):
  plpy.warning(
    "the `luzon_province_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].luzon_province_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_luzon_province_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'luzon_province_address'):
  plpy.warning(
    "the `luzon_province_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.luzon_province_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION visayas_province_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'visayas_province_address'):
  plpy.warning(
    "the `visayas_province_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].visayas_province_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_visayas_province_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'visayas_province_address'):
  plpy.warning(
    "the `visayas_province_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.visayas_province_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION mindanao_province_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mindanao_province_address'):
  plpy.warning(
    "the `mindanao_province_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].mindanao_province_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_mindanao_province_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mindanao_province_address'):
  plpy.warning(
    "the `mindanao_province_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.mindanao_province_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'address'):
  plpy.warning(
    "the `address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'address'):
  plpy.warning(
    "the `address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/en_US/__init__.py


CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION secondary_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].secondary_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_secondary_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.secondary_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state_abbr("include_territories" BOOLEAN = True ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state_abbr(include_territories
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state_abbr("include_territories" BOOLEAN = True ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state_abbr(include_territories)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION zipcode_plus4() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'zipcode_plus4'):
  plpy.warning(
    "the `zipcode_plus4` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].zipcode_plus4()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_zipcode_plus4() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'zipcode_plus4'):
  plpy.warning(
    "the `zipcode_plus4` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.zipcode_plus4()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postcode_in_state("state_abbr" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode_in_state'):
  plpy.warning(
    "the `postcode_in_state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode_in_state(state_abbr
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode_in_state("state_abbr" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode_in_state'):
  plpy.warning(
    "the `postcode_in_state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode_in_state(state_abbr)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION military_ship() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'military_ship'):
  plpy.warning(
    "the `military_ship` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].military_ship()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_military_ship() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'military_ship'):
  plpy.warning(
    "the `military_ship` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.military_ship()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION military_state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'military_state'):
  plpy.warning(
    "the `military_state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].military_state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_military_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'military_state'):
  plpy.warning(
    "the `military_state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.military_state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION military_apo() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'military_apo'):
  plpy.warning(
    "the `military_apo` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].military_apo()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_military_apo() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'military_apo'):
  plpy.warning(
    "the `military_apo` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.military_apo()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION military_dpo() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'military_dpo'):
  plpy.warning(
    "the `military_dpo` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].military_dpo()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_military_dpo() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'military_dpo'):
  plpy.warning(
    "the `military_dpo` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.military_dpo()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION zipcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'zipcode'):
  plpy.warning(
    "the `zipcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].zipcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_zipcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'zipcode'):
  plpy.warning(
    "the `zipcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.zipcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION zipcode_in_state("state_abbr" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'zipcode_in_state'):
  plpy.warning(
    "the `zipcode_in_state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].zipcode_in_state(state_abbr
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_zipcode_in_state("state_abbr" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'zipcode_in_state'):
  plpy.warning(
    "the `zipcode_in_state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.zipcode_in_state(state_abbr)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postalcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postalcode'):
  plpy.warning(
    "the `postalcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postalcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postalcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postalcode'):
  plpy.warning(
    "the `postalcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postalcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postalcode_in_state("state_abbr" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postalcode_in_state'):
  plpy.warning(
    "the `postalcode_in_state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postalcode_in_state(state_abbr
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postalcode_in_state("state_abbr" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postalcode_in_state'):
  plpy.warning(
    "the `postalcode_in_state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postalcode_in_state(state_abbr)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postalcode_plus4() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postalcode_plus4'):
  plpy.warning(
    "the `postalcode_plus4` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postalcode_plus4()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postalcode_plus4() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postalcode_plus4'):
  plpy.warning(
    "the `postalcode_plus4` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postalcode_plus4()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.es
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/es/__init__.py




-- Provider : faker.providers.address.es_ES
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/es_ES/__init__.py


CREATE OR REPLACE FUNCTION state_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_name'):
  plpy.warning(
    "the `state_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_name'):
  plpy.warning(
    "the `state_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION secondary_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].secondary_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_secondary_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.secondary_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION region() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'region'):
  plpy.warning(
    "the `region` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].region()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_region() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'region'):
  plpy.warning(
    "the `region` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.region()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION autonomous_community() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'autonomous_community'):
  plpy.warning(
    "the `autonomous_community` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].autonomous_community()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_autonomous_community() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'autonomous_community'):
  plpy.warning(
    "the `autonomous_community` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.autonomous_community()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.es_MX
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/es_MX/__init__.py


CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_suffix'):
  plpy.warning(
    "the `city_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_suffix'):
  plpy.warning(
    "the `city_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_adjective() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_adjective'):
  plpy.warning(
    "the `city_adjective` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_adjective()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_adjective() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_adjective'):
  plpy.warning(
    "the `city_adjective` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_adjective()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION secondary_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].secondary_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_secondary_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.secondary_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state_abbr() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state_abbr()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state_abbr() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state_abbr()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.fa_IR
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/fa_IR/__init__.py


CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION secondary_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].secondary_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_secondary_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.secondary_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.fi_FI
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/fi_FI/__init__.py


CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.fil_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/fil_PH/__init__.py




-- Provider : faker.providers.address.fr_CH
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/fr_CH/__init__.py


CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION canton() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'canton'):
  plpy.warning(
    "the `canton` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].canton()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_canton() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'canton'):
  plpy.warning(
    "the `canton` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.canton()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION canton_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'canton_name'):
  plpy.warning(
    "the `canton_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].canton_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_canton_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'canton_name'):
  plpy.warning(
    "the `canton_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.canton_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION canton_code() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'canton_code'):
  plpy.warning(
    "the `canton_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].canton_code()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_canton_code() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'canton_code'):
  plpy.warning(
    "the `canton_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.canton_code()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.fr_FR
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/fr_FR/__init__.py


CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION region() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'region'):
  plpy.warning(
    "the `region` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].region()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_region() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'region'):
  plpy.warning(
    "the `region` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.region()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION department() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'department'):
  plpy.warning(
    "the `department` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].department()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_department() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'department'):
  plpy.warning(
    "the `department` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.department()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION department_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'department_name'):
  plpy.warning(
    "the `department_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].department_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_department_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'department_name'):
  plpy.warning(
    "the `department_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.department_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION department_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'department_number'):
  plpy.warning(
    "the `department_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].department_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_department_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'department_number'):
  plpy.warning(
    "the `department_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.department_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.he_IL
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/he_IL/__init__.py


CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_title() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_title'):
  plpy.warning(
    "the `street_title` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_title()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_title() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_title'):
  plpy.warning(
    "the `street_title` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_title()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.hi_IN
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/hi_IN/__init__.py


CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.hr_HR
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/hr_HR/__init__.py


CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.hu_HU
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/hu_HU/__init__.py


CREATE OR REPLACE FUNCTION county() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'county'):
  plpy.warning(
    "the `county` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].county()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_county() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'county'):
  plpy.warning(
    "the `county` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.county()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_address_with_county() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_address_with_county'):
  plpy.warning(
    "the `street_address_with_county` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_address_with_county()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_address_with_county() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_address_with_county'):
  plpy.warning(
    "the `street_address_with_county` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_address_with_county()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_part() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_part'):
  plpy.warning(
    "the `city_part` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_part()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_part() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_part'):
  plpy.warning(
    "the `city_part` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_part()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION real_city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'real_city_name'):
  plpy.warning(
    "the `real_city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].real_city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_real_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'real_city_name'):
  plpy.warning(
    "the `real_city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.real_city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION frequent_street_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'frequent_street_name'):
  plpy.warning(
    "the `frequent_street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].frequent_street_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_frequent_street_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'frequent_street_name'):
  plpy.warning(
    "the `frequent_street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.frequent_street_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION building_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_number'):
  plpy.warning(
    "the `building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_number'):
  plpy.warning(
    "the `building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.hy_AM
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/hy_AM/__init__.py


CREATE OR REPLACE FUNCTION city() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postcode_in_state("state_abbr" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode_in_state'):
  plpy.warning(
    "the `postcode_in_state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode_in_state(state_abbr
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode_in_state("state_abbr" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode_in_state'):
  plpy.warning(
    "the `postcode_in_state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode_in_state(state_abbr)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION secondary_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].secondary_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_secondary_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.secondary_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state_abbr() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state_abbr()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state_abbr() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state_abbr()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street'):
  plpy.warning(
    "the `street` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street'):
  plpy.warning(
    "the `street` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION village() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'village'):
  plpy.warning(
    "the `village` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].village()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_village() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'village'):
  plpy.warning(
    "the `village` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.village()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION village_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'village_prefix'):
  plpy.warning(
    "the `village_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].village_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_village_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'village_prefix'):
  plpy.warning(
    "the `village_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.village_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.id_ID
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/id_ID/__init__.py


CREATE OR REPLACE FUNCTION street() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street'):
  plpy.warning(
    "the `street` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street'):
  plpy.warning(
    "the `street` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_prefix_short() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix_short'):
  plpy.warning(
    "the `street_prefix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix_short()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix_short() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix_short'):
  plpy.warning(
    "the `street_prefix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix_short()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_prefix_long() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix_long'):
  plpy.warning(
    "the `street_prefix_long` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix_long()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix_long() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix_long'):
  plpy.warning(
    "the `street_prefix_long` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix_long()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state_abbr() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state_abbr()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state_abbr() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state_abbr()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION country() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'country'):
  plpy.warning(
    "the `country` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].country()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_country() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'country'):
  plpy.warning(
    "the `country` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.country()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.it_IT
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/it_IT/__init__.py


CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION secondary_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].secondary_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_secondary_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.secondary_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state_abbr() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state_abbr()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state_abbr() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state_abbr()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.ja_JP
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/ja_JP/__init__.py


CREATE OR REPLACE FUNCTION prefecture() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'prefecture'):
  plpy.warning(
    "the `prefecture` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].prefecture()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_prefecture() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'prefecture'):
  plpy.warning(
    "the `prefecture` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.prefecture()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION town() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'town'):
  plpy.warning(
    "the `town` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].town()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_town() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'town'):
  plpy.warning(
    "the `town` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.town()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION chome() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'chome'):
  plpy.warning(
    "the `chome` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].chome()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_chome() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'chome'):
  plpy.warning(
    "the `chome` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.chome()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ban() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ban'):
  plpy.warning(
    "the `ban` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ban()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ban() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ban'):
  plpy.warning(
    "the `ban` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ban()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION gou() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'gou'):
  plpy.warning(
    "the `gou` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].gou()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_gou() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'gou'):
  plpy.warning(
    "the `gou` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.gou()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION building_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_name'):
  plpy.warning(
    "the `building_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_name'):
  plpy.warning(
    "the `building_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION zipcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'zipcode'):
  plpy.warning(
    "the `zipcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].zipcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_zipcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'zipcode'):
  plpy.warning(
    "the `zipcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.zipcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.ka_GE
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/ka_GE/__init__.py


CREATE OR REPLACE FUNCTION street_title() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_title'):
  plpy.warning(
    "the `street_title` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_title()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_title() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_title'):
  plpy.warning(
    "the `street_title` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_title()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.ko_KR
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/ko_KR/__init__.py


CREATE OR REPLACE FUNCTION land_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'land_number'):
  plpy.warning(
    "the `land_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].land_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_land_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'land_number'):
  plpy.warning(
    "the `land_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.land_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION land_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'land_address'):
  plpy.warning(
    "the `land_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].land_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_land_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'land_address'):
  plpy.warning(
    "the `land_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.land_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION road_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'road_number'):
  plpy.warning(
    "the `road_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].road_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_road_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'road_number'):
  plpy.warning(
    "the `road_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.road_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION road_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'road_address'):
  plpy.warning(
    "the `road_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].road_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_road_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'road_address'):
  plpy.warning(
    "the `road_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.road_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION address_detail() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'address_detail'):
  plpy.warning(
    "the `address_detail` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].address_detail()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_address_detail() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'address_detail'):
  plpy.warning(
    "the `address_detail` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.address_detail()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION road() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'road'):
  plpy.warning(
    "the `road` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].road()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_road() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'road'):
  plpy.warning(
    "the `road` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.road()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION road_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'road_name'):
  plpy.warning(
    "the `road_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].road_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_road_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'road_name'):
  plpy.warning(
    "the `road_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.road_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION road_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'road_suffix'):
  plpy.warning(
    "the `road_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].road_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_road_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'road_suffix'):
  plpy.warning(
    "the `road_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.road_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION metropolitan_city() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'metropolitan_city'):
  plpy.warning(
    "the `metropolitan_city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].metropolitan_city()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_metropolitan_city() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'metropolitan_city'):
  plpy.warning(
    "the `metropolitan_city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.metropolitan_city()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION province() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].province()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_province() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.province()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION borough() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'borough'):
  plpy.warning(
    "the `borough` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].borough()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_borough() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'borough'):
  plpy.warning(
    "the `borough` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.borough()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION town() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'town'):
  plpy.warning(
    "the `town` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].town()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_town() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'town'):
  plpy.warning(
    "the `town` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.town()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION town_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'town_suffix'):
  plpy.warning(
    "the `town_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].town_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_town_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'town_suffix'):
  plpy.warning(
    "the `town_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.town_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION building_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_name'):
  plpy.warning(
    "the `building_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_name'):
  plpy.warning(
    "the `building_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION building_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_suffix'):
  plpy.warning(
    "the `building_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_suffix'):
  plpy.warning(
    "the `building_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION building_dong() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_dong'):
  plpy.warning(
    "the `building_dong` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_dong()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_dong() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_dong'):
  plpy.warning(
    "the `building_dong` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_dong()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION old_postal_code() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'old_postal_code'):
  plpy.warning(
    "the `old_postal_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].old_postal_code()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_old_postal_code() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'old_postal_code'):
  plpy.warning(
    "the `old_postal_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.old_postal_code()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postal_code() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postal_code'):
  plpy.warning(
    "the `postal_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postal_code()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postal_code() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postal_code'):
  plpy.warning(
    "the `postal_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postal_code()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.ne_NP
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/ne_NP/__init__.py


CREATE OR REPLACE FUNCTION province() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].province()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_province() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.province()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION district() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'district'):
  plpy.warning(
    "the `district` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].district()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_district() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'district'):
  plpy.warning(
    "the `district` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.district()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION building_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_prefix'):
  plpy.warning(
    "the `building_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_prefix'):
  plpy.warning(
    "the `building_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.nl_BE
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/nl_BE/__init__.py


CREATE OR REPLACE FUNCTION province() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].province()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_province() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.province()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.nl_NL
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/nl_NL/__init__.py


CREATE OR REPLACE FUNCTION province() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].province()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_province() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.province()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.no_NO
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/no_NO/__init__.py


CREATE OR REPLACE FUNCTION building_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_number'):
  plpy.warning(
    "the `building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_number'):
  plpy.warning(
    "the `building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_suffix'):
  plpy.warning(
    "the `city_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_suffix'):
  plpy.warning(
    "the `city_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix'):
  plpy.warning(
    "the `street_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix'):
  plpy.warning(
    "the `street_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.pl_PL
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/pl_PL/__init__.py


CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_prefix_short() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix_short'):
  plpy.warning(
    "the `street_prefix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix_short()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix_short() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix_short'):
  plpy.warning(
    "the `street_prefix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix_short()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city'):
  plpy.warning(
    "the `city` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION region() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'region'):
  plpy.warning(
    "the `region` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].region()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_region() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'region'):
  plpy.warning(
    "the `region` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.region()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.pt_BR
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/pt_BR/__init__.py


CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION estado() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'estado'):
  plpy.warning(
    "the `estado` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].estado()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_estado() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'estado'):
  plpy.warning(
    "the `estado` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.estado()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION estado_nome() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'estado_nome'):
  plpy.warning(
    "the `estado_nome` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].estado_nome()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_estado_nome() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'estado_nome'):
  plpy.warning(
    "the `estado_nome` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.estado_nome()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION estado_sigla() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'estado_sigla'):
  plpy.warning(
    "the `estado_sigla` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].estado_sigla()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_estado_sigla() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'estado_sigla'):
  plpy.warning(
    "the `estado_sigla` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.estado_sigla()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION bairro() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bairro'):
  plpy.warning(
    "the `bairro` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].bairro()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_bairro() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bairro'):
  plpy.warning(
    "the `bairro` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.bairro()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postcode("formatted" BOOLEAN = True ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode(formatted
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode("formatted" BOOLEAN = True ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode(formatted)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION neighborhood() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'neighborhood'):
  plpy.warning(
    "the `neighborhood` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].neighborhood()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_neighborhood() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'neighborhood'):
  plpy.warning(
    "the `neighborhood` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.neighborhood()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state_abbr() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state_abbr()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state_abbr() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state_abbr'):
  plpy.warning(
    "the `state_abbr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state_abbr()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.pt_PT
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/pt_PT/__init__.py


CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION distrito() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'distrito'):
  plpy.warning(
    "the `distrito` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].distrito()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_distrito() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'distrito'):
  plpy.warning(
    "the `distrito` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.distrito()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION concelho() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'concelho'):
  plpy.warning(
    "the `concelho` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].concelho()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_concelho() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'concelho'):
  plpy.warning(
    "the `concelho` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.concelho()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION freguesia() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'freguesia'):
  plpy.warning(
    "the `freguesia` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].freguesia()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_freguesia() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'freguesia'):
  plpy.warning(
    "the `freguesia` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.freguesia()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION place_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'place_name'):
  plpy.warning(
    "the `place_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].place_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_place_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'place_name'):
  plpy.warning(
    "the `place_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.place_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/ru_RU/__init__.py


CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION country() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'country'):
  plpy.warning(
    "the `country` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].country()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_country() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'country'):
  plpy.warning(
    "the `country` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.country()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION region() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'region'):
  plpy.warning(
    "the `region` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].region()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_region() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'region'):
  plpy.warning(
    "the `region` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.region()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix'):
  plpy.warning(
    "the `street_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix'):
  plpy.warning(
    "the `street_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_title() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_title'):
  plpy.warning(
    "the `street_title` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_title()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_title() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_title'):
  plpy.warning(
    "the `street_title` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_title()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.sk_SK
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/sk_SK/__init__.py


CREATE OR REPLACE FUNCTION street_suffix_short() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_short'):
  plpy.warning(
    "the `street_suffix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_suffix_short()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_suffix_short() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_short'):
  plpy.warning(
    "the `street_suffix_short` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_suffix_short()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_suffix_long() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_long'):
  plpy.warning(
    "the `street_suffix_long` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_suffix_long()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_suffix_long() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_suffix_long'):
  plpy.warning(
    "the `street_suffix_long` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_suffix_long()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_with_postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_with_postcode'):
  plpy.warning(
    "the `city_with_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_with_postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_with_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_with_postcode'):
  plpy.warning(
    "the `city_with_postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_with_postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.sl_SI
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/sl_SI/__init__.py


CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.sv_SE
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/sv_SE/__init__.py


CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.ta_IN
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/ta_IN/__init__.py


CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION state() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].state()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_state() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'state'):
  plpy.warning(
    "the `state` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.state()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.th
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/th/__init__.py




-- Provider : faker.providers.address.th_TH
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/th_TH/__init__.py


CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION province() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].province()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_province() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.province()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION amphoe() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'amphoe'):
  plpy.warning(
    "the `amphoe` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].amphoe()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_amphoe() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'amphoe'):
  plpy.warning(
    "the `amphoe` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.amphoe()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION tambon() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'tambon'):
  plpy.warning(
    "the `tambon` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].tambon()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_tambon() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'tambon'):
  plpy.warning(
    "the `tambon` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.tambon()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.tl_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/tl_PH/__init__.py




-- Provider : faker.providers.address.uk_UA
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/uk_UA/__init__.py


CREATE OR REPLACE FUNCTION city_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_prefix'):
  plpy.warning(
    "the `city_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION postcode() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].postcode()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_postcode() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'postcode'):
  plpy.warning(
    "the `postcode` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.postcode()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_prefix'):
  plpy.warning(
    "the `street_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_title() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_title'):
  plpy.warning(
    "the `street_title` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_title()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_title() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_title'):
  plpy.warning(
    "the `street_title` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_title()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.zh_CN
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/zh_CN/__init__.py


CREATE OR REPLACE FUNCTION building_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_number'):
  plpy.warning(
    "the `building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_number'):
  plpy.warning(
    "the `building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION province() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].province()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_province() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'province'):
  plpy.warning(
    "the `province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.province()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION district() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'district'):
  plpy.warning(
    "the `district` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].district()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_district() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'district'):
  plpy.warning(
    "the `district` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.district()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.address.zh_TW
-- https://github.com/joke2k/faker/blob/master/faker/providers/address/zh_TW/__init__.py


CREATE OR REPLACE FUNCTION secondary_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].secondary_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_secondary_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'secondary_address'):
  plpy.warning(
    "the `secondary_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.secondary_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION building_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_number'):
  plpy.warning(
    "the `building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].building_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_building_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'building_number'):
  plpy.warning(
    "the `building_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.building_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name'):
  plpy.warning(
    "the `street_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION street_name_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name_suffix'):
  plpy.warning(
    "the `street_name_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].street_name_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_street_name_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'street_name_suffix'):
  plpy.warning(
    "the `street_name_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.street_name_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name'):
  plpy.warning(
    "the `city_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION city_name_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name_suffix'):
  plpy.warning(
    "the `city_name_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].city_name_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_city_name_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'city_name_suffix'):
  plpy.warning(
    "the `city_name_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.city_name_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION section_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'section_number'):
  plpy.warning(
    "the `section_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].section_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_section_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'section_number'):
  plpy.warning(
    "the `section_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.section_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.automotive
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/__init__.py


CREATE OR REPLACE FUNCTION license_plate() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.automotive.ar_JO
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/ar_JO/__init__.py


CREATE OR REPLACE FUNCTION initials() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'initials'):
  plpy.warning(
    "the `initials` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].initials()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_initials() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'initials'):
  plpy.warning(
    "the `initials` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.initials()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION license_plate() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.automotive.ar_PS
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/ar_PS/__init__.py


CREATE OR REPLACE FUNCTION district() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'district'):
  plpy.warning(
    "the `district` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].district()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_district() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'district'):
  plpy.warning(
    "the `district` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.district()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION license_plate() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.automotive.ar_SA
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/ar_SA/__init__.py


CREATE OR REPLACE FUNCTION license_plate_en() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate_en'):
  plpy.warning(
    "the `license_plate_en` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate_en()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate_en() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate_en'):
  plpy.warning(
    "the `license_plate_en` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate_en()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION license_plate_ar() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate_ar'):
  plpy.warning(
    "the `license_plate_ar` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate_ar()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate_ar() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate_ar'):
  plpy.warning(
    "the `license_plate_ar` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate_ar()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION license_plate() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.automotive.de_DE
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/de_DE/__init__.py


CREATE OR REPLACE FUNCTION license_plate() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.automotive.en_CA
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/en_CA/__init__.py




-- Provider : faker.providers.automotive.en_GB
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/en_GB/__init__.py




-- Provider : faker.providers.automotive.en_NZ
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/en_NZ/__init__.py




-- Provider : faker.providers.automotive.en_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/en_PH/__init__.py


CREATE OR REPLACE FUNCTION protocol_license_plate() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'protocol_license_plate'):
  plpy.warning(
    "the `protocol_license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].protocol_license_plate()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_protocol_license_plate() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'protocol_license_plate'):
  plpy.warning(
    "the `protocol_license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.protocol_license_plate()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION motorcycle_license_plate() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'motorcycle_license_plate'):
  plpy.warning(
    "the `motorcycle_license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].motorcycle_license_plate()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_motorcycle_license_plate() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'motorcycle_license_plate'):
  plpy.warning(
    "the `motorcycle_license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.motorcycle_license_plate()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION automobile_license_plate() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'automobile_license_plate'):
  plpy.warning(
    "the `automobile_license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].automobile_license_plate()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_automobile_license_plate() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'automobile_license_plate'):
  plpy.warning(
    "the `automobile_license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.automobile_license_plate()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION license_plate() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.automotive.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/en_US/__init__.py




-- Provider : faker.providers.automotive.es_ES
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/es_ES/__init__.py


CREATE OR REPLACE FUNCTION license_plate_unified() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate_unified'):
  plpy.warning(
    "the `license_plate_unified` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate_unified()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate_unified() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate_unified'):
  plpy.warning(
    "the `license_plate_unified` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate_unified()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION license_plate_by_province("province_prefix" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate_by_province'):
  plpy.warning(
    "the `license_plate_by_province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate_by_province(province_prefix
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate_by_province("province_prefix" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate_by_province'):
  plpy.warning(
    "the `license_plate_by_province` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate_by_province(province_prefix)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION license_plate() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.automotive.fil_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/fil_PH/__init__.py




-- Provider : faker.providers.automotive.fr_FR
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/fr_FR/__init__.py




-- Provider : faker.providers.automotive.hu_HU
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/hu_HU/__init__.py




-- Provider : faker.providers.automotive.id_ID
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/id_ID/__init__.py




-- Provider : faker.providers.automotive.no_NO
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/no_NO/__init__.py




-- Provider : faker.providers.automotive.pl_PL
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/pl_PL/__init__.py


CREATE OR REPLACE FUNCTION license_plate_regex_formats() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate_regex_formats'):
  plpy.warning(
    "the `license_plate_regex_formats` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate_regex_formats()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate_regex_formats() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate_regex_formats'):
  plpy.warning(
    "the `license_plate_regex_formats` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate_regex_formats()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.automotive.pt_BR
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/pt_BR/__init__.py




-- Provider : faker.providers.automotive.pt_PT
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/pt_PT/__init__.py




-- Provider : faker.providers.automotive.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/ru_RU/__init__.py


CREATE OR REPLACE FUNCTION license_plate() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION plate_letter() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'plate_letter'):
  plpy.warning(
    "the `plate_letter` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].plate_letter()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_plate_letter() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'plate_letter'):
  plpy.warning(
    "the `plate_letter` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.plate_letter()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION plate_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'plate_number'):
  plpy.warning(
    "the `plate_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].plate_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_plate_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'plate_number'):
  plpy.warning(
    "the `plate_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.plate_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION plate_number_extra() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'plate_number_extra'):
  plpy.warning(
    "the `plate_number_extra` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].plate_number_extra()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_plate_number_extra() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'plate_number_extra'):
  plpy.warning(
    "the `plate_number_extra` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.plate_number_extra()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION plate_number_special() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'plate_number_special'):
  plpy.warning(
    "the `plate_number_special` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].plate_number_special()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_plate_number_special() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'plate_number_special'):
  plpy.warning(
    "the `plate_number_special` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.plate_number_special()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION plate_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'plate_suffix'):
  plpy.warning(
    "the `plate_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].plate_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_plate_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'plate_suffix'):
  plpy.warning(
    "the `plate_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.plate_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION vehicle_category() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vehicle_category'):
  plpy.warning(
    "the `vehicle_category` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vehicle_category()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vehicle_category() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vehicle_category'):
  plpy.warning(
    "the `vehicle_category` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vehicle_category()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.automotive.sv_SE
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/sv_SE/__init__.py




-- Provider : faker.providers.automotive.th_TH
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/th_TH/__init__.py


CREATE OR REPLACE FUNCTION license_plate() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.automotive.tl_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/tl_PH/__init__.py




-- Provider : faker.providers.automotive.tr_TR
-- https://github.com/joke2k/faker/blob/master/faker/providers/automotive/tr_TR/__init__.py


CREATE OR REPLACE FUNCTION license_plate() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].license_plate()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_license_plate() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'license_plate'):
  plpy.warning(
    "the `license_plate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.license_plate()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.bank
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/__init__.py


CREATE OR REPLACE FUNCTION bank_country() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bank_country'):
  plpy.warning(
    "the `bank_country` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].bank_country()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_bank_country() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bank_country'):
  plpy.warning(
    "the `bank_country` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.bank_country()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION bban() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bban'):
  plpy.warning(
    "the `bban` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].bban()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_bban() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bban'):
  plpy.warning(
    "the `bban` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.bban()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION iban() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'iban'):
  plpy.warning(
    "the `iban` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].iban()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_iban() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'iban'):
  plpy.warning(
    "the `iban` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.iban()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION swift8("use_dataset" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'swift8'):
  plpy.warning(
    "the `swift8` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].swift8(use_dataset
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_swift8("use_dataset" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'swift8'):
  plpy.warning(
    "the `swift8` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.swift8(use_dataset)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION swift11("primary" TEXT = NULL ,"use_dataset" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'swift11'):
  plpy.warning(
    "the `swift11` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].swift11(primary
,use_dataset
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_swift11("primary" TEXT = NULL ,"use_dataset" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'swift11'):
  plpy.warning(
    "the `swift11` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.swift11(primary,use_dataset)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION swift("length" TEXT = NULL ,"primary" TEXT = NULL ,"use_dataset" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'swift'):
  plpy.warning(
    "the `swift` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].swift(length
,primary
,use_dataset
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_swift("length" TEXT = NULL ,"primary" TEXT = NULL ,"use_dataset" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'swift'):
  plpy.warning(
    "the `swift` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.swift(length,primary,use_dataset)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.bank.de_AT
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/de_AT/__init__.py




-- Provider : faker.providers.bank.de_CH
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/de_CH/__init__.py




-- Provider : faker.providers.bank.de_DE
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/de_DE/__init__.py




-- Provider : faker.providers.bank.en_GB
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/en_GB/__init__.py




-- Provider : faker.providers.bank.en_IE
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/en_IE/__init__.py




-- Provider : faker.providers.bank.en_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/en_PH/__init__.py


CREATE OR REPLACE FUNCTION bban() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bban'):
  plpy.warning(
    "the `bban` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].bban()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_bban() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bban'):
  plpy.warning(
    "the `bban` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.bban()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION iban() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'iban'):
  plpy.warning(
    "the `iban` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].iban()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_iban() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'iban'):
  plpy.warning(
    "the `iban` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.iban()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.bank.es_ES
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/es_ES/__init__.py




-- Provider : faker.providers.bank.fi_FI
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/fi_FI/__init__.py




-- Provider : faker.providers.bank.fil_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/fil_PH/__init__.py




-- Provider : faker.providers.bank.fr_CH
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/fr_CH/__init__.py




-- Provider : faker.providers.bank.fr_FR
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/fr_FR/__init__.py




-- Provider : faker.providers.bank.it_CH
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/it_CH/__init__.py




-- Provider : faker.providers.bank.it_IT
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/it_IT/__init__.py




-- Provider : faker.providers.bank.nl_NL
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/nl_NL/__init__.py




-- Provider : faker.providers.bank.no_NO
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/no_NO/__init__.py




-- Provider : faker.providers.bank.pl_PL
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/pl_PL/__init__.py




-- Provider : faker.providers.bank.pt_PT
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/pt_PT/__init__.py




-- Provider : faker.providers.bank.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/ru_RU/__init__.py


CREATE OR REPLACE FUNCTION bic() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bic'):
  plpy.warning(
    "the `bic` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].bic()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_bic() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bic'):
  plpy.warning(
    "the `bic` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.bic()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION correspondent_account() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'correspondent_account'):
  plpy.warning(
    "the `correspondent_account` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].correspondent_account()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_correspondent_account() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'correspondent_account'):
  plpy.warning(
    "the `correspondent_account` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.correspondent_account()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION checking_account() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'checking_account'):
  plpy.warning(
    "the `checking_account` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].checking_account()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_checking_account() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'checking_account'):
  plpy.warning(
    "the `checking_account` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.checking_account()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION bank() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bank'):
  plpy.warning(
    "the `bank` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].bank()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_bank() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bank'):
  plpy.warning(
    "the `bank` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.bank()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.bank.th_TH
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/th_TH/__init__.py




-- Provider : faker.providers.bank.tl_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/tl_PH/__init__.py




-- Provider : faker.providers.bank.tr_TR
-- https://github.com/joke2k/faker/blob/master/faker/providers/bank/tr_TR/__init__.py




-- Provider : faker.providers.barcode
-- https://github.com/joke2k/faker/blob/master/faker/providers/barcode/__init__.py


CREATE OR REPLACE FUNCTION ean("length" INTEGER = 13 ,"prefixes" TEXT[] = ARRAY[]::TEXT[] ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ean'):
  plpy.warning(
    "the `ean` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ean(length
,prefixes
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ean("length" INTEGER = 13 ,"prefixes" TEXT[] = ARRAY[]::TEXT[] ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ean'):
  plpy.warning(
    "the `ean` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ean(length,prefixes)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ean8("prefixes" TEXT[] = ARRAY[]::TEXT[] ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ean8'):
  plpy.warning(
    "the `ean8` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ean8(prefixes
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ean8("prefixes" TEXT[] = ARRAY[]::TEXT[] ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ean8'):
  plpy.warning(
    "the `ean8` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ean8(prefixes)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ean13("prefixes" TEXT[] = ARRAY[]::TEXT[] ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ean13'):
  plpy.warning(
    "the `ean13` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ean13(prefixes
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ean13("prefixes" TEXT[] = ARRAY[]::TEXT[] ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ean13'):
  plpy.warning(
    "the `ean13` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ean13(prefixes)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION localized_ean("length" INTEGER = 13 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'localized_ean'):
  plpy.warning(
    "the `localized_ean` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].localized_ean(length
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_localized_ean("length" INTEGER = 13 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'localized_ean'):
  plpy.warning(
    "the `localized_ean` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.localized_ean(length)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION localized_ean8() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'localized_ean8'):
  plpy.warning(
    "the `localized_ean8` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].localized_ean8()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_localized_ean8() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'localized_ean8'):
  plpy.warning(
    "the `localized_ean8` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.localized_ean8()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION localized_ean13() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'localized_ean13'):
  plpy.warning(
    "the `localized_ean13` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].localized_ean13()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_localized_ean13() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'localized_ean13'):
  plpy.warning(
    "the `localized_ean13` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.localized_ean13()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.barcode.en_CA
-- https://github.com/joke2k/faker/blob/master/faker/providers/barcode/en_CA/__init__.py




-- Provider : faker.providers.barcode.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/barcode/en_US/__init__.py


CREATE OR REPLACE FUNCTION ean13("leading_zero" TEXT = NULL ,"prefixes" TEXT[] = ARRAY[]::TEXT[] ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ean13'):
  plpy.warning(
    "the `ean13` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ean13(leading_zero
,prefixes
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ean13("leading_zero" TEXT = NULL ,"prefixes" TEXT[] = ARRAY[]::TEXT[] ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ean13'):
  plpy.warning(
    "the `ean13` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ean13(leading_zero,prefixes)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION upc_a("upc_ae_mode" BOOLEAN = False ,"base" TEXT = NULL ,"number_system_digit" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'upc_a'):
  plpy.warning(
    "the `upc_a` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].upc_a(upc_ae_mode
,base
,number_system_digit
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_upc_a("upc_ae_mode" BOOLEAN = False ,"base" TEXT = NULL ,"number_system_digit" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'upc_a'):
  plpy.warning(
    "the `upc_a` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.upc_a(upc_ae_mode,base,number_system_digit)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION upc_e("base" TEXT = NULL ,"number_system_digit" TEXT = NULL ,"safe_mode" BOOLEAN = True ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'upc_e'):
  plpy.warning(
    "the `upc_e` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].upc_e(base
,number_system_digit
,safe_mode
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_upc_e("base" TEXT = NULL ,"number_system_digit" TEXT = NULL ,"safe_mode" BOOLEAN = True ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'upc_e'):
  plpy.warning(
    "the `upc_e` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.upc_e(base,number_system_digit,safe_mode)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.barcode.es_ES
-- https://github.com/joke2k/faker/blob/master/faker/providers/barcode/es_ES/__init__.py




-- Provider : faker.providers.barcode.fr_CA
-- https://github.com/joke2k/faker/blob/master/faker/providers/barcode/fr_CA/__init__.py




-- Provider : faker.providers.barcode.ja_JP
-- https://github.com/joke2k/faker/blob/master/faker/providers/barcode/ja_JP/__init__.py


CREATE OR REPLACE FUNCTION jan("length" INTEGER = 13 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'jan'):
  plpy.warning(
    "the `jan` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].jan(length
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_jan("length" INTEGER = 13 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'jan'):
  plpy.warning(
    "the `jan` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.jan(length)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION jan8() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'jan8'):
  plpy.warning(
    "the `jan8` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].jan8()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_jan8() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'jan8'):
  plpy.warning(
    "the `jan8` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.jan8()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION jan13() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'jan13'):
  plpy.warning(
    "the `jan13` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].jan13()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_jan13() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'jan13'):
  plpy.warning(
    "the `jan13` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.jan13()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.color
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/__init__.py


CREATE OR REPLACE FUNCTION color_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'color_name'):
  plpy.warning(
    "the `color_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].color_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_color_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'color_name'):
  plpy.warning(
    "the `color_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.color_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION safe_color_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'safe_color_name'):
  plpy.warning(
    "the `safe_color_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].safe_color_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_safe_color_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'safe_color_name'):
  plpy.warning(
    "the `safe_color_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.safe_color_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION hex_color() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'hex_color'):
  plpy.warning(
    "the `hex_color` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].hex_color()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_hex_color() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'hex_color'):
  plpy.warning(
    "the `hex_color` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.hex_color()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION safe_hex_color() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'safe_hex_color'):
  plpy.warning(
    "the `safe_hex_color` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].safe_hex_color()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_safe_hex_color() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'safe_hex_color'):
  plpy.warning(
    "the `safe_hex_color` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.safe_hex_color()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION rgb_color() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'rgb_color'):
  plpy.warning(
    "the `rgb_color` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].rgb_color()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_rgb_color() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'rgb_color'):
  plpy.warning(
    "the `rgb_color` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.rgb_color()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION rgb_css_color() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'rgb_css_color'):
  plpy.warning(
    "the `rgb_css_color` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].rgb_css_color()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_rgb_css_color() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'rgb_css_color'):
  plpy.warning(
    "the `rgb_css_color` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.rgb_css_color()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION color("hue" TEXT = NULL ,"luminosity" TEXT = NULL ,"color_format" TEXT = 'hex' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'color'):
  plpy.warning(
    "the `color` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].color(hue
,luminosity
,color_format
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_color("hue" TEXT = NULL ,"luminosity" TEXT = NULL ,"color_format" TEXT = 'hex' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'color'):
  plpy.warning(
    "the `color` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.color(hue,luminosity,color_format)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.color.ar_PS
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/ar_PS/__init__.py




-- Provider : faker.providers.color.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/en_US/__init__.py




-- Provider : faker.providers.color.es_ES
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/es_ES/__init__.py




-- Provider : faker.providers.color.fa_IR
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/fa_IR/__init__.py




-- Provider : faker.providers.color.fr_FR
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/fr_FR/__init__.py




-- Provider : faker.providers.color.hr_HR
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/hr_HR/__init__.py




-- Provider : faker.providers.color.hu_HU
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/hu_HU/__init__.py




-- Provider : faker.providers.color.hy_AM
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/hy_AM/__init__.py




-- Provider : faker.providers.color.pt_BR
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/pt_BR/__init__.py




-- Provider : faker.providers.color.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/ru_RU/__init__.py




-- Provider : faker.providers.color.sk_SK
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/sk_SK/__init__.py




-- Provider : faker.providers.color.th_TH
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/th_TH/__init__.py




-- Provider : faker.providers.color.uk_UA
-- https://github.com/joke2k/faker/blob/master/faker/providers/color/uk_UA/__init__.py




-- Provider : faker.providers.company
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/__init__.py


CREATE OR REPLACE FUNCTION company() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company'):
  plpy.warning(
    "the `company` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company'):
  plpy.warning(
    "the `company` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION company_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_suffix'):
  plpy.warning(
    "the `company_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_suffix'):
  plpy.warning(
    "the `company_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION catch_phrase() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION bs() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bs'):
  plpy.warning(
    "the `bs` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].bs()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_bs() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bs'):
  plpy.warning(
    "the `bs` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.bs()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.bg_BG
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/bg_BG/__init__.py




-- Provider : faker.providers.company.cs_CZ
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/cs_CZ/__init__.py




-- Provider : faker.providers.company.de_DE
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/de_DE/__init__.py




-- Provider : faker.providers.company.en_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/en_PH/__init__.py


CREATE OR REPLACE FUNCTION company_type() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_type'):
  plpy.warning(
    "the `company_type` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_type()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_type() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_type'):
  plpy.warning(
    "the `company_type` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_type()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION random_company_adjective() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_company_adjective'):
  plpy.warning(
    "the `random_company_adjective` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].random_company_adjective()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_random_company_adjective() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_company_adjective'):
  plpy.warning(
    "the `random_company_adjective` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.random_company_adjective()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION random_company_noun_chain() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_company_noun_chain'):
  plpy.warning(
    "the `random_company_noun_chain` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].random_company_noun_chain()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_random_company_noun_chain() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_company_noun_chain'):
  plpy.warning(
    "the `random_company_noun_chain` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.random_company_noun_chain()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION random_company_product() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_company_product'):
  plpy.warning(
    "the `random_company_product` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].random_company_product()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_random_company_product() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_company_product'):
  plpy.warning(
    "the `random_company_product` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.random_company_product()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION random_company_acronym() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_company_acronym'):
  plpy.warning(
    "the `random_company_acronym` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].random_company_acronym()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_random_company_acronym() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_company_acronym'):
  plpy.warning(
    "the `random_company_acronym` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.random_company_acronym()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/en_US/__init__.py




-- Provider : faker.providers.company.es_MX
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/es_MX/__init__.py


CREATE OR REPLACE FUNCTION company_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION catch_phrase() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION bs() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bs'):
  plpy.warning(
    "the `bs` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].bs()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_bs() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bs'):
  plpy.warning(
    "the `bs` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.bs()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.fa_IR
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/fa_IR/__init__.py


CREATE OR REPLACE FUNCTION company() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company'):
  plpy.warning(
    "the `company` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company'):
  plpy.warning(
    "the `company` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.fi_FI
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/fi_FI/__init__.py


CREATE OR REPLACE FUNCTION company_business_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_business_id'):
  plpy.warning(
    "the `company_business_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_business_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_business_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_business_id'):
  plpy.warning(
    "the `company_business_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_business_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION company_vat() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_vat'):
  plpy.warning(
    "the `company_vat` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_vat()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_vat() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_vat'):
  plpy.warning(
    "the `company_vat` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_vat()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.fil_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/fil_PH/__init__.py


CREATE OR REPLACE FUNCTION random_noun_ish_good_trait() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_noun_ish_good_trait'):
  plpy.warning(
    "the `random_noun_ish_good_trait` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].random_noun_ish_good_trait()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_random_noun_ish_good_trait() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_noun_ish_good_trait'):
  plpy.warning(
    "the `random_noun_ish_good_trait` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.random_noun_ish_good_trait()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION random_good_service_adjective() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_good_service_adjective'):
  plpy.warning(
    "the `random_good_service_adjective` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].random_good_service_adjective()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_random_good_service_adjective() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_good_service_adjective'):
  plpy.warning(
    "the `random_good_service_adjective` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.random_good_service_adjective()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION random_good_service_adjective_chain() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_good_service_adjective_chain'):
  plpy.warning(
    "the `random_good_service_adjective_chain` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].random_good_service_adjective_chain()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_random_good_service_adjective_chain() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_good_service_adjective_chain'):
  plpy.warning(
    "the `random_good_service_adjective_chain` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.random_good_service_adjective_chain()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION random_object_of_concern() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_object_of_concern'):
  plpy.warning(
    "the `random_object_of_concern` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].random_object_of_concern()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_random_object_of_concern() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_object_of_concern'):
  plpy.warning(
    "the `random_object_of_concern` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.random_object_of_concern()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION english_catch_phrase() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_catch_phrase'):
  plpy.warning(
    "the `english_catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].english_catch_phrase()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_english_catch_phrase() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_catch_phrase'):
  plpy.warning(
    "the `english_catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.english_catch_phrase()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION catch_phrase() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.fr_CH
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/fr_CH/__init__.py


CREATE OR REPLACE FUNCTION ide() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ide'):
  plpy.warning(
    "the `ide` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ide()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ide() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ide'):
  plpy.warning(
    "the `ide` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ide()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION uid() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'uid'):
  plpy.warning(
    "the `uid` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].uid()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_uid() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'uid'):
  plpy.warning(
    "the `uid` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.uid()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION idi() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'idi'):
  plpy.warning(
    "the `idi` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].idi()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_idi() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'idi'):
  plpy.warning(
    "the `idi` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.idi()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.fr_FR
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/fr_FR/__init__.py


CREATE OR REPLACE FUNCTION catch_phrase_noun() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase_noun'):
  plpy.warning(
    "the `catch_phrase_noun` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase_noun()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase_noun() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase_noun'):
  plpy.warning(
    "the `catch_phrase_noun` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase_noun()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION catch_phrase_attribute() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase_attribute'):
  plpy.warning(
    "the `catch_phrase_attribute` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase_attribute()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase_attribute() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase_attribute'):
  plpy.warning(
    "the `catch_phrase_attribute` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase_attribute()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION catch_phrase_verb() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase_verb'):
  plpy.warning(
    "the `catch_phrase_verb` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase_verb()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase_verb() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase_verb'):
  plpy.warning(
    "the `catch_phrase_verb` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase_verb()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION catch_phrase() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION siren() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'siren'):
  plpy.warning(
    "the `siren` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].siren()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_siren() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'siren'):
  plpy.warning(
    "the `siren` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.siren()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION siret("max_sequential_digits" INTEGER = 2 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'siret'):
  plpy.warning(
    "the `siret` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].siret(max_sequential_digits
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_siret("max_sequential_digits" INTEGER = 2 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'siret'):
  plpy.warning(
    "the `siret` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.siret(max_sequential_digits)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.hr_HR
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/hr_HR/__init__.py




-- Provider : faker.providers.company.hu_HU
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/hu_HU/__init__.py


CREATE OR REPLACE FUNCTION company_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_suffix'):
  plpy.warning(
    "the `company_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_suffix'):
  plpy.warning(
    "the `company_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.hy_AM
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/hy_AM/__init__.py




-- Provider : faker.providers.company.id_ID
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/id_ID/__init__.py


CREATE OR REPLACE FUNCTION company_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.it_IT
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/it_IT/__init__.py


CREATE OR REPLACE FUNCTION catch_phrase() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION bs() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bs'):
  plpy.warning(
    "the `bs` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].bs()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_bs() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bs'):
  plpy.warning(
    "the `bs` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.bs()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION company_vat() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_vat'):
  plpy.warning(
    "the `company_vat` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_vat()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_vat() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_vat'):
  plpy.warning(
    "the `company_vat` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_vat()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.ja_JP
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/ja_JP/__init__.py


CREATE OR REPLACE FUNCTION company_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION company_category() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_category'):
  plpy.warning(
    "the `company_category` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_category()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_category() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_category'):
  plpy.warning(
    "the `company_category` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_category()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.ko_KR
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/ko_KR/__init__.py


CREATE OR REPLACE FUNCTION catch_phrase() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION bs() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bs'):
  plpy.warning(
    "the `bs` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].bs()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_bs() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bs'):
  plpy.warning(
    "the `bs` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.bs()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.nl_NL
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/nl_NL/__init__.py


CREATE OR REPLACE FUNCTION large_company() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'large_company'):
  plpy.warning(
    "the `large_company` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].large_company()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_large_company() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'large_company'):
  plpy.warning(
    "the `large_company` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.large_company()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION company_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.no_NO
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/no_NO/__init__.py




-- Provider : faker.providers.company.pl_PL
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/pl_PL/__init__.py


CREATE OR REPLACE FUNCTION company_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION regon() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'regon'):
  plpy.warning(
    "the `regon` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].regon()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_regon() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'regon'):
  plpy.warning(
    "the `regon` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.regon()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION local_regon() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_regon'):
  plpy.warning(
    "the `local_regon` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].local_regon()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_local_regon() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_regon'):
  plpy.warning(
    "the `local_regon` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.local_regon()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION company_vat() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_vat'):
  plpy.warning(
    "the `company_vat` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_vat()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_vat() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_vat'):
  plpy.warning(
    "the `company_vat` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_vat()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.pt_BR
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/pt_BR/__init__.py


CREATE OR REPLACE FUNCTION catch_phrase_noun() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase_noun'):
  plpy.warning(
    "the `catch_phrase_noun` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase_noun()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase_noun() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase_noun'):
  plpy.warning(
    "the `catch_phrase_noun` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase_noun()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION catch_phrase_attribute() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase_attribute'):
  plpy.warning(
    "the `catch_phrase_attribute` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase_attribute()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase_attribute() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase_attribute'):
  plpy.warning(
    "the `catch_phrase_attribute` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase_attribute()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION catch_phrase_verb() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase_verb'):
  plpy.warning(
    "the `catch_phrase_verb` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase_verb()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase_verb() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase_verb'):
  plpy.warning(
    "the `catch_phrase_verb` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase_verb()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION catch_phrase() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION company_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_id'):
  plpy.warning(
    "the `company_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_id'):
  plpy.warning(
    "the `company_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION cnpj() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cnpj'):
  plpy.warning(
    "the `cnpj` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].cnpj()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_cnpj() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cnpj'):
  plpy.warning(
    "the `cnpj` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.cnpj()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.pt_PT
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/pt_PT/__init__.py




-- Provider : faker.providers.company.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/ru_RU/__init__.py


CREATE OR REPLACE FUNCTION catch_phrase() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].catch_phrase()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_catch_phrase() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'catch_phrase'):
  plpy.warning(
    "the `catch_phrase` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.catch_phrase()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION large_company() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'large_company'):
  plpy.warning(
    "the `large_company` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].large_company()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_large_company() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'large_company'):
  plpy.warning(
    "the `large_company` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.large_company()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION company_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION businesses_inn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'businesses_inn'):
  plpy.warning(
    "the `businesses_inn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].businesses_inn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_businesses_inn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'businesses_inn'):
  plpy.warning(
    "the `businesses_inn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.businesses_inn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION individuals_inn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'individuals_inn'):
  plpy.warning(
    "the `individuals_inn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].individuals_inn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_individuals_inn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'individuals_inn'):
  plpy.warning(
    "the `individuals_inn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.individuals_inn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION businesses_ogrn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'businesses_ogrn'):
  plpy.warning(
    "the `businesses_ogrn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].businesses_ogrn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_businesses_ogrn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'businesses_ogrn'):
  plpy.warning(
    "the `businesses_ogrn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.businesses_ogrn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION individuals_ogrn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'individuals_ogrn'):
  plpy.warning(
    "the `individuals_ogrn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].individuals_ogrn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_individuals_ogrn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'individuals_ogrn'):
  plpy.warning(
    "the `individuals_ogrn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.individuals_ogrn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION kpp() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'kpp'):
  plpy.warning(
    "the `kpp` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].kpp()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_kpp() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'kpp'):
  plpy.warning(
    "the `kpp` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.kpp()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.sk_SK
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/sk_SK/__init__.py




-- Provider : faker.providers.company.sl_SI
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/sl_SI/__init__.py




-- Provider : faker.providers.company.sv_SE
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/sv_SE/__init__.py




-- Provider : faker.providers.company.th_TH
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/th_TH/__init__.py


CREATE OR REPLACE FUNCTION company_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION company_limited_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_limited_prefix'):
  plpy.warning(
    "the `company_limited_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_limited_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_limited_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_limited_prefix'):
  plpy.warning(
    "the `company_limited_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_limited_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION company_limited_suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_limited_suffix'):
  plpy.warning(
    "the `company_limited_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_limited_suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_limited_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_limited_suffix'):
  plpy.warning(
    "the `company_limited_suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_limited_suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION nonprofit_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'nonprofit_prefix'):
  plpy.warning(
    "the `nonprofit_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].nonprofit_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_nonprofit_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'nonprofit_prefix'):
  plpy.warning(
    "the `nonprofit_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.nonprofit_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.tl_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/tl_PH/__init__.py




-- Provider : faker.providers.company.tr_TR
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/tr_TR/__init__.py


CREATE OR REPLACE FUNCTION large_company() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'large_company'):
  plpy.warning(
    "the `large_company` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].large_company()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_large_company() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'large_company'):
  plpy.warning(
    "the `large_company` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.large_company()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.zh_CN
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/zh_CN/__init__.py


CREATE OR REPLACE FUNCTION company_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.company.zh_TW
-- https://github.com/joke2k/faker/blob/master/faker/providers/company/zh_TW/__init__.py


CREATE OR REPLACE FUNCTION company_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_prefix'):
  plpy.warning(
    "the `company_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.credit_card
-- https://github.com/joke2k/faker/blob/master/faker/providers/credit_card/__init__.py


CREATE OR REPLACE FUNCTION credit_card_provider("card_type" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_provider'):
  plpy.warning(
    "the `credit_card_provider` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].credit_card_provider(card_type
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_credit_card_provider("card_type" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_provider'):
  plpy.warning(
    "the `credit_card_provider` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.credit_card_provider(card_type)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION credit_card_number("card_type" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_number'):
  plpy.warning(
    "the `credit_card_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].credit_card_number(card_type
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_credit_card_number("card_type" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_number'):
  plpy.warning(
    "the `credit_card_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.credit_card_number(card_type)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION credit_card_expire("start" TEXT = 'now' ,"end" TEXT = '+10y' ,"date_format" TEXT = '%m/%y' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_expire'):
  plpy.warning(
    "the `credit_card_expire` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].credit_card_expire(start
,end
,date_format
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_credit_card_expire("start" TEXT = 'now' ,"end" TEXT = '+10y' ,"date_format" TEXT = '%m/%y' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_expire'):
  plpy.warning(
    "the `credit_card_expire` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.credit_card_expire(start,end,date_format)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION credit_card_full("card_type" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_full'):
  plpy.warning(
    "the `credit_card_full` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].credit_card_full(card_type
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_credit_card_full("card_type" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_full'):
  plpy.warning(
    "the `credit_card_full` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.credit_card_full(card_type)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION credit_card_security_code("card_type" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_security_code'):
  plpy.warning(
    "the `credit_card_security_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].credit_card_security_code(card_type
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_credit_card_security_code("card_type" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_security_code'):
  plpy.warning(
    "the `credit_card_security_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.credit_card_security_code(card_type)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.credit_card.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/credit_card/en_US/__init__.py




-- Provider : faker.providers.credit_card.fa_IR
-- https://github.com/joke2k/faker/blob/master/faker/providers/credit_card/fa_IR/__init__.py


CREATE OR REPLACE FUNCTION credit_card_expire("start" TEXT = 'now' ,"end" TEXT = '+3y' ,"date_format" TEXT = '%y/%m' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_expire'):
  plpy.warning(
    "the `credit_card_expire` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].credit_card_expire(start
,end
,date_format
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_credit_card_expire("start" TEXT = 'now' ,"end" TEXT = '+3y' ,"date_format" TEXT = '%y/%m' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_expire'):
  plpy.warning(
    "the `credit_card_expire` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.credit_card_expire(start,end,date_format)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.credit_card.pt_PT
-- https://github.com/joke2k/faker/blob/master/faker/providers/credit_card/pt_PT/__init__.py


CREATE OR REPLACE FUNCTION credit_card_expire("start" TEXT = 'now' ,"end" TEXT = '+4y' ,"date_format" TEXT = '%m/%y' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_expire'):
  plpy.warning(
    "the `credit_card_expire` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].credit_card_expire(start
,end
,date_format
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_credit_card_expire("start" TEXT = 'now' ,"end" TEXT = '+4y' ,"date_format" TEXT = '%m/%y' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_expire'):
  plpy.warning(
    "the `credit_card_expire` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.credit_card_expire(start,end,date_format)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.credit_card.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/credit_card/ru_RU/__init__.py


CREATE OR REPLACE FUNCTION credit_card_expire("start" TEXT = 'now' ,"end" TEXT = '+4y' ,"date_format" TEXT = '%m/%y' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_expire'):
  plpy.warning(
    "the `credit_card_expire` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].credit_card_expire(start
,end
,date_format
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_credit_card_expire("start" TEXT = 'now' ,"end" TEXT = '+4y' ,"date_format" TEXT = '%m/%y' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_expire'):
  plpy.warning(
    "the `credit_card_expire` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.credit_card_expire(start,end,date_format)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION credit_card_full("card_type" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_full'):
  plpy.warning(
    "the `credit_card_full` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].credit_card_full(card_type
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_credit_card_full("card_type" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'credit_card_full'):
  plpy.warning(
    "the `credit_card_full` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.credit_card_full(card_type)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/__init__.py


CREATE OR REPLACE FUNCTION currency() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'currency'):
  plpy.warning(
    "the `currency` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].currency()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_currency() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'currency'):
  plpy.warning(
    "the `currency` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.currency()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION currency_code() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'currency_code'):
  plpy.warning(
    "the `currency_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].currency_code()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_currency_code() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'currency_code'):
  plpy.warning(
    "the `currency_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.currency_code()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION currency_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'currency_name'):
  plpy.warning(
    "the `currency_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].currency_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_currency_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'currency_name'):
  plpy.warning(
    "the `currency_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.currency_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION currency_symbol("code" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'currency_symbol'):
  plpy.warning(
    "the `currency_symbol` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].currency_symbol(code
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_currency_symbol("code" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'currency_symbol'):
  plpy.warning(
    "the `currency_symbol` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.currency_symbol(code)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION cryptocurrency() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cryptocurrency'):
  plpy.warning(
    "the `cryptocurrency` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].cryptocurrency()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_cryptocurrency() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cryptocurrency'):
  plpy.warning(
    "the `cryptocurrency` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.cryptocurrency()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION cryptocurrency_code() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cryptocurrency_code'):
  plpy.warning(
    "the `cryptocurrency_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].cryptocurrency_code()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_cryptocurrency_code() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cryptocurrency_code'):
  plpy.warning(
    "the `cryptocurrency_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.cryptocurrency_code()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION cryptocurrency_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cryptocurrency_name'):
  plpy.warning(
    "the `cryptocurrency_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].cryptocurrency_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_cryptocurrency_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cryptocurrency_name'):
  plpy.warning(
    "the `cryptocurrency_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.cryptocurrency_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.cs_CZ
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/cs_CZ/__init__.py


CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.de_AT
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/de_AT/__init__.py


CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.de_DE
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/de_DE/__init__.py


CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.en_AU
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/en_AU/__init__.py


CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.en_CA
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/en_CA/__init__.py


CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/en_US/__init__.py


CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.es_ES
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/es_ES/__init__.py


CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.fr_CA
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/fr_CA/__init__.py


CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.fr_FR
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/fr_FR/__init__.py


CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.it_IT
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/it_IT/__init__.py


CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.pl_PL
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/pl_PL/__init__.py


CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/ru_RU/__init__.py


CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.sk_SK
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/sk_SK/__init__.py


CREATE OR REPLACE FUNCTION pricetag() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pricetag()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pricetag() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pricetag'):
  plpy.warning(
    "the `pricetag` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pricetag()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.currency.sv_SE
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/sv_SE/__init__.py




-- Provider : faker.providers.currency.th_TH
-- https://github.com/joke2k/faker/blob/master/faker/providers/currency/th_TH/__init__.py




-- Provider : faker.providers.date_time
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/__init__.py


CREATE OR REPLACE FUNCTION unix_time("end_datetime" TEXT = NULL ,"start_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'unix_time'):
  plpy.warning(
    "the `unix_time` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].unix_time(end_datetime
,start_datetime
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_unix_time("end_datetime" TEXT = NULL ,"start_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'unix_time'):
  plpy.warning(
    "the `unix_time` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.unix_time(end_datetime,start_datetime)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION time_delta("end_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'time_delta'):
  plpy.warning(
    "the `time_delta` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].time_delta(end_datetime
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_time_delta("end_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'time_delta'):
  plpy.warning(
    "the `time_delta` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.time_delta(end_datetime)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_time("tzinfo" TEXT = NULL ,"end_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time'):
  plpy.warning(
    "the `date_time` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_time(tzinfo
,end_datetime
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_time("tzinfo" TEXT = NULL ,"end_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time'):
  plpy.warning(
    "the `date_time` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_time(tzinfo,end_datetime)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_time_ad("tzinfo" TEXT = NULL ,"end_datetime" TEXT = NULL ,"start_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_ad'):
  plpy.warning(
    "the `date_time_ad` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_time_ad(tzinfo
,end_datetime
,start_datetime
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_time_ad("tzinfo" TEXT = NULL ,"end_datetime" TEXT = NULL ,"start_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_ad'):
  plpy.warning(
    "the `date_time_ad` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_time_ad(tzinfo,end_datetime,start_datetime)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION iso8601("tzinfo" TEXT = NULL ,"end_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'iso8601'):
  plpy.warning(
    "the `iso8601` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].iso8601(tzinfo
,end_datetime
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_iso8601("tzinfo" TEXT = NULL ,"end_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'iso8601'):
  plpy.warning(
    "the `iso8601` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.iso8601(tzinfo,end_datetime)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date("pattern" TEXT = '%Y-%m-%d' ,"end_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date'):
  plpy.warning(
    "the `date` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date(pattern
,end_datetime
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date("pattern" TEXT = '%Y-%m-%d' ,"end_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date'):
  plpy.warning(
    "the `date` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date(pattern,end_datetime)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_object("end_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_object'):
  plpy.warning(
    "the `date_object` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_object(end_datetime
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_object("end_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_object'):
  plpy.warning(
    "the `date_object` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_object(end_datetime)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION time_object("end_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'time_object'):
  plpy.warning(
    "the `time_object` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].time_object(end_datetime
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_time_object("end_datetime" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'time_object'):
  plpy.warning(
    "the `time_object` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.time_object(end_datetime)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_time_between("start_date" TEXT = '-30y' ,"end_date" TEXT = 'now' ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_between'):
  plpy.warning(
    "the `date_time_between` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_time_between(start_date
,end_date
,tzinfo
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_time_between("start_date" TEXT = '-30y' ,"end_date" TEXT = 'now' ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_between'):
  plpy.warning(
    "the `date_time_between` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_time_between(start_date,end_date,tzinfo)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_between("start_date" TEXT = '-30y' ,"end_date" TEXT = 'today' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_between'):
  plpy.warning(
    "the `date_between` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_between(start_date
,end_date
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_between("start_date" TEXT = '-30y' ,"end_date" TEXT = 'today' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_between'):
  plpy.warning(
    "the `date_between` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_between(start_date,end_date)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION future_datetime("end_date" TEXT = '+30d' ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'future_datetime'):
  plpy.warning(
    "the `future_datetime` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].future_datetime(end_date
,tzinfo
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_future_datetime("end_date" TEXT = '+30d' ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'future_datetime'):
  plpy.warning(
    "the `future_datetime` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.future_datetime(end_date,tzinfo)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION future_date("end_date" TEXT = '+30d' ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'future_date'):
  plpy.warning(
    "the `future_date` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].future_date(end_date
,tzinfo
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_future_date("end_date" TEXT = '+30d' ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'future_date'):
  plpy.warning(
    "the `future_date` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.future_date(end_date,tzinfo)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION past_datetime("start_date" TEXT = '-30d' ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'past_datetime'):
  plpy.warning(
    "the `past_datetime` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].past_datetime(start_date
,tzinfo
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_past_datetime("start_date" TEXT = '-30d' ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'past_datetime'):
  plpy.warning(
    "the `past_datetime` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.past_datetime(start_date,tzinfo)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION past_date("start_date" TEXT = '-30d' ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'past_date'):
  plpy.warning(
    "the `past_date` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].past_date(start_date
,tzinfo
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_past_date("start_date" TEXT = '-30d' ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'past_date'):
  plpy.warning(
    "the `past_date` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.past_date(start_date,tzinfo)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_time_between_dates("datetime_start" TEXT = NULL ,"datetime_end" TEXT = NULL ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_between_dates'):
  plpy.warning(
    "the `date_time_between_dates` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_time_between_dates(datetime_start
,datetime_end
,tzinfo
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_time_between_dates("datetime_start" TEXT = NULL ,"datetime_end" TEXT = NULL ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_between_dates'):
  plpy.warning(
    "the `date_time_between_dates` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_time_between_dates(datetime_start,datetime_end,tzinfo)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_between_dates("date_start" TEXT = NULL ,"date_end" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_between_dates'):
  plpy.warning(
    "the `date_between_dates` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_between_dates(date_start
,date_end
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_between_dates("date_start" TEXT = NULL ,"date_end" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_between_dates'):
  plpy.warning(
    "the `date_between_dates` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_between_dates(date_start,date_end)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_time_this_century("before_now" BOOLEAN = True ,"after_now" BOOLEAN = False ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_this_century'):
  plpy.warning(
    "the `date_time_this_century` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_time_this_century(before_now
,after_now
,tzinfo
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_time_this_century("before_now" BOOLEAN = True ,"after_now" BOOLEAN = False ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_this_century'):
  plpy.warning(
    "the `date_time_this_century` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_time_this_century(before_now,after_now,tzinfo)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_time_this_decade("before_now" BOOLEAN = True ,"after_now" BOOLEAN = False ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_this_decade'):
  plpy.warning(
    "the `date_time_this_decade` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_time_this_decade(before_now
,after_now
,tzinfo
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_time_this_decade("before_now" BOOLEAN = True ,"after_now" BOOLEAN = False ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_this_decade'):
  plpy.warning(
    "the `date_time_this_decade` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_time_this_decade(before_now,after_now,tzinfo)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_time_this_year("before_now" BOOLEAN = True ,"after_now" BOOLEAN = False ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_this_year'):
  plpy.warning(
    "the `date_time_this_year` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_time_this_year(before_now
,after_now
,tzinfo
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_time_this_year("before_now" BOOLEAN = True ,"after_now" BOOLEAN = False ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_this_year'):
  plpy.warning(
    "the `date_time_this_year` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_time_this_year(before_now,after_now,tzinfo)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_time_this_month("before_now" BOOLEAN = True ,"after_now" BOOLEAN = False ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_this_month'):
  plpy.warning(
    "the `date_time_this_month` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_time_this_month(before_now
,after_now
,tzinfo
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_time_this_month("before_now" BOOLEAN = True ,"after_now" BOOLEAN = False ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_time_this_month'):
  plpy.warning(
    "the `date_time_this_month` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_time_this_month(before_now,after_now,tzinfo)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_this_century("before_today" BOOLEAN = True ,"after_today" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_this_century'):
  plpy.warning(
    "the `date_this_century` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_this_century(before_today
,after_today
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_this_century("before_today" BOOLEAN = True ,"after_today" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_this_century'):
  plpy.warning(
    "the `date_this_century` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_this_century(before_today,after_today)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_this_decade("before_today" BOOLEAN = True ,"after_today" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_this_decade'):
  plpy.warning(
    "the `date_this_decade` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_this_decade(before_today
,after_today
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_this_decade("before_today" BOOLEAN = True ,"after_today" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_this_decade'):
  plpy.warning(
    "the `date_this_decade` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_this_decade(before_today,after_today)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_this_year("before_today" BOOLEAN = True ,"after_today" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_this_year'):
  plpy.warning(
    "the `date_this_year` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_this_year(before_today
,after_today
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_this_year("before_today" BOOLEAN = True ,"after_today" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_this_year'):
  plpy.warning(
    "the `date_this_year` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_this_year(before_today,after_today)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_this_month("before_today" BOOLEAN = True ,"after_today" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_this_month'):
  plpy.warning(
    "the `date_this_month` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_this_month(before_today
,after_today
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_this_month("before_today" BOOLEAN = True ,"after_today" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_this_month'):
  plpy.warning(
    "the `date_this_month` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_this_month(before_today,after_today)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION time_series("start_date" TEXT = '-30d' ,"end_date" TEXT = 'now' ,"precision" TEXT = NULL ,"distrib" TEXT = NULL ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'time_series'):
  plpy.warning(
    "the `time_series` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].time_series(start_date
,end_date
,precision
,distrib
,tzinfo
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_time_series("start_date" TEXT = '-30d' ,"end_date" TEXT = 'now' ,"precision" TEXT = NULL ,"distrib" TEXT = NULL ,"tzinfo" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'time_series'):
  plpy.warning(
    "the `time_series` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.time_series(start_date,end_date,precision,distrib,tzinfo)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION am_pm() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'am_pm'):
  plpy.warning(
    "the `am_pm` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].am_pm()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_am_pm() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'am_pm'):
  plpy.warning(
    "the `am_pm` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.am_pm()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION day_of_month() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_month'):
  plpy.warning(
    "the `day_of_month` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_month()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_month() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_month'):
  plpy.warning(
    "the `day_of_month` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_month()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month'):
  plpy.warning(
    "the `month` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month'):
  plpy.warning(
    "the `month` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION year() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'year'):
  plpy.warning(
    "the `year` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].year()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_year() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'year'):
  plpy.warning(
    "the `year` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.year()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION century() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'century'):
  plpy.warning(
    "the `century` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].century()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_century() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'century'):
  plpy.warning(
    "the `century` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.century()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION timezone() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'timezone'):
  plpy.warning(
    "the `timezone` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].timezone()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_timezone() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'timezone'):
  plpy.warning(
    "the `timezone` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.timezone()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pytimezone("args" TEXT = '' ,"kwargs" TEXT = '' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pytimezone'):
  plpy.warning(
    "the `pytimezone` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pytimezone(args
,kwargs
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pytimezone("args" TEXT = '' ,"kwargs" TEXT = '' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pytimezone'):
  plpy.warning(
    "the `pytimezone` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pytimezone(args,kwargs)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION date_of_birth("tzinfo" TEXT = NULL ,"minimum_age" INTEGER = 0 ,"maximum_age" INTEGER = 115 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_of_birth'):
  plpy.warning(
    "the `date_of_birth` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date_of_birth(tzinfo
,minimum_age
,maximum_age
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date_of_birth("tzinfo" TEXT = NULL ,"minimum_age" INTEGER = 0 ,"maximum_age" INTEGER = 115 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date_of_birth'):
  plpy.warning(
    "the `date_of_birth` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date_of_birth(tzinfo,minimum_age,maximum_age)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.ar_AA
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/ar_AA/__init__.py


CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION am_pm() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'am_pm'):
  plpy.warning(
    "the `am_pm` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].am_pm()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_am_pm() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'am_pm'):
  plpy.warning(
    "the `am_pm` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.am_pm()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.ar_EG
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/ar_EG/__init__.py




-- Provider : faker.providers.date_time.cs_CZ
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/cs_CZ/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.de_AT
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/de_AT/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.de_DE
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/de_DE/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.en_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/en_PH/__init__.py




-- Provider : faker.providers.date_time.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/en_US/__init__.py




-- Provider : faker.providers.date_time.es_ES
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/es_ES/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.fil_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/fil_PH/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.fr_FR
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/fr_FR/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.hi_IN
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/hi_IN/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.hr_HR
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/hr_HR/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.hu_HU
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/hu_HU/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.hy_AM
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/hy_AM/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.id_ID
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/id_ID/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.it_IT
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/it_IT/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.ko_KR
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/ko_KR/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.pl_PL
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/pl_PL/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.pt_PT
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/pt_PT/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/ru_RU/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.sk_SK
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/sk_SK/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.sl_SI
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/sl_SI/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.ta_IN
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/ta_IN/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.th_TH
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/th_TH/__init__.py


CREATE OR REPLACE FUNCTION date("pattern" TEXT = '%-d %b %Y' ,"end_datetime" TEXT = NULL ,"thai_digit" BOOLEAN = False ,"buddhist_era" BOOLEAN = True ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date'):
  plpy.warning(
    "the `date` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].date(pattern
,end_datetime
,thai_digit
,buddhist_era
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_date("pattern" TEXT = '%-d %b %Y' ,"end_datetime" TEXT = NULL ,"thai_digit" BOOLEAN = False ,"buddhist_era" BOOLEAN = True ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'date'):
  plpy.warning(
    "the `date` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.date(pattern,end_datetime,thai_digit,buddhist_era)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION century("thai_digit" BOOLEAN = False ,"buddhist_era" BOOLEAN = True ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'century'):
  plpy.warning(
    "the `century` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].century(thai_digit
,buddhist_era
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_century("thai_digit" BOOLEAN = False ,"buddhist_era" BOOLEAN = True ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'century'):
  plpy.warning(
    "the `century` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.century(thai_digit,buddhist_era)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.date_time.tl_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/tl_PH/__init__.py




-- Provider : faker.providers.date_time.tr_TR
-- https://github.com/joke2k/faker/blob/master/faker/providers/date_time/tr_TR/__init__.py


CREATE OR REPLACE FUNCTION day_of_week() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].day_of_week()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_day_of_week() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'day_of_week'):
  plpy.warning(
    "the `day_of_week` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.day_of_week()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION month_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].month_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_month_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'month_name'):
  plpy.warning(
    "the `month_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.month_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.file
-- https://github.com/joke2k/faker/blob/master/faker/providers/file/__init__.py


CREATE OR REPLACE FUNCTION mime_type("category" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mime_type'):
  plpy.warning(
    "the `mime_type` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].mime_type(category
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_mime_type("category" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mime_type'):
  plpy.warning(
    "the `mime_type` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.mime_type(category)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION file_name("category" TEXT = NULL ,"extension" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'file_name'):
  plpy.warning(
    "the `file_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].file_name(category
,extension
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_file_name("category" TEXT = NULL ,"extension" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'file_name'):
  plpy.warning(
    "the `file_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.file_name(category,extension)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION file_extension("category" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'file_extension'):
  plpy.warning(
    "the `file_extension` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].file_extension(category
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_file_extension("category" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'file_extension'):
  plpy.warning(
    "the `file_extension` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.file_extension(category)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION file_path("depth" INTEGER = 1 ,"category" TEXT = NULL ,"extension" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'file_path'):
  plpy.warning(
    "the `file_path` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].file_path(depth
,category
,extension
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_file_path("depth" INTEGER = 1 ,"category" TEXT = NULL ,"extension" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'file_path'):
  plpy.warning(
    "the `file_path` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.file_path(depth,category,extension)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unix_device("prefix" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'unix_device'):
  plpy.warning(
    "the `unix_device` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].unix_device(prefix
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_unix_device("prefix" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'unix_device'):
  plpy.warning(
    "the `unix_device` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.unix_device(prefix)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unix_partition("prefix" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'unix_partition'):
  plpy.warning(
    "the `unix_partition` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].unix_partition(prefix
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_unix_partition("prefix" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'unix_partition'):
  plpy.warning(
    "the `unix_partition` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.unix_partition(prefix)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.geo
-- https://github.com/joke2k/faker/blob/master/faker/providers/geo/__init__.py


CREATE OR REPLACE FUNCTION coordinate("center" TEXT = NULL ,"radius" FLOAT = 0.001 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'coordinate'):
  plpy.warning(
    "the `coordinate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].coordinate(center
,radius
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_coordinate("center" TEXT = NULL ,"radius" FLOAT = 0.001 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'coordinate'):
  plpy.warning(
    "the `coordinate` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.coordinate(center,radius)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION latitude() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'latitude'):
  plpy.warning(
    "the `latitude` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].latitude()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_latitude() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'latitude'):
  plpy.warning(
    "the `latitude` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.latitude()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION longitude() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'longitude'):
  plpy.warning(
    "the `longitude` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].longitude()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_longitude() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'longitude'):
  plpy.warning(
    "the `longitude` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.longitude()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION latlng() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'latlng'):
  plpy.warning(
    "the `latlng` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].latlng()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_latlng() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'latlng'):
  plpy.warning(
    "the `latlng` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.latlng()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION local_latlng("country_code" TEXT = 'US' ,"coords_only" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_latlng'):
  plpy.warning(
    "the `local_latlng` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].local_latlng(country_code
,coords_only
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_local_latlng("country_code" TEXT = 'US' ,"coords_only" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_latlng'):
  plpy.warning(
    "the `local_latlng` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.local_latlng(country_code,coords_only)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION location_on_land("coords_only" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'location_on_land'):
  plpy.warning(
    "the `location_on_land` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].location_on_land(coords_only
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_location_on_land("coords_only" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'location_on_land'):
  plpy.warning(
    "the `location_on_land` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.location_on_land(coords_only)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.geo.de_AT
-- https://github.com/joke2k/faker/blob/master/faker/providers/geo/de_AT/__init__.py


CREATE OR REPLACE FUNCTION local_latitude() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_latitude'):
  plpy.warning(
    "the `local_latitude` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].local_latitude()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_local_latitude() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_latitude'):
  plpy.warning(
    "the `local_latitude` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.local_latitude()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION local_longitude() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_longitude'):
  plpy.warning(
    "the `local_longitude` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].local_longitude()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_local_longitude() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_longitude'):
  plpy.warning(
    "the `local_longitude` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.local_longitude()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.geo.el_GR
-- https://github.com/joke2k/faker/blob/master/faker/providers/geo/el_GR/__init__.py


CREATE OR REPLACE FUNCTION local_latlng() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_latlng'):
  plpy.warning(
    "the `local_latlng` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].local_latlng()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_local_latlng() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_latlng'):
  plpy.warning(
    "the `local_latlng` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.local_latlng()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION local_latitude() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_latitude'):
  plpy.warning(
    "the `local_latitude` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].local_latitude()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_local_latitude() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_latitude'):
  plpy.warning(
    "the `local_latitude` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.local_latitude()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION local_longitude() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_longitude'):
  plpy.warning(
    "the `local_longitude` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].local_longitude()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_local_longitude() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'local_longitude'):
  plpy.warning(
    "the `local_longitude` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.local_longitude()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.geo.en_IE
-- https://github.com/joke2k/faker/blob/master/faker/providers/geo/en_IE/__init__.py




-- Provider : faker.providers.geo.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/geo/en_US/__init__.py




-- Provider : faker.providers.geo.pt_PT
-- https://github.com/joke2k/faker/blob/master/faker/providers/geo/pt_PT/__init__.py


CREATE OR REPLACE FUNCTION nationality() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'nationality'):
  plpy.warning(
    "the `nationality` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].nationality()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_nationality() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'nationality'):
  plpy.warning(
    "the `nationality` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.nationality()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.geo.tr_TR
-- https://github.com/joke2k/faker/blob/master/faker/providers/geo/tr_TR/__init__.py




-- Provider : faker.providers.internet
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/__init__.py


CREATE OR REPLACE FUNCTION email("domain" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'email'):
  plpy.warning(
    "the `email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].email(domain
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_email("domain" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'email'):
  plpy.warning(
    "the `email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.email(domain)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION safe_domain_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'safe_domain_name'):
  plpy.warning(
    "the `safe_domain_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].safe_domain_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_safe_domain_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'safe_domain_name'):
  plpy.warning(
    "the `safe_domain_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.safe_domain_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION safe_email() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'safe_email'):
  plpy.warning(
    "the `safe_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].safe_email()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_safe_email() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'safe_email'):
  plpy.warning(
    "the `safe_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.safe_email()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION free_email() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'free_email'):
  plpy.warning(
    "the `free_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].free_email()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_free_email() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'free_email'):
  plpy.warning(
    "the `free_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.free_email()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION company_email() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_email'):
  plpy.warning(
    "the `company_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].company_email()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_company_email() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'company_email'):
  plpy.warning(
    "the `company_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.company_email()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION free_email_domain() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'free_email_domain'):
  plpy.warning(
    "the `free_email_domain` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].free_email_domain()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_free_email_domain() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'free_email_domain'):
  plpy.warning(
    "the `free_email_domain` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.free_email_domain()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ascii_email() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ascii_email'):
  plpy.warning(
    "the `ascii_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ascii_email()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ascii_email() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ascii_email'):
  plpy.warning(
    "the `ascii_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ascii_email()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ascii_safe_email() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ascii_safe_email'):
  plpy.warning(
    "the `ascii_safe_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ascii_safe_email()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ascii_safe_email() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ascii_safe_email'):
  plpy.warning(
    "the `ascii_safe_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ascii_safe_email()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ascii_free_email() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ascii_free_email'):
  plpy.warning(
    "the `ascii_free_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ascii_free_email()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ascii_free_email() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ascii_free_email'):
  plpy.warning(
    "the `ascii_free_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ascii_free_email()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ascii_company_email() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ascii_company_email'):
  plpy.warning(
    "the `ascii_company_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ascii_company_email()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ascii_company_email() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ascii_company_email'):
  plpy.warning(
    "the `ascii_company_email` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ascii_company_email()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION user_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'user_name'):
  plpy.warning(
    "the `user_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].user_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_user_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'user_name'):
  plpy.warning(
    "the `user_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.user_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION hostname("levels" INTEGER = 1 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'hostname'):
  plpy.warning(
    "the `hostname` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].hostname(levels
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_hostname("levels" INTEGER = 1 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'hostname'):
  plpy.warning(
    "the `hostname` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.hostname(levels)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION domain_name("levels" INTEGER = 1 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_name'):
  plpy.warning(
    "the `domain_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].domain_name(levels
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_domain_name("levels" INTEGER = 1 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_name'):
  plpy.warning(
    "the `domain_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.domain_name(levels)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION domain_word() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_word'):
  plpy.warning(
    "the `domain_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].domain_word()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_domain_word() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_word'):
  plpy.warning(
    "the `domain_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.domain_word()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION dga("year" TEXT = NULL ,"month" TEXT = NULL ,"day" TEXT = NULL ,"tld" TEXT = NULL ,"length" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'dga'):
  plpy.warning(
    "the `dga` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].dga(year
,month
,day
,tld
,length
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_dga("year" TEXT = NULL ,"month" TEXT = NULL ,"day" TEXT = NULL ,"tld" TEXT = NULL ,"length" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'dga'):
  plpy.warning(
    "the `dga` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.dga(year,month,day,tld,length)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION tld() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'tld'):
  plpy.warning(
    "the `tld` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].tld()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_tld() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'tld'):
  plpy.warning(
    "the `tld` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.tld()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION http_method() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'http_method'):
  plpy.warning(
    "the `http_method` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].http_method()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_http_method() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'http_method'):
  plpy.warning(
    "the `http_method` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.http_method()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION url("schemes" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'url'):
  plpy.warning(
    "the `url` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].url(schemes
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_url("schemes" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'url'):
  plpy.warning(
    "the `url` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.url(schemes)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ipv4_network_class() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ipv4_network_class'):
  plpy.warning(
    "the `ipv4_network_class` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ipv4_network_class()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ipv4_network_class() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ipv4_network_class'):
  plpy.warning(
    "the `ipv4_network_class` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ipv4_network_class()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ipv4("network" BOOLEAN = False ,"address_class" TEXT = NULL ,"private" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ipv4'):
  plpy.warning(
    "the `ipv4` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ipv4(network
,address_class
,private
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ipv4("network" BOOLEAN = False ,"address_class" TEXT = NULL ,"private" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ipv4'):
  plpy.warning(
    "the `ipv4` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ipv4(network,address_class,private)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ipv4_private("network" BOOLEAN = False ,"address_class" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ipv4_private'):
  plpy.warning(
    "the `ipv4_private` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ipv4_private(network
,address_class
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ipv4_private("network" BOOLEAN = False ,"address_class" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ipv4_private'):
  plpy.warning(
    "the `ipv4_private` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ipv4_private(network,address_class)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ipv4_public("network" BOOLEAN = False ,"address_class" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ipv4_public'):
  plpy.warning(
    "the `ipv4_public` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ipv4_public(network
,address_class
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ipv4_public("network" BOOLEAN = False ,"address_class" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ipv4_public'):
  plpy.warning(
    "the `ipv4_public` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ipv4_public(network,address_class)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ipv6("network" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ipv6'):
  plpy.warning(
    "the `ipv6` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ipv6(network
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ipv6("network" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ipv6'):
  plpy.warning(
    "the `ipv6` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ipv6(network)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION mac_address() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mac_address'):
  plpy.warning(
    "the `mac_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].mac_address()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_mac_address() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mac_address'):
  plpy.warning(
    "the `mac_address` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.mac_address()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION port_number("is_system" BOOLEAN = False ,"is_user" BOOLEAN = False ,"is_dynamic" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'port_number'):
  plpy.warning(
    "the `port_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].port_number(is_system
,is_user
,is_dynamic
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_port_number("is_system" BOOLEAN = False ,"is_user" BOOLEAN = False ,"is_dynamic" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'port_number'):
  plpy.warning(
    "the `port_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.port_number(is_system,is_user,is_dynamic)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION uri_page() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'uri_page'):
  plpy.warning(
    "the `uri_page` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].uri_page()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_uri_page() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'uri_page'):
  plpy.warning(
    "the `uri_page` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.uri_page()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION uri_path("deep" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'uri_path'):
  plpy.warning(
    "the `uri_path` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].uri_path(deep
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_uri_path("deep" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'uri_path'):
  plpy.warning(
    "the `uri_path` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.uri_path(deep)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION uri_extension() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'uri_extension'):
  plpy.warning(
    "the `uri_extension` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].uri_extension()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_uri_extension() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'uri_extension'):
  plpy.warning(
    "the `uri_extension` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.uri_extension()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION uri() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'uri'):
  plpy.warning(
    "the `uri` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].uri()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_uri() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'uri'):
  plpy.warning(
    "the `uri` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.uri()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION slug("value" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'slug'):
  plpy.warning(
    "the `slug` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].slug(value
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_slug("value" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'slug'):
  plpy.warning(
    "the `slug` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.slug(value)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION image_url("width" TEXT = NULL ,"height" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'image_url'):
  plpy.warning(
    "the `image_url` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].image_url(width
,height
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_image_url("width" TEXT = NULL ,"height" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'image_url'):
  plpy.warning(
    "the `image_url` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.image_url(width,height)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.internet.ar_AA
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/ar_AA/__init__.py




-- Provider : faker.providers.internet.bg_BG
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/bg_BG/__init__.py




-- Provider : faker.providers.internet.bs_BA
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/bs_BA/__init__.py




-- Provider : faker.providers.internet.cs_CZ
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/cs_CZ/__init__.py




-- Provider : faker.providers.internet.de_AT
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/de_AT/__init__.py




-- Provider : faker.providers.internet.de_DE
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/de_DE/__init__.py




-- Provider : faker.providers.internet.el_GR
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/el_GR/__init__.py


CREATE OR REPLACE FUNCTION user_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'user_name'):
  plpy.warning(
    "the `user_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].user_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_user_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'user_name'):
  plpy.warning(
    "the `user_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.user_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION domain_word() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_word'):
  plpy.warning(
    "the `domain_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].domain_word()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_domain_word() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_word'):
  plpy.warning(
    "the `domain_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.domain_word()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.internet.en_AU
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/en_AU/__init__.py




-- Provider : faker.providers.internet.en_GB
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/en_GB/__init__.py




-- Provider : faker.providers.internet.en_NZ
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/en_NZ/__init__.py




-- Provider : faker.providers.internet.en_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/en_PH/__init__.py


CREATE OR REPLACE FUNCTION domain_word() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_word'):
  plpy.warning(
    "the `domain_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].domain_word()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_domain_word() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_word'):
  plpy.warning(
    "the `domain_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.domain_word()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.internet.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/en_US/__init__.py




-- Provider : faker.providers.internet.es_ES
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/es_ES/__init__.py




-- Provider : faker.providers.internet.fa_IR
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/fa_IR/__init__.py




-- Provider : faker.providers.internet.fi_FI
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/fi_FI/__init__.py




-- Provider : faker.providers.internet.fil_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/fil_PH/__init__.py




-- Provider : faker.providers.internet.fr_CH
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/fr_CH/__init__.py




-- Provider : faker.providers.internet.fr_FR
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/fr_FR/__init__.py




-- Provider : faker.providers.internet.hr_HR
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/hr_HR/__init__.py




-- Provider : faker.providers.internet.hu_HU
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/hu_HU/__init__.py




-- Provider : faker.providers.internet.id_ID
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/id_ID/__init__.py




-- Provider : faker.providers.internet.it_IT
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/it_IT/__init__.py




-- Provider : faker.providers.internet.ja_JP
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/ja_JP/__init__.py


CREATE OR REPLACE FUNCTION domain_word() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_word'):
  plpy.warning(
    "the `domain_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].domain_word()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_domain_word() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_word'):
  plpy.warning(
    "the `domain_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.domain_word()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.internet.ko_KR
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/ko_KR/__init__.py




-- Provider : faker.providers.internet.no_NO
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/no_NO/__init__.py




-- Provider : faker.providers.internet.pl_PL
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/pl_PL/__init__.py




-- Provider : faker.providers.internet.pt_BR
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/pt_BR/__init__.py




-- Provider : faker.providers.internet.pt_PT
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/pt_PT/__init__.py




-- Provider : faker.providers.internet.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/ru_RU/__init__.py




-- Provider : faker.providers.internet.sk_SK
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/sk_SK/__init__.py




-- Provider : faker.providers.internet.sl_SI
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/sl_SI/__init__.py




-- Provider : faker.providers.internet.sv_SE
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/sv_SE/__init__.py




-- Provider : faker.providers.internet.tl_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/tl_PH/__init__.py




-- Provider : faker.providers.internet.uk_UA
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/uk_UA/__init__.py




-- Provider : faker.providers.internet.zh_CN
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/zh_CN/__init__.py


CREATE OR REPLACE FUNCTION domain_word() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_word'):
  plpy.warning(
    "the `domain_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].domain_word()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_domain_word() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_word'):
  plpy.warning(
    "the `domain_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.domain_word()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION domain_name("levels" INTEGER = 1 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_name'):
  plpy.warning(
    "the `domain_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].domain_name(levels
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_domain_name("levels" INTEGER = 1 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_name'):
  plpy.warning(
    "the `domain_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.domain_name(levels)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.internet.zh_TW
-- https://github.com/joke2k/faker/blob/master/faker/providers/internet/zh_TW/__init__.py


CREATE OR REPLACE FUNCTION domain_word() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_word'):
  plpy.warning(
    "the `domain_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].domain_word()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_domain_word() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'domain_word'):
  plpy.warning(
    "the `domain_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.domain_word()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.isbn
-- https://github.com/joke2k/faker/blob/master/faker/providers/isbn/__init__.py


CREATE OR REPLACE FUNCTION isbn13("separator" TEXT = '-' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'isbn13'):
  plpy.warning(
    "the `isbn13` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].isbn13(separator
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_isbn13("separator" TEXT = '-' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'isbn13'):
  plpy.warning(
    "the `isbn13` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.isbn13(separator)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION isbn10("separator" TEXT = '-' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'isbn10'):
  plpy.warning(
    "the `isbn10` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].isbn10(separator
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_isbn10("separator" TEXT = '-' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'isbn10'):
  plpy.warning(
    "the `isbn10` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.isbn10(separator)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.job
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/__init__.py


CREATE OR REPLACE FUNCTION job() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'job'):
  plpy.warning(
    "the `job` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].job()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_job() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'job'):
  plpy.warning(
    "the `job` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.job()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.job.ar_AA
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/ar_AA/__init__.py




-- Provider : faker.providers.job.bs_BA
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/bs_BA/__init__.py




-- Provider : faker.providers.job.de_DE
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/de_DE/__init__.py




-- Provider : faker.providers.job.el_GR
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/el_GR/__init__.py




-- Provider : faker.providers.job.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/en_US/__init__.py




-- Provider : faker.providers.job.fa_IR
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/fa_IR/__init__.py




-- Provider : faker.providers.job.fi_FI
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/fi_FI/__init__.py




-- Provider : faker.providers.job.fr_CH
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/fr_CH/__init__.py




-- Provider : faker.providers.job.fr_FR
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/fr_FR/__init__.py




-- Provider : faker.providers.job.hr_HR
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/hr_HR/__init__.py




-- Provider : faker.providers.job.hu_HU
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/hu_HU/__init__.py


CREATE OR REPLACE FUNCTION job() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'job'):
  plpy.warning(
    "the `job` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].job()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_job() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'job'):
  plpy.warning(
    "the `job` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.job()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.job.hy_AM
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/hy_AM/__init__.py




-- Provider : faker.providers.job.ja_JP
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/ja_JP/__init__.py




-- Provider : faker.providers.job.ko_KR
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/ko_KR/__init__.py




-- Provider : faker.providers.job.pl_PL
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/pl_PL/__init__.py




-- Provider : faker.providers.job.pt_BR
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/pt_BR/__init__.py




-- Provider : faker.providers.job.pt_PT
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/pt_PT/__init__.py




-- Provider : faker.providers.job.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/ru_RU/__init__.py




-- Provider : faker.providers.job.sk_SK
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/sk_SK/__init__.py


CREATE OR REPLACE FUNCTION job() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'job'):
  plpy.warning(
    "the `job` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].job()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_job() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'job'):
  plpy.warning(
    "the `job` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.job()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.job.th_TH
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/th_TH/__init__.py




-- Provider : faker.providers.job.tr_TR
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/tr_TR/__init__.py




-- Provider : faker.providers.job.uk_UA
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/uk_UA/__init__.py




-- Provider : faker.providers.job.zh_CN
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/zh_CN/__init__.py




-- Provider : faker.providers.job.zh_TW
-- https://github.com/joke2k/faker/blob/master/faker/providers/job/zh_TW/__init__.py




-- Provider : faker.providers.lorem
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/__init__.py


CREATE OR REPLACE FUNCTION words("nb" INTEGER = 3 ,"ext_word_list" TEXT = NULL ,"unique" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'words'):
  plpy.warning(
    "the `words` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].words(nb
,ext_word_list
,unique
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_words("nb" INTEGER = 3 ,"ext_word_list" TEXT = NULL ,"unique" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'words'):
  plpy.warning(
    "the `words` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.words(nb,ext_word_list,unique)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION word("ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'word'):
  plpy.warning(
    "the `word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].word(ext_word_list
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_word("ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'word'):
  plpy.warning(
    "the `word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.word(ext_word_list)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION sentence("nb_words" INTEGER = 6 ,"variable_nb_words" BOOLEAN = True ,"ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sentence'):
  plpy.warning(
    "the `sentence` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].sentence(nb_words
,variable_nb_words
,ext_word_list
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_sentence("nb_words" INTEGER = 6 ,"variable_nb_words" BOOLEAN = True ,"ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sentence'):
  plpy.warning(
    "the `sentence` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.sentence(nb_words,variable_nb_words,ext_word_list)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION sentences("nb" INTEGER = 3 ,"ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sentences'):
  plpy.warning(
    "the `sentences` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].sentences(nb
,ext_word_list
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_sentences("nb" INTEGER = 3 ,"ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sentences'):
  plpy.warning(
    "the `sentences` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.sentences(nb,ext_word_list)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION paragraph("nb_sentences" INTEGER = 3 ,"variable_nb_sentences" BOOLEAN = True ,"ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'paragraph'):
  plpy.warning(
    "the `paragraph` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].paragraph(nb_sentences
,variable_nb_sentences
,ext_word_list
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_paragraph("nb_sentences" INTEGER = 3 ,"variable_nb_sentences" BOOLEAN = True ,"ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'paragraph'):
  plpy.warning(
    "the `paragraph` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.paragraph(nb_sentences,variable_nb_sentences,ext_word_list)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION paragraphs("nb" INTEGER = 3 ,"ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'paragraphs'):
  plpy.warning(
    "the `paragraphs` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].paragraphs(nb
,ext_word_list
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_paragraphs("nb" INTEGER = 3 ,"ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'paragraphs'):
  plpy.warning(
    "the `paragraphs` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.paragraphs(nb,ext_word_list)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION text("max_nb_chars" INTEGER = 200 ,"ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'text'):
  plpy.warning(
    "the `text` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].text(max_nb_chars
,ext_word_list
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_text("max_nb_chars" INTEGER = 200 ,"ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'text'):
  plpy.warning(
    "the `text` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.text(max_nb_chars,ext_word_list)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION texts("nb_texts" INTEGER = 3 ,"max_nb_chars" INTEGER = 200 ,"ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'texts'):
  plpy.warning(
    "the `texts` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].texts(nb_texts
,max_nb_chars
,ext_word_list
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_texts("nb_texts" INTEGER = 3 ,"max_nb_chars" INTEGER = 200 ,"ext_word_list" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'texts'):
  plpy.warning(
    "the `texts` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.texts(nb_texts,max_nb_chars,ext_word_list)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.lorem.ar_AA
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/ar_AA/__init__.py




-- Provider : faker.providers.lorem.el_GR
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/el_GR/__init__.py




-- Provider : faker.providers.lorem.en_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/en_PH/__init__.py


CREATE OR REPLACE FUNCTION english_word() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_word'):
  plpy.warning(
    "the `english_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].english_word()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_english_word() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_word'):
  plpy.warning(
    "the `english_word` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.english_word()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION english_words("nb" INTEGER = 3 ,"unique" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_words'):
  plpy.warning(
    "the `english_words` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].english_words(nb
,unique
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_english_words("nb" INTEGER = 3 ,"unique" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_words'):
  plpy.warning(
    "the `english_words` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.english_words(nb,unique)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION english_sentence("nb_words" INTEGER = 6 ,"variable_nb_words" BOOLEAN = True ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_sentence'):
  plpy.warning(
    "the `english_sentence` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].english_sentence(nb_words
,variable_nb_words
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_english_sentence("nb_words" INTEGER = 6 ,"variable_nb_words" BOOLEAN = True ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_sentence'):
  plpy.warning(
    "the `english_sentence` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.english_sentence(nb_words,variable_nb_words)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION english_sentences("nb" INTEGER = 3 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_sentences'):
  plpy.warning(
    "the `english_sentences` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].english_sentences(nb
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_english_sentences("nb" INTEGER = 3 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_sentences'):
  plpy.warning(
    "the `english_sentences` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.english_sentences(nb)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION english_paragraph("nb_sentences" INTEGER = 3 ,"variable_nb_sentences" BOOLEAN = True ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_paragraph'):
  plpy.warning(
    "the `english_paragraph` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].english_paragraph(nb_sentences
,variable_nb_sentences
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_english_paragraph("nb_sentences" INTEGER = 3 ,"variable_nb_sentences" BOOLEAN = True ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_paragraph'):
  plpy.warning(
    "the `english_paragraph` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.english_paragraph(nb_sentences,variable_nb_sentences)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION english_paragraphs("nb" INTEGER = 3 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_paragraphs'):
  plpy.warning(
    "the `english_paragraphs` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].english_paragraphs(nb
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_english_paragraphs("nb" INTEGER = 3 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_paragraphs'):
  plpy.warning(
    "the `english_paragraphs` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.english_paragraphs(nb)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION english_text("max_nb_chars" INTEGER = 200 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_text'):
  plpy.warning(
    "the `english_text` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].english_text(max_nb_chars
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_english_text("max_nb_chars" INTEGER = 200 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_text'):
  plpy.warning(
    "the `english_text` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.english_text(max_nb_chars)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION english_texts("nb_texts" INTEGER = 3 ,"max_nb_chars" INTEGER = 200 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_texts'):
  plpy.warning(
    "the `english_texts` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].english_texts(nb_texts
,max_nb_chars
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_english_texts("nb_texts" INTEGER = 3 ,"max_nb_chars" INTEGER = 200 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'english_texts'):
  plpy.warning(
    "the `english_texts` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.english_texts(nb_texts,max_nb_chars)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.lorem.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/en_US/__init__.py




-- Provider : faker.providers.lorem.fil_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/fil_PH/__init__.py




-- Provider : faker.providers.lorem.fr_FR
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/fr_FR/__init__.py




-- Provider : faker.providers.lorem.he_IL
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/he_IL/__init__.py




-- Provider : faker.providers.lorem.hy_AM
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/hy_AM/__init__.py




-- Provider : faker.providers.lorem.ja_JP
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/ja_JP/__init__.py




-- Provider : faker.providers.lorem.la
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/la/__init__.py




-- Provider : faker.providers.lorem.pl_PL
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/pl_PL/__init__.py




-- Provider : faker.providers.lorem.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/ru_RU/__init__.py




-- Provider : faker.providers.lorem.th_TH
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/th_TH/__init__.py




-- Provider : faker.providers.lorem.tl_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/tl_PH/__init__.py




-- Provider : faker.providers.lorem.zh_CN
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/zh_CN/__init__.py




-- Provider : faker.providers.lorem.zh_TW
-- https://github.com/joke2k/faker/blob/master/faker/providers/lorem/zh_TW/__init__.py




-- Provider : faker.providers.misc
-- https://github.com/joke2k/faker/blob/master/faker/providers/misc/__init__.py


CREATE OR REPLACE FUNCTION null_boolean() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'null_boolean'):
  plpy.warning(
    "the `null_boolean` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].null_boolean()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_null_boolean() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'null_boolean'):
  plpy.warning(
    "the `null_boolean` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.null_boolean()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION binary("length" INTEGER = 1048576 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'binary'):
  plpy.warning(
    "the `binary` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].binary(length
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_binary("length" INTEGER = 1048576 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'binary'):
  plpy.warning(
    "the `binary` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.binary(length)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION md5("raw_output" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'md5'):
  plpy.warning(
    "the `md5` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].md5(raw_output
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_md5("raw_output" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'md5'):
  plpy.warning(
    "the `md5` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.md5(raw_output)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION sha1("raw_output" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sha1'):
  plpy.warning(
    "the `sha1` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].sha1(raw_output
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_sha1("raw_output" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sha1'):
  plpy.warning(
    "the `sha1` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.sha1(raw_output)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION sha256("raw_output" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sha256'):
  plpy.warning(
    "the `sha256` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].sha256(raw_output
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_sha256("raw_output" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sha256'):
  plpy.warning(
    "the `sha256` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.sha256(raw_output)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION password("length" INTEGER = 10 ,"special_chars" BOOLEAN = True ,"digits" BOOLEAN = True ,"upper_case" BOOLEAN = True ,"lower_case" BOOLEAN = True ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'password'):
  plpy.warning(
    "the `password` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].password(length
,special_chars
,digits
,upper_case
,lower_case
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_password("length" INTEGER = 10 ,"special_chars" BOOLEAN = True ,"digits" BOOLEAN = True ,"upper_case" BOOLEAN = True ,"lower_case" BOOLEAN = True ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'password'):
  plpy.warning(
    "the `password` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.password(length,special_chars,digits,upper_case,lower_case)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION zip("uncompressed_size" INTEGER = 65536 ,"num_files" INTEGER = 1 ,"min_file_size" INTEGER = 4096 ,"compression" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'zip'):
  plpy.warning(
    "the `zip` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].zip(uncompressed_size
,num_files
,min_file_size
,compression
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_zip("uncompressed_size" INTEGER = 65536 ,"num_files" INTEGER = 1 ,"min_file_size" INTEGER = 4096 ,"compression" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'zip'):
  plpy.warning(
    "the `zip` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.zip(uncompressed_size,num_files,min_file_size,compression)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION tar("uncompressed_size" INTEGER = 65536 ,"num_files" INTEGER = 1 ,"min_file_size" INTEGER = 4096 ,"compression" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'tar'):
  plpy.warning(
    "the `tar` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].tar(uncompressed_size
,num_files
,min_file_size
,compression
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_tar("uncompressed_size" INTEGER = 65536 ,"num_files" INTEGER = 1 ,"min_file_size" INTEGER = 4096 ,"compression" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'tar'):
  plpy.warning(
    "the `tar` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.tar(uncompressed_size,num_files,min_file_size,compression)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION json("data_columns" TEXT = NULL ,"num_rows" INTEGER = 10 ,"indent" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'json'):
  plpy.warning(
    "the `json` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].json(data_columns
,num_rows
,indent
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_json("data_columns" TEXT = NULL ,"num_rows" INTEGER = 10 ,"indent" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'json'):
  plpy.warning(
    "the `json` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.json(data_columns,num_rows,indent)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION fixed_width("data_columns" TEXT = NULL ,"num_rows" INTEGER = 10 ,"align" TEXT = 'left' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'fixed_width'):
  plpy.warning(
    "the `fixed_width` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].fixed_width(data_columns
,num_rows
,align
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_fixed_width("data_columns" TEXT = NULL ,"num_rows" INTEGER = 10 ,"align" TEXT = 'left' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'fixed_width'):
  plpy.warning(
    "the `fixed_width` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.fixed_width(data_columns,num_rows,align)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.misc.en_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/misc/en_PH/__init__.py


CREATE OR REPLACE FUNCTION gemstone_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'gemstone_name'):
  plpy.warning(
    "the `gemstone_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].gemstone_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_gemstone_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'gemstone_name'):
  plpy.warning(
    "the `gemstone_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.gemstone_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION mountain_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mountain_name'):
  plpy.warning(
    "the `mountain_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].mountain_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_mountain_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mountain_name'):
  plpy.warning(
    "the `mountain_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.mountain_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION plant_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'plant_name'):
  plpy.warning(
    "the `plant_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].plant_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_plant_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'plant_name'):
  plpy.warning(
    "the `plant_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.plant_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION space_object_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'space_object_name'):
  plpy.warning(
    "the `space_object_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].space_object_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_space_object_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'space_object_name'):
  plpy.warning(
    "the `space_object_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.space_object_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION random_object_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_object_name'):
  plpy.warning(
    "the `random_object_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].random_object_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_random_object_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'random_object_name'):
  plpy.warning(
    "the `random_object_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.random_object_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.misc.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/misc/en_US/__init__.py




-- Provider : faker.providers.misc.fil_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/misc/fil_PH/__init__.py




-- Provider : faker.providers.misc.tl_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/misc/tl_PH/__init__.py




-- Provider : faker.providers.person
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/__init__.py


CREATE OR REPLACE FUNCTION name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'name'):
  plpy.warning(
    "the `name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'name'):
  plpy.warning(
    "the `name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name'):
  plpy.warning(
    "the `first_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name'):
  plpy.warning(
    "the `first_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION last_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name'):
  plpy.warning(
    "the `last_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].last_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_last_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name'):
  plpy.warning(
    "the `last_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.last_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION name_male() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'name_male'):
  plpy.warning(
    "the `name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].name_male()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_name_male() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'name_male'):
  plpy.warning(
    "the `name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.name_male()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION name_nonbinary() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'name_nonbinary'):
  plpy.warning(
    "the `name_nonbinary` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].name_nonbinary()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_name_nonbinary() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'name_nonbinary'):
  plpy.warning(
    "the `name_nonbinary` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.name_nonbinary()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION name_female() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'name_female'):
  plpy.warning(
    "the `name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].name_female()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_name_female() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'name_female'):
  plpy.warning(
    "the `name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.name_female()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name_male() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_male'):
  plpy.warning(
    "the `first_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_male()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_male() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_male'):
  plpy.warning(
    "the `first_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_male()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name_nonbinary() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_nonbinary'):
  plpy.warning(
    "the `first_name_nonbinary` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_nonbinary()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_nonbinary() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_nonbinary'):
  plpy.warning(
    "the `first_name_nonbinary` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_nonbinary()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name_female() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_female'):
  plpy.warning(
    "the `first_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_female()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_female() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_female'):
  plpy.warning(
    "the `first_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_female()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION last_name_male() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name_male'):
  plpy.warning(
    "the `last_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].last_name_male()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_last_name_male() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name_male'):
  plpy.warning(
    "the `last_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.last_name_male()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION last_name_nonbinary() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name_nonbinary'):
  plpy.warning(
    "the `last_name_nonbinary` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].last_name_nonbinary()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_last_name_nonbinary() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name_nonbinary'):
  plpy.warning(
    "the `last_name_nonbinary` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.last_name_nonbinary()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION last_name_female() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name_female'):
  plpy.warning(
    "the `last_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].last_name_female()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_last_name_female() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name_female'):
  plpy.warning(
    "the `last_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.last_name_female()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'prefix'):
  plpy.warning(
    "the `prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'prefix'):
  plpy.warning(
    "the `prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION prefix_male() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'prefix_male'):
  plpy.warning(
    "the `prefix_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].prefix_male()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_prefix_male() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'prefix_male'):
  plpy.warning(
    "the `prefix_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.prefix_male()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION prefix_nonbinary() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'prefix_nonbinary'):
  plpy.warning(
    "the `prefix_nonbinary` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].prefix_nonbinary()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_prefix_nonbinary() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'prefix_nonbinary'):
  plpy.warning(
    "the `prefix_nonbinary` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.prefix_nonbinary()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION prefix_female() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'prefix_female'):
  plpy.warning(
    "the `prefix_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].prefix_female()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_prefix_female() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'prefix_female'):
  plpy.warning(
    "the `prefix_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.prefix_female()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'suffix'):
  plpy.warning(
    "the `suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'suffix'):
  plpy.warning(
    "the `suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION suffix_male() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'suffix_male'):
  plpy.warning(
    "the `suffix_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].suffix_male()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_suffix_male() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'suffix_male'):
  plpy.warning(
    "the `suffix_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.suffix_male()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION suffix_nonbinary() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'suffix_nonbinary'):
  plpy.warning(
    "the `suffix_nonbinary` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].suffix_nonbinary()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_suffix_nonbinary() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'suffix_nonbinary'):
  plpy.warning(
    "the `suffix_nonbinary` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.suffix_nonbinary()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION suffix_female() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'suffix_female'):
  plpy.warning(
    "the `suffix_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].suffix_female()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_suffix_female() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'suffix_female'):
  plpy.warning(
    "the `suffix_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.suffix_female()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION language_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'language_name'):
  plpy.warning(
    "the `language_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].language_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_language_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'language_name'):
  plpy.warning(
    "the `language_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.language_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.person.ar_AA
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/ar_AA/__init__.py




-- Provider : faker.providers.person.ar_PS
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/ar_PS/__init__.py




-- Provider : faker.providers.person.ar_SA
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/ar_SA/__init__.py




-- Provider : faker.providers.person.bg_BG
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/bg_BG/__init__.py




-- Provider : faker.providers.person.cs_CZ
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/cs_CZ/__init__.py




-- Provider : faker.providers.person.de_AT
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/de_AT/__init__.py




-- Provider : faker.providers.person.de_CH
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/de_CH/__init__.py




-- Provider : faker.providers.person.de_DE
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/de_DE/__init__.py




-- Provider : faker.providers.person.dk_DK
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/dk_DK/__init__.py




-- Provider : faker.providers.person.el_GR
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/el_GR/__init__.py




-- Provider : faker.providers.person.en_GB
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/en_GB/__init__.py




-- Provider : faker.providers.person.en_IE
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/en_IE/__init__.py




-- Provider : faker.providers.person.en_IN
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/en_IN/__init__.py




-- Provider : faker.providers.person.en_NZ
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/en_NZ/__init__.py




-- Provider : faker.providers.person.en_TH
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/en_TH/__init__.py




-- Provider : faker.providers.person.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/en_US/__init__.py




-- Provider : faker.providers.person.es_CA
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/es_CA/__init__.py




-- Provider : faker.providers.person.es_ES
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/es_ES/__init__.py




-- Provider : faker.providers.person.es_MX
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/es_MX/__init__.py




-- Provider : faker.providers.person.et_EE
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/et_EE/__init__.py


CREATE OR REPLACE FUNCTION first_name_male_est() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_male_est'):
  plpy.warning(
    "the `first_name_male_est` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_male_est()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_male_est() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_male_est'):
  plpy.warning(
    "the `first_name_male_est` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_male_est()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name_female_est() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_female_est'):
  plpy.warning(
    "the `first_name_female_est` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_female_est()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_female_est() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_female_est'):
  plpy.warning(
    "the `first_name_female_est` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_female_est()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name_male_rus() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_male_rus'):
  plpy.warning(
    "the `first_name_male_rus` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_male_rus()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_male_rus() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_male_rus'):
  plpy.warning(
    "the `first_name_male_rus` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_male_rus()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name_female_rus() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_female_rus'):
  plpy.warning(
    "the `first_name_female_rus` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_female_rus()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_female_rus() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_female_rus'):
  plpy.warning(
    "the `first_name_female_rus` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_female_rus()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name_est() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_est'):
  plpy.warning(
    "the `first_name_est` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_est()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_est() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_est'):
  plpy.warning(
    "the `first_name_est` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_est()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name_rus() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_rus'):
  plpy.warning(
    "the `first_name_rus` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_rus()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_rus() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_rus'):
  plpy.warning(
    "the `first_name_rus` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_rus()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION last_name_est() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name_est'):
  plpy.warning(
    "the `last_name_est` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].last_name_est()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_last_name_est() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name_est'):
  plpy.warning(
    "the `last_name_est` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.last_name_est()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION last_name_rus() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name_rus'):
  plpy.warning(
    "the `last_name_rus` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].last_name_rus()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_last_name_rus() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name_rus'):
  plpy.warning(
    "the `last_name_rus` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.last_name_rus()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.person.fa_IR
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/fa_IR/__init__.py


CREATE OR REPLACE FUNCTION suffix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'suffix'):
  plpy.warning(
    "the `suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].suffix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_suffix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'suffix'):
  plpy.warning(
    "the `suffix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.suffix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.person.fi_FI
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/fi_FI/__init__.py




-- Provider : faker.providers.person.fr_CA
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/fr_CA/__init__.py




-- Provider : faker.providers.person.fr_CH
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/fr_CH/__init__.py




-- Provider : faker.providers.person.fr_FR
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/fr_FR/__init__.py




-- Provider : faker.providers.person.ga_IE
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/ga_IE/__init__.py




-- Provider : faker.providers.person.he_IL
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/he_IL/__init__.py




-- Provider : faker.providers.person.hi_IN
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/hi_IN/__init__.py




-- Provider : faker.providers.person.hr_HR
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/hr_HR/__init__.py




-- Provider : faker.providers.person.hu_HU
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/hu_HU/__init__.py


CREATE OR REPLACE FUNCTION first_name_male_abbreviated() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_male_abbreviated'):
  plpy.warning(
    "the `first_name_male_abbreviated` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_male_abbreviated()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_male_abbreviated() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_male_abbreviated'):
  plpy.warning(
    "the `first_name_male_abbreviated` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_male_abbreviated()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name_female_abbreviated() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_female_abbreviated'):
  plpy.warning(
    "the `first_name_female_abbreviated` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_female_abbreviated()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_female_abbreviated() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_female_abbreviated'):
  plpy.warning(
    "the `first_name_female_abbreviated` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_female_abbreviated()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.person.hy_AM
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/hy_AM/__init__.py




-- Provider : faker.providers.person.id_ID
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/id_ID/__init__.py




-- Provider : faker.providers.person.it_IT
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/it_IT/__init__.py




-- Provider : faker.providers.person.ja_JP
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/ja_JP/__init__.py


CREATE OR REPLACE FUNCTION first_name_pair() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_pair'):
  plpy.warning(
    "the `first_name_pair` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_pair()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_pair() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_pair'):
  plpy.warning(
    "the `first_name_pair` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_pair()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name_male_pair() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_male_pair'):
  plpy.warning(
    "the `first_name_male_pair` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_male_pair()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_male_pair() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_male_pair'):
  plpy.warning(
    "the `first_name_male_pair` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_male_pair()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name_female_pair() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_female_pair'):
  plpy.warning(
    "the `first_name_female_pair` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_female_pair()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_female_pair() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_female_pair'):
  plpy.warning(
    "the `first_name_female_pair` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_female_pair()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION last_name_pair() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name_pair'):
  plpy.warning(
    "the `last_name_pair` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].last_name_pair()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_last_name_pair() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name_pair'):
  plpy.warning(
    "the `last_name_pair` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.last_name_pair()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name'):
  plpy.warning(
    "the `first_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name'):
  plpy.warning(
    "the `first_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name_male() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_male'):
  plpy.warning(
    "the `first_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_male()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_male() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_male'):
  plpy.warning(
    "the `first_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_male()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_name_female() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_female'):
  plpy.warning(
    "the `first_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_female()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_female() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_female'):
  plpy.warning(
    "the `first_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_female()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION last_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name'):
  plpy.warning(
    "the `last_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].last_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_last_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name'):
  plpy.warning(
    "the `last_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.last_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_kana_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_kana_name'):
  plpy.warning(
    "the `first_kana_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_kana_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_kana_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_kana_name'):
  plpy.warning(
    "the `first_kana_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_kana_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_kana_name_male() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_kana_name_male'):
  plpy.warning(
    "the `first_kana_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_kana_name_male()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_kana_name_male() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_kana_name_male'):
  plpy.warning(
    "the `first_kana_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_kana_name_male()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_kana_name_female() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_kana_name_female'):
  plpy.warning(
    "the `first_kana_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_kana_name_female()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_kana_name_female() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_kana_name_female'):
  plpy.warning(
    "the `first_kana_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_kana_name_female()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION last_kana_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_kana_name'):
  plpy.warning(
    "the `last_kana_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].last_kana_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_last_kana_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_kana_name'):
  plpy.warning(
    "the `last_kana_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.last_kana_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_romanized_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_romanized_name'):
  plpy.warning(
    "the `first_romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_romanized_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_romanized_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_romanized_name'):
  plpy.warning(
    "the `first_romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_romanized_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_romanized_name_male() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_romanized_name_male'):
  plpy.warning(
    "the `first_romanized_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_romanized_name_male()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_romanized_name_male() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_romanized_name_male'):
  plpy.warning(
    "the `first_romanized_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_romanized_name_male()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_romanized_name_female() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_romanized_name_female'):
  plpy.warning(
    "the `first_romanized_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_romanized_name_female()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_romanized_name_female() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_romanized_name_female'):
  plpy.warning(
    "the `first_romanized_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_romanized_name_female()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION last_romanized_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_romanized_name'):
  plpy.warning(
    "the `last_romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].last_romanized_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_last_romanized_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_romanized_name'):
  plpy.warning(
    "the `last_romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.last_romanized_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION kana_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'kana_name'):
  plpy.warning(
    "the `kana_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].kana_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_kana_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'kana_name'):
  plpy.warning(
    "the `kana_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.kana_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION kana_name_male() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'kana_name_male'):
  plpy.warning(
    "the `kana_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].kana_name_male()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_kana_name_male() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'kana_name_male'):
  plpy.warning(
    "the `kana_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.kana_name_male()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION kana_name_female() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'kana_name_female'):
  plpy.warning(
    "the `kana_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].kana_name_female()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_kana_name_female() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'kana_name_female'):
  plpy.warning(
    "the `kana_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.kana_name_female()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION romanized_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'romanized_name'):
  plpy.warning(
    "the `romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].romanized_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_romanized_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'romanized_name'):
  plpy.warning(
    "the `romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.romanized_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION romanized_name_male() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'romanized_name_male'):
  plpy.warning(
    "the `romanized_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].romanized_name_male()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_romanized_name_male() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'romanized_name_male'):
  plpy.warning(
    "the `romanized_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.romanized_name_male()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION romanized_name_female() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'romanized_name_female'):
  plpy.warning(
    "the `romanized_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].romanized_name_female()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_romanized_name_female() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'romanized_name_female'):
  plpy.warning(
    "the `romanized_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.romanized_name_female()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.person.ka_GE
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/ka_GE/__init__.py




-- Provider : faker.providers.person.ko_KR
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/ko_KR/__init__.py




-- Provider : faker.providers.person.lt_LT
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/lt_LT/__init__.py




-- Provider : faker.providers.person.lv_LV
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/lv_LV/__init__.py




-- Provider : faker.providers.person.ne_NP
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/ne_NP/__init__.py




-- Provider : faker.providers.person.nl_NL
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/nl_NL/__init__.py




-- Provider : faker.providers.person.no_NO
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/no_NO/__init__.py




-- Provider : faker.providers.person.or_IN
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/or_IN/__init__.py


CREATE OR REPLACE FUNCTION first_name_unisex() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_unisex'):
  plpy.warning(
    "the `first_name_unisex` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_name_unisex()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_name_unisex() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_name_unisex'):
  plpy.warning(
    "the `first_name_unisex` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_name_unisex()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION middle_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'middle_name'):
  plpy.warning(
    "the `middle_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].middle_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_middle_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'middle_name'):
  plpy.warning(
    "the `middle_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.middle_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.person.pl_PL
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/pl_PL/__init__.py


CREATE OR REPLACE FUNCTION last_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name'):
  plpy.warning(
    "the `last_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].last_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_last_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_name'):
  plpy.warning(
    "the `last_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.last_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION identity_card_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'identity_card_number'):
  plpy.warning(
    "the `identity_card_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].identity_card_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_identity_card_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'identity_card_number'):
  plpy.warning(
    "the `identity_card_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.identity_card_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pesel_compute_check_digit("pesel" TEXT = '' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pesel_compute_check_digit'):
  plpy.warning(
    "the `pesel_compute_check_digit` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pesel_compute_check_digit(pesel
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pesel_compute_check_digit("pesel" TEXT = '' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pesel_compute_check_digit'):
  plpy.warning(
    "the `pesel_compute_check_digit` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pesel_compute_check_digit(pesel)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pesel("date_of_birth" TEXT = NULL ,"sex" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pesel'):
  plpy.warning(
    "the `pesel` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pesel(date_of_birth
,sex
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pesel("date_of_birth" TEXT = NULL ,"sex" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pesel'):
  plpy.warning(
    "the `pesel` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pesel(date_of_birth,sex)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pwz_doctor_compute_check_digit("x" TEXT = '' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pwz_doctor_compute_check_digit'):
  plpy.warning(
    "the `pwz_doctor_compute_check_digit` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pwz_doctor_compute_check_digit(x
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pwz_doctor_compute_check_digit("x" TEXT = '' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pwz_doctor_compute_check_digit'):
  plpy.warning(
    "the `pwz_doctor_compute_check_digit` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pwz_doctor_compute_check_digit(x)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pwz_doctor() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pwz_doctor'):
  plpy.warning(
    "the `pwz_doctor` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pwz_doctor()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pwz_doctor() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pwz_doctor'):
  plpy.warning(
    "the `pwz_doctor` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pwz_doctor()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pwz_nurse("kind" TEXT = 'nurse' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pwz_nurse'):
  plpy.warning(
    "the `pwz_nurse` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pwz_nurse(kind
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pwz_nurse("kind" TEXT = 'nurse' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pwz_nurse'):
  plpy.warning(
    "the `pwz_nurse` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pwz_nurse(kind)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION nip() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'nip'):
  plpy.warning(
    "the `nip` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].nip()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_nip() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'nip'):
  plpy.warning(
    "the `nip` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.nip()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.person.pt_BR
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/pt_BR/__init__.py




-- Provider : faker.providers.person.pt_PT
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/pt_PT/__init__.py


CREATE OR REPLACE FUNCTION prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'prefix'):
  plpy.warning(
    "the `prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'prefix'):
  plpy.warning(
    "the `prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.person.ro_RO
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/ro_RO/__init__.py




-- Provider : faker.providers.person.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/ru_RU/__init__.py


CREATE OR REPLACE FUNCTION middle_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'middle_name'):
  plpy.warning(
    "the `middle_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].middle_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_middle_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'middle_name'):
  plpy.warning(
    "the `middle_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.middle_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION middle_name_male() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'middle_name_male'):
  plpy.warning(
    "the `middle_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].middle_name_male()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_middle_name_male() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'middle_name_male'):
  plpy.warning(
    "the `middle_name_male` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.middle_name_male()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION middle_name_female() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'middle_name_female'):
  plpy.warning(
    "the `middle_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].middle_name_female()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_middle_name_female() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'middle_name_female'):
  plpy.warning(
    "the `middle_name_female` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.middle_name_female()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.person.sl_SI
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/sl_SI/__init__.py




-- Provider : faker.providers.person.sv_SE
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/sv_SE/__init__.py




-- Provider : faker.providers.person.ta_IN
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/ta_IN/__init__.py




-- Provider : faker.providers.person.th_TH
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/th_TH/__init__.py




-- Provider : faker.providers.person.tr_TR
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/tr_TR/__init__.py




-- Provider : faker.providers.person.tw_GH
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/tw_GH/__init__.py




-- Provider : faker.providers.person.uk_UA
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/uk_UA/__init__.py




-- Provider : faker.providers.person.zh_CN
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/zh_CN/__init__.py


CREATE OR REPLACE FUNCTION romanized_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'romanized_name'):
  plpy.warning(
    "the `romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].romanized_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_romanized_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'romanized_name'):
  plpy.warning(
    "the `romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.romanized_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_romanized_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_romanized_name'):
  plpy.warning(
    "the `first_romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_romanized_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_romanized_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_romanized_name'):
  plpy.warning(
    "the `first_romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_romanized_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION last_romanized_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_romanized_name'):
  plpy.warning(
    "the `last_romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].last_romanized_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_last_romanized_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_romanized_name'):
  plpy.warning(
    "the `last_romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.last_romanized_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.person.zh_TW
-- https://github.com/joke2k/faker/blob/master/faker/providers/person/zh_TW/__init__.py


CREATE OR REPLACE FUNCTION romanized_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'romanized_name'):
  plpy.warning(
    "the `romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].romanized_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_romanized_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'romanized_name'):
  plpy.warning(
    "the `romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.romanized_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION first_romanized_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_romanized_name'):
  plpy.warning(
    "the `first_romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].first_romanized_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_first_romanized_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'first_romanized_name'):
  plpy.warning(
    "the `first_romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.first_romanized_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION last_romanized_name() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_romanized_name'):
  plpy.warning(
    "the `last_romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].last_romanized_name()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_last_romanized_name() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'last_romanized_name'):
  plpy.warning(
    "the `last_romanized_name` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.last_romanized_name()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.phone_number
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/__init__.py


CREATE OR REPLACE FUNCTION phone_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'phone_number'):
  plpy.warning(
    "the `phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].phone_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_phone_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'phone_number'):
  plpy.warning(
    "the `phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.phone_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION country_calling_code() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'country_calling_code'):
  plpy.warning(
    "the `country_calling_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].country_calling_code()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_country_calling_code() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'country_calling_code'):
  plpy.warning(
    "the `country_calling_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.country_calling_code()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION msisdn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'msisdn'):
  plpy.warning(
    "the `msisdn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].msisdn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_msisdn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'msisdn'):
  plpy.warning(
    "the `msisdn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.msisdn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.phone_number.ar_JO
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/ar_JO/__init__.py


CREATE OR REPLACE FUNCTION operator_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'operator_id'):
  plpy.warning(
    "the `operator_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].operator_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_operator_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'operator_id'):
  plpy.warning(
    "the `operator_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.operator_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION area_code() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'area_code'):
  plpy.warning(
    "the `area_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].area_code()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_area_code() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'area_code'):
  plpy.warning(
    "the `area_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.area_code()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION cellphone_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cellphone_number'):
  plpy.warning(
    "the `cellphone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].cellphone_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_cellphone_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cellphone_number'):
  plpy.warning(
    "the `cellphone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.cellphone_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION telephone_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'telephone_number'):
  plpy.warning(
    "the `telephone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].telephone_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_telephone_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'telephone_number'):
  plpy.warning(
    "the `telephone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.telephone_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION service_phone_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'service_phone_number'):
  plpy.warning(
    "the `service_phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].service_phone_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_service_phone_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'service_phone_number'):
  plpy.warning(
    "the `service_phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.service_phone_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION phone_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'phone_number'):
  plpy.warning(
    "the `phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].phone_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_phone_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'phone_number'):
  plpy.warning(
    "the `phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.phone_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.phone_number.ar_PS
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/ar_PS/__init__.py


CREATE OR REPLACE FUNCTION provider_code() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'provider_code'):
  plpy.warning(
    "the `provider_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].provider_code()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_provider_code() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'provider_code'):
  plpy.warning(
    "the `provider_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.provider_code()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION area_code() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'area_code'):
  plpy.warning(
    "the `area_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].area_code()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_area_code() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'area_code'):
  plpy.warning(
    "the `area_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.area_code()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION cellphone_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cellphone_number'):
  plpy.warning(
    "the `cellphone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].cellphone_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_cellphone_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cellphone_number'):
  plpy.warning(
    "the `cellphone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.cellphone_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION telephone_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'telephone_number'):
  plpy.warning(
    "the `telephone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].telephone_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_telephone_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'telephone_number'):
  plpy.warning(
    "the `telephone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.telephone_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION service_phone_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'service_phone_number'):
  plpy.warning(
    "the `service_phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].service_phone_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_service_phone_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'service_phone_number'):
  plpy.warning(
    "the `service_phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.service_phone_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION toll_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'toll_number'):
  plpy.warning(
    "the `toll_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].toll_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_toll_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'toll_number'):
  plpy.warning(
    "the `toll_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.toll_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION phone_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'phone_number'):
  plpy.warning(
    "the `phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].phone_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_phone_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'phone_number'):
  plpy.warning(
    "the `phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.phone_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.phone_number.bg_BG
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/bg_BG/__init__.py




-- Provider : faker.providers.phone_number.bs_BA
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/bs_BA/__init__.py




-- Provider : faker.providers.phone_number.cs_CZ
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/cs_CZ/__init__.py




-- Provider : faker.providers.phone_number.de_DE
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/de_DE/__init__.py




-- Provider : faker.providers.phone_number.dk_DK
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/dk_DK/__init__.py




-- Provider : faker.providers.phone_number.el_GR
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/el_GR/__init__.py




-- Provider : faker.providers.phone_number.en_AU
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/en_AU/__init__.py


CREATE OR REPLACE FUNCTION area_code() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'area_code'):
  plpy.warning(
    "the `area_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].area_code()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_area_code() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'area_code'):
  plpy.warning(
    "the `area_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.area_code()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION phone_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'phone_number'):
  plpy.warning(
    "the `phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].phone_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_phone_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'phone_number'):
  plpy.warning(
    "the `phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.phone_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.phone_number.en_CA
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/en_CA/__init__.py




-- Provider : faker.providers.phone_number.en_GB
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/en_GB/__init__.py


CREATE OR REPLACE FUNCTION cellphone_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cellphone_number'):
  plpy.warning(
    "the `cellphone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].cellphone_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_cellphone_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cellphone_number'):
  plpy.warning(
    "the `cellphone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.cellphone_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.phone_number.en_IN
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/en_IN/__init__.py




-- Provider : faker.providers.phone_number.en_NZ
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/en_NZ/__init__.py


CREATE OR REPLACE FUNCTION area_code() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'area_code'):
  plpy.warning(
    "the `area_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].area_code()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_area_code() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'area_code'):
  plpy.warning(
    "the `area_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.area_code()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION phone_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'phone_number'):
  plpy.warning(
    "the `phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].phone_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_phone_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'phone_number'):
  plpy.warning(
    "the `phone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.phone_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.phone_number.en_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/en_PH/__init__.py


CREATE OR REPLACE FUNCTION globe_mobile_number_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'globe_mobile_number_prefix'):
  plpy.warning(
    "the `globe_mobile_number_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].globe_mobile_number_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_globe_mobile_number_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'globe_mobile_number_prefix'):
  plpy.warning(
    "the `globe_mobile_number_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.globe_mobile_number_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION smart_mobile_number_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'smart_mobile_number_prefix'):
  plpy.warning(
    "the `smart_mobile_number_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].smart_mobile_number_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_smart_mobile_number_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'smart_mobile_number_prefix'):
  plpy.warning(
    "the `smart_mobile_number_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.smart_mobile_number_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION sun_mobile_number_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sun_mobile_number_prefix'):
  plpy.warning(
    "the `sun_mobile_number_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].sun_mobile_number_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_sun_mobile_number_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sun_mobile_number_prefix'):
  plpy.warning(
    "the `sun_mobile_number_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.sun_mobile_number_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION bayantel_landline_identifier() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bayantel_landline_identifier'):
  plpy.warning(
    "the `bayantel_landline_identifier` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].bayantel_landline_identifier()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_bayantel_landline_identifier() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bayantel_landline_identifier'):
  plpy.warning(
    "the `bayantel_landline_identifier` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.bayantel_landline_identifier()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION misc_landline_identifier() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'misc_landline_identifier'):
  plpy.warning(
    "the `misc_landline_identifier` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].misc_landline_identifier()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_misc_landline_identifier() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'misc_landline_identifier'):
  plpy.warning(
    "the `misc_landline_identifier` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.misc_landline_identifier()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION non_area2_landline_area_code() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'non_area2_landline_area_code'):
  plpy.warning(
    "the `non_area2_landline_area_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].non_area2_landline_area_code()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_non_area2_landline_area_code() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'non_area2_landline_area_code'):
  plpy.warning(
    "the `non_area2_landline_area_code` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.non_area2_landline_area_code()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION globe_mobile_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'globe_mobile_number'):
  plpy.warning(
    "the `globe_mobile_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].globe_mobile_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_globe_mobile_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'globe_mobile_number'):
  plpy.warning(
    "the `globe_mobile_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.globe_mobile_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION smart_mobile_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'smart_mobile_number'):
  plpy.warning(
    "the `smart_mobile_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].smart_mobile_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_smart_mobile_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'smart_mobile_number'):
  plpy.warning(
    "the `smart_mobile_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.smart_mobile_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION sun_mobile_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sun_mobile_number'):
  plpy.warning(
    "the `sun_mobile_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].sun_mobile_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_sun_mobile_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sun_mobile_number'):
  plpy.warning(
    "the `sun_mobile_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.sun_mobile_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION mobile_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mobile_number'):
  plpy.warning(
    "the `mobile_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].mobile_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_mobile_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mobile_number'):
  plpy.warning(
    "the `mobile_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.mobile_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION globe_area2_landline_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'globe_area2_landline_number'):
  plpy.warning(
    "the `globe_area2_landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].globe_area2_landline_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_globe_area2_landline_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'globe_area2_landline_number'):
  plpy.warning(
    "the `globe_area2_landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.globe_area2_landline_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pldt_area2_landline_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pldt_area2_landline_number'):
  plpy.warning(
    "the `pldt_area2_landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pldt_area2_landline_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pldt_area2_landline_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pldt_area2_landline_number'):
  plpy.warning(
    "the `pldt_area2_landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pldt_area2_landline_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION bayantel_area2_landline_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bayantel_area2_landline_number'):
  plpy.warning(
    "the `bayantel_area2_landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].bayantel_area2_landline_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_bayantel_area2_landline_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'bayantel_area2_landline_number'):
  plpy.warning(
    "the `bayantel_area2_landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.bayantel_area2_landline_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION misc_area2_landline_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'misc_area2_landline_number'):
  plpy.warning(
    "the `misc_area2_landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].misc_area2_landline_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_misc_area2_landline_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'misc_area2_landline_number'):
  plpy.warning(
    "the `misc_area2_landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.misc_area2_landline_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION area2_landline_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'area2_landline_number'):
  plpy.warning(
    "the `area2_landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].area2_landline_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_area2_landline_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'area2_landline_number'):
  plpy.warning(
    "the `area2_landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.area2_landline_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION non_area2_landline_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'non_area2_landline_number'):
  plpy.warning(
    "the `non_area2_landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].non_area2_landline_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_non_area2_landline_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'non_area2_landline_number'):
  plpy.warning(
    "the `non_area2_landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.non_area2_landline_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION landline_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'landline_number'):
  plpy.warning(
    "the `landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].landline_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_landline_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'landline_number'):
  plpy.warning(
    "the `landline_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.landline_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.phone_number.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/en_US/__init__.py




-- Provider : faker.providers.phone_number.es_ES
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/es_ES/__init__.py




-- Provider : faker.providers.phone_number.es_MX
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/es_MX/__init__.py




-- Provider : faker.providers.phone_number.fa_IR
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/fa_IR/__init__.py




-- Provider : faker.providers.phone_number.fi_FI
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/fi_FI/__init__.py




-- Provider : faker.providers.phone_number.fil_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/fil_PH/__init__.py




-- Provider : faker.providers.phone_number.fr_CH
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/fr_CH/__init__.py




-- Provider : faker.providers.phone_number.fr_FR
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/fr_FR/__init__.py




-- Provider : faker.providers.phone_number.he_IL
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/he_IL/__init__.py




-- Provider : faker.providers.phone_number.hi_IN
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/hi_IN/__init__.py




-- Provider : faker.providers.phone_number.hr_HR
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/hr_HR/__init__.py




-- Provider : faker.providers.phone_number.hu_HU
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/hu_HU/__init__.py




-- Provider : faker.providers.phone_number.hy_AM
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/hy_AM/__init__.py




-- Provider : faker.providers.phone_number.id_ID
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/id_ID/__init__.py




-- Provider : faker.providers.phone_number.it_IT
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/it_IT/__init__.py




-- Provider : faker.providers.phone_number.ja_JP
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/ja_JP/__init__.py




-- Provider : faker.providers.phone_number.ko_KR
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/ko_KR/__init__.py




-- Provider : faker.providers.phone_number.lt_LT
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/lt_LT/__init__.py




-- Provider : faker.providers.phone_number.lv_LV
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/lv_LV/__init__.py




-- Provider : faker.providers.phone_number.ne_NP
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/ne_NP/__init__.py




-- Provider : faker.providers.phone_number.nl_BE
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/nl_BE/__init__.py




-- Provider : faker.providers.phone_number.nl_NL
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/nl_NL/__init__.py




-- Provider : faker.providers.phone_number.no_NO
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/no_NO/__init__.py




-- Provider : faker.providers.phone_number.pl_PL
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/pl_PL/__init__.py




-- Provider : faker.providers.phone_number.pt_BR
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/pt_BR/__init__.py


CREATE OR REPLACE FUNCTION cellphone_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cellphone_number'):
  plpy.warning(
    "the `cellphone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].cellphone_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_cellphone_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cellphone_number'):
  plpy.warning(
    "the `cellphone_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.cellphone_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.phone_number.pt_PT
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/pt_PT/__init__.py




-- Provider : faker.providers.phone_number.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/ru_RU/__init__.py




-- Provider : faker.providers.phone_number.sk_SK
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/sk_SK/__init__.py




-- Provider : faker.providers.phone_number.sl_SI
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/sl_SI/__init__.py




-- Provider : faker.providers.phone_number.sv_SE
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/sv_SE/__init__.py




-- Provider : faker.providers.phone_number.ta_IN
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/ta_IN/__init__.py




-- Provider : faker.providers.phone_number.th_TH
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/th_TH/__init__.py




-- Provider : faker.providers.phone_number.tl_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/tl_PH/__init__.py




-- Provider : faker.providers.phone_number.tr_TR
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/tr_TR/__init__.py




-- Provider : faker.providers.phone_number.tw_GH
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/tw_GH/__init__.py




-- Provider : faker.providers.phone_number.uk_UA
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/uk_UA/__init__.py




-- Provider : faker.providers.phone_number.zh_CN
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/zh_CN/__init__.py


CREATE OR REPLACE FUNCTION phonenumber_prefix() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'phonenumber_prefix'):
  plpy.warning(
    "the `phonenumber_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].phonenumber_prefix()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_phonenumber_prefix() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'phonenumber_prefix'):
  plpy.warning(
    "the `phonenumber_prefix` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.phonenumber_prefix()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.phone_number.zh_TW
-- https://github.com/joke2k/faker/blob/master/faker/providers/phone_number/zh_TW/__init__.py




-- Provider : faker.providers.profile
-- https://github.com/joke2k/faker/blob/master/faker/providers/profile/__init__.py


CREATE OR REPLACE FUNCTION simple_profile("sex" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'simple_profile'):
  plpy.warning(
    "the `simple_profile` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].simple_profile(sex
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_simple_profile("sex" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'simple_profile'):
  plpy.warning(
    "the `simple_profile` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.simple_profile(sex)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION profile("fields" TEXT = NULL ,"sex" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'profile'):
  plpy.warning(
    "the `profile` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].profile(fields
,sex
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_profile("fields" TEXT = NULL ,"sex" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'profile'):
  plpy.warning(
    "the `profile` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.profile(fields,sex)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.python
-- https://github.com/joke2k/faker/blob/master/faker/providers/python/__init__.py


CREATE OR REPLACE FUNCTION pybool() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pybool'):
  plpy.warning(
    "the `pybool` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pybool()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pybool() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pybool'):
  plpy.warning(
    "the `pybool` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pybool()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pystr("min_chars" TEXT = NULL ,"max_chars" INTEGER = 20 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pystr'):
  plpy.warning(
    "the `pystr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pystr(min_chars
,max_chars
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pystr("min_chars" TEXT = NULL ,"max_chars" INTEGER = 20 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pystr'):
  plpy.warning(
    "the `pystr` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pystr(min_chars,max_chars)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pystr_format("string_format" TEXT = '?#-###{{random_int}}{{random_letter}}' ,"letters" TEXT = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pystr_format'):
  plpy.warning(
    "the `pystr_format` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pystr_format(string_format
,letters
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pystr_format("string_format" TEXT = '?#-###{{random_int}}{{random_letter}}' ,"letters" TEXT = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pystr_format'):
  plpy.warning(
    "the `pystr_format` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pystr_format(string_format,letters)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pyfloat("left_digits" TEXT = NULL ,"right_digits" TEXT = NULL ,"positive" BOOLEAN = False ,"min_value" TEXT = NULL ,"max_value" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pyfloat'):
  plpy.warning(
    "the `pyfloat` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pyfloat(left_digits
,right_digits
,positive
,min_value
,max_value
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pyfloat("left_digits" TEXT = NULL ,"right_digits" TEXT = NULL ,"positive" BOOLEAN = False ,"min_value" TEXT = NULL ,"max_value" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pyfloat'):
  plpy.warning(
    "the `pyfloat` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pyfloat(left_digits,right_digits,positive,min_value,max_value)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pyint("min_value" INTEGER = 0 ,"max_value" INTEGER = 9999 ,"step" INTEGER = 1 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pyint'):
  plpy.warning(
    "the `pyint` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pyint(min_value
,max_value
,step
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pyint("min_value" INTEGER = 0 ,"max_value" INTEGER = 9999 ,"step" INTEGER = 1 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pyint'):
  plpy.warning(
    "the `pyint` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pyint(min_value,max_value,step)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pydecimal("left_digits" TEXT = NULL ,"right_digits" TEXT = NULL ,"positive" BOOLEAN = False ,"min_value" TEXT = NULL ,"max_value" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pydecimal'):
  plpy.warning(
    "the `pydecimal` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pydecimal(left_digits
,right_digits
,positive
,min_value
,max_value
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pydecimal("left_digits" TEXT = NULL ,"right_digits" TEXT = NULL ,"positive" BOOLEAN = False ,"min_value" TEXT = NULL ,"max_value" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pydecimal'):
  plpy.warning(
    "the `pydecimal` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pydecimal(left_digits,right_digits,positive,min_value,max_value)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pytuple("nb_elements" INTEGER = 10 ,"variable_nb_elements" BOOLEAN = True ,"value_types" TEXT = NULL ,"allowed_types" TEXT = '' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pytuple'):
  plpy.warning(
    "the `pytuple` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pytuple(nb_elements
,variable_nb_elements
,value_types
,allowed_types
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pytuple("nb_elements" INTEGER = 10 ,"variable_nb_elements" BOOLEAN = True ,"value_types" TEXT = NULL ,"allowed_types" TEXT = '' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pytuple'):
  plpy.warning(
    "the `pytuple` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pytuple(nb_elements,variable_nb_elements,value_types,allowed_types)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pyset("nb_elements" INTEGER = 10 ,"variable_nb_elements" BOOLEAN = True ,"value_types" TEXT = NULL ,"allowed_types" TEXT = '' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pyset'):
  plpy.warning(
    "the `pyset` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pyset(nb_elements
,variable_nb_elements
,value_types
,allowed_types
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pyset("nb_elements" INTEGER = 10 ,"variable_nb_elements" BOOLEAN = True ,"value_types" TEXT = NULL ,"allowed_types" TEXT = '' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pyset'):
  plpy.warning(
    "the `pyset` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pyset(nb_elements,variable_nb_elements,value_types,allowed_types)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pylist("nb_elements" INTEGER = 10 ,"variable_nb_elements" BOOLEAN = True ,"value_types" TEXT = NULL ,"allowed_types" TEXT = '' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pylist'):
  plpy.warning(
    "the `pylist` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pylist(nb_elements
,variable_nb_elements
,value_types
,allowed_types
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pylist("nb_elements" INTEGER = 10 ,"variable_nb_elements" BOOLEAN = True ,"value_types" TEXT = NULL ,"allowed_types" TEXT = '' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pylist'):
  plpy.warning(
    "the `pylist` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pylist(nb_elements,variable_nb_elements,value_types,allowed_types)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pyiterable("nb_elements" INTEGER = 10 ,"variable_nb_elements" BOOLEAN = True ,"value_types" TEXT = NULL ,"allowed_types" TEXT = '' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pyiterable'):
  plpy.warning(
    "the `pyiterable` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pyiterable(nb_elements
,variable_nb_elements
,value_types
,allowed_types
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pyiterable("nb_elements" INTEGER = 10 ,"variable_nb_elements" BOOLEAN = True ,"value_types" TEXT = NULL ,"allowed_types" TEXT = '' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pyiterable'):
  plpy.warning(
    "the `pyiterable` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pyiterable(nb_elements,variable_nb_elements,value_types,allowed_types)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pydict("nb_elements" INTEGER = 10 ,"variable_nb_elements" BOOLEAN = True ,"value_types" TEXT = NULL ,"allowed_types" TEXT = '' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pydict'):
  plpy.warning(
    "the `pydict` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pydict(nb_elements
,variable_nb_elements
,value_types
,allowed_types
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pydict("nb_elements" INTEGER = 10 ,"variable_nb_elements" BOOLEAN = True ,"value_types" TEXT = NULL ,"allowed_types" TEXT = '' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pydict'):
  plpy.warning(
    "the `pydict` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pydict(nb_elements,variable_nb_elements,value_types,allowed_types)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pystruct("count" INTEGER = 10 ,"value_types" TEXT = NULL ,"allowed_types" TEXT = '' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pystruct'):
  plpy.warning(
    "the `pystruct` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pystruct(count
,value_types
,allowed_types
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pystruct("count" INTEGER = 10 ,"value_types" TEXT = NULL ,"allowed_types" TEXT = '' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pystruct'):
  plpy.warning(
    "the `pystruct` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pystruct(count,value_types,allowed_types)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.bg_BG
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/bg_BG/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.cs_CZ
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/cs_CZ/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION birth_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'birth_number'):
  plpy.warning(
    "the `birth_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].birth_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_birth_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'birth_number'):
  plpy.warning(
    "the `birth_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.birth_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.de_AT
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/de_AT/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.de_CH
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/de_CH/__init__.py




-- Provider : faker.providers.ssn.de_DE
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/de_DE/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.dk_DK
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/dk_DK/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.el_CY
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/el_CY/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.el_GR
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/el_GR/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION police_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'police_id'):
  plpy.warning(
    "the `police_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].police_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_police_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'police_id'):
  plpy.warning(
    "the `police_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.police_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.en_CA
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/en_CA/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.en_GB
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/en_GB/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.en_IE
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/en_IE/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.en_IN
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/en_IN/__init__.py


CREATE OR REPLACE FUNCTION aadhaar_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'aadhaar_id'):
  plpy.warning(
    "the `aadhaar_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].aadhaar_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_aadhaar_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'aadhaar_id'):
  plpy.warning(
    "the `aadhaar_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.aadhaar_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.en_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/en_PH/__init__.py


CREATE OR REPLACE FUNCTION sss() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sss'):
  plpy.warning(
    "the `sss` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].sss()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_sss() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'sss'):
  plpy.warning(
    "the `sss` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.sss()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION gsis() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'gsis'):
  plpy.warning(
    "the `gsis` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].gsis()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_gsis() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'gsis'):
  plpy.warning(
    "the `gsis` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.gsis()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION pagibig() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pagibig'):
  plpy.warning(
    "the `pagibig` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].pagibig()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_pagibig() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'pagibig'):
  plpy.warning(
    "the `pagibig` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.pagibig()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION philhealth() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'philhealth'):
  plpy.warning(
    "the `philhealth` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].philhealth()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_philhealth() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'philhealth'):
  plpy.warning(
    "the `philhealth` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.philhealth()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION umid() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'umid'):
  plpy.warning(
    "the `umid` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].umid()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_umid() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'umid'):
  plpy.warning(
    "the `umid` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.umid()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.en_US
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/en_US/__init__.py


CREATE OR REPLACE FUNCTION itin() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'itin'):
  plpy.warning(
    "the `itin` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].itin()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_itin() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'itin'):
  plpy.warning(
    "the `itin` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.itin()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ein() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ein'):
  plpy.warning(
    "the `ein` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ein()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ein() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ein'):
  plpy.warning(
    "the `ein` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ein()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION invalid_ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'invalid_ssn'):
  plpy.warning(
    "the `invalid_ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].invalid_ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_invalid_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'invalid_ssn'):
  plpy.warning(
    "the `invalid_ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.invalid_ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ssn("taxpayer_identification_number_type" TEXT = 'SSN' ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn(taxpayer_identification_number_type
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn("taxpayer_identification_number_type" TEXT = 'SSN' ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn(taxpayer_identification_number_type)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.es_CA
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/es_CA/__init__.py




-- Provider : faker.providers.ssn.es_ES
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/es_ES/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION nie() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'nie'):
  plpy.warning(
    "the `nie` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].nie()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_nie() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'nie'):
  plpy.warning(
    "the `nie` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.nie()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION nif() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'nif'):
  plpy.warning(
    "the `nif` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].nif()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_nif() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'nif'):
  plpy.warning(
    "the `nif` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.nif()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION cif() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cif'):
  plpy.warning(
    "the `cif` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].cif()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_cif() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cif'):
  plpy.warning(
    "the `cif` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.cif()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION doi() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'doi'):
  plpy.warning(
    "the `doi` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].doi()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_doi() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'doi'):
  plpy.warning(
    "the `doi` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.doi()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.es_MX
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/es_MX/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION curp() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'curp'):
  plpy.warning(
    "the `curp` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].curp()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_curp() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'curp'):
  plpy.warning(
    "the `curp` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.curp()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION rfc("natural" BOOLEAN = True ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'rfc'):
  plpy.warning(
    "the `rfc` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].rfc(natural
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_rfc("natural" BOOLEAN = True ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'rfc'):
  plpy.warning(
    "the `rfc` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.rfc(natural)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.et_EE
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/et_EE/__init__.py


CREATE OR REPLACE FUNCTION ssn("min_age" INTEGER = 16 ,"max_age" INTEGER = 90 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn(min_age
,max_age
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn("min_age" INTEGER = 16 ,"max_age" INTEGER = 90 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn(min_age,max_age)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.fi_FI
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/fi_FI/__init__.py


CREATE OR REPLACE FUNCTION ssn("min_age" INTEGER = 0 ,"max_age" INTEGER = 105 ,"artificial" BOOLEAN = False ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn(min_age
,max_age
,artificial
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn("min_age" INTEGER = 0 ,"max_age" INTEGER = 105 ,"artificial" BOOLEAN = False ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn(min_age,max_age,artificial)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.fil_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/fil_PH/__init__.py




-- Provider : faker.providers.ssn.fr_CH
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/fr_CH/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.fr_FR
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/fr_FR/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.he_IL
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/he_IL/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.hr_HR
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/hr_HR/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.hu_HU
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/hu_HU/__init__.py


CREATE OR REPLACE FUNCTION ssn("dob" TEXT = NULL ,"gender" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn(dob
,gender
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn("dob" TEXT = NULL ,"gender" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn(dob,gender)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.it_IT
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/it_IT/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.ko_KR
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/ko_KR/__init__.py




-- Provider : faker.providers.ssn.lb_LU
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/lb_LU/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.lt_LT
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/lt_LT/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.lv_LV
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/lv_LV/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.mt_MT
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/mt_MT/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.nl_BE
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/nl_BE/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.nl_NL
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/nl_NL/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.no_NO
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/no_NO/__init__.py


CREATE OR REPLACE FUNCTION ssn("dob" TEXT = NULL ,"gender" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn(dob
,gender
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn("dob" TEXT = NULL ,"gender" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn(dob,gender)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.pl_PL
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/pl_PL/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.pt_BR
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/pt_BR/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION cpf() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cpf'):
  plpy.warning(
    "the `cpf` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].cpf()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_cpf() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'cpf'):
  plpy.warning(
    "the `cpf` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.cpf()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION rg() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'rg'):
  plpy.warning(
    "the `rg` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].rg()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_rg() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'rg'):
  plpy.warning(
    "the `rg` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.rg()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.pt_PT
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/pt_PT/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.ro_RO
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/ro_RO/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.ru_RU
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/ru_RU/__init__.py




-- Provider : faker.providers.ssn.sk_SK
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/sk_SK/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION birth_number() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'birth_number'):
  plpy.warning(
    "the `birth_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].birth_number()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_birth_number() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'birth_number'):
  plpy.warning(
    "the `birth_number` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.birth_number()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.sl_SI
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/sl_SI/__init__.py


CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.sv_SE
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/sv_SE/__init__.py


CREATE OR REPLACE FUNCTION ssn("min_age" INTEGER = 18 ,"max_age" INTEGER = 90 ,"long" BOOLEAN = False ,"dash" BOOLEAN = True ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn(min_age
,max_age
,long
,dash
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn("min_age" INTEGER = 18 ,"max_age" INTEGER = 90 ,"long" BOOLEAN = False ,"dash" BOOLEAN = True ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn(min_age,max_age,long,dash)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION org_id("long" BOOLEAN = False ,"dash" BOOLEAN = True ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'org_id'):
  plpy.warning(
    "the `org_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].org_id(long
,dash
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_org_id("long" BOOLEAN = False ,"dash" BOOLEAN = True ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'org_id'):
  plpy.warning(
    "the `org_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.org_id(long,dash)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION org_and_vat_id("long" BOOLEAN = False ,"dash" BOOLEAN = True ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'org_and_vat_id'):
  plpy.warning(
    "the `org_and_vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].org_and_vat_id(long
,dash
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_org_and_vat_id("long" BOOLEAN = False ,"dash" BOOLEAN = True ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'org_and_vat_id'):
  plpy.warning(
    "the `org_and_vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.org_and_vat_id(long,dash)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.th_TH
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/th_TH/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION vat_id() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].vat_id()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_vat_id() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'vat_id'):
  plpy.warning(
    "the `vat_id` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.vat_id()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.tl_PH
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/tl_PH/__init__.py




-- Provider : faker.providers.ssn.tr_TR
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/tr_TR/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.uk_UA
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/uk_UA/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.zh_CN
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/zh_CN/__init__.py


CREATE OR REPLACE FUNCTION ssn("min_age" INTEGER = 18 ,"max_age" INTEGER = 90 ,"gender" TEXT = NULL ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn(min_age
,max_age
,gender
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn("min_age" INTEGER = 18 ,"max_age" INTEGER = 90 ,"gender" TEXT = NULL ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn(min_age,max_age,gender)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.ssn.zh_TW
-- https://github.com/joke2k/faker/blob/master/faker/providers/ssn/zh_TW/__init__.py


CREATE OR REPLACE FUNCTION ssn() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ssn()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ssn() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ssn'):
  plpy.warning(
    "the `ssn` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ssn()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;



-- Provider : faker.providers.user_agent
-- https://github.com/joke2k/faker/blob/master/faker/providers/user_agent/__init__.py


CREATE OR REPLACE FUNCTION mac_processor() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mac_processor'):
  plpy.warning(
    "the `mac_processor` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].mac_processor()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_mac_processor() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mac_processor'):
  plpy.warning(
    "the `mac_processor` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.mac_processor()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION linux_processor() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'linux_processor'):
  plpy.warning(
    "the `linux_processor` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].linux_processor()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_linux_processor() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'linux_processor'):
  plpy.warning(
    "the `linux_processor` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.linux_processor()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION user_agent() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'user_agent'):
  plpy.warning(
    "the `user_agent` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].user_agent()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_user_agent() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'user_agent'):
  plpy.warning(
    "the `user_agent` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.user_agent()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION chrome("version_from" INTEGER = 13 ,"version_to" INTEGER = 63 ,"build_from" INTEGER = 800 ,"build_to" INTEGER = 899 ) RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'chrome'):
  plpy.warning(
    "the `chrome` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].chrome(version_from
,version_to
,build_from
,build_to
)
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_chrome("version_from" INTEGER = 13 ,"version_to" INTEGER = 63 ,"build_from" INTEGER = 800 ,"build_to" INTEGER = 899 ) RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'chrome'):
  plpy.warning(
    "the `chrome` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.chrome(version_from,version_to,build_from,build_to)
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION firefox() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'firefox'):
  plpy.warning(
    "the `firefox` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].firefox()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_firefox() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'firefox'):
  plpy.warning(
    "the `firefox` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.firefox()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION safari() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'safari'):
  plpy.warning(
    "the `safari` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].safari()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_safari() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'safari'):
  plpy.warning(
    "the `safari` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.safari()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION opera() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'opera'):
  plpy.warning(
    "the `opera` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].opera()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_opera() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'opera'):
  plpy.warning(
    "the `opera` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.opera()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION internet_explorer() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'internet_explorer'):
  plpy.warning(
    "the `internet_explorer` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].internet_explorer()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_internet_explorer() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'internet_explorer'):
  plpy.warning(
    "the `internet_explorer` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.internet_explorer()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION windows_platform_token() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'windows_platform_token'):
  plpy.warning(
    "the `windows_platform_token` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].windows_platform_token()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_windows_platform_token() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'windows_platform_token'):
  plpy.warning(
    "the `windows_platform_token` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.windows_platform_token()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION linux_platform_token() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'linux_platform_token'):
  plpy.warning(
    "the `linux_platform_token` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].linux_platform_token()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_linux_platform_token() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'linux_platform_token'):
  plpy.warning(
    "the `linux_platform_token` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.linux_platform_token()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION mac_platform_token() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mac_platform_token'):
  plpy.warning(
    "the `mac_platform_token` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].mac_platform_token()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_mac_platform_token() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'mac_platform_token'):
  plpy.warning(
    "the `mac_platform_token` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.mac_platform_token()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION android_platform_token() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'android_platform_token'):
  plpy.warning(
    "the `android_platform_token` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].android_platform_token()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_android_platform_token() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'android_platform_token'):
  plpy.warning(
    "the `android_platform_token` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.android_platform_token()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION ios_platform_token() RETURNS TEXT
AS $$
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ios_platform_token'):
  plpy.warning(
    "the `ios_platform_token` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
return GD['Faker'].ios_platform_token()
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;

CREATE OR REPLACE FUNCTION unique_ios_platform_token() RETURNS TEXT
AS $$
from faker.exceptions import UniquenessException
try:
  GD['Faker']
except KeyError:
  plpy.execute('SELECT autoinit();')
  if not 'Faker' in GD:
    return None
if not hasattr(GD['Faker'],'ios_platform_token'):
  plpy.warning(
    "the `ios_platform_token` method is not available in the current locale(s)",
    hint="See https://faker.readthedocs.io/en/master/locales.html"
  )
  return None
try:
  result=GD['Faker'].unique.ios_platform_token()
except UniquenessException:
  plpy.warning(
    "Got duplicated values after 1,000 iterations.",
    detail="You probably consumed all the unique values !",
    hint="You can reset the uniqueness cache with SELECT @extschema@.unique_clear()"
  )
  return None
return result
$$
  LANGUAGE plpython3u
  VOLATILE
  CALLED ON NULL INPUT
  SECURITY INVOKER
  PARALLEL SAFE
  SET search_path = @extschema@
;





CREATE OR REPLACE FUNCTION unique_clear() RETURNS BOOLEAN
AS $$
  try:
    GD['Faker'].unique.clear()
  except KeyError:
    plpy.warning(
      "faker is not initialized.",
      hint="Use SELECT @extschema@.faker(); first."
    )
    return False
  return True
$$
  LANGUAGE plpython3u
  VOLATILE
  SECURITY INVOKER
;


CREATE OR REPLACE FUNCTION _functions()
RETURNS TABLE ( name TEXT, locale TEXT )
AS $$
SELECT *
FROM ( VALUES
('city_suffix', NULL),
('unique_city_suffix', NULL),
('street_suffix', NULL),
('unique_street_suffix', NULL),
('building_number', NULL),
('unique_building_number', NULL),
('city', NULL),
('unique_city', NULL),
('street_name', NULL),
('unique_street_name', NULL),
('street_address', NULL),
('unique_street_address', NULL),
('postcode', NULL),
('unique_postcode', NULL),
('address', NULL),
('unique_address', NULL),
('country', NULL),
('unique_country', NULL),
('country_code', NULL),
('unique_country_code', NULL),
('street_suffix_short', 'cs_CZ'),
('unique_street_suffix_short', 'cs_CZ'),
('street_suffix_long', 'cs_CZ'),
('unique_street_suffix_long', 'cs_CZ'),
('city_name', 'cs_CZ'),
('unique_city_name', 'cs_CZ'),
('street_name', 'cs_CZ'),
('unique_street_name', 'cs_CZ'),
('state', 'cs_CZ'),
('unique_state', 'cs_CZ'),
('city_with_postcode', 'cs_CZ'),
('unique_city_with_postcode', 'cs_CZ'),
('street_prefix', 'da_DK'),
('unique_street_prefix', 'da_DK'),
('city_name', 'da_DK'),
('unique_city_name', 'da_DK'),
('state', 'da_DK'),
('unique_state', 'da_DK'),
('street_suffix_short', 'de_AT'),
('unique_street_suffix_short', 'de_AT'),
('street_suffix_long', 'de_AT'),
('unique_street_suffix_long', 'de_AT'),
('city_name', 'de_AT'),
('unique_city_name', 'de_AT'),
('state', 'de_AT'),
('unique_state', 'de_AT'),
('city_with_postcode', 'de_AT'),
('unique_city_with_postcode', 'de_AT'),
('street_suffix_short', 'de_DE'),
('unique_street_suffix_short', 'de_DE'),
('street_suffix_long', 'de_DE'),
('unique_street_suffix_long', 'de_DE'),
('city_name', 'de_DE'),
('unique_city_name', 'de_DE'),
('state', 'de_DE'),
('unique_state', 'de_DE'),
('city_with_postcode', 'de_DE'),
('unique_city_with_postcode', 'de_DE'),
('line_address', 'el_GR'),
('unique_line_address', 'el_GR'),
('street_prefix', 'el_GR'),
('unique_street_prefix', 'el_GR'),
('street_prefix_short', 'el_GR'),
('unique_street_prefix_short', 'el_GR'),
('street_prefix_long', 'el_GR'),
('unique_street_prefix_long', 'el_GR'),
('street', 'el_GR'),
('unique_street', 'el_GR'),
('city', 'el_GR'),
('unique_city', 'el_GR'),
('region', 'el_GR'),
('unique_region', 'el_GR'),
('city_prefix', 'en_AU'),
('unique_city_prefix', 'en_AU'),
('secondary_address', 'en_AU'),
('unique_secondary_address', 'en_AU'),
('state', 'en_AU'),
('unique_state', 'en_AU'),
('state_abbr', 'en_AU'),
('unique_state_abbr', 'en_AU'),
('province', 'en_CA'),
('unique_province', 'en_CA'),
('province_abbr', 'en_CA'),
('unique_province_abbr', 'en_CA'),
('city_prefix', 'en_CA'),
('unique_city_prefix', 'en_CA'),
('secondary_address', 'en_CA'),
('unique_secondary_address', 'en_CA'),
('postal_code_letter', 'en_CA'),
('unique_postal_code_letter', 'en_CA'),
('postcode', 'en_CA'),
('unique_postcode', 'en_CA'),
('postcode_in_province', 'en_CA'),
('unique_postcode_in_province', 'en_CA'),
('postalcode_in_province', 'en_CA'),
('unique_postalcode_in_province', 'en_CA'),
('postalcode', 'en_CA'),
('unique_postalcode', 'en_CA'),
('postcode', 'en_GB'),
('unique_postcode', 'en_GB'),
('city_prefix', 'en_GB'),
('unique_city_prefix', 'en_GB'),
('secondary_address', 'en_GB'),
('unique_secondary_address', 'en_GB'),
('county', 'en_GB'),
('unique_county', 'en_GB'),
('postcode', 'en_IE'),
('unique_postcode', 'en_IE'),
('county', 'en_IE'),
('unique_county', 'en_IE'),
('city_name', 'en_IN'),
('unique_city_name', 'en_IN'),
('state', 'en_IN'),
('unique_state', 'en_IN'),
('state', 'en_NZ'),
('unique_state', 'en_NZ'),
('te_reo_part', 'en_NZ'),
('unique_te_reo_part', 'en_NZ'),
('te_reo_first', 'en_NZ'),
('unique_te_reo_first', 'en_NZ'),
('te_reo_ending', 'en_NZ'),
('unique_te_reo_ending', 'en_NZ'),
('city_prefix', 'en_NZ'),
('unique_city_prefix', 'en_NZ'),
('city_suffix', 'en_NZ'),
('unique_city_suffix', 'en_NZ'),
('rd_number', 'en_NZ'),
('unique_rd_number', 'en_NZ'),
('secondary_address', 'en_NZ'),
('unique_secondary_address', 'en_NZ'),
('metro_manila_postcode', 'en_PH'),
('unique_metro_manila_postcode', 'en_PH'),
('luzon_province_postcode', 'en_PH'),
('unique_luzon_province_postcode', 'en_PH'),
('visayas_province_postcode', 'en_PH'),
('unique_visayas_province_postcode', 'en_PH'),
('mindanao_province_postcode', 'en_PH'),
('unique_mindanao_province_postcode', 'en_PH'),
('postcode', 'en_PH'),
('unique_postcode', 'en_PH'),
('luzon_province', 'en_PH'),
('unique_luzon_province', 'en_PH'),
('visayas_province', 'en_PH'),
('unique_visayas_province', 'en_PH'),
('mindanao_province', 'en_PH'),
('unique_mindanao_province', 'en_PH'),
('province', 'en_PH'),
('unique_province', 'en_PH'),
('standalone_building_number', 'en_PH'),
('unique_standalone_building_number', 'en_PH'),
('partitioned_building_number', 'en_PH'),
('unique_partitioned_building_number', 'en_PH'),
('building_number', 'en_PH'),
('unique_building_number', 'en_PH'),
('ordinal_street_number', 'en_PH'),
('unique_ordinal_street_number', 'en_PH'),
('floor_number', 'en_PH'),
('unique_floor_number', 'en_PH'),
('ordinal_floor_number', 'en_PH'),
('unique_ordinal_floor_number', 'en_PH'),
('floor_unit_number', 'en_PH'),
('unique_floor_unit_number', 'en_PH'),
('building_unit_number', 'en_PH'),
('unique_building_unit_number', 'en_PH'),
('building_name', 'en_PH'),
('unique_building_name', 'en_PH'),
('building_name_suffix', 'en_PH'),
('unique_building_name_suffix', 'en_PH'),
('subdivision_block_number', 'en_PH'),
('unique_subdivision_block_number', 'en_PH'),
('subdivision_lot_number', 'en_PH'),
('unique_subdivision_lot_number', 'en_PH'),
('subdivision_unit_number', 'en_PH'),
('unique_subdivision_unit_number', 'en_PH'),
('subdivision_name', 'en_PH'),
('unique_subdivision_name', 'en_PH'),
('subdivision_name_suffix', 'en_PH'),
('unique_subdivision_name_suffix', 'en_PH'),
('metro_manila_lgu', 'en_PH'),
('unique_metro_manila_lgu', 'en_PH'),
('province_lgu', 'en_PH'),
('unique_province_lgu', 'en_PH'),
('metro_manila_address', 'en_PH'),
('unique_metro_manila_address', 'en_PH'),
('luzon_province_address', 'en_PH'),
('unique_luzon_province_address', 'en_PH'),
('visayas_province_address', 'en_PH'),
('unique_visayas_province_address', 'en_PH'),
('mindanao_province_address', 'en_PH'),
('unique_mindanao_province_address', 'en_PH'),
('address', 'en_PH'),
('unique_address', 'en_PH'),
('city_prefix', 'en_US'),
('unique_city_prefix', 'en_US'),
('secondary_address', 'en_US'),
('unique_secondary_address', 'en_US'),
('state', 'en_US'),
('unique_state', 'en_US'),
('state_abbr', 'en_US'),
('unique_state_abbr', 'en_US'),
('postcode', 'en_US'),
('unique_postcode', 'en_US'),
('zipcode_plus4', 'en_US'),
('unique_zipcode_plus4', 'en_US'),
('postcode_in_state', 'en_US'),
('unique_postcode_in_state', 'en_US'),
('military_ship', 'en_US'),
('unique_military_ship', 'en_US'),
('military_state', 'en_US'),
('unique_military_state', 'en_US'),
('military_apo', 'en_US'),
('unique_military_apo', 'en_US'),
('military_dpo', 'en_US'),
('unique_military_dpo', 'en_US'),
('zipcode', 'en_US'),
('unique_zipcode', 'en_US'),
('zipcode_in_state', 'en_US'),
('unique_zipcode_in_state', 'en_US'),
('postalcode', 'en_US'),
('unique_postalcode', 'en_US'),
('postalcode_in_state', 'en_US'),
('unique_postalcode_in_state', 'en_US'),
('postalcode_plus4', 'en_US'),
('unique_postalcode_plus4', 'en_US'),
('state_name', 'es_ES'),
('unique_state_name', 'es_ES'),
('street_prefix', 'es_ES'),
('unique_street_prefix', 'es_ES'),
('secondary_address', 'es_ES'),
('unique_secondary_address', 'es_ES'),
('state', 'es_ES'),
('unique_state', 'es_ES'),
('region', 'es_ES'),
('unique_region', 'es_ES'),
('autonomous_community', 'es_ES'),
('unique_autonomous_community', 'es_ES'),
('city_prefix', 'es_MX'),
('unique_city_prefix', 'es_MX'),
('city_suffix', 'es_MX'),
('unique_city_suffix', 'es_MX'),
('city_adjective', 'es_MX'),
('unique_city_adjective', 'es_MX'),
('street_prefix', 'es_MX'),
('unique_street_prefix', 'es_MX'),
('secondary_address', 'es_MX'),
('unique_secondary_address', 'es_MX'),
('state', 'es_MX'),
('unique_state', 'es_MX'),
('state_abbr', 'es_MX'),
('unique_state_abbr', 'es_MX'),
('city_prefix', 'fa_IR'),
('unique_city_prefix', 'fa_IR'),
('secondary_address', 'fa_IR'),
('unique_secondary_address', 'fa_IR'),
('state', 'fa_IR'),
('unique_state', 'fa_IR'),
('street_prefix', 'fi_FI'),
('unique_street_prefix', 'fi_FI'),
('city_name', 'fi_FI'),
('unique_city_name', 'fi_FI'),
('state', 'fi_FI'),
('unique_state', 'fi_FI'),
('street_prefix', 'fr_CH'),
('unique_street_prefix', 'fr_CH'),
('city_prefix', 'fr_CH'),
('unique_city_prefix', 'fr_CH'),
('canton', 'fr_CH'),
('unique_canton', 'fr_CH'),
('canton_name', 'fr_CH'),
('unique_canton_name', 'fr_CH'),
('canton_code', 'fr_CH'),
('unique_canton_code', 'fr_CH'),
('street_prefix', 'fr_FR'),
('unique_street_prefix', 'fr_FR'),
('city_prefix', 'fr_FR'),
('unique_city_prefix', 'fr_FR'),
('region', 'fr_FR'),
('unique_region', 'fr_FR'),
('department', 'fr_FR'),
('unique_department', 'fr_FR'),
('department_name', 'fr_FR'),
('unique_department_name', 'fr_FR'),
('department_number', 'fr_FR'),
('unique_department_number', 'fr_FR'),
('city_name', 'he_IL'),
('unique_city_name', 'he_IL'),
('street_title', 'he_IL'),
('unique_street_title', 'he_IL'),
('city_name', 'hi_IN'),
('unique_city_name', 'hi_IN'),
('state', 'hi_IN'),
('unique_state', 'hi_IN'),
('city_name', 'hr_HR'),
('unique_city_name', 'hr_HR'),
('street_name', 'hr_HR'),
('unique_street_name', 'hr_HR'),
('state', 'hr_HR'),
('unique_state', 'hr_HR'),
('county', 'hu_HU'),
('unique_county', 'hu_HU'),
('street_address_with_county', 'hu_HU'),
('unique_street_address_with_county', 'hu_HU'),
('city_prefix', 'hu_HU'),
('unique_city_prefix', 'hu_HU'),
('city_part', 'hu_HU'),
('unique_city_part', 'hu_HU'),
('real_city_name', 'hu_HU'),
('unique_real_city_name', 'hu_HU'),
('frequent_street_name', 'hu_HU'),
('unique_frequent_street_name', 'hu_HU'),
('postcode', 'hu_HU'),
('unique_postcode', 'hu_HU'),
('street_name', 'hu_HU'),
('unique_street_name', 'hu_HU'),
('building_number', 'hu_HU'),
('unique_building_number', 'hu_HU'),
('city', 'hy_AM'),
('unique_city', 'hy_AM'),
('city_prefix', 'hy_AM'),
('unique_city_prefix', 'hy_AM'),
('postcode', 'hy_AM'),
('unique_postcode', 'hy_AM'),
('postcode_in_state', 'hy_AM'),
('unique_postcode_in_state', 'hy_AM'),
('secondary_address', 'hy_AM'),
('unique_secondary_address', 'hy_AM'),
('state', 'hy_AM'),
('unique_state', 'hy_AM'),
('state_abbr', 'hy_AM'),
('unique_state_abbr', 'hy_AM'),
('street', 'hy_AM'),
('unique_street', 'hy_AM'),
('street_prefix', 'hy_AM'),
('unique_street_prefix', 'hy_AM'),
('village', 'hy_AM'),
('unique_village', 'hy_AM'),
('village_prefix', 'hy_AM'),
('unique_village_prefix', 'hy_AM'),
('street', 'id_ID'),
('unique_street', 'id_ID'),
('street_prefix_short', 'id_ID'),
('unique_street_prefix_short', 'id_ID'),
('street_prefix_long', 'id_ID'),
('unique_street_prefix_long', 'id_ID'),
('city_name', 'id_ID'),
('unique_city_name', 'id_ID'),
('state', 'id_ID'),
('unique_state', 'id_ID'),
('state_abbr', 'id_ID'),
('unique_state_abbr', 'id_ID'),
('country', 'id_ID'),
('unique_country', 'id_ID'),
('city_prefix', 'it_IT'),
('unique_city_prefix', 'it_IT'),
('secondary_address', 'it_IT'),
('unique_secondary_address', 'it_IT'),
('state', 'it_IT'),
('unique_state', 'it_IT'),
('state_abbr', 'it_IT'),
('unique_state_abbr', 'it_IT'),
('prefecture', 'ja_JP'),
('unique_prefecture', 'ja_JP'),
('city', 'ja_JP'),
('unique_city', 'ja_JP'),
('town', 'ja_JP'),
('unique_town', 'ja_JP'),
('chome', 'ja_JP'),
('unique_chome', 'ja_JP'),
('ban', 'ja_JP'),
('unique_ban', 'ja_JP'),
('gou', 'ja_JP'),
('unique_gou', 'ja_JP'),
('building_name', 'ja_JP'),
('unique_building_name', 'ja_JP'),
('postcode', 'ja_JP'),
('unique_postcode', 'ja_JP'),
('zipcode', 'ja_JP'),
('unique_zipcode', 'ja_JP'),
('street_title', 'ka_GE'),
('unique_street_title', 'ka_GE'),
('city_name', 'ka_GE'),
('unique_city_name', 'ka_GE'),
('land_number', 'ko_KR'),
('unique_land_number', 'ko_KR'),
('land_address', 'ko_KR'),
('unique_land_address', 'ko_KR'),
('road_number', 'ko_KR'),
('unique_road_number', 'ko_KR'),
('road_address', 'ko_KR'),
('unique_road_address', 'ko_KR'),
('address_detail', 'ko_KR'),
('unique_address_detail', 'ko_KR'),
('road', 'ko_KR'),
('unique_road', 'ko_KR'),
('road_name', 'ko_KR'),
('unique_road_name', 'ko_KR'),
('road_suffix', 'ko_KR'),
('unique_road_suffix', 'ko_KR'),
('metropolitan_city', 'ko_KR'),
('unique_metropolitan_city', 'ko_KR'),
('province', 'ko_KR'),
('unique_province', 'ko_KR'),
('city', 'ko_KR'),
('unique_city', 'ko_KR'),
('borough', 'ko_KR'),
('unique_borough', 'ko_KR'),
('town', 'ko_KR'),
('unique_town', 'ko_KR'),
('town_suffix', 'ko_KR'),
('unique_town_suffix', 'ko_KR'),
('building_name', 'ko_KR'),
('unique_building_name', 'ko_KR'),
('building_suffix', 'ko_KR'),
('unique_building_suffix', 'ko_KR'),
('building_dong', 'ko_KR'),
('unique_building_dong', 'ko_KR'),
('old_postal_code', 'ko_KR'),
('unique_old_postal_code', 'ko_KR'),
('postcode', 'ko_KR'),
('unique_postcode', 'ko_KR'),
('postal_code', 'ko_KR'),
('unique_postal_code', 'ko_KR'),
('province', 'ne_NP'),
('unique_province', 'ne_NP'),
('district', 'ne_NP'),
('unique_district', 'ne_NP'),
('city', 'ne_NP'),
('unique_city', 'ne_NP'),
('building_prefix', 'ne_NP'),
('unique_building_prefix', 'ne_NP'),
('province', 'nl_BE'),
('unique_province', 'nl_BE'),
('city', 'nl_BE'),
('unique_city', 'nl_BE'),
('province', 'nl_NL'),
('unique_province', 'nl_NL'),
('city', 'nl_NL'),
('unique_city', 'nl_NL'),
('building_number', 'no_NO'),
('unique_building_number', 'no_NO'),
('city_suffix', 'no_NO'),
('unique_city_suffix', 'no_NO'),
('street_suffix', 'no_NO'),
('unique_street_suffix', 'no_NO'),
('street_prefix', 'pl_PL'),
('unique_street_prefix', 'pl_PL'),
('street_prefix_short', 'pl_PL'),
('unique_street_prefix_short', 'pl_PL'),
('street_name', 'pl_PL'),
('unique_street_name', 'pl_PL'),
('city', 'pl_PL'),
('unique_city', 'pl_PL'),
('region', 'pl_PL'),
('unique_region', 'pl_PL'),
('street_prefix', 'pt_BR'),
('unique_street_prefix', 'pt_BR'),
('estado', 'pt_BR'),
('unique_estado', 'pt_BR'),
('estado_nome', 'pt_BR'),
('unique_estado_nome', 'pt_BR'),
('estado_sigla', 'pt_BR'),
('unique_estado_sigla', 'pt_BR'),
('bairro', 'pt_BR'),
('unique_bairro', 'pt_BR'),
('postcode', 'pt_BR'),
('unique_postcode', 'pt_BR'),
('neighborhood', 'pt_BR'),
('unique_neighborhood', 'pt_BR'),
('state', 'pt_BR'),
('unique_state', 'pt_BR'),
('state_abbr', 'pt_BR'),
('unique_state_abbr', 'pt_BR'),
('street_prefix', 'pt_PT'),
('unique_street_prefix', 'pt_PT'),
('city_name', 'pt_PT'),
('unique_city_name', 'pt_PT'),
('distrito', 'pt_PT'),
('unique_distrito', 'pt_PT'),
('concelho', 'pt_PT'),
('unique_concelho', 'pt_PT'),
('freguesia', 'pt_PT'),
('unique_freguesia', 'pt_PT'),
('place_name', 'pt_PT'),
('unique_place_name', 'pt_PT'),
('city_prefix', 'ru_RU'),
('unique_city_prefix', 'ru_RU'),
('city_name', 'ru_RU'),
('unique_city_name', 'ru_RU'),
('country', 'ru_RU'),
('unique_country', 'ru_RU'),
('region', 'ru_RU'),
('unique_region', 'ru_RU'),
('street_suffix', 'ru_RU'),
('unique_street_suffix', 'ru_RU'),
('street_title', 'ru_RU'),
('unique_street_title', 'ru_RU'),
('street_name', 'ru_RU'),
('unique_street_name', 'ru_RU'),
('street_suffix_short', 'sk_SK'),
('unique_street_suffix_short', 'sk_SK'),
('street_suffix_long', 'sk_SK'),
('unique_street_suffix_long', 'sk_SK'),
('city_name', 'sk_SK'),
('unique_city_name', 'sk_SK'),
('street_name', 'sk_SK'),
('unique_street_name', 'sk_SK'),
('state', 'sk_SK'),
('unique_state', 'sk_SK'),
('city_with_postcode', 'sk_SK'),
('unique_city_with_postcode', 'sk_SK'),
('city_name', 'sl_SI'),
('unique_city_name', 'sl_SI'),
('street_name', 'sl_SI'),
('unique_street_name', 'sl_SI'),
('state', 'sl_SI'),
('unique_state', 'sl_SI'),
('street_prefix', 'sv_SE'),
('unique_street_prefix', 'sv_SE'),
('city_name', 'sv_SE'),
('unique_city_name', 'sv_SE'),
('state', 'sv_SE'),
('unique_state', 'sv_SE'),
('city_name', 'ta_IN'),
('unique_city_name', 'ta_IN'),
('state', 'ta_IN'),
('unique_state', 'ta_IN'),
('street_prefix', 'th_TH'),
('unique_street_prefix', 'th_TH'),
('province', 'th_TH'),
('unique_province', 'th_TH'),
('amphoe', 'th_TH'),
('unique_amphoe', 'th_TH'),
('tambon', 'th_TH'),
('unique_tambon', 'th_TH'),
('city_prefix', 'uk_UA'),
('unique_city_prefix', 'uk_UA'),
('postcode', 'uk_UA'),
('unique_postcode', 'uk_UA'),
('street_prefix', 'uk_UA'),
('unique_street_prefix', 'uk_UA'),
('street_title', 'uk_UA'),
('unique_street_title', 'uk_UA'),
('building_number', 'zh_CN'),
('unique_building_number', 'zh_CN'),
('city_name', 'zh_CN'),
('unique_city_name', 'zh_CN'),
('province', 'zh_CN'),
('unique_province', 'zh_CN'),
('district', 'zh_CN'),
('unique_district', 'zh_CN'),
('secondary_address', 'zh_TW'),
('unique_secondary_address', 'zh_TW'),
('building_number', 'zh_TW'),
('unique_building_number', 'zh_TW'),
('street_name', 'zh_TW'),
('unique_street_name', 'zh_TW'),
('street_name_suffix', 'zh_TW'),
('unique_street_name_suffix', 'zh_TW'),
('city_name', 'zh_TW'),
('unique_city_name', 'zh_TW'),
('city_name_suffix', 'zh_TW'),
('unique_city_name_suffix', 'zh_TW'),
('section_number', 'zh_TW'),
('unique_section_number', 'zh_TW'),
('license_plate', NULL),
('unique_license_plate', NULL),
('initials', 'ar_JO'),
('unique_initials', 'ar_JO'),
('license_plate', 'ar_JO'),
('unique_license_plate', 'ar_JO'),
('district', 'ar_PS'),
('unique_district', 'ar_PS'),
('license_plate', 'ar_PS'),
('unique_license_plate', 'ar_PS'),
('license_plate_en', 'ar_SA'),
('unique_license_plate_en', 'ar_SA'),
('license_plate_ar', 'ar_SA'),
('unique_license_plate_ar', 'ar_SA'),
('license_plate', 'ar_SA'),
('unique_license_plate', 'ar_SA'),
('license_plate', 'de_DE'),
('unique_license_plate', 'de_DE'),
('protocol_license_plate', 'en_PH'),
('unique_protocol_license_plate', 'en_PH'),
('motorcycle_license_plate', 'en_PH'),
('unique_motorcycle_license_plate', 'en_PH'),
('automobile_license_plate', 'en_PH'),
('unique_automobile_license_plate', 'en_PH'),
('license_plate', 'en_PH'),
('unique_license_plate', 'en_PH'),
('license_plate_unified', 'es_ES'),
('unique_license_plate_unified', 'es_ES'),
('license_plate_by_province', 'es_ES'),
('unique_license_plate_by_province', 'es_ES'),
('license_plate', 'es_ES'),
('unique_license_plate', 'es_ES'),
('license_plate_regex_formats', 'pl_PL'),
('unique_license_plate_regex_formats', 'pl_PL'),
('license_plate', 'ru_RU'),
('unique_license_plate', 'ru_RU'),
('plate_letter', 'ru_RU'),
('unique_plate_letter', 'ru_RU'),
('plate_number', 'ru_RU'),
('unique_plate_number', 'ru_RU'),
('plate_number_extra', 'ru_RU'),
('unique_plate_number_extra', 'ru_RU'),
('plate_number_special', 'ru_RU'),
('unique_plate_number_special', 'ru_RU'),
('plate_suffix', 'ru_RU'),
('unique_plate_suffix', 'ru_RU'),
('vehicle_category', 'ru_RU'),
('unique_vehicle_category', 'ru_RU'),
('license_plate', 'th_TH'),
('unique_license_plate', 'th_TH'),
('license_plate', 'tr_TR'),
('unique_license_plate', 'tr_TR'),
('bank_country', NULL),
('unique_bank_country', NULL),
('bban', NULL),
('unique_bban', NULL),
('iban', NULL),
('unique_iban', NULL),
('swift8', NULL),
('unique_swift8', NULL),
('swift11', NULL),
('unique_swift11', NULL),
('swift', NULL),
('unique_swift', NULL),
('bban', 'en_PH'),
('unique_bban', 'en_PH'),
('iban', 'en_PH'),
('unique_iban', 'en_PH'),
('bic', 'ru_RU'),
('unique_bic', 'ru_RU'),
('correspondent_account', 'ru_RU'),
('unique_correspondent_account', 'ru_RU'),
('checking_account', 'ru_RU'),
('unique_checking_account', 'ru_RU'),
('bank', 'ru_RU'),
('unique_bank', 'ru_RU'),
('ean', NULL),
('unique_ean', NULL),
('ean8', NULL),
('unique_ean8', NULL),
('ean13', NULL),
('unique_ean13', NULL),
('localized_ean', NULL),
('unique_localized_ean', NULL),
('localized_ean8', NULL),
('unique_localized_ean8', NULL),
('localized_ean13', NULL),
('unique_localized_ean13', NULL),
('ean13', 'en_US'),
('unique_ean13', 'en_US'),
('upc_a', 'en_US'),
('unique_upc_a', 'en_US'),
('upc_e', 'en_US'),
('unique_upc_e', 'en_US'),
('jan', 'ja_JP'),
('unique_jan', 'ja_JP'),
('jan8', 'ja_JP'),
('unique_jan8', 'ja_JP'),
('jan13', 'ja_JP'),
('unique_jan13', 'ja_JP'),
('color_name', NULL),
('unique_color_name', NULL),
('safe_color_name', NULL),
('unique_safe_color_name', NULL),
('hex_color', NULL),
('unique_hex_color', NULL),
('safe_hex_color', NULL),
('unique_safe_hex_color', NULL),
('rgb_color', NULL),
('unique_rgb_color', NULL),
('rgb_css_color', NULL),
('unique_rgb_css_color', NULL),
('color', NULL),
('unique_color', NULL),
('company', NULL),
('unique_company', NULL),
('company_suffix', NULL),
('unique_company_suffix', NULL),
('catch_phrase', NULL),
('unique_catch_phrase', NULL),
('bs', NULL),
('unique_bs', NULL),
('company_type', 'en_PH'),
('unique_company_type', 'en_PH'),
('random_company_adjective', 'en_PH'),
('unique_random_company_adjective', 'en_PH'),
('random_company_noun_chain', 'en_PH'),
('unique_random_company_noun_chain', 'en_PH'),
('random_company_product', 'en_PH'),
('unique_random_company_product', 'en_PH'),
('random_company_acronym', 'en_PH'),
('unique_random_company_acronym', 'en_PH'),
('company_prefix', 'es_MX'),
('unique_company_prefix', 'es_MX'),
('catch_phrase', 'es_MX'),
('unique_catch_phrase', 'es_MX'),
('bs', 'es_MX'),
('unique_bs', 'es_MX'),
('company', 'fa_IR'),
('unique_company', 'fa_IR'),
('company_business_id', 'fi_FI'),
('unique_company_business_id', 'fi_FI'),
('company_vat', 'fi_FI'),
('unique_company_vat', 'fi_FI'),
('random_noun_ish_good_trait', 'fil_PH'),
('unique_random_noun_ish_good_trait', 'fil_PH'),
('random_good_service_adjective', 'fil_PH'),
('unique_random_good_service_adjective', 'fil_PH'),
('random_good_service_adjective_chain', 'fil_PH'),
('unique_random_good_service_adjective_chain', 'fil_PH'),
('random_object_of_concern', 'fil_PH'),
('unique_random_object_of_concern', 'fil_PH'),
('english_catch_phrase', 'fil_PH'),
('unique_english_catch_phrase', 'fil_PH'),
('catch_phrase', 'fil_PH'),
('unique_catch_phrase', 'fil_PH'),
('ide', 'fr_CH'),
('unique_ide', 'fr_CH'),
('uid', 'fr_CH'),
('unique_uid', 'fr_CH'),
('idi', 'fr_CH'),
('unique_idi', 'fr_CH'),
('catch_phrase_noun', 'fr_FR'),
('unique_catch_phrase_noun', 'fr_FR'),
('catch_phrase_attribute', 'fr_FR'),
('unique_catch_phrase_attribute', 'fr_FR'),
('catch_phrase_verb', 'fr_FR'),
('unique_catch_phrase_verb', 'fr_FR'),
('catch_phrase', 'fr_FR'),
('unique_catch_phrase', 'fr_FR'),
('siren', 'fr_FR'),
('unique_siren', 'fr_FR'),
('siret', 'fr_FR'),
('unique_siret', 'fr_FR'),
('company_suffix', 'hu_HU'),
('unique_company_suffix', 'hu_HU'),
('company_prefix', 'id_ID'),
('unique_company_prefix', 'id_ID'),
('catch_phrase', 'it_IT'),
('unique_catch_phrase', 'it_IT'),
('bs', 'it_IT'),
('unique_bs', 'it_IT'),
('company_vat', 'it_IT'),
('unique_company_vat', 'it_IT'),
('company_prefix', 'ja_JP'),
('unique_company_prefix', 'ja_JP'),
('company_category', 'ja_JP'),
('unique_company_category', 'ja_JP'),
('catch_phrase', 'ko_KR'),
('unique_catch_phrase', 'ko_KR'),
('bs', 'ko_KR'),
('unique_bs', 'ko_KR'),
('large_company', 'nl_NL'),
('unique_large_company', 'nl_NL'),
('company_prefix', 'nl_NL'),
('unique_company_prefix', 'nl_NL'),
('company_prefix', 'pl_PL'),
('unique_company_prefix', 'pl_PL'),
('regon', 'pl_PL'),
('unique_regon', 'pl_PL'),
('local_regon', 'pl_PL'),
('unique_local_regon', 'pl_PL'),
('company_vat', 'pl_PL'),
('unique_company_vat', 'pl_PL'),
('catch_phrase_noun', 'pt_BR'),
('unique_catch_phrase_noun', 'pt_BR'),
('catch_phrase_attribute', 'pt_BR'),
('unique_catch_phrase_attribute', 'pt_BR'),
('catch_phrase_verb', 'pt_BR'),
('unique_catch_phrase_verb', 'pt_BR'),
('catch_phrase', 'pt_BR'),
('unique_catch_phrase', 'pt_BR'),
('company_id', 'pt_BR'),
('unique_company_id', 'pt_BR'),
('cnpj', 'pt_BR'),
('unique_cnpj', 'pt_BR'),
('catch_phrase', 'ru_RU'),
('unique_catch_phrase', 'ru_RU'),
('large_company', 'ru_RU'),
('unique_large_company', 'ru_RU'),
('company_prefix', 'ru_RU'),
('unique_company_prefix', 'ru_RU'),
('businesses_inn', 'ru_RU'),
('unique_businesses_inn', 'ru_RU'),
('individuals_inn', 'ru_RU'),
('unique_individuals_inn', 'ru_RU'),
('businesses_ogrn', 'ru_RU'),
('unique_businesses_ogrn', 'ru_RU'),
('individuals_ogrn', 'ru_RU'),
('unique_individuals_ogrn', 'ru_RU'),
('kpp', 'ru_RU'),
('unique_kpp', 'ru_RU'),
('company_prefix', 'th_TH'),
('unique_company_prefix', 'th_TH'),
('company_limited_prefix', 'th_TH'),
('unique_company_limited_prefix', 'th_TH'),
('company_limited_suffix', 'th_TH'),
('unique_company_limited_suffix', 'th_TH'),
('nonprofit_prefix', 'th_TH'),
('unique_nonprofit_prefix', 'th_TH'),
('large_company', 'tr_TR'),
('unique_large_company', 'tr_TR'),
('company_prefix', 'zh_CN'),
('unique_company_prefix', 'zh_CN'),
('company_prefix', 'zh_TW'),
('unique_company_prefix', 'zh_TW'),
('credit_card_provider', NULL),
('unique_credit_card_provider', NULL),
('credit_card_number', NULL),
('unique_credit_card_number', NULL),
('credit_card_expire', NULL),
('unique_credit_card_expire', NULL),
('credit_card_full', NULL),
('unique_credit_card_full', NULL),
('credit_card_security_code', NULL),
('unique_credit_card_security_code', NULL),
('credit_card_expire', 'fa_IR'),
('unique_credit_card_expire', 'fa_IR'),
('credit_card_expire', 'pt_PT'),
('unique_credit_card_expire', 'pt_PT'),
('credit_card_expire', 'ru_RU'),
('unique_credit_card_expire', 'ru_RU'),
('credit_card_full', 'ru_RU'),
('unique_credit_card_full', 'ru_RU'),
('currency', NULL),
('unique_currency', NULL),
('currency_code', NULL),
('unique_currency_code', NULL),
('currency_name', NULL),
('unique_currency_name', NULL),
('currency_symbol', NULL),
('unique_currency_symbol', NULL),
('cryptocurrency', NULL),
('unique_cryptocurrency', NULL),
('cryptocurrency_code', NULL),
('unique_cryptocurrency_code', NULL),
('cryptocurrency_name', NULL),
('unique_cryptocurrency_name', NULL),
('pricetag', NULL),
('unique_pricetag', NULL),
('pricetag', 'cs_CZ'),
('unique_pricetag', 'cs_CZ'),
('pricetag', 'de_AT'),
('unique_pricetag', 'de_AT'),
('pricetag', 'de_DE'),
('unique_pricetag', 'de_DE'),
('pricetag', 'en_AU'),
('unique_pricetag', 'en_AU'),
('pricetag', 'en_CA'),
('unique_pricetag', 'en_CA'),
('pricetag', 'en_US'),
('unique_pricetag', 'en_US'),
('pricetag', 'es_ES'),
('unique_pricetag', 'es_ES'),
('pricetag', 'fr_CA'),
('unique_pricetag', 'fr_CA'),
('pricetag', 'fr_FR'),
('unique_pricetag', 'fr_FR'),
('pricetag', 'it_IT'),
('unique_pricetag', 'it_IT'),
('pricetag', 'pl_PL'),
('unique_pricetag', 'pl_PL'),
('pricetag', 'ru_RU'),
('unique_pricetag', 'ru_RU'),
('pricetag', 'sk_SK'),
('unique_pricetag', 'sk_SK'),
('unix_time', NULL),
('unique_unix_time', NULL),
('time_delta', NULL),
('unique_time_delta', NULL),
('date_time', NULL),
('unique_date_time', NULL),
('date_time_ad', NULL),
('unique_date_time_ad', NULL),
('iso8601', NULL),
('unique_iso8601', NULL),
('date', NULL),
('unique_date', NULL),
('date_object', NULL),
('unique_date_object', NULL),
('time_object', NULL),
('unique_time_object', NULL),
('date_time_between', NULL),
('unique_date_time_between', NULL),
('date_between', NULL),
('unique_date_between', NULL),
('future_datetime', NULL),
('unique_future_datetime', NULL),
('future_date', NULL),
('unique_future_date', NULL),
('past_datetime', NULL),
('unique_past_datetime', NULL),
('past_date', NULL),
('unique_past_date', NULL),
('date_time_between_dates', NULL),
('unique_date_time_between_dates', NULL),
('date_between_dates', NULL),
('unique_date_between_dates', NULL),
('date_time_this_century', NULL),
('unique_date_time_this_century', NULL),
('date_time_this_decade', NULL),
('unique_date_time_this_decade', NULL),
('date_time_this_year', NULL),
('unique_date_time_this_year', NULL),
('date_time_this_month', NULL),
('unique_date_time_this_month', NULL),
('date_this_century', NULL),
('unique_date_this_century', NULL),
('date_this_decade', NULL),
('unique_date_this_decade', NULL),
('date_this_year', NULL),
('unique_date_this_year', NULL),
('date_this_month', NULL),
('unique_date_this_month', NULL),
('time_series', NULL),
('unique_time_series', NULL),
('am_pm', NULL),
('unique_am_pm', NULL),
('day_of_month', NULL),
('unique_day_of_month', NULL),
('day_of_week', NULL),
('unique_day_of_week', NULL),
('month', NULL),
('unique_month', NULL),
('month_name', NULL),
('unique_month_name', NULL),
('year', NULL),
('unique_year', NULL),
('century', NULL),
('unique_century', NULL),
('timezone', NULL),
('unique_timezone', NULL),
('pytimezone', NULL),
('unique_pytimezone', NULL),
('date_of_birth', NULL),
('unique_date_of_birth', NULL),
('month_name', 'ar_AA'),
('unique_month_name', 'ar_AA'),
('am_pm', 'ar_AA'),
('unique_am_pm', 'ar_AA'),
('day_of_week', 'ar_AA'),
('unique_day_of_week', 'ar_AA'),
('day_of_week', 'cs_CZ'),
('unique_day_of_week', 'cs_CZ'),
('month_name', 'cs_CZ'),
('unique_month_name', 'cs_CZ'),
('day_of_week', 'de_AT'),
('unique_day_of_week', 'de_AT'),
('month_name', 'de_AT'),
('unique_month_name', 'de_AT'),
('day_of_week', 'de_DE'),
('unique_day_of_week', 'de_DE'),
('month_name', 'de_DE'),
('unique_month_name', 'de_DE'),
('day_of_week', 'es_ES'),
('unique_day_of_week', 'es_ES'),
('month_name', 'es_ES'),
('unique_month_name', 'es_ES'),
('day_of_week', 'fil_PH'),
('unique_day_of_week', 'fil_PH'),
('month_name', 'fil_PH'),
('unique_month_name', 'fil_PH'),
('day_of_week', 'fr_FR'),
('unique_day_of_week', 'fr_FR'),
('month_name', 'fr_FR'),
('unique_month_name', 'fr_FR'),
('day_of_week', 'hi_IN'),
('unique_day_of_week', 'hi_IN'),
('month_name', 'hi_IN'),
('unique_month_name', 'hi_IN'),
('day_of_week', 'hr_HR'),
('unique_day_of_week', 'hr_HR'),
('month_name', 'hr_HR'),
('unique_month_name', 'hr_HR'),
('day_of_week', 'hu_HU'),
('unique_day_of_week', 'hu_HU'),
('month_name', 'hu_HU'),
('unique_month_name', 'hu_HU'),
('day_of_week', 'hy_AM'),
('unique_day_of_week', 'hy_AM'),
('month_name', 'hy_AM'),
('unique_month_name', 'hy_AM'),
('day_of_week', 'id_ID'),
('unique_day_of_week', 'id_ID'),
('month_name', 'id_ID'),
('unique_month_name', 'id_ID'),
('day_of_week', 'it_IT'),
('unique_day_of_week', 'it_IT'),
('month_name', 'it_IT'),
('unique_month_name', 'it_IT'),
('day_of_week', 'ko_KR'),
('unique_day_of_week', 'ko_KR'),
('month_name', 'ko_KR'),
('unique_month_name', 'ko_KR'),
('day_of_week', 'pl_PL'),
('unique_day_of_week', 'pl_PL'),
('month_name', 'pl_PL'),
('unique_month_name', 'pl_PL'),
('day_of_week', 'pt_PT'),
('unique_day_of_week', 'pt_PT'),
('month_name', 'pt_PT'),
('unique_month_name', 'pt_PT'),
('day_of_week', 'ru_RU'),
('unique_day_of_week', 'ru_RU'),
('month_name', 'ru_RU'),
('unique_month_name', 'ru_RU'),
('day_of_week', 'sk_SK'),
('unique_day_of_week', 'sk_SK'),
('month_name', 'sk_SK'),
('unique_month_name', 'sk_SK'),
('day_of_week', 'sl_SI'),
('unique_day_of_week', 'sl_SI'),
('month_name', 'sl_SI'),
('unique_month_name', 'sl_SI'),
('day_of_week', 'ta_IN'),
('unique_day_of_week', 'ta_IN'),
('month_name', 'ta_IN'),
('unique_month_name', 'ta_IN'),
('date', 'th_TH'),
('unique_date', 'th_TH'),
('century', 'th_TH'),
('unique_century', 'th_TH'),
('day_of_week', 'tr_TR'),
('unique_day_of_week', 'tr_TR'),
('month_name', 'tr_TR'),
('unique_month_name', 'tr_TR'),
('mime_type', NULL),
('unique_mime_type', NULL),
('file_name', NULL),
('unique_file_name', NULL),
('file_extension', NULL),
('unique_file_extension', NULL),
('file_path', NULL),
('unique_file_path', NULL),
('unix_device', NULL),
('unique_unix_device', NULL),
('unix_partition', NULL),
('unique_unix_partition', NULL),
('coordinate', NULL),
('unique_coordinate', NULL),
('latitude', NULL),
('unique_latitude', NULL),
('longitude', NULL),
('unique_longitude', NULL),
('latlng', NULL),
('unique_latlng', NULL),
('local_latlng', NULL),
('unique_local_latlng', NULL),
('location_on_land', NULL),
('unique_location_on_land', NULL),
('local_latitude', 'de_AT'),
('unique_local_latitude', 'de_AT'),
('local_longitude', 'de_AT'),
('unique_local_longitude', 'de_AT'),
('local_latlng', 'el_GR'),
('unique_local_latlng', 'el_GR'),
('local_latitude', 'el_GR'),
('unique_local_latitude', 'el_GR'),
('local_longitude', 'el_GR'),
('unique_local_longitude', 'el_GR'),
('nationality', 'pt_PT'),
('unique_nationality', 'pt_PT'),
('email', NULL),
('unique_email', NULL),
('safe_domain_name', NULL),
('unique_safe_domain_name', NULL),
('safe_email', NULL),
('unique_safe_email', NULL),
('free_email', NULL),
('unique_free_email', NULL),
('company_email', NULL),
('unique_company_email', NULL),
('free_email_domain', NULL),
('unique_free_email_domain', NULL),
('ascii_email', NULL),
('unique_ascii_email', NULL),
('ascii_safe_email', NULL),
('unique_ascii_safe_email', NULL),
('ascii_free_email', NULL),
('unique_ascii_free_email', NULL),
('ascii_company_email', NULL),
('unique_ascii_company_email', NULL),
('user_name', NULL),
('unique_user_name', NULL),
('hostname', NULL),
('unique_hostname', NULL),
('domain_name', NULL),
('unique_domain_name', NULL),
('domain_word', NULL),
('unique_domain_word', NULL),
('dga', NULL),
('unique_dga', NULL),
('tld', NULL),
('unique_tld', NULL),
('http_method', NULL),
('unique_http_method', NULL),
('url', NULL),
('unique_url', NULL),
('ipv4_network_class', NULL),
('unique_ipv4_network_class', NULL),
('ipv4', NULL),
('unique_ipv4', NULL),
('ipv4_private', NULL),
('unique_ipv4_private', NULL),
('ipv4_public', NULL),
('unique_ipv4_public', NULL),
('ipv6', NULL),
('unique_ipv6', NULL),
('mac_address', NULL),
('unique_mac_address', NULL),
('port_number', NULL),
('unique_port_number', NULL),
('uri_page', NULL),
('unique_uri_page', NULL),
('uri_path', NULL),
('unique_uri_path', NULL),
('uri_extension', NULL),
('unique_uri_extension', NULL),
('uri', NULL),
('unique_uri', NULL),
('slug', NULL),
('unique_slug', NULL),
('image_url', NULL),
('unique_image_url', NULL),
('user_name', 'el_GR'),
('unique_user_name', 'el_GR'),
('domain_word', 'el_GR'),
('unique_domain_word', 'el_GR'),
('domain_word', 'en_PH'),
('unique_domain_word', 'en_PH'),
('domain_word', 'ja_JP'),
('unique_domain_word', 'ja_JP'),
('domain_word', 'zh_CN'),
('unique_domain_word', 'zh_CN'),
('domain_name', 'zh_CN'),
('unique_domain_name', 'zh_CN'),
('domain_word', 'zh_TW'),
('unique_domain_word', 'zh_TW'),
('isbn13', NULL),
('unique_isbn13', NULL),
('isbn10', NULL),
('unique_isbn10', NULL),
('job', NULL),
('unique_job', NULL),
('job', 'hu_HU'),
('unique_job', 'hu_HU'),
('job', 'sk_SK'),
('unique_job', 'sk_SK'),
('words', NULL),
('unique_words', NULL),
('word', NULL),
('unique_word', NULL),
('sentence', NULL),
('unique_sentence', NULL),
('sentences', NULL),
('unique_sentences', NULL),
('paragraph', NULL),
('unique_paragraph', NULL),
('paragraphs', NULL),
('unique_paragraphs', NULL),
('text', NULL),
('unique_text', NULL),
('texts', NULL),
('unique_texts', NULL),
('english_word', 'en_PH'),
('unique_english_word', 'en_PH'),
('english_words', 'en_PH'),
('unique_english_words', 'en_PH'),
('english_sentence', 'en_PH'),
('unique_english_sentence', 'en_PH'),
('english_sentences', 'en_PH'),
('unique_english_sentences', 'en_PH'),
('english_paragraph', 'en_PH'),
('unique_english_paragraph', 'en_PH'),
('english_paragraphs', 'en_PH'),
('unique_english_paragraphs', 'en_PH'),
('english_text', 'en_PH'),
('unique_english_text', 'en_PH'),
('english_texts', 'en_PH'),
('unique_english_texts', 'en_PH'),
('null_boolean', NULL),
('unique_null_boolean', NULL),
('binary', NULL),
('unique_binary', NULL),
('md5', NULL),
('unique_md5', NULL),
('sha1', NULL),
('unique_sha1', NULL),
('sha256', NULL),
('unique_sha256', NULL),
('password', NULL),
('unique_password', NULL),
('zip', NULL),
('unique_zip', NULL),
('tar', NULL),
('unique_tar', NULL),
('json', NULL),
('unique_json', NULL),
('fixed_width', NULL),
('unique_fixed_width', NULL),
('gemstone_name', 'en_PH'),
('unique_gemstone_name', 'en_PH'),
('mountain_name', 'en_PH'),
('unique_mountain_name', 'en_PH'),
('plant_name', 'en_PH'),
('unique_plant_name', 'en_PH'),
('space_object_name', 'en_PH'),
('unique_space_object_name', 'en_PH'),
('random_object_name', 'en_PH'),
('unique_random_object_name', 'en_PH'),
('name', NULL),
('unique_name', NULL),
('first_name', NULL),
('unique_first_name', NULL),
('last_name', NULL),
('unique_last_name', NULL),
('name_male', NULL),
('unique_name_male', NULL),
('name_nonbinary', NULL),
('unique_name_nonbinary', NULL),
('name_female', NULL),
('unique_name_female', NULL),
('first_name_male', NULL),
('unique_first_name_male', NULL),
('first_name_nonbinary', NULL),
('unique_first_name_nonbinary', NULL),
('first_name_female', NULL),
('unique_first_name_female', NULL),
('last_name_male', NULL),
('unique_last_name_male', NULL),
('last_name_nonbinary', NULL),
('unique_last_name_nonbinary', NULL),
('last_name_female', NULL),
('unique_last_name_female', NULL),
('prefix', NULL),
('unique_prefix', NULL),
('prefix_male', NULL),
('unique_prefix_male', NULL),
('prefix_nonbinary', NULL),
('unique_prefix_nonbinary', NULL),
('prefix_female', NULL),
('unique_prefix_female', NULL),
('suffix', NULL),
('unique_suffix', NULL),
('suffix_male', NULL),
('unique_suffix_male', NULL),
('suffix_nonbinary', NULL),
('unique_suffix_nonbinary', NULL),
('suffix_female', NULL),
('unique_suffix_female', NULL),
('language_name', NULL),
('unique_language_name', NULL),
('first_name_male_est', 'et_EE'),
('unique_first_name_male_est', 'et_EE'),
('first_name_female_est', 'et_EE'),
('unique_first_name_female_est', 'et_EE'),
('first_name_male_rus', 'et_EE'),
('unique_first_name_male_rus', 'et_EE'),
('first_name_female_rus', 'et_EE'),
('unique_first_name_female_rus', 'et_EE'),
('first_name_est', 'et_EE'),
('unique_first_name_est', 'et_EE'),
('first_name_rus', 'et_EE'),
('unique_first_name_rus', 'et_EE'),
('last_name_est', 'et_EE'),
('unique_last_name_est', 'et_EE'),
('last_name_rus', 'et_EE'),
('unique_last_name_rus', 'et_EE'),
('suffix', 'fa_IR'),
('unique_suffix', 'fa_IR'),
('first_name_male_abbreviated', 'hu_HU'),
('unique_first_name_male_abbreviated', 'hu_HU'),
('first_name_female_abbreviated', 'hu_HU'),
('unique_first_name_female_abbreviated', 'hu_HU'),
('first_name_pair', 'ja_JP'),
('unique_first_name_pair', 'ja_JP'),
('first_name_male_pair', 'ja_JP'),
('unique_first_name_male_pair', 'ja_JP'),
('first_name_female_pair', 'ja_JP'),
('unique_first_name_female_pair', 'ja_JP'),
('last_name_pair', 'ja_JP'),
('unique_last_name_pair', 'ja_JP'),
('first_name', 'ja_JP'),
('unique_first_name', 'ja_JP'),
('first_name_male', 'ja_JP'),
('unique_first_name_male', 'ja_JP'),
('first_name_female', 'ja_JP'),
('unique_first_name_female', 'ja_JP'),
('last_name', 'ja_JP'),
('unique_last_name', 'ja_JP'),
('first_kana_name', 'ja_JP'),
('unique_first_kana_name', 'ja_JP'),
('first_kana_name_male', 'ja_JP'),
('unique_first_kana_name_male', 'ja_JP'),
('first_kana_name_female', 'ja_JP'),
('unique_first_kana_name_female', 'ja_JP'),
('last_kana_name', 'ja_JP'),
('unique_last_kana_name', 'ja_JP'),
('first_romanized_name', 'ja_JP'),
('unique_first_romanized_name', 'ja_JP'),
('first_romanized_name_male', 'ja_JP'),
('unique_first_romanized_name_male', 'ja_JP'),
('first_romanized_name_female', 'ja_JP'),
('unique_first_romanized_name_female', 'ja_JP'),
('last_romanized_name', 'ja_JP'),
('unique_last_romanized_name', 'ja_JP'),
('kana_name', 'ja_JP'),
('unique_kana_name', 'ja_JP'),
('kana_name_male', 'ja_JP'),
('unique_kana_name_male', 'ja_JP'),
('kana_name_female', 'ja_JP'),
('unique_kana_name_female', 'ja_JP'),
('romanized_name', 'ja_JP'),
('unique_romanized_name', 'ja_JP'),
('romanized_name_male', 'ja_JP'),
('unique_romanized_name_male', 'ja_JP'),
('romanized_name_female', 'ja_JP'),
('unique_romanized_name_female', 'ja_JP'),
('first_name_unisex', 'or_IN'),
('unique_first_name_unisex', 'or_IN'),
('middle_name', 'or_IN'),
('unique_middle_name', 'or_IN'),
('last_name', 'pl_PL'),
('unique_last_name', 'pl_PL'),
('identity_card_number', 'pl_PL'),
('unique_identity_card_number', 'pl_PL'),
('pesel_compute_check_digit', 'pl_PL'),
('unique_pesel_compute_check_digit', 'pl_PL'),
('pesel', 'pl_PL'),
('unique_pesel', 'pl_PL'),
('pwz_doctor_compute_check_digit', 'pl_PL'),
('unique_pwz_doctor_compute_check_digit', 'pl_PL'),
('pwz_doctor', 'pl_PL'),
('unique_pwz_doctor', 'pl_PL'),
('pwz_nurse', 'pl_PL'),
('unique_pwz_nurse', 'pl_PL'),
('nip', 'pl_PL'),
('unique_nip', 'pl_PL'),
('prefix', 'pt_PT'),
('unique_prefix', 'pt_PT'),
('middle_name', 'ru_RU'),
('unique_middle_name', 'ru_RU'),
('middle_name_male', 'ru_RU'),
('unique_middle_name_male', 'ru_RU'),
('middle_name_female', 'ru_RU'),
('unique_middle_name_female', 'ru_RU'),
('romanized_name', 'zh_CN'),
('unique_romanized_name', 'zh_CN'),
('first_romanized_name', 'zh_CN'),
('unique_first_romanized_name', 'zh_CN'),
('last_romanized_name', 'zh_CN'),
('unique_last_romanized_name', 'zh_CN'),
('romanized_name', 'zh_TW'),
('unique_romanized_name', 'zh_TW'),
('first_romanized_name', 'zh_TW'),
('unique_first_romanized_name', 'zh_TW'),
('last_romanized_name', 'zh_TW'),
('unique_last_romanized_name', 'zh_TW'),
('phone_number', NULL),
('unique_phone_number', NULL),
('country_calling_code', NULL),
('unique_country_calling_code', NULL),
('msisdn', NULL),
('unique_msisdn', NULL),
('operator_id', 'ar_JO'),
('unique_operator_id', 'ar_JO'),
('area_code', 'ar_JO'),
('unique_area_code', 'ar_JO'),
('cellphone_number', 'ar_JO'),
('unique_cellphone_number', 'ar_JO'),
('telephone_number', 'ar_JO'),
('unique_telephone_number', 'ar_JO'),
('service_phone_number', 'ar_JO'),
('unique_service_phone_number', 'ar_JO'),
('phone_number', 'ar_JO'),
('unique_phone_number', 'ar_JO'),
('provider_code', 'ar_PS'),
('unique_provider_code', 'ar_PS'),
('area_code', 'ar_PS'),
('unique_area_code', 'ar_PS'),
('cellphone_number', 'ar_PS'),
('unique_cellphone_number', 'ar_PS'),
('telephone_number', 'ar_PS'),
('unique_telephone_number', 'ar_PS'),
('service_phone_number', 'ar_PS'),
('unique_service_phone_number', 'ar_PS'),
('toll_number', 'ar_PS'),
('unique_toll_number', 'ar_PS'),
('phone_number', 'ar_PS'),
('unique_phone_number', 'ar_PS'),
('area_code', 'en_AU'),
('unique_area_code', 'en_AU'),
('phone_number', 'en_AU'),
('unique_phone_number', 'en_AU'),
('cellphone_number', 'en_GB'),
('unique_cellphone_number', 'en_GB'),
('area_code', 'en_NZ'),
('unique_area_code', 'en_NZ'),
('phone_number', 'en_NZ'),
('unique_phone_number', 'en_NZ'),
('globe_mobile_number_prefix', 'en_PH'),
('unique_globe_mobile_number_prefix', 'en_PH'),
('smart_mobile_number_prefix', 'en_PH'),
('unique_smart_mobile_number_prefix', 'en_PH'),
('sun_mobile_number_prefix', 'en_PH'),
('unique_sun_mobile_number_prefix', 'en_PH'),
('bayantel_landline_identifier', 'en_PH'),
('unique_bayantel_landline_identifier', 'en_PH'),
('misc_landline_identifier', 'en_PH'),
('unique_misc_landline_identifier', 'en_PH'),
('non_area2_landline_area_code', 'en_PH'),
('unique_non_area2_landline_area_code', 'en_PH'),
('globe_mobile_number', 'en_PH'),
('unique_globe_mobile_number', 'en_PH'),
('smart_mobile_number', 'en_PH'),
('unique_smart_mobile_number', 'en_PH'),
('sun_mobile_number', 'en_PH'),
('unique_sun_mobile_number', 'en_PH'),
('mobile_number', 'en_PH'),
('unique_mobile_number', 'en_PH'),
('globe_area2_landline_number', 'en_PH'),
('unique_globe_area2_landline_number', 'en_PH'),
('pldt_area2_landline_number', 'en_PH'),
('unique_pldt_area2_landline_number', 'en_PH'),
('bayantel_area2_landline_number', 'en_PH'),
('unique_bayantel_area2_landline_number', 'en_PH'),
('misc_area2_landline_number', 'en_PH'),
('unique_misc_area2_landline_number', 'en_PH'),
('area2_landline_number', 'en_PH'),
('unique_area2_landline_number', 'en_PH'),
('non_area2_landline_number', 'en_PH'),
('unique_non_area2_landline_number', 'en_PH'),
('landline_number', 'en_PH'),
('unique_landline_number', 'en_PH'),
('cellphone_number', 'pt_BR'),
('unique_cellphone_number', 'pt_BR'),
('phonenumber_prefix', 'zh_CN'),
('unique_phonenumber_prefix', 'zh_CN'),
('simple_profile', NULL),
('unique_simple_profile', NULL),
('profile', NULL),
('unique_profile', NULL),
('pybool', NULL),
('unique_pybool', NULL),
('pystr', NULL),
('unique_pystr', NULL),
('pystr_format', NULL),
('unique_pystr_format', NULL),
('pyfloat', NULL),
('unique_pyfloat', NULL),
('pyint', NULL),
('unique_pyint', NULL),
('pydecimal', NULL),
('unique_pydecimal', NULL),
('pytuple', NULL),
('unique_pytuple', NULL),
('pyset', NULL),
('unique_pyset', NULL),
('pylist', NULL),
('unique_pylist', NULL),
('pyiterable', NULL),
('unique_pyiterable', NULL),
('pydict', NULL),
('unique_pydict', NULL),
('pystruct', NULL),
('unique_pystruct', NULL),
('ssn', NULL),
('unique_ssn', NULL),
('vat_id', 'bg_BG'),
('unique_vat_id', 'bg_BG'),
('vat_id', 'cs_CZ'),
('unique_vat_id', 'cs_CZ'),
('birth_number', 'cs_CZ'),
('unique_birth_number', 'cs_CZ'),
('vat_id', 'de_AT'),
('unique_vat_id', 'de_AT'),
('vat_id', 'de_DE'),
('unique_vat_id', 'de_DE'),
('vat_id', 'dk_DK'),
('unique_vat_id', 'dk_DK'),
('vat_id', 'el_CY'),
('unique_vat_id', 'el_CY'),
('vat_id', 'el_GR'),
('unique_vat_id', 'el_GR'),
('police_id', 'el_GR'),
('unique_police_id', 'el_GR'),
('ssn', 'en_CA'),
('unique_ssn', 'en_CA'),
('ssn', 'en_GB'),
('unique_ssn', 'en_GB'),
('vat_id', 'en_GB'),
('unique_vat_id', 'en_GB'),
('vat_id', 'en_IE'),
('unique_vat_id', 'en_IE'),
('aadhaar_id', 'en_IN'),
('unique_aadhaar_id', 'en_IN'),
('sss', 'en_PH'),
('unique_sss', 'en_PH'),
('gsis', 'en_PH'),
('unique_gsis', 'en_PH'),
('pagibig', 'en_PH'),
('unique_pagibig', 'en_PH'),
('philhealth', 'en_PH'),
('unique_philhealth', 'en_PH'),
('umid', 'en_PH'),
('unique_umid', 'en_PH'),
('ssn', 'en_PH'),
('unique_ssn', 'en_PH'),
('itin', 'en_US'),
('unique_itin', 'en_US'),
('ein', 'en_US'),
('unique_ein', 'en_US'),
('invalid_ssn', 'en_US'),
('unique_invalid_ssn', 'en_US'),
('ssn', 'en_US'),
('unique_ssn', 'en_US'),
('vat_id', 'es_ES'),
('unique_vat_id', 'es_ES'),
('nie', 'es_ES'),
('unique_nie', 'es_ES'),
('nif', 'es_ES'),
('unique_nif', 'es_ES'),
('cif', 'es_ES'),
('unique_cif', 'es_ES'),
('doi', 'es_ES'),
('unique_doi', 'es_ES'),
('ssn', 'es_MX'),
('unique_ssn', 'es_MX'),
('curp', 'es_MX'),
('unique_curp', 'es_MX'),
('rfc', 'es_MX'),
('unique_rfc', 'es_MX'),
('ssn', 'et_EE'),
('unique_ssn', 'et_EE'),
('vat_id', 'et_EE'),
('unique_vat_id', 'et_EE'),
('ssn', 'fi_FI'),
('unique_ssn', 'fi_FI'),
('vat_id', 'fi_FI'),
('unique_vat_id', 'fi_FI'),
('ssn', 'fr_CH'),
('unique_ssn', 'fr_CH'),
('vat_id', 'fr_CH'),
('unique_vat_id', 'fr_CH'),
('vat_id', 'fr_FR'),
('unique_vat_id', 'fr_FR'),
('ssn', 'he_IL'),
('unique_ssn', 'he_IL'),
('ssn', 'hr_HR'),
('unique_ssn', 'hr_HR'),
('vat_id', 'hr_HR'),
('unique_vat_id', 'hr_HR'),
('ssn', 'hu_HU'),
('unique_ssn', 'hu_HU'),
('vat_id', 'hu_HU'),
('unique_vat_id', 'hu_HU'),
('ssn', 'it_IT'),
('unique_ssn', 'it_IT'),
('vat_id', 'it_IT'),
('unique_vat_id', 'it_IT'),
('vat_id', 'lb_LU'),
('unique_vat_id', 'lb_LU'),
('vat_id', 'lt_LT'),
('unique_vat_id', 'lt_LT'),
('vat_id', 'lv_LV'),
('unique_vat_id', 'lv_LV'),
('vat_id', 'mt_MT'),
('unique_vat_id', 'mt_MT'),
('ssn', 'nl_BE'),
('unique_ssn', 'nl_BE'),
('vat_id', 'nl_BE'),
('unique_vat_id', 'nl_BE'),
('ssn', 'nl_NL'),
('unique_ssn', 'nl_NL'),
('vat_id', 'nl_NL'),
('unique_vat_id', 'nl_NL'),
('ssn', 'no_NO'),
('unique_ssn', 'no_NO'),
('ssn', 'pl_PL'),
('unique_ssn', 'pl_PL'),
('vat_id', 'pl_PL'),
('unique_vat_id', 'pl_PL'),
('ssn', 'pt_BR'),
('unique_ssn', 'pt_BR'),
('cpf', 'pt_BR'),
('unique_cpf', 'pt_BR'),
('rg', 'pt_BR'),
('unique_rg', 'pt_BR'),
('vat_id', 'pt_PT'),
('unique_vat_id', 'pt_PT'),
('vat_id', 'ro_RO'),
('unique_vat_id', 'ro_RO'),
('vat_id', 'sk_SK'),
('unique_vat_id', 'sk_SK'),
('birth_number', 'sk_SK'),
('unique_birth_number', 'sk_SK'),
('vat_id', 'sl_SI'),
('unique_vat_id', 'sl_SI'),
('ssn', 'sv_SE'),
('unique_ssn', 'sv_SE'),
('org_id', 'sv_SE'),
('unique_org_id', 'sv_SE'),
('vat_id', 'sv_SE'),
('unique_vat_id', 'sv_SE'),
('org_and_vat_id', 'sv_SE'),
('unique_org_and_vat_id', 'sv_SE'),
('ssn', 'th_TH'),
('unique_ssn', 'th_TH'),
('vat_id', 'th_TH'),
('unique_vat_id', 'th_TH'),
('ssn', 'tr_TR'),
('unique_ssn', 'tr_TR'),
('ssn', 'uk_UA'),
('unique_ssn', 'uk_UA'),
('ssn', 'zh_CN'),
('unique_ssn', 'zh_CN'),
('ssn', 'zh_TW'),
('unique_ssn', 'zh_TW'),
('mac_processor', NULL),
('unique_mac_processor', NULL),
('linux_processor', NULL),
('unique_linux_processor', NULL),
('user_agent', NULL),
('unique_user_agent', NULL),
('chrome', NULL),
('unique_chrome', NULL),
('firefox', NULL),
('unique_firefox', NULL),
('safari', NULL),
('unique_safari', NULL),
('opera', NULL),
('unique_opera', NULL),
('internet_explorer', NULL),
('unique_internet_explorer', NULL),
('windows_platform_token', NULL),
('unique_windows_platform_token', NULL),
('linux_platform_token', NULL),
('unique_linux_platform_token', NULL),
('mac_platform_token', NULL),
('unique_mac_platform_token', NULL),
('android_platform_token', NULL),
('unique_android_platform_token', NULL),
('ios_platform_token', NULL),
('unique_ios_platform_token', NULL),
('unique_clear',NULL),
('_functions',NULL)
) AS t (name,locale);
$$
  LANGUAGE SQL
  IMMUTABLE
  SECURITY INVOKER
  PARALLEL SAFE
;
