Learn Postgres, Reason and Svelte

You've got some practice with using SQL to select, update, and join database tables.

But perhaps you've found yourself with a sneaking suspicion that you could be more efficient with your PostgreSQL.

Does your query seem slow?

A lesson on how to profile queries will point you in the direction of a fix.

Are you performing multi-step operations one at a time that are susceptible to errors?

The "all or nothing" transaction is the cure.

These are just a couple of examples of the techniques, tips, and tricks that Tyler Clark has learned in his years of experience working on large scale production applications.

Other topics in this course include working with CSV files, different techniques for aggregating & filtering, and more!

Watch Tyler's course, and continue your journey toward SQL mastery.

Check out the [**Community Notes for this course.**](https://github.com/eggheadio-projects/advanced-sql-for-professional-developers)

PostgreSQL is a powerful, open source object-relational database system.

postgres

Advanced SQL for Professional Developers

JavaScript community has been shaken recently by a release of Svelte 3 and for a good reason - it's a completely different approach than React or Vue. To quote the docs:

"[Svelte](https://svelte.dev/) is a radical new approach to building user interfaces. Whereas traditional frameworks like React and Vue do the bulk of their work in the browser, Svelte shifts that work into a compile step that happens when you build your app."

**The best part?** If you have 26 spare minutes you can learn the basics of Svelte 3 and start building your own apps with it!

Enjoy!



The magical disappearing UI framework

 - The web's JavaScript bloat crisis, solved. Svelte turns your templates into tiny, framework-less vanilla JavaScript.
 - Simple and familiar. Build apps out of composable, easy-to-write blocks using languages you already know.
 - Super fast, rock solid. Compile-time static analysis ensures the browser does no more work than it needs to.

svelte

Up and running with Svelte 3

Most applications rely on databases to store data. Understanding how to create a database and communicate with it unlocks a critical power in your web development career. 

In this course, Tyler presents all the building blocks of creating and interacting with a PostgreSQL database. From creating a brand new table, up through organizing and aggregating data across multiple tables, you will learn the fundamental skills of SQL — and you’ll be prepared to apply them right away.

After completing this course, you’ll be ready to tackle more challenging SQL topics like proper data modeling, normalizing data, and exploring different database types.


Check out the [**Community Notes for this course.**](https://github.com/eggheadio-projects/sql-fundamentals)

SQL Fundamentals

This course foremost will teach you about the syntax and semantics of the programming language Reason or also referred to as ReasonML. In addition, the course touches on best practices recommended by the official documentation. Each lesson is focusing on a specific feature, concept or best practice and can be watched independently. Still, the whole course is carefully crafted, and each lesson builds up on the previous ones.

Simple, fast & type safe code that leverages the JavaScript & OCaml ecosystems.

reason

Get Started with Reason

You know the basics of Postgres, but most meaningful queries will require you to combine tables in novel ways to ask questions you couldn't ask with a single table alone. Joins and unions come up over and over again in interview questions -- because of how fundamental they are. This course will make you a master of your tables, and give you the power to answer questions you couldn't before. 

Understand Joins and Unions in Postgres

In this course we will show you how to wield the power behind the elusive window function. Which five movies were the highest grossing each year? Who are the highest performers in each department relative to their peers? These questions ask us to partition records into subgroups and answer questions about those groups -- that’s the power of a window function. 

Many programmers will reach for their favorite scripting language to solve problems like these, but window functions allow you to answer them with the speed and efficiency of the Postgres query planner.

Plus, with the power to further slice and dice this derivative information, there’s no limit to the questions you can answer with raw SQL.

If you’re interested in the Postgres client that is used in this course you can [download it here](https://macpostgresclient.com/?source=brett) to check it out and follow along.

Using Postgres Window Functions

It’s amazing how much you can accomplish with a basic knowledge of SQL. In this course we’ll learn how to store lots of information (many millions of things!) and answer nearly any question we might have about that information (on the order of milliseconds!) 

We’ll learn enough to make you say you “know SQL” -- table creation, inserts, selects, updates, deletes, aggregations, indexes, joins, and constraints. Along the way we’ll model real world problems so that you can see just how powerful SQL will make you!

If you’re interested in the Postgres client that is used in this course you can [download it here](https://macpostgresclient.com/?source=brett) to check it out and follow along.

Get Started With PostgreSQL

Node.js is a well established server runtime that many companies are using worldwide. Express.js is a server framework for Node.js used by over 5 million projects. ReasonML is a type-safe functional language that compiles to Javascript.

This playlist collects the basic pieces of information a programmer needs to get started building servers in ReasonML on Node.js and Express.js. Follow along to learn how to get the speed of Node, combined with the added type-safety of Reason.

Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.

node

Making an HTTP server in ReasonML on top of Node.js

Ongoing playlist.

Don't be afraid to watch videos at 1.25x if the pace is too slow!

ReasonML Applications for the React Developer

Creating forms is one of the simplest and most complicated things at the same time. A basic form consists of many different things happening, we have to retain the value, we have to keep watch of validation and we have to show error messages when something is invalid, this is on both the fields and on the entire form itself if we send a request off to the backend service.

So we're going to create a form using just the normal svelte features. Then we'll look into creating a form using the svelte forms lib. 

Create forms in Svelte with Svelte Forms Lib

Creating tables is actually quite simple. However before we go creating tables we need to first understand the data we want to store. To make sure our data scales appropriately we need to break down the data into its smallest form so we can easily add data and read from it. 

### Other DB Types
https://dev.mysql.com/doc/refman/8.0/en/data-types.html
https://docs.oracle.com/cd/B28359_01/server.111/b28318/datatype.htm
https://docs.microsoft.com/en-us/sql/t-sql/data-types/data-types-transact-sql?view=sql-server-2017
https://www.postgresql.org/docs/9.5/datatype.html

Create a Table with SQL Create

Tables in databases are not worth much value if they do not actually hold data. In this lesson we will use the insert statement to add rows of data to our table. We'll break down each component of the statement and review what is required for a successful insert. 


Add Data to a Table with SQL Insert

Databases are not really good for anything if we are not able to get the data out. By using the select statement, we can pull out all of the data within our database table. Let's work with different queries that pulls out all of our columns, just some of the columns, and even filters out duplicate column values. 

Query Data with the Select Command in SQL

SQL gives us the power to choose what data we pull out of our table. We will use the where clause within our select statement with many operators. These include the greater than, less than, equal, and not equal. We will also use some special operators such as "in", "between", and "is". 

Conditionally Select out Filtered Data with SQL Where

When working with database tables, we want to make sure we keep our data as simple as possible. This can sometimes mean having multiple tables that share some data columns. Using the join statement, we can combine data between two tables on similar column data to gather more information in one query. Let’s work through some common join statements like left, right, inner, and cross join. 


Combining Tables Together with SQL Join Statements

Another powerful SQL skill is understanding how to group rows together by column values.  Once the data is grouped together, it can be difficult to understand how to actually work with the groupings. In this lesson, we will use the group by clause, as well as the count, sum, avg, min, and max aggregate functions. 

### Counts with create date and first name example: 
```sql
SELECT u.total, u.create_date, first_name 
FROM Users us 
INNER JOIN (SELECT count(create_date) AS total, create_date 
   FROM Users
   GROUP BY create_date) u ON u.create_date = us.create_date;
```

### Min create date with first name example: 
```sql
SELECT create_date, first_name 
FROM Users 
WHERE create_date = (select min(create_date) FROM Users);
```
### Aggregate functions: 

https://www.postgresql.org/docs/9.5/functions-aggregate.html
https://dev.mysql.com/doc/refman/8.0/en/group-by-functions.html
https://docs.microsoft.com/en-us/sql/t-sql/functions/aggregate-functions-transact-sql
https://docs.oracle.com/database/121/SQLRF/functions003.htm

Select Grouped and Aggregated Data with SQL

Relational databases can organize their data in a way that makes it more efficient to add/update/read/delete from. Similar to books, using SQL we can create indexes which defines how to our organize data behind the scenes. 

### More Info 
https://www.postgresql.org/docs/9.1/indexes.html

https://dev.mysql.com/doc/refman/8.0/en/mysql-indexes.html

https://docs.oracle.com/cd/E11882_01/server.112/e40540/indexiot.htm#CNCPT721

https://docs.microsoft.com/en-us/sql/relational-databases/indexes/clustered-and-nonclustered-indexes-described?view=sql-server-2017

Organize Table Data with Indexes

SQL is dynamic enough to handle queries within queries. These inner queries are called subqueries and they can be used in many different sections of another query. In this video we will use subqueries within a where clause, a join statement, and as a column value. 

### Answer to video challenge
```
select user_handle, sku, (select avg(quantity) from Purchases where user_handle = p.user_handle and sku = p.sku) from Purchases p group by user_handle, sku;
```

Subquery Dynamic Datasets in SQL

One of the core commands in SQL is update. This is how we can modify the data that is already in our database table. Let’s update our users table and change one of our user's duplicated user handle to a new UUID. We'll even use a postgres extension to generate new UUIDs.  




**UUIDs / GUIDs**

*Postgres* - http://www.postgresqltutorial.com/postgresql-uuid/

*SQL Server*- https://docs.microsoft.com/en-us/sql/t-sql/functions/newid-transact-sql?view=sql-server-2017

*MySQL* - https://dev.mysql.com/doc/refman/8.0/en/miscellaneous-functions.html#function_uuid

*Oracle* - https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html




Update Data in a Table with SQL Update

Deleting data within our table is easily done by using ether the delete, truncate, or just dropping the table altogether from our database. Let’s remove a user from our table using the delete command, remove everyone with truncate, then drop the entire table with the drop command. 

Removing Data with SQL Delete, Truncate, and Drop

This course is designed to take someone that has no experience with relational databases and teach them how to at least create, read, update, and delete. We'll explore many different aspects of SQL and what makes working in relational databases easy. This video also goes over how to install postgres on your machine so you can follow along. 


### Install Homebrew for Mac
https://brew.sh/

### Windows postgres installer
https://www.postgresql.org/download/windows/

Topics

Instructors

Content Type

Free or Pro