menu

Search By Label

In PostgreSQL, the FOUND variable is a simple flag that helps you check if a query has found any results. It's like a "yes" or "no" indicator. 
 
1. When a query successfully finds one or more results, FOUND is set to true (or "yes").
2. When a query doesn't find any results, FOUND is set to false (or "no").

You can use FOUND in control structures like IF statements to make decisions based on whether your query found anything or not. It's a handy way to handle the outcome of a database search in your SQL scripts.
In PostgreSQL scripts, you can use global variables by defining custom variables and using them within your SQL code.
 
Example:

-- set a global variable 
SET my_var = 42;-- use the global variable 
SELECT * FROM my_table WHERE column = my_var;-- unset the global variable RESET my_var;

Complexity: Managing many small services can be like juggling a lot of balls. It can get complicated to coordinate and keep track of all these services. This complexity can make development and debugging more challenging.

Communication Overhead: In a microservices architecture, services often need to talk to each other over a network. This communication adds overhead and can slow things down compared to a monolithic system where everything is in one place.

Deployment Challenges: Deploying changes to multiple services can be like herding cats. Each service may have its own version, and coordinating updates across all of them can be tricky. It requires careful planning and automation.
Flexibility: Microservices allow you to independently build and update different application parts. It's like having building blocks that you can rearrange or replace without affecting the entire structure. This flexibility makes it easier to adapt to changing needs and technologies.

Scalability: Imagine you're running a restaurant, and each dish is prepared in its kitchen. If one dish becomes popular, you can add more kitchens just for that dish without changing the whole restaurant. Microservices work similarly, allowing you to scale specific application parts to handle more traffic or load.

Fault Isolation: In a large application, if one part breaks, it can sometimes bring down the entire thing. If one service has an issue with microservices, it's like a single light bulb going out in a string of lights. The rest of the lights (services) can keep shining. This helps with fault isolation and keeps your application more robust.
This tool can help you learn things like: 

1. How many rows were affected by a command? 
2. What's the unique ID of the last row that was added to a table?
3. If there was an error, what's the reason for it?
 
You can use this tool in a program or script to check these things. 

For example, if you update some data in a table, you can use "GET DIAGNOSTICS" to see how many rows got changed and if there was any problem. This can be really handy for keeping track of what's going on when you're working with a database. 

Example:

-- Let's say we update some data in a table. 
UPDATE my_table SET column1 = 'new_value' WHERE id = 42;-- Now, we want to know how many rows got changed and if there's a unique ID for the last row. 
GET DIAGNOSTICS rows_affected = ROW_COUNT, last_oid = RESULT_OID;-- We can print these values to see what happened. 
RAISE NOTICE 'Rows affected: %, Last OID: %', rows_affected, last_oid; 
We use RAISE NOTICE to generate a notice message like we use the console.logs() on Javascript. The message can include placeholders (e.g., %) where you can insert values or variables. 

Example:

CREATE OR REPLACE FUNCTION example_function() RETURNS void AS $$ 
BEGIN 
 -- Some code here 
 
 -- Raise a notice message 
 RAISE NOTICE 'This is a notice message: %', 'Additional data'; 
 
 -- More code here 
END; 
$$ LANGUAGE plpgsql; 

The :not pseudo selector is useful for styling a group of elements while leaving the last (or specified) element unstyled.

 
HTML
One
Two
Three
Four


CSS
.css-not-selector-shortcut { 
 display: flex; 
}

ul { padding-left: 0; }
li { list-style-type: none; margin: 0; padding: 0 0.75rem; }
li:not(:last-child) { border-right: 2px solid #d2d5e4; }

Did you know that in Ruby 3.1.3 and prior some regexps could take a long time to process?

Don't believe me? Try running this in a 3.1.3 irb console:

`/^a*b?a*$/ =~ "a" * 50000 + "x"`

Your system will halt for like 10 seconds before returning no matches. This is the basis for ReDoS (Regexp Denial of Service) attacks.

Thankfully, Ruby 3.2.0 has fixed this and the same regexp gets resolved in 0.003 seconds. They also added a `Regex.timeout` global option which would prevent your app from falling victim to ReDoS attacks!

Yesterday I implemented gzip request support in a project and noticed there are no gems for that. There's `Rack::Deflater` but that's for responses, not requests. Apparently, incoming gzipped payloads are uncommon. 🤷‍♀

Maybe an opportunity to write a new gem? 🤔

y - stage this hunk

n - do not stage this hunk

q - quit; do not stage this hunk or any of the remaining ones

a - stage this hunk and all later hunks in the file

d - do not stage this hunk or any of the later hunks in the file

g - select a hunk to go to

/ - search for a hunk matching the given regex

j - leave this hunk undecided, see next undecided hunk

J - leave this hunk undecided, see next hunk

k - leave this hunk undecided, see previous undecided hunk

K - leave this hunk undecided, see previous hunk

s - split the current hunk into smaller hunks

e - manually edit the current hunk

? - print help

By default, Rails ships with three environments: "development," "test," and "production." To navigate between each environment, you can use the following command: 
 
 
bin/rails db:environment:set RAILS_ENV="YOUR_ENVIRONMENT" 
In Ruby, the .empty? method is used to check whether a data structure, such as a string, array, or hash, is empty. It returns true if the object it is called on contains no elements or characters, and false otherwise. 

Example:

# Strings 
empty_string = "" 
non_empty_string = "Hello, world!"empty_string.empty? # => true 
non_empty_string.empty? # => false# Arrays 
empty_array = [] 
non_empty_array = [1, 2, 3]empty_array.empty? # => true 
non_empty_array.empty? # => false# Hashes 
empty_hash = {} 
non_empty_hash = { name: "John", age: 30 }empty_hash.empty? # => true 
non_empty_hash.empty? # => false

 In PostgreSQL, the AVG function is used to calculate the average (arithmetic mean) of a set of numeric values within a specified column of a table. It's a convenient way to find the average value of a dataset in a SQL query. 

Syntax:

AVG(column_name) 
In PostgreSQL, the ROUND function is used to round a numeric value to a specified number of decimal places. It is a very useful function when you need to control the precision of numeric values in your database queries or calculations. 

Syntax:

ROUND(numeric_expression, number_of_decimal_places) 
Is a JavaScript method used for displaying an interactive list of the properties of a specified JavaScript object. It is particularly useful for examining the structure and contents of complex objects, such as DOM elements or custom JavaScript objects. 

Here's how `console.dir()` works with an example:

const person = { 
 firstName: "John", 
 lastName: "Doe", 
 age: 30, 
 address: { 
 street: "123 Main St", 
 city: "Anytown", 
 state: "CA", 
 zip: "12345", 
 }, 
};console.dir(person);/* output: 
Object 
 age: 30 
 address: Object 
 city: "Anytown" 
 state: "CA" 
 street: "123 Main St" 
 zip: "12345" 
 firstName: "John" 
 lastName: "Doe" 
*/