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




-- Pr