docs: def getOpenIDStore(filestore_path, table_prefix):
      """
      Returns an OpenID association store object based on the database
      engine chosen for this Django application.
  
      * If no database engine is chosen, a filesystem-based store will
        be used whose path is filestore_path.
  
      * If a database engine is chosen, a store object for that database
        type will be returned.
  
      * If the chosen engine is not supported by the OpenID library,
        raise ImproperlyConfigured.
  
      * If a database store is used, this will create the tables
        necessary to use it.  The table names will be prefixed with
        table_prefix.  DO NOT use the same table prefix for both an
        OpenID consumer and an OpenID server in the same database.
  
      The result of this function should be passed to the Consumer
      constructor as the store parameter.
      """
      if not settings.DATABASES.get('default', {'ENGINE':None}).get('ENGINE'):
          return FileOpenIDStore(filestore_path)
  
      # Possible side-effect: create a database connection if one isn't
      # already open.
      connection.cursor()
  
      # Create table names to specify for SQL-backed stores.
      tablenames = {
          'associations_table': table_prefix + 'openid_associations',
          'nonces_table': table_prefix + 'openid_nonces',
          }
  
      types = {
          'django.db.backends.postgresql': sqlstore.PostgreSQLStore,
          'django.db.backends.mysql': sqlstore.MySQLStore,
          'django.db.backends.sqlite3': sqlstore.SQLiteStore,
          }
  
      try:
          s = types[settings.DATABASES.get('default', {'ENGINE':None}).get('ENGINE')](connection.connection,
                                              **tablenames)
      except KeyError:
          raise ImproperlyConfigured, \
                "Database engine %s not supported by OpenID library" % \
                (settings.DATABASES.get('default', {'ENGINE':None}).get('ENGINE'),)
  
      try:
          s.createTables()
      except (SystemExit, KeyboardInterrupt, MemoryError), e:
          raise
      except:
          # XXX This is not the Right Way to do this, but because the
          # underlying database implementation might differ in behavior
          # at this point, we can't reliably catch the right
          # exception(s) here.  Ideally, the SQL store in the OpenID
          # library would catch exceptions that it expects and fail
          # silently, but that could be bad, too.  More ideally, the SQL
          # store would not attempt to create tables it knows already
          # exists.
          pass
  
      return s