Overviews of SQL Joins (with LaTeX code)

Here’s a short overview of SQL joins, find the source code of the document attached to the PDF (use Adobe Reader to access it).

SQL Joins

\documentclass[12pt]{article}
\usepackage{xcolor}
\usepackage{arev}
\usepackage{attachfile}
 
 
\usepackage{tikz}
\usetikzlibrary{shapes,snakes}
\def\firstcircle{(0,0) circle (2cm)}
\def\secondcircle{(0:3cm) circle (2cm)}
 
\colorlet{circle edge}{blue!50}
\colorlet{circle area}{blue!20}
\colorlet{white area}{white}
 
\tikzset{
filled/.style={fill=circle area, draw=circle edge, thick},
outline/.style={draw=circle edge, thick},
white/.style={fill=white area, draw=circle edge, very thick}
}
 
\begin{document}
 
\textattachfile{\jobname.tex}{\LaTeX~Code}
 
\section{Inner Join}
 
Inner joins return those records, that are present in table 1 and table 2.
 
\begin{center}
\begin{tikzpicture}[scale=1, every node/.style={scale=1}] % Inner Join
    \begin{scope}
        \clip \firstcircle;
        \fill[filled] \secondcircle;
    \end{scope}
    \draw[outline] \firstcircle node {A};
    \draw[outline] \secondcircle node {B};
\end{tikzpicture}
\end{center}
 
\section{Left Join}
 
Every record from table 1 is returned, regardless if it has a matching record in table 2. If the record has a matching record in table 2 this record from table 2 is returned as well.
 
\begin{center}
\begin{tikzpicture}[scale=1, every node/.style={scale=1}] % Left Join
    \begin{scope}
        \clip \firstcircle;
        \draw[filled] \firstcircle node {A}
                                     \secondcircle;
    \end{scope}
    \draw[outline] \firstcircle
                   \secondcircle node {B};
\end{tikzpicture}
\end{center}
 
\clearpage
 
\section{Left Outer Join}
 
Those records from table 1 are returned, that do not have a match in table 2.
 
\begin{center}
\begin{tikzpicture}[scale=1, every node/.style={scale=1}] % Left Outer Join
    \draw[filled] \firstcircle node {A};
    \draw[white] \secondcircle node {B};
    \draw[outline] \firstcircle node {A};
\end{tikzpicture}
\end{center}
 
\section{Right Join}
 
Every record from table 2 is returned, regardless if it has a matching record in table 1. If the record has a matching record in table 1 this record from table 1 is returned as well.
 
\begin{center}
\begin{tikzpicture}[scale=1, every node/.style={scale=1}] % Right Join
    \begin{scope}
        \clip \secondcircle;
        \draw[filled] \firstcircle \secondcircle node {B};
    \end{scope}
    \draw[outline] \firstcircle node {A} \secondcircle;
\end{tikzpicture}
 
\end{center}
 
\clearpage
 
\section{Right Outer Join}
 
Those records from table 2 are returned, that do not have a match in table 1.
 
\begin{center}
\begin{tikzpicture}[scale=1, every node/.style={scale=1}] % Right Join 2
    \draw[filled]   \secondcircle node {B};
    \draw[white]  \firstcircle node {A};
    \draw[outline] \secondcircle node {B};
\end{tikzpicture}
\end{center}
 
 
 
\section{Theta Join}
 
Every row from dataset 1 is multiplied by every row of dataset 2. Usually a mistake unless you really want this Cartesian product.
 
\begin{center}
\begin{tikzpicture}[scale=1, every node/.style={scale=1}] % Theta
    \draw[filled] \firstcircle node {A} \secondcircle node {B};
\end{tikzpicture}
\end{center}
 
\clearpage
 
\section{Full Outer}
 
Returns all records from table 1 and table 2 regardless if they have matches in the other table. Records, that do match, are linked together via key. 
 
\begin{center}
\begin{tikzpicture}[scale=1, every node/.style={scale=1}] % Full Outer
    \draw[filled] \firstcircle node {A};
    \draw[filled] \secondcircle node {B};
    \begin{scope}
        \clip \firstcircle;
         \fill[white] \secondcircle;
        \draw[outline] \secondcircle;  
        \draw[outline] \firstcircle;  
    \end{scope}
\end{tikzpicture}
\end{center}
 
\end{document}

Beamer-Vorlage für (MINT)-Vorlesungen

Ich habe heute die erste Version einer Beamer-Vorlage für Vorlesungen auf github hochgeladen. Ziel war es, sowohl einzelne Module (Vorlesungen) als auch den kompletten Foliensatz erzeugen zu können. Die Vorlage eignet sich nicht nur für MINT-Veranstaltungen, mein Fokus lag aber auf dem sauberen Einbinden von Quellcodes, was bei geisteswissenschaftlichen Vorlesungen vielleicht nicht der Hauptfokus ist.

Die Dateien finden sich unter https://github.com/UweZiegenhagen/MINT-Lecture-Slide-Template

Pull Requests, Kommentare und Vorschläge werden gern gesehen.

Als nächstes baue ich noch Beispiele für die von mir definierten Befehle ein, die ein vereinfachtes Einbetten von Grafiken und Quellcodes erlauben.

Raspi 4, Libreelec und das Argon One Gehäuse

Für einen meiner Raspberry Pi 4, den ich vor allem als Mediacenter mit Kodi nutzen möchte, habe ich mir ein Argon One Gehäuse bestellt.

Die Installation des Pi im Gehäuse war leicht, die Passform ist gut. Die Installation der Software war aber ein wenig hakelig, daher möchte ich sie hier kurz beschreiben.

Für die folgenden Dinge aktiviert man in Libreelec den SSH-Zugang, mittels User „root“ und Passwort „libreelec“ kommt man dann z.B. via Putty auf den Pi. Da man als root unterwegs ist, entfallen sudo Befehle.

Als erstes installiert man folgende Addons aus dem Libreelec Repo: „Raspberry Pi Tools“ und „System Tools“

Die Argon-Software für Libreelec erhält und führt man aus mittels

curl https://download.argon40.com/argonone-setup-libreelec.sh | bash

Das normale Skript für Raspian (https://download.argon40.com/argon1.sh) funktioniert hier m.E. nicht, es muss die Version für Libreelec sein.

Das Skript für die Konfiguration kann man dann mittels ./argonone-config ausführen. Standardmäßig ist der Lüfter so eingestellt, dass er bei 90° C auf 100% springt. Möchte man das anpassen, kann man mittels nano argononed.conf die Konfiguration anpassen.

LibreELEC:~ # nano argononed.conf
#
# Argon One Fan Speed Configuration
#
# Min Temp=Fan Speed

45=25
65=50
90=100

Mittels reboot oder systemctl restart argononed.service kann man den Dienst (neu) starten.
Die aktuelle Temperatur erhält man übrigens mittels vcgencmd measure_temp.

SQL: Nur den aktuellsten Eintrag aus einer gejointen Tabelle laden

Ich habe seit ein paar Monaten wieder verstärkt Gelegenheit, meine rostigen SQL-Kenntnisse aufzufrischen. Kürzlich bin ich dabei an einer kleinen Herausforderung vorbeigekommen, die mich doch ein paar Minuten mehr beschäftigt hat. Gegeben sind zwei Tabellen, Namen und Adressen.

Namen

ID Name
1 Anna Amsel
2 Bernd Borstel
3 Cesar Causel
4 Dagmal Dack

Adressen

ID NameID Adresse
1 1 Amselweg 2
2 2 Badgasse 34
3 3 Chausseeweg 123
4 3 Dorfstraße 34
5 1 Alabasterpfad 32

ID ist jeweils der Primary Key, NameID der Fremdschlüssel von Adressen auf Namen. Ziel der Übung ist es, alle Namen mit der (sofern vorhanden) aktuellsten Adresse abzufragen.

Ein inner join bringt ganz klar das falsche Ergebnis, denn Dagmar Dack fehlt in der Ergebnismenge, Anna und Cesar sind zweimal vertreten.

SELECT n.Name, a.Adresse FROM Namen n JOIN Adressen a ON n.ID = a.NameID ;

Ein left join muss her, was das Ergebnis aber nur ein wenig besser macht: Dagmar ist jetzt drin, Anna und Cesar aber immer noch doppelt:

SELECT n.Name, a.Adresse FROM Namen n JOIN Adressen a ON n.ID = a.NameID ;

Beholfen habe ich mir dann mit einem Subselect:

SELECT n.Name, a.Adresse FROM Namen n
LEFT JOIN (SELECT MAX(ID) ID, MIN(NameID) NameID, MIN(Adresse) Adresse FROM Adressen GROUP BY NameID) a
ON n.ID = a.NameID

Ergebnis

Name Adresse
Anna Amsel Alabasterpfad 32
Bernd Borstel Badgasse 34
Cesar Causel Chausseeweg 123
Dagmal Dack NULL

Aufgabenlisten mit dem tasks Paket setzen

Heute mal ein Beispiel, wie man mit dem tasks Paket Aufgabenlisten setzen kann. Im nächsten Schritt werde ich dann die Listen per Export aus Trello befüllen.

\documentclass[12pt,ngerman]{scrartcl}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{babel}
\usepackage{tasks}
\usepackage{fontawesome}
 
\NewTasksEnvironment[label=\faHandORight,label-width=15pt]{todo}[*](1)
\NewTasksEnvironment[label=\faHandRockO,label-width=15pt]{progress}[*](1)
\NewTasksEnvironment[label=\faThumbsOUp,label-width=15pt]{done}[*](1)
 
\begin{document}
 
\section*{TODO}
 
\begin{todo}
* Blumen gießen
* Einkaufen gehen
* Zeitschriften sortieren
\end{todo}
 
\section*{PROGRESSING}
 
\begin{progress}
* Keller aufräumen
* Bücher sortieren
* Rechner neu installieren
\end{progress}
 
\section*{DONE}
 
\begin{done}
* Steuererklärung
* Server neu installieren
* SSH-Zugang einrichten
\end{done}
 
\end{document}

Monatskalender für LaTeX mit Python erzeugen

Hier ein Beispiel, wie man mit Python kleine Monatskalender erzeugen kann. Geht auch mit LaTeX allein, ich möchte aber verschiedene Output-Formate (Markdown, HTML, etc.) erzeugen und dabei die komplette Kontrolle über den Code behalten.

# -*- coding: utf-8 -*-
 
import calendar
import datetime
 
def number_of_weeks(year, month):
    """
        Returns a tupel with the ISO no of the first and week and the no of weeks
    """
    tup_month_days = calendar.monthrange(year, month)
    first = datetime.date(year, month, 1)
    last = datetime.date(year, month, tup_month_days[1])
    first_week = first.isocalendar()[1]
    last_week = last.isocalendar()[1]
    return (first_week, last_week, last_week-first_week+1)
 
def gen_cal_latex(year, month):
    """
        https://stackoverflow.com/questions/9459337/assign-value-to-an-individual-cell-in-a-two-dimensional-python-array
    """
    c = calendar.TextCalendar()
    week_month_first, week_month_last, no_of_weeks = number_of_weeks(year, month)
 
    # generate calendar list, using tupel as a key    
    m = {(i, j):' ' for i in range(no_of_weeks) for j in range(7)}
 
    for tupel_date in c.itermonthdays4(year, month):
        t_year, t_month, t_day, t_weekday = tupel_date
        # use only dates inside the required month
        if t_month == month:
            temp_date = datetime.date(t_year, t_month, t_day)
            # check in which week we are with the current date
            # to get index for the list
            week_no = temp_date.isocalendar()[1]
            m[week_no % week_month_first, t_weekday] = t_day
 
    print(r'\begin{tabular}{rrrrrrr}')
    print(r'Mo & Di & Mi & Do & Fr & Sa & So \\')
    for i in m:
        if i[1] < 6:
            print('{0} &'.format(m[i]), end='')
        else:
            print('{0}'.format(m[i]),end='')
        if i[1] == 6:
            print(r'\\')
    print(r'\end{tabular}')
 
gen_cal_latex(2020, 4)

Erzeugt werden kleine Monatskalender der Form

\begin{tabular}{rrrrrrr}
Mo & Di & Mi & Do & Fr & Sa & So \\
  &  &1 &2 &3 &4 &5\\
6 &7 &8 &9 &10 &11 &12\\
13 &14 &15 &16 &17 &18 &19\\
20 &21 &22 &23 &24 &25 &26\\
27 &28 &29 &30 &  &  & \\
\end{tabular}

Per Copy & Paste kann man den Code in ein LaTeX-Dokument kopieren, natürlich lässt sich das alles auch direkt in eine LaTeX-Datei schreiben.

Ein Xerox 860 System sucht ein neues Zuhause

Aus dem Nachlass eines Nachbarn habe ich gestern ein Xerox 860 System bekommen.

Wer es nicht kennt (so wie ich bis gestern noch):

Bevor PCs und Macs den Markt aufrollten, gab es auch Systeme für die Verarbeitung von Texten, die sich durch hohe Kosten und (aus heutiger Sicht) ungewöhnliche Maße auszeichnen.

Das Xerox 860 war so etwas wie der Rolls-Royce unter diesen Systemen. 128 KByte (!) RAM, keine Festplatte, zwei 8″ Diskettenlaufwerke in einem 80 Kilo Block, dazu ein fast 30 Kilo schwerer Drucker und ein Schwarz-Weiss-Monitor.

Es gibt sogar einen Basic-Interpreter dafür, das System ist wohl CP/M kompatibel.

Da die Maschine nicht wirklich wohnzimmer-tauglich ist, suche ich ein Plätzchen in einem Museum oder einer privaten Sammlung dafür. Ich möchte kein Geld dafür haben, die Maschine muss nur in Köln abgeholt werden.

UPDATE 17.05.2020

Die Xerox hat, zusammen mit einer SUN, einer VAX und weiteren Stücken, ihren Weg in das Technikmuseum Matthias Schmitt (www.tecmumas.de) angetreten.

Trello-Boards exportieren mit py-trello

Hier etwas Beispiel-Code, um Trello-Boards zu exportieren. Unten im Code nur nach stdout, Code für LaTeX und HTML/MD werde ich im Github Repository https://github.com/UweZiegenhagen/python-trello-output ergänzen.

from trello import TrelloClient # pip install py-trello
 
client = TrelloClient(
    api_key='<secret_api_key>',
    token='<secret_token>'
)
 
def list_all_boards(client):
    """
        get list of all boards to determine the ID
        for further functions
    """
    all_boards = client.list_boards()
    for counter, board in enumerate(all_boards):
        print(counter, board.name)
 
## uncomment if needed
# list_all_boards(client)
 
def print_cards_from_board(board_id, client):
    """
        Access board with ID board_id in the client instance
        and print all non-archived lists with their non-archived cards 
    """
    all_boards = client.list_boards()
    my_board = all_boards[board_id] # 15 = my someday projects
    all_lists_on_board = my_board.list_lists()
 
    for list in all_lists_on_board:
        if not list.closed:
            for card in list.list_cards():
                if not card.closed:
                    print(list.name, ':' , card.name)
 
print_cards_from_board(15, client)

TeX-Dokumentstrukturen visualisieren mit Graphviz und Python

Hier ein Code-Schnipsel, um die Inputs und Includes von LaTeX-Dokumenten zu visualisieren. Ist noch ein wenig rudimentär und hardcoded, in den nächsten Tagen werde ich den Code mal in ein Github-Repo packen und dann ein wenig aufräumen. Aktuell wird eine Datei Master.tex erwartet, eine Graph.dot Datei wird als Output geschrieben. Das Skript geht rekursiv durch die TeX-Dateien durch und sucht nach \input, \include, \includegraphics und \lstinputlisting Befehlen.

# -*- coding: utf-8 -*-
import re
 
nodes = []
 
# which commands indicate following
commandsToFollow = ('input', 'include')
 
def find_ext_references(somefile):
    with open(somefile) as file:
        filecontent = file.readlines()
        for i in filecontent:
            search_results = re.findall(r"(\\)(includegraphics|include|lstinputlisting|input)(\[?.*\]?{)(.+?)(})", i)
            for j in search_results:
                print(j)
                nodes.append((somefile, j[3], j[1]))
                if j[1].endswith(commandsToFollow):
                    find_ext_references(j[3]+'.tex') # assume that no extension is used for input/include
 
find_ext_references('Master.tex')
 
print(nodes)
 
if len(nodes)>0:
    with open('graph.dot','w') as output:
            output.write('digraph IncludesInputs {\n')
            output.write('node [shape=box];\n\n')
            for k in nodes:
                if k[2].endswith(commandsToFollow):
                    output.write('"'+k[0] + '"->"' + k[1] + '.tex" [color="green"];\n')
                elif k[2].endswith('graphics'):
                    output.write('"'+k[0] + '"->"' + k[1] + '" [color="blue"];\n')         
                elif k[2].endswith('listing'):
                    output.write('"'+k[0] + '"->"' + k[1] + '" [color="red"];\n')                             
 
            output.write('}')

Übersetzt man die Graph.dot dann mit der dot.exe aus Graphviz, so erhält man für ein kleines Beispiel den folgenden Graphen. (Beispielaufruf: dot -Tpng Graph.dot)

Git / Github Cheat Sheet

Da ich sie immer wieder vergesse, hier die (für mich) wichtigsten git Befehle.

Befehl Erläuterung
git config –global user.name „Max Mustermann“ Setze Usernamen
git config –global user.email „Max@Mustermann.de“ Setze User E-Mail-Adresse
git clone „githublink“ clone ein Repo von Github
git status Status des Repositories
git add „Datei“ Füge Datei zur Staging-Umgebung hinzu, git add . für alle Dateien im aktuellen Verzeichnis
git reset HEAD „Datei“ unstage Datei
git commit -m „Kommentar“ commit in das lokale Repository
git push origin master pushe Änderungen zurück nach github
git mv „datei1“ „datei2“ benennt Datei um
git rm „datei1“ löscht Datei
git init „Projektname“ legt lokal ein neues Repository an
git ls-files zeigt alle Dateien im Repo rekursiv