SELECT Funktion

Installation und Anwendung von Datenbankschnittstellen wie SQLite, PostgreSQL, MySQL, der DB-API 2.0 und sonstigen Datenbanksystemen.
BlackJack

Re: SELECT Funktion

Beitragvon BlackJack » Donnerstag 22. Juni 2017, 13:06

@Bindl: Ich würde ja gerne noch was zu der Funktion im ersten Beitrag sagen. Als erstes: Die Namen sind so alle schlecht gewählt, bis auf `row`, wobei das an zwei Stellen der passende Name ist, und an zwei anderen Stellen der falsche Name ist. Denn der Name wird manchmal an *eine* Datenbankzeile gebunden, und manchmal an *mehrere* Datenbankzeilen.

`selection()` beschreibt keine Tätigkeit und damit auch nicht was die Funktion macht.

`all` ist der Name einer (nützlichen) eingebauten Funktion. Den sollte man nicht an etwas anderes binden. Das führt zu Irritationen beim Leser. Das Argument ist ein Flag, da sollte man also nicht `None` und *irgendwas anderes* übergeben, sondern `True` und `False`.

Schliessen von Ressourcen würde ich mit ``with`` und `contextlib.closing()` erledigen (sofern das Objekt selbst kein Kontextmanager ist). Wenn man das mit dem Cursor macht, dann wird man den `row`-Namen los, weil man einfach direkt ``return`` verwenden kann.

Die beiden Zweige von dem ``if``/``else`` enden mit genau dem gleichen Code. Der sollte da also nicht zweimal stehen, sondern einmal hinter dem ``if``/``else``.

Mit vernünftigeren Namen und ``with`` könnte das dann so aussehen:
  1. def select(
  2.     result_column_name,
  3.     table_name,
  4.     column_name_1,
  5.     column_name_2,
  6.     value_1,
  7.     value_2,
  8.     fetch_all,
  9. ):
  10.     with closing(g.connection.cursor()) as cursor:
  11.         if value_2 is None:
  12.             cursor.execute(
  13.                 'SELECT %s FROM %s WHERE %s = %s',
  14.                 (result_column_name, table_name, column_name_1, value_1,)
  15.             )
  16.         else:
  17.             cursor.execute(
  18.                 'SELECT %s FROM %s WHERE %s = %s AND %s = %s',
  19.                 (
  20.                     result_column_name,
  21.                     table_name,
  22.                     column_name_1,
  23.                     value_1,
  24.                     column_name_2,
  25.                     value_2,
  26.                 )
  27.             )
  28.         return cursor.fetchall() if fetch_all else cursor.fetchone()


So wirklich wesentlich unterscheiden sich die beiden Zweige in der Funktion ja nicht und nummerierte Namen sind in der Regel auch keine gute Wahl. Sie deuten oft darauf hin, dass man keine einzelnen Namen und Werte, sondern eigentlich eine Datenstruktur verwenden sollte. Oft eine Liste. Und auch das wäre hier sinnvoll: Eine Liste mit Paaren von Spaltennamen und Werten aus denen dann die Anfrage aufgebaut wird (ungetestet):
  1. def select(result_column_name, table_name, names_and_values, fetch_all):
  2.     sql = 'SELECT %s FROM %s'
  3.  
  4.     query_values = list()
  5.     for item in names_and_values:
  6.         query_values.extend(item)
  7.  
  8.     if query_values:
  9.         sql += ' WHERE ' + ' AND '.join(['%s = %s'] * len(names_and_values))
  10.  
  11.     with closing(g.connection.cursor()) as cursor:
  12.         cursor.execute(sql, query_values)
  13.         return cursor.fetchall() if fetch_all else cursor.fetchone()


Ein Aufruf würde dann so aussehen:
  1.     row = select(
  2.         'user_hashed_password',
  3.         'user',
  4.         [('user_name', request.form['logname'])],
  5.         False
  6.     )

Und man kann dann nicht nur ein oder zwei Kriterien übegerben, sondern 0 bis beliebig viele.

Achtung: Die Funktion hat natürlich immer noch das Problem mit den SQL-Namen und -Werten von der Ausgangsfunktion!

Was immer noch unpraktisch ist (neben der Tatsache das die Funktion nicht funktioniert ;-)) ist die unterschiedliche Struktur des Rückgabewerts in Abhängigkeit des letzten Arguments. Für solche APIs werden Dich andere Programmierer irgendwann anfangen zu hassen. Und da man selbst der ”andere Programmierer” ist, wenn man den Code eine Weile nicht angefasst hat, kann man das auch nicht mit „ist ja nur für mich“ abtun. Man könnte leicht zwei Funktionen schreiben und den gemeinsamen Teil in eine nicht-öffentliche Funktion auslagern:
  1. def _select(result_column_name, table_name, names_and_values, method_name):
  2.     sql = 'SELECT %s FROM %s'
  3.  
  4.     query_values = list()
  5.     for item in names_and_values:
  6.         query_values.extend(item)
  7.  
  8.     if query_values:
  9.         sql += ' WHERE ' + ' AND '.join(['%s = %s'] * len(names_and_values))
  10.  
  11.     with closing(g.connection.cursor()) as cursor:
  12.         cursor.execute(sql, query_values)
  13.         return getattr(cursor, method_name)()
  14.  
  15.  
  16. def select_one(result_column_name, table_name, names_and_values):
  17.     return _select(result_column_name, table_name, names_and_values, 'fetchone')
  18.  
  19.  
  20. def select_all(result_column_name, table_name, names_and_values):
  21.     return _select(result_column_name, table_name, names_and_values, 'fetchall')


Um noch mal auf SQLAlchemy zurück zu kommen: Das Datei hochladen in einem anderen Thema von Dir könnte man statt so:
  1.             cursor = g.connection.cursor()
  2.             cursor.execute(
  3.                 'INSERT INTO file (file_file, file_name, file_author,'
  4.                 ' file_upload, file_type, data_size)'
  5.                 ' VALUES (%s, %s, %s, NOW(), %s, %s)',
  6.                 (
  7.                     data,
  8.                     filename,
  9.                     session['username'],
  10.                     os.path.splitext(filename)[1],
  11.                     len(data),
  12.                 )
  13.             )
  14.             g.connection.commit()
  15.             cursor.close()


dann so schreiben:
  1.             g.session.add(
  2.                 File(
  3.                     content=data,
  4.                     name=filename,
  5.                     author=session['username'],
  6.                     type=os.path.splitext(filename)[1],
  7.                     size=len(data),
  8.                 )
  9.             )
  10.             g.session.commit()


Alle PDF-Dateien eines Benutzer abzufragen, ginge beispielsweise so:
  1.     pdf_files = (
  2.         g.session.query(File)
  3.             .filter(File.user_name == User.name, File.type == 'pdf')
  4.             .order_by(File.name)
  5.             .all()
  6.     )


An alle Dateien eines Benutzers kommt man, wenn man die Fremdschlüsselbeziehungen definiert hat, über das Benutzerobjekt ganz einfach so:
  1.     files = user.files


Und man kann den Datenmodell-Objekten natürlich auch Methoden verpassen, damit man die Abfragen nicht überall im Code verteilt. Beispielsweise eine Methode die von einem Benutzer alle Dateien eines bestimmten Typs abfragen kann:
  1. class User(Base):
  2.     # ...
  3.  
  4.     def get_files(self, file_type=None):
  5.         query = self.files_query  # <- Bei Fremdschlüsselbeziehung definiert.
  6.         if file_type is not None:
  7.             query = query.filter(File.type == file_type)
  8.         return query.all()


Damit kann man dann woanders im Code einfach das hier schreiben wenn man ein Benutzer-Objekt hat:
  1.     pdf_files = user.get_files('pdf')

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder