Single DB connection during class's lifetime. Metaclass, singleton and __new__() examples and references.

[Thomas Jollans]

On 12/10/2018 01:19, Ryan Johnson wrote:
> I am working on using mysql.connector in a class and have found an example of how to create a single connection that spans the lifetime of all instances of the class:
> 
> https://softwareengineering.stackexchange.com/a/358061/317228
> 
> however, I do not understand a few things about the class, including
> 
> 1. Why it is subclassed as an object: `class Postgres(object):` ? I thought classes were necessarily objects.

This was sometimes necessary in Python 2.

> 2. Why is this portion of code directly addressing the class, instead of using the `cls` reference variable?
> connection = Postgres._instance.connection = psycopg2.connect(**db_config)
> cursor = Postgres._instance.cursor = connection.cursor()

In a subclass, the `cls' argument would refer to the subclass, while 
`Postgres' would still refer to the original class. I have no idea what 
this is trying to achieve, and I think it's probably a bug. Maybe 
someone else has an idea.

> 3. And is it me or does anyone else think {anydb}.connector’s usage is messy and inelegant? Ex:
> print('connecting to PostgreSQL database...')
> connection = Postgres._instance.connection = psycopg2.connect(**db_config)
> cursor = Postgres._instance.cursor = connection.cursor()
> cursor.execute('SELECT VERSION()')
> db_version = cursor.fetchone()
> 	Why can’t we associate the focus of the connection with the connection itself, instead of creating a separate cursor object?

You can have multiple cursors on the same connection.

> 
> Also, within the code example, and in Python in general, why does there needs to be a __new__ constructor when there’s an __init__ constructor? I’ve read about the usage of singletons. It seems you could create singletons within  __init__ or __new__ . Any enlightenment would be really helpful. I am very sleep-deprived, so I’m sorry if this seems like a dumb question.
> 
> I have read the official docs. Have also been reading “Python 3: Patterns, Recipes, and Idioms”. The first was mildly helpful but I still don’t see the benefit of a __new__ constructor.

You can't create a singleton with __init__: by the time __init__ is 
called, a new instance has already been created, and you can't switch 
the object for a different one. By using __new__, you can bypass the 
creation of a new instance.

If what you want is some shared state between all instances, a class 
variable or global will do just fine and there's no need for a singleton 
instance of anything.

> Why is there dislike for Metaclasses?

They can be confusing.