Could it be acceptable to cache a clear case of the database connection on application start?

Searching in the MSDN documentation on thread safety, I quote:

Any public static [...] people of the type are thread safe. Any instance people aren't certain to be thread safe.

Considering that, could it be acceptable/safe for code similar to this example below:

public static class BookingMapper
{
  public static Database Db { get; set; }

  static BookingMapper()
  {
    Db = DatabaseFactory.CreateDatabase();
  }

  public static string GetBooking(int id)
  {
    using (DbCommand cmd = Db.GetStoredProcCommand("getBooking"))
    {
      Db.AddInParameter(cmd, "@Id", DbType.Int32, id);
      using (IDataReader dr = Db.ExecuteReader(cmd))
      {
        ...
      }
    }
  }
}

If it's acceptable, do you know the benefits/disadvantages of utilizing this kind of approach over simply instantiating the Database on each and every method call?

Thanks ahead of time.

Update:

Further studies have pointed me to some PrimaryObjects.com article which, within the Putting the Database Factory to Use section indicates this is appropriate. But I am still wondering if you will find pros/cons to doing the work by doing this?

Similar question

1) You will find two methods to interpret that standard phrase on Thread Safety from MSDN, and If only they'd clarify it. Your interpretation could be nice, however i think that what it really means is the fact that:

Any people (techniques, fields, qualities, etc) that are members of this kind, which are public and static, are thread safe

(e.g. you will find two methods to interpret the subphrase "people of the type")

2) Generally, you won't want to share a db connection around - you need to open an association, do your work, and close it. You cannot have multiple open visitors connected having a single connection (this really is generic db/connection advice, not ing library specific).

3) On some additional reading through within the ing library, the Database object came back through the CreateDatabase call is not an association itself, also it appears like the bond management is handled when i mentioned in point 2. Therefore it appears like the Database object itself could be securely shared around.