python - with - sqlalchemy pandas




SQLAlchemy: mecanismo, conexão e diferença de sessão (2)

Eu uso o SQLAlchemy e há pelo menos três entidades: engine , session e connection , que possuem o método execute , então se eu, por exemplo, quiser selecionar todos os registros da table eu posso fazer isso

engine.execute(select([table])).fetchall()

e isto

connection.execute(select([table])).fetchall()

e até mesmo isso

session.execute(select([table])).fetchall()

- os resultados serão os mesmos.

Pelo que entendi, se alguém usa engine.execute ele cria connection , abre session (Alchemy cuida disso para você) e executa a consulta. Mas existe uma diferença global entre essas três maneiras de realizar tal tarefa?


Aqui está um exemplo de execução de DCL (Data Control Language), como GRANT

def grantAccess(db, tb, user):
  import sqlalchemy as SA
  import psycopg2

  url = "{d}+{driver}://{u}:{p}@{h}:{port}/{db}".\
            format(d="redshift",
            driver='psycopg2',
            u=username,
            p=password,
            h=host,
            port=port,
            db=db)
  engine = SA.create_engine(url)
  cnn = engine.connect()
  trans = cnn.begin()
  strSQL = "GRANT SELECT on table " + tb + " to " + user + " ;"
  try:
      cnn.execute(strSQL)
      trans.commit()
  except:
      trans.rollback()
      raise

A resposta de Nabeel abrange muitos detalhes e é útil, mas achei confuso seguir. Como esse é atualmente o primeiro resultado do Google para esse problema, adicione meu entendimento sobre isso para futuras pessoas que encontrarem essa pergunta:

Executando .execute ()

Como OP e Nabell Ahmed observam, ao executar um nome de tabela SELECT * FROM tablename , não há diferença no resultado fornecido.

As diferenças entre esses três objetos se tornam importantes dependendo do contexto em que a SELECT é usada ou, mais comumente, quando você deseja fazer outras coisas como INSERT , DELETE , etc.

Quando usar o mecanismo, conexão, sessão geralmente

  • Mecanismo é o objeto de nível mais baixo usado pelo SQLAlchemy. Ele mantém um pool de conexões disponíveis para uso sempre que o aplicativo precisar conversar com o banco de dados. .execute() é um método de conveniência que primeiro chama conn = engine.connect(close_with_result=True) e, em seguida, conn.execute() . O parâmetro close_with_result significa que a conexão é fechada automaticamente. (Eu estou parafraseando um pouco o código-fonte, mas essencialmente verdade). edit: Aqui está o código-fonte para engine.execute

    Você pode usar o mecanismo para executar o SQL bruto.

    result = engine.execute('SELECT * FROM tablename;')
    #what engine.execute() is doing under the hood
    conn = engine.connect(close_with_result=True)
    result = conn.execute('SELECT * FROM tablename;')
    
    #after you iterate over the results, the result and connection get closed
    for row in result:
        print(result['columnname']
    
    #or you can explicitly close the result, which also closes the connection
    result.close()

    Isso é coberto nos documentos sob uso básico .

  • Connection é (como vimos acima) o que realmente faz o trabalho de executar uma consulta SQL. Você deve fazer isso sempre que desejar maior controle sobre os atributos da conexão, quando ela for fechada, etc. Por exemplo, um exemplo muito importante disso é uma Transaction , que permite decidir quando confirmar suas alterações no banco de dados. No uso normal, as alterações são automaticamente confirmadas. Com o uso de transações, você poderia (por exemplo) executar várias instruções SQL diferentes e, se algo der errado com uma delas, você poderia desfazer todas as alterações de uma só vez.

    connection = engine.connect()
    trans = connection.begin()
    try:
        connection.execute("INSERT INTO films VALUES ('Comedy', '82 minutes');")
        connection.execute("INSERT INTO datalog VALUES ('added a comedy');")
        trans.commit()
    except:
        trans.rollback()
        raise

    Isso permitiria que você desfizesse ambas as alterações se uma falha, como se você tivesse esquecido de criar a tabela de registro de dados.

    Então, se você está executando código SQL bruto e precisa de controle, use conexões

  • Sessões são usadas para o aspecto Object Management Relationship (ORM) do SQLAlchemy (na verdade, você pode ver isso como elas são importadas: from sqlalchemy.orm import sessionmaker ). Eles usam conexões e transações sob o controle para executar suas instruções SQL geradas automaticamente. .execute() é uma função de conveniência que passa para o que a sessão está ligada (geralmente um mecanismo, mas pode ser uma conexão).

    Se você estiver usando a funcionalidade ORM, use session; Se você está apenas fazendo consultas SQL diretas não vinculadas a objetos, provavelmente é melhor usar as conexões diretamente.





psycopg2