Today I Learned

In JavaScript, a generator is a special type of function that allows you to pause and resume its execution. Generators are defined using the function* syntax, and they are capable of producing a sequence of values lazily, one at a time. They are particularly useful for working with asynchronous code and creating iterable objects.

Let's assume you have a web application that fetches a large dataset of users from a remote API. Loading all users at once would be inefficient and slow. Instead, you can use a generator to paginate through the data, fetching a limited number of users at a time as needed.

Example:

async function* fetchUsers() { 
 let page = 1; 
 const perPage = 10; // Number of users per page

 while (true) { 
  const response = await fetch(`https://api.example.com/users?page=${page}&per_page=${perPage}`); 
  const users = await response.json();

  if (users.length === 0) { 
    // No more users to fetch 
    break; 
  }

  for (const user of users) { 
    yield user; 
  }

  page++; 
 } 
}

// Usage: 
const userGenerator = fetchUsers();(async () => { 
 for await (const user of userGenerator) { 
 console.log(`User: ${user.name}, Email: ${user.email}`); 
 } 
})();

Using range filter for Elasticsearch

Elasticsearch

A range filter in an Elasticsearch query is used to filter documents based on a specific numeric or date field falling within a specified range of values. This filter allows you to retrieve documents that meet certain criteria within a specified range.

When dealing with numeric fields (e.g., prices, quantities), you can use a range filter to find documents where the field value falls within a specified numeric range.

Example:

{ 
 "range": { 
   "price": { 
     "gte": 20, 
     "lte": 50 
   } 
 } 
}

For date fields (e.g., timestamps, dates of events), you can use a range filter to filter documents within a specified date range.

Example:

{ 
 "range": { 
   "event_date": { 
     "gte": "2023-01-01", 
     "lte": "2023-12-31" 
   } 
 } 
}

Using Regex matching

Postgres

You can use the "regexp_match" function to perform regular expression matching within SQL queries. This function allows you to extract matched substrings from a text column based on a regular expression pattern.

Example:

SELECT regexp_match(column_name, 'your_regex_pattern') AS matched_text 
FROM table_name;

Min/Max Postgres methods

Postgres

In PostgreSQL, the "MIN" and "MAX" functions are aggregate functions used to find the minimum and maximum values within a set of rows or a specific column in a table.

The "MIN" function is used to find the minimum value within a set of values. It can be applied to both numeric and non-numeric data types. When used in conjunction with a GROUP BY clause, it finds the minimum value for each group.

Example:
Find the minimum value in a column:

SELECT MIN(column_name) FROM table_name;

The "MAX" function is used to find the maximum value within a set of values, similar to MIN. It can be applied to both numeric and non-numeric data types. When used with GROUP BY, it finds the maximum value for each group.

Example:
Find the maximum value in a column:

SELECT MAX(column_name) FROM table_name;

string_agg method

Postgres

string_agg function: This function is used for string aggregation or concatenation within groups of rows. It takes an expression (usually a column) and concatenates the values of that expression across rows in a group, separated by a specified delimiter.

For example, suppose you have a table of orders and you want to concatenate the names of products for each order, separated by commas:

SELECT order_id, string_agg(product_name, ', ') AS products 
FROM order_details 
GROUP BY order_id;

In this query, string_agg(product_name, ', ') concatenates the product_name values for each order, separated by commas.

It's a useful function for creating comma-separated lists or combining text values within groups when working with SQL in PostgreSQL.

Shortcut to make iTerm tab go full-screen

Iterm

To make a specific session (tab) in iTerm go full screen, you can use the following shortcut:

Press `Cmd` + `Shift` + `Enter`

This keyboard shortcut will maximize the current session (tab) to full-screen mode without affecting other tabs.

Use % as a wildcard on searching

Postgres

If you want to match text that ends with "-dev" using a WHERE sentence in PostgreSQL, you can do so using the LIKE operator and the percent sign % as a wildcard. Here's how:

-- Example: Match strings that end with '-dev' 
SELECT * 
FROM your_table 
WHERE your_column LIKE '%-dev';

In this example, the LIKE operator with the pattern "%-dev" will match any strings in your_column that end with "-dev". The percent sign % acts as a wildcard for zero or more characters. So, it matches any text that ends with "-dev".

Upper/Lower Method

Postgres

In PostgreSQL, the `UPPER` and `LOWER` functions are used to manipulate the case of text strings. Here's a quick explanation of each function with an example:

UPPER Function:
The UPPER function converts all characters in a text string to uppercase.

Syntax:

UPPER(string)

LOWER Function:
The LOWER function converts all characters in a text string to lowercase.

Syntax:

LOWER(string)

What are Views

Postgres

In PostgreSQL, a view is a virtual table created by a query. It behaves like a table but doesn't store data itself; instead, it's a saved query that can be referenced like a table. Views are useful for simplifying complex queries, providing an abstracted layer over tables, and controlling access to data.

Explanation:
1. A view is defined by a SQL query and has a name.
2. The view's data is dynamically generated based on the query whenever the view is queried.
3. Views can simplify complex joins or aggregations and abstract the underlying data structure for users.

Example:
Suppose you have a database with a table orders containing order information with columns like `order_id`, `customer_id`, and `order_date`. You want to create a view that shows only the orders placed by a specific customer. Here's how you can do it:

-- Create a view named "customer_orders" to show orders for a specific customer 
CREATE VIEW customer_orders AS 
SELECT order_id, order_date 
FROM orders 
WHERE customer_id = '12345';

Substring function

Postgres

In PostgreSQL, the SUBSTRING function is used to extract a portion of a string from within another string. It allows you to specify the starting position and the length of the substring you want to extract.

Example:

SUBSTRING(string FROM start_position [FOR length])

Where-in sentence on Postgres

Postgres

In PostgreSQL and SQL in general, the `WHERE` clause, combined with the `IN` operator, is used to filter rows from a table based on a specified list of values. It allows you to retrieve rows that match any of the values provided in the list. The `IN` operator simplifies querying for multiple values without the need for multiple `OR` conditions.

Example:

SELECT column1, column2, ... 
FROM table_name 
WHERE column_name IN (value1, value2, ...);

Double negation

Javascript

In JavaScript, the double exclamation mark (!!) is often used as a shorthand to convert a value to its corresponding Boolean representation. It essentially coerces a value to either true or false. Here's a quick explanation and example of its use:

Example:

let someValue = "Hello";
let isTruthy = !!someValue; 
console.log(isTruthy); // truesomeValue = 0;
let isFalsy = !!someValue; 
console.log(isFalsy); // false

Git Grep

Git

"git grep" is a Git command used for searching through your Git repository's files for specific text patterns. It's a powerful tool for finding where a particular string or regular expression appears in your codebase. The "git grep" command can be especially helpful for debugging, refactoring, or finding specific references in your code.

Usage:

git grep [options] pattern