Foxhound Systems

June 27, 2025 · assist

https://example.com/user/281714/invoice/3981292
https://example.com/user/c011fcb7-a180-4430-9412-3684a3a3668c/invoice/264265c0-4861-473e-bc67-80d3b8341847
select generate_tsid() as tsid, 'first' as ord
union
select generate_tsid() as tsid, 'second' as ord
union
select generate_tsid() as tsid, 'third' as ord
union
select generate_tsid() as tsid, 'fourth' as ord
order by tsid asc;
select tsid, ord from (
		select generate_tsid() as tsid, 'first' as ord
	) alias
union
select tsid, ord from (
		select pg_sleep(0.001), generate_tsid() as tsid, 'second' as ord
	) alias
union
select tsid, ord from (
		select pg_sleep(0.001), generate_tsid() as tsid, 'third' as ord
	) alias
union
select tsid, ord from (
		select pg_sleep(0.001), generate_tsid() as tsid, 'fourth' as ord
	) alias
order by tsid asc;
https://example.com/user/281714/invoice/3981292
https://example.com/user/E34NNFRTCQ15/invoice/DXZBE2D7TB04
ALTER TABLE public.users ALTER COLUMN id TYPE int8 USING id::int8;
ALTER TABLE public.users ALTER COLUMN id SET DEFAULT generate_tsid();
CREATE TABLE public.users (
	id int8 NOT NULL DEFAULT generate_tsid(),
	"name" varchar NOT NULL,
	CONSTRAINT users_pk PRIMARY KEY (id)
);
-- PostgreSQL
drop sequence if exists "generate_tsid_seq";
create sequence "generate_tsid_seq" maxvalue 1024 as smallint cycle;

create or replace function generate_tsid() returns bigint as $$
declare
    -- Milliseconds precision
    C_MILLI_PREC bigint := 10^3;
    -- Random component bit length: 12 bits
    C_RANDOM_LEN bigint := 2^12;
    -- TSID epoch: seconds since 2020-01-01Z
    -- extract(epoch from '2020-01-01'::date)
    C_TSID_EPOCH bigint := 1577836800;

	-- 42 bits
    C_TIMESTAMP_COMPONENT bigint := floor((extract('epoch' from clock_timestamp()) - C_TSID_EPOCH) * C_MILLI_PREC);
    -- 12 bits
    C_RANDOM_COMPONENT bigint := floor(random() * C_RANDOM_LEN);
    -- 10 bits
    C_COUNTER_COMPONENT bigint := nextval('generate_tsid_seq') - 1;
begin
    return ((C_TIMESTAMP_COMPONENT << 22) | (C_RANDOM_COMPONENT << 10) | C_COUNTER_COMPONENT);
end $$ language plpgsql;
def getUserActivityHandler(userId):
	# [1] Check the cache for activity feed data for the given user
	cachedActivityFeedItems = retrieveCachedActivityFeedForUser(key=userId)
	# [2] If activity feed data was found for this user, return it
	if(cachedActivityFeedItems != None):
		# CACHE HIT
		return cachedActivityFeedItems

	# CACHE MISS
	# [3] Otherwise, run SQL queries for each type of activity feed item
	recentPosts = findRecentPostsForUser(userId)
	recentComments = findRecentCommentsForUser(userId)
	recentCompleteTasks = findRecentCompletedTasksForUser(userId)

	# [4] Sort all retrieved items by date
	sortedActivityFeedItems = sortByDate([
		recentPosts,
		recentComments,
		recentCompletedTasks
	])
	# [5] Save the sorted activity feed items in the cache,
	#     associated with the current user id
	saveCachedActivityForUser(key=userId, sortedActivityFeedItems)
	# [6] In addition, return the same activity feed data
	return sortedActivityFeedItems
# Runs a SQL query to retrieve recent posts
posts = selectAllRecentPosts()
postCounts = {}
for post in posts:
    # Runs a SQL query to count of posts for a given user
    postCounts[post.authorId] = countPostsForAuthor(post.authorId)
SELECT *
FROM posts
WHERE created >= NOW() - INTERVAL '1' DAY;
SELECT COUNT(DISTINCT posts.id)
FROM posts
WHERE posts.author_id = 123;
SELECT recent_authors.id, COUNT(posts.id)
FROM (
    SELECT DISTINCT users.*
    FROM users
    INNER JOIN posts
    ON users.id = posts.author_id
    WHERE posts.created >= NOW() - INTERVAL '1' DAY
) AS recent_authors
INNER JOIN posts
ON recent_authors.id = posts.author_id
GROUP BY recent_authors.id;
SELECT users.id, COUNT(DISTINCT posts.id)
FROM users
LEFT JOIN posts
ON users.id = posts.authorId
GROUP BY users.id;
SELECT
    author,
    post_title,
    view_count,
    AVG(view_count) OVER (PARTITION BY author) AS average_view_count
FROM
    post_metrics;
SELECT
    account_id,
    abs(value) AS charge_amount,
    CASE WHEN value > 0 THEN 'CREDIT' ELSE 'DEBIT' END AS charge_kind,
    SUM(value) OVER (
        PARTITION BY account_id
        ORDER BY created_at
        ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
        ) AS balance,
    created_at AS transaction_date
FROM charges;
SELECT
    col_1, col_2, col_3
FROM
    some_table
INNER JOIN
    some_other_table
...
UNION
SELECT
    col_1, col_2, col_3
FROM
    some_table
LEFT JOIN
    another_table
...
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    password_hash VARCHAR,
    email_address VARCHAR,
    created_at TIMESTAMP
);
CREATE INDEX users_created_at_index ON users (created_at);
postgres=# \d users
                                          Table "public.users"
    Column     |            Type             | Collation | Nullable |              Default
---------------+-----------------------------+-----------+----------+-----------------------------------
 id            | integer                     |           | not null | nextval('users_id_seq'::regclass)
 password_hash | character varying           |           |          |
 email_address | character varying           |           |          |
 created_at    | timestamp without time zone |           |          |
Indexes:
    "users_pkey" PRIMARY KEY, btree (id)
    "users_created_at_index" btree (created_at)
SELECT *
FROM users
WHERE created_at >= NOW() - INTERVAL '7' DAY;
SELECT first, last, email
FROM users
WHERE first = '?'
AND last = '?';
CREATE INDEX users_first_last_index ON users (first, last);
SELECT email, created_at
FROM users
WHERE email = '?'
AND created_at >= '?';
CREATE INDEX users_email_created_at_index ON users (email, created_at);
newtype ValidationRule a = ValidationRule { validate :: a -> Bool }
eq_ :: Eq a => a -> ValidationRule a
eq_ ruleValue = ValidationRule $ \actual -> actual == ruleValue
equalsFive :: ValidationRule Int
equalsFive = eq_ 5
lt_, gt_ :: Ord a => a -> ValidationRule a
gt_ ruleValue = ValidationRule $ \actual -> actual > ruleValue
lt_ ruleValue = ValidationRule $ \actual -> actual < ruleValue
and_, or_ :: ValidationRule a -> ValidationRule a -> ValidationRule a
and_ rule1 rule2 = ValidationRule $ \actual ->
    validate rule1 actual && validate rule2 actual
or_ rule1 rule2 = ValidationRule $ \actual ->
    validate rule1 actual || validate rule2 actual
not_ :: ValidationRule a -> ValidationRule a
not_ rule = ValidationRule $ \actual -> not $ validate rule actual
geq_ :: Ord a => a -> ValidationRule a
geq_ value = gt_ value `or_` eq_ value
instance Functor ValidationRule where
    fmap :: (a -> b) -> ValidationRule a -> ValidationRule b
    fmap f rule = ValidationRule $ \actual ->
        validate rule ????
notQuiteFmap :: (b -> a) -> ValidationRule a -> ValidationRule b
notQuiteFmap f rule = ValidationRule $ \actual ->
    validate rule (f actual)
data Account = Account
    { accountBalance :: Integer
    , accountName :: Text
    , accountOwner :: Text
    }

negative_ :: ValidationRule Integer
negative_ = lt_ 0
overdrawn :: ValidationRule Account
overdrawn = contramap accountBalance negative_
accountOwnedBy :: Text -> ValidationRule Account
accountOwnedBy owner = contramap accountOwner $ eq_ owner

withdrawalAllowed :: ValidationRule Account
withdrawalAllowed =
    accountOwnedBy "Alice" `and_` (not_ overdrawn)
type ErrMsg = Text

data Validation err
    = Success
    | Failure err

type ValidationResult = Validation [ErrMsg]

success :: ValidationResult
success = Success

failure :: ErrMsg -> ValidationResult
failure errMsg = Failure [errMsg]

newtype ValidationRule a =
    ValidationRule { validate :: a -> ValidationResult }
eq_ :: (Show a, Eq a) => a -> ValidationRule a
eq_ value = ValidationRule $ \actual ->
    if actual == value then
        success
    else
        failure (Text.pack $ "Expected " <> show actual <> " to equal " <> show value)

and_ :: ValidationRule a -> ValidationRule a -> ValidationRule a
and_ rule1 rule2 = ValidationRule $ \actual ->
    case (validate rule1 actual, validate rule2 actual) of
        (Failure e1, Failure e2) -> Failure (e1 <> e2)
        (Failure e1, _)          -> Failure e1
        (_, Failure e2)          -> Failure e2
        (Success, Success)       -> Success

or_ :: ValidationRule a -> ValidationRule a -> ValidationRule a
or_ rule1 rule2 = ValidationRule $ \actual ->
    case (validate rule1 actual, validate rule2 actual) of
        (Failure e1, Failure e2) -> Failure (e1 <> e2)
        (Success, _)             -> Success
        (_, Success)             -> Success
data SqlExpr
    = B Bool
    | And SqlExpr SqlExpr
    | Or SqlExpr SqlExpr
    | Not SqlExpr
eval :: SqlExpr -> Bool
eval (B b)             = b
eval (Leq expr1 expr2) = eval expr1 <= eval expr2
eval (And expr1 expr2) = eval expr1 && eval expr2
eval (Or expr1 expr2)  = eval expr2 || eval expr2
eval (Not expr)        = not (eval expr)
data SqlExpr
    = I Int
    | B Bool
    | Leq SqlExpr SqlExpr
    | And SqlExpr SqlExpr
    | Or SqlExpr SqlExpr
    | Not SqlExpr
data SqlExpr a
    = I Int
    | B Bool
    | Leq (SqlExpr Int) (SqlExpr Int)
    | And (SqlExpr Bool) (SqlExpr Bool)
    | Or (SqlExpr Bool) (SqlExpr Bool)
    | Not (SqlExpr Bool)
eval :: SqlExpr a -> a
eval (B b)             = b
eval (I i)             = i
eval (Leq expr1 expr2) = eval expr1 <= eval expr2
eval (And expr1 expr2) = eval expr1 && eval expr2
eval (Or expr1 expr2)  = eval expr2 || eval expr2
eval (Not expr)        = not (eval expr)
Main.hs:30:26: error:
    • Couldn't match expected type ‘a’ with actual type ‘Bool’
      ‘a’ is a rigid type variable bound by
        the type signature for:
          eval :: forall a. SqlExpr a -> a
        at Main.hs:29:1-22
    • In the expression: b
      In an equation for ‘eval’: eval (B b) = b
    • Relevant bindings include
        eval :: SqlExpr a -> a (bound at Main.hs:30:1)
   |
30 | eval (B b)             = b
   |
data SqlExprResult
    = BoolResult Bool
    | IntResult Int


eval :: SqlExpr a -> SqlExprResult
eval (B b) = BoolResult b
eval (I i) = IntResult i
eval (Leq expr1 expr2) =
    let IntResult i1 = eval expr1
        IntResult i2 = eval expr2
    in BoolResult (i1 <= i2)
...
newtype SqlExpr a =
    SqlExpr { unSqlExpr :: a }


bool :: Bool -> SqlExpr Bool
bool b = SqlExpr b


int :: Int -> SqlExpr Int
int i = SqlExpr i


leq :: SqlExpr Int -> SqlExpr Int -> SqlExpr Bool
leq expr1 expr2 = SqlExpr (unSqlExpr expr1 <= unSqlExpr expr2)

...

eval :: SqlExpr a -> a
eval = unSqlExpr
{-# LANGUAGE OverloadedStrings #-}

import Data.Text.Lazy.Builder ( Builder )

-- Stand-in for Database.Persist.PersistValue
data PersistValue
    = PersistInt64 Integer
    | PersistBool Bool


data SqlExpr a =
    SqlExpr { unSqlExpr :: (Builder,  [PersistValue]) }


bool :: Bool -> SqlExpr Bool
bool b = SqlExpr ("?", [PersistBool b])


int :: Int -> SqlExpr Int
int i = SqlExpr ("?", [PersistInt64 (fromIntegral i)])


leq :: SqlExpr Int -> SqlExpr Int -> SqlExpr Bool
leq expr1 expr2 =
        let (b1, v1) = unSqlExpr expr1
            (b2, v2) = unSqlExpr expr2
            in SqlExpr ( b1 <> " <= " <> b2, v1 <> v2)


and_ :: SqlExpr Bool -> SqlExpr Bool -> SqlExpr Bool
and_ expr1 expr2 =
   let (b1, v1) = unSqlExpr expr1
       (b2, v2) = unSqlExpr expr2
   in SqlExpr ( b1 <> " AND " <> b2, v1 <> v2)


or_ :: SqlExpr Bool -> SqlExpr Bool -> SqlExpr Bool
or_ expr1 expr2 =
   let (b1, v1) = unSqlExpr expr1
       (b2, v2) = unSqlExpr expr2
   in SqlExpr ( b1 <> " OR " <> b2, v1 <> v2)


not_ :: SqlExpr Bool -> SqlExpr Bool
not_ expr =
    let (b, v) = unSqlExpr expr
    in SqlExpr ("NOT " <> b, v)
{-# LANGUAGE OverloadedStrings #-}

import Data.Text.Lazy.Builder ( Builder )

data PersistValue
    = PersistInt64 Integer
    | PersistBool Bool

type WithParens = Bool


parens :: Builder -> Builder
parens b = "(" <> b <> ")"


parensM :: Bool -> Builder -> Builder
parensM True  = parens
parensM False = id


data  SqlExpr a =
    SqlExpr { unSqlExpr :: WithParens -> (Builder,  [PersistValue]) }


bool :: Bool -> SqlExpr Bool
bool b = SqlExpr $ \_ -> ("?", [PersistBool b])


int :: Int -> SqlExpr Int
int i = SqlExpr (const ("?", [PersistInt64 (fromIntegral i)]))


leq :: SqlExpr Int -> SqlExpr Int -> SqlExpr Bool
leq expr1 expr2 =
        let (b1, v1) = unSqlExpr expr1 True
            (b2, v2) = unSqlExpr expr2 True
            in SqlExpr $ \p -> (parensM p (b1 <> " <= " <> b2), v1 <> v2)


and_ :: SqlExpr Bool -> SqlExpr Bool -> SqlExpr Bool
and_ expr1 expr2 =
    let (b1, v1) = unSqlExpr expr1 True
        (b2, v2) = unSqlExpr expr2 True
    in SqlExpr $ \p -> (parensM p  ( b1 <> " AND " <> b2), v1 <> v2)


or_ :: SqlExpr Bool -> SqlExpr Bool -> SqlExpr Bool
or_ expr1 expr2 =
    let (b1, v1) = unSqlExpr expr1 True
        (b2, v2) = unSqlExpr expr2 True
    in SqlExpr $ \p -> ( parensM p (b1 <> " OR " <> b2), v1 <> v2)


not_ :: SqlExpr Bool -> SqlExpr Bool
not_ expr =
    let (b, v) = unSqlExpr expr True
    in SqlExpr $ \p -> (parensM p ("NOT " <> b), v)


where_ :: SqlExpr Bool -> (Builder, [PersistValue])
where_ e =
    let (b, v) = unSqlExpr e False
    in ("WHERE " <> b, v)
                                stores
                                +---------+------+
     customers            +---->| id      | int  |<----------------+
     +----------+------+  |     | address | text |                 |
+--->| id       | int  |  |     +---------+------+                 |
|    | name     | text |  |                                        |
|    | store_id | int  +--+                   employees            |
|    +----------+------+                      +----------+------+  |
|                                      +----->| id       | int  |  |
|                                      |      | name     | text |  |
|  customer_orders                     |      | role     | text |  |
|  +-------------+-----------+         |      | store_id | int  +--+
|  | id          | int       |<--+     |      +----------+------+
+--+ customer_id | int       |   |     |
   | created     | timestamp |   |     |
   +-------------+-----------+   |     |  employee_markouts
                                 |     |  +--------------+-----------+
                                 |     |  | id           | int       |
    customer_order_items         |     +--+ employee_id  | int       |
    +-------------------+-----+  |        | meal_item_id | int       +--+
    | id                | int |  |        | created      | timestamp |  |
    | customer_order_id | int +--+        +--------------+-----------+  |
 +--+ meal_item_id      | int |                                         |
 |  +-------------------+-----+                                         |
 |                                 meal_items                           |
 |                                 +-------+------+                     |
 +-------------------------------->| id    | int  |<--------------------+
                                   | label | text |
                                   | price | int  |
                                   +-------+------+
SELECT meal_items.*, employee_markouts.employee_id
FROM stores
INNER JOIN employees
ON stores.id = employees.store_id
INNER JOIN employee_markouts
ON employees.id = employee_markouts.employee_id
INNER JOIN meal_items
ON employee_markouts.meal_item_id = meal_items.id
WHERE stores.id = 250
AND employee_markouts.created >= '2021-02-03'
AND employee_markouts.created < '2021-02-04';
SELECT
  meal_items.*,
  employee_markouts.employee_id,
  customer_orders.customer_id
FROM stores
-- employees branch
LEFT JOIN employees
ON stores.id = employees.store_id
LEFT JOIN employee_markouts
ON employees.id = employee_markouts.employee_id
-- customers branch
LEFT JOIN customers
ON (stores.id = customers.store_id AND employee_markouts.id IS null)
LEFT JOIN customer_orders
ON customers.id = customer_orders.customer_id
LEFT JOIN customer_order_items
ON customer_orders.id = customer_order_items.customer_order_id
-- join both branches into meal_items
LEFT JOIN meal_items
ON (customer_order_items.meal_item_id = meal_items.id
    OR employee_markouts.meal_item_id = meal_items.id
   )
WHERE stores.id = 250
AND meal_items.id IS NOT null
AND ( employee_markouts.created >= '2021-02-03' AND employee_markouts.created < '2021-02-04'
      OR customer_orders.created >= '2021-02-03' AND customer_orders.created < '2021-02-04'
    )
GROUP BY meal_items.id, employee_markouts.id, customer_orders.id, customer_order_items.id;
SELECT meal_items.*, customer_orders.customer_id
FROM stores
INNER JOIN customers
ON stores.id = customers.store_id
INNER JOIN customer_orders
ON customers.id = customer_orders.customer_id
INNER JOIN customer_order_items
ON customer_orders.id = customer_order_items.customer_order_id
INNER JOIN meal_items
ON customer_order_items.meal_item_id = meal_items.id
WHERE stores.id = 250
AND customer_orders.created >= '2021-02-03'
AND customer_orders.created < '2021-02-04';
SELECT -- employees query
  meal_items.*,
  employee_markouts.employee_id,
  null as customer_id
FROM stores
INNER JOIN employees
ON stores.id = employees.store_id
INNER JOIN employee_markouts
ON employees.id = employee_markouts.employee_id
INNER JOIN meal_items
ON employee_markouts.meal_item_id = meal_items.id
WHERE stores.id = 250
AND employee_markouts.created >= '2021-02-03'
AND employee_markouts.created < '2021-02-04'
UNION ALL
SELECT -- customers query
  meal_items.*,
  null as employee_id,
  customer_orders.customer_id
FROM stores
INNER JOIN customers
ON stores.id = customers.store_id
INNER JOIN customer_orders
ON customers.id = customer_orders.customer_id
INNER JOIN customer_order_items
ON customer_orders.id = customer_order_items.customer_order_id
INNER JOIN meal_items
ON customer_order_items.meal_item_id = meal_items.id
WHERE stores.id = 250
AND customer_orders.created >= '2021-02-03'
AND customer_orders.created < '2021-02-04';
SELECT * FROM (
   -- ... Query #4 from above, omitted for brevity
) results ORDER BY id;
square :: Int -> Int
square x = x * x

fmap square [1,2,3,4,5] -- returns [1,4,9,16,25]
type Dollars = Int

data CustomerInvoice = CustomerInvoice
    { invoiceNumber :: Int
    , amountDue     :: Dollars
    , tax           :: Dollars
    , billableItems :: [String]
    , status        :: InvoiceStatus
    , createdAt     :: UTCTime
    , dueDate       :: Day
    }

data InvoiceStatus
    = Issued
    | Paid
    | Canceled
createCustomerNotification :: CustomerInvoice -> String
createCustomerNotification invoice =
    case status invoice of
        Issued ->
            "Invoice #" ++ show (invoiceNumber invoice) ++ " due on " ++ show (dueDate invoice)

        Paid ->
            "Successfully paid invoice #" ++ show (invoiceNumber invoice)

        Canceled ->
            "Invoice #" ++ show (invoiceNumber invoice) ++ " has been canceled"
data InvoiceStatus
    = Issued
    | Paid
    | Canceled
    | Refunded
CustomerInvoice.hs:(15,5)-(20,35): error: [-Wincomplete-patterns, -Werror=incomplete-patterns]
    Pattern match(es) are non-exhaustive
    In a case alternative: Patterns not matched: Refunded
   |
15 |     case status invoice of
   |     ^^^^^^^^^^^^^^^^^^^^^^...
Person
    name Text
    age Int Maybe
BlogPost
    title Text
    authorId PersonId
    publicationDate UTCTime
BlogPostTag
    label Text
    blogPostId BlogPostId
authors = queryAuthorsByCountry('USA')          // 1
foreach author <- authors:                      // N
    authors[author.id]['books'] = queryBooksByAuthorId(author.id)
authors = queryAuthorsByCountry('USA')          // 1
foreach author <- authors:                      // N
    books = queryBooksByAuthorId(author.id)
    foreach book <- books:                      // N * M
        book_genre_tags = queryBookGenresByBookId(book.id)
        // ...
authors = queryAuthorsByCountry('USA')
author_id_list = []
foreach author <- authors:
    author_id_list.push(author.id)

books = queryBooksByAuthorIds(author_id_list)
book_id_list = []
foreach book <- books:
    book_id_list.push(book.id)

book_genre_tags = queryBookGenresByBookIds(book_id_list)
   users
   +---------+-------+
+->| id      | int   |<----+      posts
|  | name    | text  |     |      +-------------+------------+
|  | email   | text  |     |      | id          | int        |<-+
|  +---------+-------+     +------+ user_id     | int        |  |
|                                 | title       | text       |  |
|                                 | body        | text       |  |
|                                 | created_at  | timestamp  |  |
|  post_comments                  +-------------+------------+  |
|  +-------------+------------+                                 |
|  | id          | int        |                                 |
|  | post_id     | int        +---------------------------------+
+--+ user_id     | int        |
   | body        | text       |
   | created_at  | timestamp  |
   +-------------+------------+

SELECT
    users.id AS user_id,
    users.name,
    posts.id AS post_id,
    posts.title,
    posts.created_at
FROM users
LEFT JOIN posts
ON users.id = posts.user_id;
data Entity a = Entity
    { entityKey :: Key a
    , entityVal :: a
    }
[(Entity User, Entity Post, Entity PostComment)]
[(Entity User, [(Entity Post, [Entity PostComment])])]
{-# LANGUAGE FlexibleContexts #-}

import qualified Data.Map         as Map
import           Data.Traversable
import           Database.Persist ( Entity (..), Key )

groupData :: (Ord (Key a)) => [(Entity a, b)] -> [(Entity a, [b])]
groupData res =
    Map.elems $ foldr
        (\(a, b) accumulator ->
            Map.insertWith
                mergeData
                (entityKey a)
                (a, [b])
                accumulator
        ) Map.empty res

mergeData :: (a, [b]) -> (a, [b]) -> (a, [b])
mergeData (a, b) (a', b') =
    (a, b ++ b')
genericMergeData :: (Semigroup a, Semigroup b) => (a, b) -> (a, b) -> (a, b)
genericMergeData (a, b) (a', b') =
    (a, b) <> (a', b')
data GroupedPostResult = GroupedPostResult
    { groupedResultUser :: Entity User
    , groupedResultPosts :: [Entity Post]
    }

instance Semigroup GroupedPostResult where
    GroupedPostResult a b <> GroupedPostResult _ b' = GroupedPostResult a (b ++ b')
newtype GroupedPostResultMap = GroupedPostResultMap
    { unGroupedPostResultMap :: Map (Key User) GroupedPostResult
    }

instance Semigroup GroupedPostResultMap where
    GroupedPostResultMap lhs <> GroupedPostResultMap rhs = GroupedPostResultMap $ Map.unionWith (<>) lhs rhs

instance Monoid GroupedPostResultMap where
    mempty = GroupedPostResultMap Map.empty
    mappend = (<>)

groupData :: [(Entity User, Entity Post)] -> [(Entity User, [Entity Post])]
groupData =
    fmap (\(GroupedPostResult a b) -> (a, b)) .
        Map.elems .
        unGroupedPostResultMap .
        mconcat .
        fmap (\(a, b) -> GroupedPostResultMap $
                            Map.singleton (entityKey a) (GroupedPostResult a [b])
             )
{-# LANGUAGE FlexibleContexts #-}

import           Data.Coerce
import           Data.Map.Strict  as Map
import           Data.Map.Append
import           Data.Semigroup
import           Database.Persist
type GroupedListStructure a b c =
    [(Entity a, [(Entity b, [Entity c])])]
type GroupedMapStructure a b c =
    Map ( Key a )
        ( Entity a
        , Map ( Key b )
              ( Entity b
              , Map (Key c) (Entity c)
              )
        )
newtype AppendMap k v = AppendMap
    { unAppendMap :: Map k v
    }
type GroupedAppendMapStructure a b c =
    AppendMap ( Key a )
              ( Entity a
              , AppendMap ( Key b )
                          ( Entity b
                          , AppendMap (Key c) (Entity c)
                          )
              )
type GroupedAppendMapSemigroupStructure a b c =
    AppendMap ( Key a )
              ( First (Entity a)
              , AppendMap ( Key b )
                          ( First (Entity b)
                          , AppendMap (Key c) (First (Entity c))
                          )
              )
makeGroupedStructure :: (Entity a, Entity b, Entity c)
                     -> GroupedAppendMapSemigroupStructure a b c
makeGroupedStructure (a, b, c) =
    AppendMap $ Map.singleton
            ( entityKey a )
            ( First a
            , AppendMap $ Map.singleton
                ( entityKey b )
                ( First b
                , AppendMap $ Map.singleton (entityKey c) (First c)
                )
            )
groupWith :: (Monoid m, Coercible m b) => (r -> m) -> [r] -> b
groupWith fn =
    coerce . mconcat . fmap fn


groupData :: (Ord (Key a), Ord (Key b), Ord (Key c))
          => [(Entity a, Entity b, Entity c)]
          -> Map (Key a) (Entity a, Map (Key b) (Entity b, Map (Key c) (Entity c)))
groupData =
    groupWith makeGroupedStructure
transformMap :: Map (Key a) (Entity a, Map (Key b) (Entity b, Map (Key c) (Entity c)))
             -> [(Entity a, [(Entity b, [Entity c ])])]
transformMap map =
    fmap (\(parentA, childrenA) ->
             ( parentA
             , fmap (\(parentB, childrenB) ->
                        ( parentB
                        , Map.elems $ childrenB
                        )
                    ) (Map.elems $ childrenA)
             )
         ) (Map.elems map)
groupQueryResults :: (Ord (Key a), Ord (Key b), Ord (Key c))
                  => [(Entity a, Entity b, Entity c)]
                  -> [(Entity a, [(Entity b, [Entity c])])]
groupQueryResults =
    transformMap . groupData
-- The type representing each row from our Esqueleto query
type PostModel = (Entity User, Entity Post, Entity PostComment)

-- The resulting grouped type we want to achieve
type GroupedPostModel =
    Map UserId
        ( Entity User
        , Map PostId
              ( Entity Post
              , Map PostCommentId (Entity PostComment)
              )
        )

-- The intermediary semigroup type that defines grouping behavior
-- This corresponds directly to GroupedPostModel above
type GroupedPostSemigroup =
    AppendMap ( UserId )
              ( First (Entity User)
              , AppendMap ( PostId )
                          ( First (Entity Post)
                          , AppendMap ( PostCommentId )
                                      ( First (Entity PostComment) )
                          )
              )

-- Takes our query result and produces values in the semigroup shape above
makeSinglePostGroup :: PostModel -> GroupedPostSemigroup
makeSinglePostGroup (user, post, postComment) =
    AppendMap $ Map.singleton
            ( entityKey user )
            ( First user
            , AppendMap $ Map.singleton
                ( entityKey post )
                ( First post
                , AppendMap $ Map.singleton (entityKey postComment) (First postComment)
                )
            )

-- Copied directly from the previous section
groupWith :: (Monoid m, Coercible m b) => (r -> m) -> [r] -> b
groupWith fn =
    coerce . mconcat . fmap fn

groupData :: [PostModel] -> GroupedPostModel
groupData =
    groupWith makeSinglePostGroup

id	name
1	Bob
2	Alice
522,848,938,755,798,323	Jim
522,849,990,964,860,213	Jane

Feature	Auto-incr. Integers	UUIDs	TSIDs
Key Type	Variable size integer	128-bit integer	64-bit integer
Uniqueness	Unique within a database	Universally unique	Unique across nodes
Predictability	Predictable sequence	Unpredictable	Unpredictable
Space Efficiency	High (small size)	Low (large size)	Moderate (larger than integers but smaller than UUIDs)
Data locality	High (sequential increment)	Low (random order)	High (time-sorted with random component)
Performance	High (efficient indexing, inserts, reads)	Poor (inefficient inserts, scattered indexes, read penalty)	High (similar to integers)
Readability	High (simple numbers)	Low (32 character strings)	Moderate (13 character strings)
Chronological Sorting	Yes, implicit (based on sequence)	No inherent order	Yes, time-sorted (based on time component)
Multi-node Generation	Not feasible	Easily feasible	Feasible with node IDs
Security (Inference Risk)	High (German Tank Problem)	Low (no inference)	Low (no inference)
Ease of Implementation	High (natively supported)	Moderate (varies by database)	Low (least support, requires function implementation, managing node IDs)
Scalability	Varies (limited by integer type)	High (no practical limit)	High (at least ~70 years, limited by timestamp size)
Migration Flexibility	Moderate (can change to larger integer type)	Low (hard to change key type)	High (drop-in compatible with integers)

author	post_title	view_count	average_view_count
John Smith	SQL basics, pt 1	1012	772
John Smith	SQL basics, pt 2	748	772
John Smith	SQL basics, pt 3	556	772
Michael Walters	Use Python for your next project	972	1660.5
Michael Walters	I was wrong, use Rust for your next project	2349	1660.5

account_id	value	date
1	20	2022-07-12
2	95	2022-07-12
2	40	2022-07-13
1	35	2022-07-13
1	50	2022-07-14
1	-15	2022-07-15
2	-135	2022-07-15

Table	Number of Records
`stores`	800
`employees`	20,000
`employee_markouts`	25,000
`customers`	20,000
`customer_orders`	100,000
`customer_order_items`	550,482
`meal_items`	500

tsid	ord
522,836,310,860,897,560	fourth
522,836,310,861,131,029	first
522,836,310,862,691,606	second
522,836,310,863,962,391	third

tsid	ord
522,837,249,527,293,229	first
522,837,249,533,629,742	second
522,837,249,545,303,343	third
522,837,249,554,283,824	fourth

account_id	charge_amount	charge_kind	balance	transaction_date
1	20	CREDIT	20	2022-07-12
1	35	CREDIT	55	2022-07-13
1	50	CREDIT	105	2022-07-14
1	15	DEBIT	90	2022-07-15
2	95	CREDIT	95	2022-07-12
2	40	CREDIT	135	2022-07-13
2	135	DEBIT	0	2022-07-15

id	label	price	employee_id	customer_id
5	Stinky Tofu	21.24		3769
17	Chicken Sandwich	18.37		11085
25	Kebab	16.30		3769
…	…	…	…	…
173	Pizza	3.73	3737
339	Tuna Sashimi	21.41	3737
…	…	…	…	…
490	Ribeye Steak	20.10		1052

Web Service Language	EC2 Instance Type	CPU	RAM	Monthly Cost Per Instance	Number of Instances Used	Total Monthly Cost
PHP	`c5.xlarge`	4 Dedicated CPU cores	8 GB	$122	2	$244
Haskell	`t3.nano`	2 Flex CPU cores (limited to 20% use)	0.5 GB	$3.75	4	$15

user_id	name	post_id	title	created_at
1	John Smith	10	How to write SQL	2020-11-18 13:06:02
1	John Smith	11	How to write SQL pt. 2	2020-11-21 18:17:34
1	John Smith	12	How to write SQL pt. 3	2020-12-01 15:26:22
2	Karen Doe	17	How to really write SQL	2021-01-18 11:19:44

Foxhound Systems

The AI delegation dilemma

The AI delegation dilemma

A triangle of trade-offs

The roots of the dilemma

The nature of LLMs and code generation

The cost of context and implicit knowledge

Navigating the dilemma

Picking your two priorities wisely

Get a working prototype quickly: Prompt Efficiency + Output Usability (sacrificing Design Fidelity)

Produce a useful starting point: Design Fidelity + Prompt Efficiency (sacrificing Output Usability)

Create comprehensive specifications for maximal precision: Design Fidelity + Output Usability (sacrificing Prompt Efficiency)

Avoid the dilemma entirely

Takeaways

TSIDs strike the perfect balance between integers and UUIDs for most databases

TSIDs strike the perfect balance between integers and UUIDs for most databases

Auto-incrementing integer keys

Benefits of auto-incrementing integers

Downsides of auto-incrementing integers

Universally Unique Identifier keys

Benefits of UUIDs

Downsides of UUIDs

Table with integer identifiers

Table with UUID identifiers

Time-sorted Unique Identifier keys

Benefits of TSIDs

Downsides of TSIDs

TSID implementation example

Feature shootout: Auto-incrementing integers vs. UUIDs vs. TSIDs

TSIDs: Have your cake and eat it too

Technical Debt is not real

Technical Debt is not real

The conceptual origins of “Technical Debt”

Because of the way it is

Buying on credit

Paying down debt

Striking a balance in managing technical debt

The missing letter in 'MVP'

The missing letter in 'MVP'

Avoiding runaway costs: What the idea of the MVP gets right

The common criticism of MVPs

An MVP must be representative

Determining what is representative

Make sure your next MVP is an MVRP

Essential elements of high performance applications: Server side caching

Essential elements of high performance applications

Server side caching

Server side caching flow: cache hits and misses

Expunging stale data: Cache invalidation

Selecting a store for our cached data

Wrap up

Further reading about caching

Essential elements of high performance applications: Offloading work to the SQL database

Essential elements of high performance applications

Offloading work to the SQL database

Joins and Subqueries

Grouping and Aggregations

Window Functions

Basic window function example

More advanced window function example

Set Operations: Union, Intersect, and Except

Wrap Up

Further reading about offloading work to the database

Essential elements of high performance applications: SQL indexes

Essential elements of high performance applications

SQL indexes

SQL indexes

Multicolumn indexes

Covering indexes

Further reading about indexes

Composable Data Validation with Haskell

Composable Data Validation with Haskell

Creating an eDSL

Making rules composable

Handling complex data types

Adding validation results

Conclusion

Final tagless encodings have little to do with typeclasses

Final tagless encodings have little to do with typeclasses

An Initial Encoding

Query #4 - Retrieving both employee and customer meal items using `UNION`

Query #5 - Retrieving both employee and customer meal items using `UNION`, ordered by `id`