Learn Jest, Postgres and Redwoodjs

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

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

In this collection, we build a minimal flashcard application using React, primarily focusing on function components and the hooks API. To make sure we can understand and maintain existing code, there are also a few lessons toward the end that use class components so you can get familiar with the syntax. We cover important React concepts, and sprinkle in libraries that are pretty standard in the ecosystem like @reach/router, Jest, and React testing library. We start with create-react-app so we can get right into it without worrying about configuring tooling. There's [a separate course for that here](https://egghead.io/courses/modern-javascript-tooling-with-react?af=5mx0ie)

jest

Build a React App with the Hooks API

In this course we are going to work through properly setting up Enzyme with Jest to test rendered components. This includes the nitty gritty of making our testing environment work with various versions of React. After we get our environment setup ready, we’ll work through the different ways we can render a component within our test pages. With a rendered component we can now test component methods and properties to assert that they are what is intended. 

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

Test React Components with Enzyme and Jest

End-to-end testing assures you of a few things: that all the integrated pieces of an application properly function, all those pieces work together as expected, and your tests include and simulate real-user scenarios — something unit and integration tests just don't do.

This course introduces you to two great tools for E2E testing: 

* Puppeteer opens and runs applications in a Chromium browser and performs the actions it's given.
* Jest asserts that the integrated pieces work as expected and that add-on libraries like Faker and pixelmatch take our tests to the next level.

Over 9 lessons, we will create common application features and use Puppeteer and Jest to run different types of tests against them. You'll get practice using these tools to render content, mimic user activity, automate tests, and measure the overall performance of your application.

End to End Testing with Google's Puppeteer and Jest

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

RedwoodJS takes the JAMstack philosophy to the next level. It brings together all the tools modern web development has to offer:

- React
- GraphQL
- Prisma

RedwoodJS abstracts database management away from you so that you can just build your schema and it will do all the plumbing. This collection will go over how to create a RedwoodJS project and the scripts that will help make your developer experience a joy.


Bringing full-stack to the JAMstack

Do you love the JAMstack philosophy but need a database-backed web app? Want great developer experience and easy scaling? Redwood is here! Built on React, GraphQL, and Prisma, Redwood works with the components and development workflow you love, but with simple conventions and helpers to make your experience even better.

redwoodjs

Introduction to RedwoodJS: full-stack framework for JAMstack

Here are all the Egghead.io lessons about testing with Jest! http://facebook.github.io/jest (https://kcd.im/egghead-jest)

Testing JavaScript with Jest

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

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

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

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

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

Kent walks us through the internals of dom-testing-library and react-testing-library. 

There is a lot of set-up and tear down when testing UI components. These two libraries take away a lot of the work required to test React components well. 

Jest is commonly used in tandem with react-testing-library to assert results of your components. Jest simulates most browser apis with jsdom. react-testing-library helps you get values out of your components the same way your end users will. 

Links from the show:
- [Testing Library](https://testing-library.com)
- [Testing Javascript](https://testingjavascript.com)
- [Unit vs Integration vs E2E](https://kentcdodds.com/blog/unit-vs-integration-vs-e2e-tests)
- [Why you shouldn't ReactDOM.render to the body](https://medium.com/@dan_abramov/two-weird-tricks-that-fix-react-7cf9bbdef375)
- [Effective Snapshot Testing]( https://kentcdodds.com/blog/effective-snapshot-testing/)
- [Dev Tips with Kent](https://youtu.be/ttmvAm6esSc)
- https://kcd.im/news

Understanding how react-testing-library works with Kent C. Dodds

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/

Setup and Introduction to SQL Fundamentals

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

Topics

Instructors

Content Type