Updates

Author: eoinkelly

.gitignore

@@ -2,6 +2,7 @@
 *.class
 .vagrant/
 
+/dist/
 # haskell compile artefacts
 *.o
 *.hi

Rakefile

@@ -0,0 +1,31 @@
+require 'rake'
+require 'pry'
+
+markdowns = Rake::FileList.new('**/*.md') do |fl|
+  fl.exclude do |f|
+    `git ls-files #{f}`.empty?
+  end
+end
+
+# all foo/bar/blah.md becomes foo/bar/blah.html
+htmls = markdowns.ext('html').pathmap('dist/%p')
+
+task default: :html
+
+task html: htmls
+
+# tell rake to create the dist dir if it does not exist
+# also creates a "directory task"
+directory 'dist'
+
+# tell rake how to convert a markdown file to html
+rule '.html' => ['.md', 'dist'] do |t| # t is instance of Rake::Task
+  # puts "mkdir -p #{t.name.pathmap('%d')}"
+  # puts "pandoc -o #{t.name} #{t.source}"
+  mkdir_p t.name.pathmap('%d')
+  sh "pandoc -o dist/#{t.name} #{t.source}"
+end
+
+task :clean do
+  rm_rf 'dist'
+end

c/enums.c

@@ -0,0 +1,20 @@
+
+enum printFormat
+{
+	PRINT_NOTHING = 0,			/* to make sure someone initializes this */
+	PRINT_UNALIGNED,
+	PRINT_ALIGNED,
+	PRINT_WRAPPED,
+	PRINT_HTML,
+	PRINT_ASCIIDOC,
+	PRINT_LATEX,
+	PRINT_LATEX_LONGTABLE,
+	PRINT_TROFF_MS
+	/* add your favourite output format here ... */
+};
+
+int
+main()
+{
+  return PRINT_UNALIGNED;
+}

c/enums.s

@@ -0,0 +1,23 @@
+	.section	__TEXT,__text,regular,pure_instructions
+	.macosx_version_min 10, 11
+	.globl	_main
+	.align	4, 0x90
+_main:                                  ## @main
+	.cfi_startproc
+## BB#0:
+	pushq	%rbp
+Ltmp0:
+	.cfi_def_cfa_offset 16
+Ltmp1:
+	.cfi_offset %rbp, -16
+	movq	%rsp, %rbp
+Ltmp2:
+	.cfi_def_cfa_register %rbp
+	movl	$3, %eax
+	movl	$0, -4(%rbp)
+	popq	%rbp
+	retq
+	.cfi_endproc
+
+
+.subsections_via_symbols

databases/book-learning-sql.md

@@ -24,7 +24,7 @@
     * a "surrogate key" is a primary key containing columns inserted just to
       have a unique key e.g. an "id" column
     * a "compound key" is a key containing more than one column
-    * a "foreign key" is one or more columns which can be used togother to
+    * a "foreign key" is one or more columns which can be used together to
       uniquely idenify a single row in another table
         * whose only function as a way of linking this record to a record in
           another table
@@ -124,24 +124,189 @@ will warn you when it does that.
 
 # Aside: Character sets and collations
 
-QUESTION: is the lenght restriction on string types in bytes and if so how are
-multi-byte chars handled
-
 * default character set is `latin1`
 * you can specify character set at the server, database table or column level
 * MySQL lets you mix and match character sets and encodings at all levels
 
-    See separate file on character sets, encodings, unicode etc.
+    See my other notes on character sets, encodings, unicode etc.
 
 ```sql
 SHOW CHARACTER SET;
 -- look at the `maxlen` column to see how many bytes required by each character
 set
 ```
 
-END CHAP 2
+# Chapter 3: Queries
+
+When query is sent f
+
+1. client (lib or tool) makes connection to server
+1. client sends query text
+1. query is checked
+    * syntax correct
+    * user has permission to access data
+    * user has permission to execute the query (functions etc.)
+1. query is handed to the optimizer to create an "execution plan"
+1. server executes the execution plan
+1. server returns table of results to client
+
+## Query clauses
+
+Queries are made up of 6 clauses
+
+### 1. Select
+
+```
+http://www.postgresqltutorial.com/postgresql-select-distinct/
+```
+
+* first clause in the syntax but almost the last clause to be evaluated
+* filters columns from the big "in memory table" that From clause will build
+* things included as a column in the results are
+    * column names from table created by Join clause
+    * literals: number, string etc. `"foo"`, `33`
+    * expressions: `some_col * 3`
+    * built-in function calls
+    * user defined function calls
+* allows you to define "column aliases" via 2 ways (AS is optional)
+    1. `some_val result`
+    1. `some_val AS result`
+* has two forms (three in postgres)
+    1. `SELECT ALL ...`
+        * ALL (the default) will return all candidate rows, including duplicates.
+    1. `SELECT DISTINCT <column list> ...`
+        * DISTINCT eliminates duplicate rows from the result. (one row is kept
+          from each group of duplicates)
+        * If you specify multiple columns, the DISTINCT clause will evaluate
+          the duplicate based on the combination of values of those columns.
+        * note that the 'DISTINCT` does not apply to a single column
+    1. `SELECT DISTINCT ON (<expression>) <column list> FROM ...`
+        * DISTINCT ON calcluates the result of `<expression>` for all rows and eliminates all but the first row for each group where the result is the same
+
+Gotchas
+
+* `SELECT DISTINCT` without an `ORDER BY` clause is a code smell!
+    * the "first row" of each set is unpredictable unless ORDER BY is used to
+      ensure that the desired row appears first.
+* Notice that the DISTINCT ON expression must match the leftmost expression in
+  the ORDER BY clause.
+
+```sql
+-- * these functions are defined in SQL (alternatives: pgsql, C, python, ruby etc.)
+-- * functions persist longer than just each query so we have to drop them each time we run this script
+drop function IF EXISTS one();
+CREATE FUNCTION one() RETURNS integer AS $$
+    SELECT 1 AS result;
+$$ LANGUAGE SQL;
+
+drop function IF EXISTS add_em(INTEGER, INTEGER);
+CREATE FUNCTION add_em(integer, integer) RETURNS integer AS $$
+    SELECT $1 + $2;
+$$ LANGUAGE SQL;
+
+SELECT id,
+    bt_transaction_id,
+    'hello'         AS literal_string,
+    'other'         no_as_literal_string,
+    33              AS literal_int,
+    4 * 5           AS expression,
+    one()           AS user_defined_func,
+    add_em(4,6)     AS user_defined_func_2,
+    round(3.1459)   AS built_in_func
+FROM settled_transactions;
+```
+
+
+### 2. From
+
+* identifies tables to pull data from and how they should be joined into a single table
+* types of table
+    1. permenant table
+        * stored on disk
+    2. temporary table
+        * created as teh result of a subquery
+        * `SELECT a.foo, b.foo FROM (SELECT ... FROM ... WHERE ...) AS a;`
+    3. virtual table
+        * views
+
+Subqueries
+
+* a query embedded in another query
+* returns a table that can be used by the outer query
+* it is very common to alias the returned table so it can easily be used by the
+  outer query
+* covered more in chap 9
+
+Syntax is:
+
+```sql
+SELECT ... FROM (subquery) AS subq_result WHERE ...
+SELECT a.foo, b.foo FROM (SELECT ... FROM ... WHERE ...) AS a;
+```
+
+View
+
+* a query which is stored in the "data dictionary"
+* its data is not stored on disk
+
+```sql
+CREATE VIEW <view_name> AS <select statement>
+CREATE VIEW some_view AS SELECT a, b, c FROM ...
+```
+
+Joins
+
+* specify how to combine the given permenant, virtual, temporary tables into
+  one large table
+* it is very common to alias tables uses in a join
+
+```sql
+SELECT <things> FROM <table-a> AS a <join condition> <table-b> AS b ON <on-condition>
+-- again the AS keyword is optional
+```
+
+UP TO START WHERE CLAUSE
+### 3. Where
+
+* filters unwanted rows from the big "in memory table" or "result set table"
+  that From will build.
+* WHERE takes one or more "filter conditions"
+* each filter condition is combined using a logical AND, OR, NOT.
+* note that `=` is the equality symbol in a filter condition (not `==` as it is in most programming languages)
+```
+WHERE <filter-condition> and|or|not <filter-condition> ...
+```
+
+### 4. Order by
+
+* sort the rows of the final result set by one or more columns
+
+
+### 5. Group by
+
+* finds trends in data
+* groups rows together by common column values
+* HAVING filters grouped data the same way WHERE filters raw data
+* described more fully in chap 8
+* each row in the result table that GROUP BY creates is a "group"!
+* GROUP BY is all about collapsing multiple rows in the results table - it does not change columns.
+* To collapse multiple rows into a single row we need to instruct the DB about how to do it for each column
+    * some columns will have the same value for each row so the output value can just be the input
+        * this is the case for the columns you specify in the GROUP BY clause (because we have chosen to use these columns to make our categories)
+    * other columns will need a function to help with a signature a bit like
+        * `function boil_down(column_values: Set<T>) -> <T>`
+    * examples of "boil down" functions are
+        * sum()
+        * max()
+        * min()
+
+### 6. Having
+
+* filters out unwanted groups
+* HAVING filters grouped data the same way WHERE filters raw data
 
 
+UP TO END OF SELECT CLAUSE IN CHAP 3
 
 
 

databases/window-functions.md

@@ -0,0 +1,22 @@
+# Window functions
+
+```
+SELECT a, b, avg(c) OVER (PARTITION BY a) FROM some_table;
+SELECT <col-1>, <col-2>, <window-function-col> FROM <source-table>
+    <window-function-col> is <grouping-func> OVER (PARTITION BY <partition-col-name>)
+```
+
+How postgres generates the `<result-table>`
+
+* foreach row in `<source-table>`
+    * start building new resulttable row
+        * copy `<col-1>` and `<col-2>` from `<source-table>` to `<result-table>`
+        * start processing the <window-function-col>
+            1. read the value of <partition-col-name> from the current row
+            2. use that value to do a search of the table for all rows whose
+               <partition-col-name> matches that value.
+            3. take the set of rows (note: full rows of table) generated in the
+               step above and feed it into the `<grouping-func>`.
+            4. copy the output of the gropuing function into the result-table row
+
+

elixir/anonymous-functions.exs

@@ -30,7 +30,7 @@ IO.puts handle_open.(File.open("./notthere.txt"))
 # return “FizzBuzz.” If the first is zero, return “Fizz.” If the second is
 # zero, return “Buzz.” Otherwise return the third argument”
 
-# note: no static types for args or return value!
+# note: no enforced types for args or return value!
 buzzer = fn
   0, 0, _ -> "FizzBuzz"
   0, _, _ -> "Fizz"
@@ -87,8 +87,10 @@ IO.puts apply.(add_two, 55)
 # & the "function capture" operator
 # =================================
 
+# these are equivalent
 doubler_1 = fn x -> x * 2 end
 doubler_2 = &(&1 * 2)
+
 # & operator
 
 # Uses:
@@ -110,8 +112,10 @@ isp = &Kernel.inspect(&1)
 isp = &Kernel.inspect/1 # same as above
 
 list = [1,3,5,7,9]
+
 IO.puts Kernel.inspect(Enum.map(list, doubler_2))
-IO.puts isp.(Enum.map(list, doubler_2))
+IO.puts isp.(Enum.map(list, doubler_2)) # note it is invoked as anonymous func i.e. isp.(things)
+
 IO.puts Kernel.inspect(Enum.map(list, &(&1 * 2))) # short syntax nice for quick inline functions
 IO.inspect Enum.map(list, &(&1 * 2)) # short syntax nice for quick inline functions
 
@@ -121,7 +125,9 @@ Enum.each [1,2,3,4], fn x -> IO.inspect x end
 Enum.each [1,2,3,4], &IO.inspect/1
 
 
+# Blocks
+# ======
+
 # blocks are used to create scopes in elixir
 # their syntax is  do: (<STATEMENTS SEPARATED BY NEWLINES>)
 # but the do..end syntax is more common
-

elixir/attributes.exs

@@ -19,7 +19,8 @@ defmodule Foo do
     IO.puts "#{@author} at #{@version}"
   end
 
-  # you can redefine attributes - what is the use-case for this?
+  # you can redefine attributes - a good example of this is using @doc to
+  # document functions
   @author "Totoro"
   @version "blah"
 

elixir/basic-types.exs

@@ -22,7 +22,8 @@ header.("Strings")
 #   Unicode codepoints.
 # * => Elixir strings are "UTF-8 encoded binaries"
 #
-# The "weird l" has code point 322 so cannot be represented as one byte
+# The "weird l" in the example below has code point 322 so cannot be
+# represented as one byte
 #
 # iex(1)> ex = "hełło"
 # "hełło"
@@ -51,8 +52,8 @@ IO.inspect String.length "foo"
 # Char lists
 # ##########
 #
-# * is a list of code point integers
-# * is delimited by single quotes
+# * delimited by single quotes
+# * a list of code point integers
 # * will display it as the glyphs not the codepoints as long as all the
 #   codepoints are within the 0-255 range
 # * are useful when interfacing with Erlang (strings are lists in Erlang)