DEV Community: blugreenspace

Finding Which Columns Value Has Actually Changed in PostgreSQL Trigger Functions

blugreenspace — Sun, 07 Apr 2024 15:49:15 +0000

Finding Which Columns Value Has Actually Changed in PostgreSQL Trigger Functions

In PostgreSQL, triggers are powerful tools used to execute custom actions when certain events occur on a specified table. One common use case for triggers is auditing changes to data. When implementing an audit trail, it's essential to identify which columns have been modified in an update operation. This article explores how to efficiently determine which columns have had their values changed within a trigger function.

The Challenge

When an update operation occurs on a table, it's necessary to identify which columns have been modified and record these changes. However, PostgreSQL does not provide built-in functionality to directly identify the changed columns within a trigger function. Instead, developers need to devise a method to achieve this.

Solution With Example

To identify the changed columns within a PostgreSQL trigger function, we can compare the old and new values of each column using dynamic SQL and JSON functions. Let's illustrate this with an example trigger function:

CREATE OR REPLACE FUNCTION audit_changes()
RETURNS TRIGGER AS
$$
DECLARE
    _changed_columns TEXT[];
BEGIN
    SELECT array_agg(pre.key)
    INTO _changed_columns
    FROM jsonb_each(to_jsonb(old)) AS pre
    CROSS JOIN jsonb_each(to_jsonb(new)) AS post
    WHERE pre.key = post.key
      AND pre.value IS DISTINCT FROM post.value
    ;

    -- Perform actions based on the changed columns
    -- For example, log the changes to an audit table
    INSERT INTO audit_table (table_name, changed_columns)
    VALUES (TG_TABLE_NAME, _changed_columns);

    RETURN NEW;
END;
$$
LANGUAGE plpgsql;

Once the trigger function audit_changes() is defined, it can be associated with a specific table and event (e.g., BEFORE UPDATE):

CREATE TRIGGER audit_table_changes
BEFORE UPDATE ON your_table
FOR EACH ROW
EXECUTE FUNCTION audit_changes();

This trigger will execute the audit_changes() function before each UPDATE operation on your_table. It will identify the changed columns, log them into an audit table, and then allow the original update operation to proceed.

Conclusion

In PostgreSQL trigger functions, identifying changed columns is a common requirement for various purposes such as auditing and conditional logic. By leveraging PostgreSQL's JSONB functions, we can efficiently compare old and new row states to determine which columns have been modified. Implementing this logic within trigger functions allows for automated tracking of changes, enhancing data integrity and auditability in database systems.

Preventing Empty Updates In PostgreSQL Tables Using A Simple Trigger Function

blugreenspace — Thu, 26 Oct 2023 14:51:50 +0000

The Need for Preventing Empty Updates

Empty updates are silent problems in PostgreSQL, occurring when an UPDATE makes no real changes to data. They're wasteful and can lead to loops in scenarios with recursive triggers.

Some common causes of empty updates include:

Triggers meant to maintain data integrity can trigger loops if they update the same table. This leads to inefficiencies.
Two tables need to stay in sync. Changes in one table trigger updates in the other, and vice versa. Mismanagement can lead to recursive circular updates, causing empty updates and performance issues.

The Solution: A Simple Trigger Function

CREATE OR REPLACE FUNCTION prevent_empty_update()
RETURNS trigger
LANGUAGE plpgsql
AS $function$
DECLARE
BEGIN
    if old is not distinct from new then
        return null;
    end if;

    return new;
END;
$function$;

The if old is not distinct from new then condition evaluates if the old and new data are the same. If they are identical, it means that the update does not change any values in the row, and the function returns null.
If the condition is not met, indicating that the update will make changes to the row, the function returns new, allowing the update to proceed.

Application Of The Trigger Function

To put this trigger function into action, you need to apply it to the specific tables where you want to prevent empty updates.
Use the BEFORE UPDATE trigger to execute the prevent_empty_update() function for each row before the update is performed.

CREATE TRIGGER prevent_empty_updates
BEFORE UPDATE ON your_table
FOR EACH ROW
EXECUTE FUNCTION prevent_empty_update();

By implementing this trigger function, you can improve the efficiency and reliability of your PostgreSQL database, reducing the risk of unnecessary data modifications and recursive loops.

Understanding Closures in Python

blugreenspace — Sun, 10 Sep 2023 15:46:50 +0000

Closures are a powerful concept in programming that exist in both Python and many other programming languages. They allow functions to retain access to their enclosing scope's variables even after the outer function has completed execution.

In Python, a closure is a nested function that captures and remembers the values of variables in the enclosing (containing) function's local scope, even if the enclosing function has finished executing. This means that a closure "closes over" the variables it needs, allowing them to persist beyond the lifetime of the enclosing function.

To create a closure, you typically define a nested function inside another function and return that nested function.

How Closures Work

Let's start with a simple example to illustrate how closures work in Python:

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

closure = outer_function(10)
result = closure(5)
print(result)  # Output: 15

In this example, inner_function is defined inside outer_function. When outer_function is called with an argument of 10, it returns inner_function, which is then assigned to the closure variable. Later, when closure is called with an argument of 5, it still has access to the x variable from its enclosing scope, resulting in the output 15.

Why Use Closures?

Closures can be incredibly useful in various scenarios, such as:

Function Factories: Closures can be used to generate specialized functions based on some initial configuration or parameters. This is particularly handy when you need to create multiple similar functions with different settings.

Callbacks: Closures are commonly used in event-driven programming to create callback functions that carry additional context or state information.

Data Encapsulation: You can use closures to encapsulate data within a function, creating a private scope for that data. This helps in maintaining data integrity and preventing unintended modifications.

Decorator Pattern: Modifying the behaviour of functions without altering their code.

Memoization: Closures can be used to cache the results of expensive function calls, improving performance by avoiding unnecessary re-computation.

Now, let's dive into some Python code examples to understand closures better.

Function Factory

def exponentiate(power):
    def inner(base):
        return base ** power
    return inner

square = exponentiate(2)
cube = exponentiate(3)

print(square(4))  # Output: 16
print(cube(4))    # Output: 64

Here, exponentiate is a function factory that generates functions for calculating squares and cubes.

Callbacks

def event_handler(event_name):
    def callback(*args, **kwargs):
        print(f"Event '{event_name}' triggered with args: {args}, kwargs: {kwargs}")
    return callback

button_click = event_handler("button_click")
button_click("left_click", x=100, y=200)
# Event 'button_click' triggered with args: ('left_click',), kwargs: {'x': 100, 'y': 200}

In this example, event_handler creates a callback function tailored for a specific event.

Data Encapsulation

def counter():
    count = 0

    def increment():
        nonlocal count  # Use nonlocal to modify the count variable in the enclosing scope
        count += 1
        return count

    def decrement():
        nonlocal count
        count -= 1
        return count

    return increment, decrement

inc, dec = counter()  # Get closures for increment and decrement
print(inc())  # Output: 1
print(inc())  # Output: 2
print(dec())  # Output: 1

In this example, counter returns two closures: increment and decrement. These closures share access to the count variable and allow us to modify it without exposing it to the global scope.

Decorators

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

# Output:
# Something is happening before the function is called.
# Hello!
# Something is happening after the function is called.

This code defines a decorator my_decorator, which wraps the say_hello function with additional behaviour.

Memoization

import time


def memoize(func):
    cache = {}

    def wrapper(n):
        if n not in cache:
            cache[n] = func(n)
        return cache[n]

    return wrapper


@memoize
def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)


start_time = time.time()
factorial(300)
print((time.time() - start_time)*1000, "ms in 1st time")

start_time = time.time()
factorial(300)
print((time.time() - start_time)*1000, "ms in 2nd time")

# Output:
# 1.6314983367919922 ms in 1st time
# 0.004291534423828125 ms in 2nd time

In this example, we have created a memoize closure that takes a function func as its input. The cache dictionary within the closure stores previously computed results to avoid redundant calculations.

The wrapper function is the actual closure, which takes an argument n. It checks if the result for n is already in the cache. If it is, it returns the cached value; otherwise, it computes the result using the original func and caches it before returning.

The @memoize decorator is applied to the factorial function, which enables memoization for the factorial function. Now, when you call factorial(n) for any value of n, the function will check if the result is already cached before performing the actual factorial computation. This dramatically reduces redundant calculations and improves performance for large values of n.

Using closures and memoization in this way can significantly optimize recursive functions and is a useful technique in many algorithmic scenarios.

Conclusion

Closures are a powerful and versatile feature in Python. They enable you to create functions that retain access to their surrounding context, making them useful for a wide range of programming tasks. Understanding closures is essential for writing clean, maintainable, and expressive Python code.

Understanding Python Context Managers

blugreenspace — Sun, 03 Sep 2023 16:57:21 +0000

Context managers are a powerful yet often underutilized feature in Python. They allow you to manage resources, handle exceptions, and simplify your code. In this article, we'll explore what context managers are and how to use them effectively with plenty of code examples.

What is a Context Manager?

Before diving into the implementation details, let's briefly review what context managers are and why they are important.

A context manager is responsible for setting up and tearing down resources before and after a block of code is executed. They are commonly used with the with statement to ensure that resources are acquired and released properly, even if an exception occurs within the block of code.

Python's built-in context managers, like open() for file handling, socket for network connections, or lock for managing threads, demonstrate the importance and versatility of this feature.

Code Examples

Now let's dive into practical examples to understand how context managers work and how they can improve your Python code.

Example 1: Inbuilt Context Manager

with open('example.txt', 'w') as file:
    file.write('Hello, Context Managers!')

In this example, the open() function returns a context manager that automatically closes the file when the block is exited, even if an exception occurs.

Example 2: Custom Context Manager

class DatabaseConnection:
    def __init__(self, db_url):
        self.db_url = db_url
        self.connection = None

    def __enter__(self):
        self.connection = connect_to_database(self.db_url)
        return self.connection

    def __exit__(self, exc_type, exc_value, traceback):
        if self.connection:
            self.connection.close()
        print('exc:', exc_type, exc_value, traceback)
        # To handle the exception, return a True value
        # Otherwise, the exception will be raised by the 'with' statement

# Using a custom context manager to handle database connections
with DatabaseConnection('example.com/db'):
    # Perform database operations

# The connection is automatically closed when the 'with' block exits

Here, we define a custom context manager DatabaseConnection that manages a database connection. The __enter__() method establishes the connection, and the __exit__() method ensures it is properly closed, even in the presence of exceptions.

If an exception occurs, Python passes the exc_type, exc_value, and traceback to the __exit__ method. You can handle the exception here. If anything other than True is returned by the __exit__ method, then the exception is raised by the with statement.

Example 3: Using the `contextlib` Module

@contextmanager
def file_manager(file_name, mode):
    try:
        file = open(file_name, mode)
        yield file
    finally:
        file.close()

# Using the file manager context manager
with file_manager("example.txt", "w") as file:
    file.write("Hello, world!")

In this example, file_manager ensures that the file is properly opened, yields the file object for use within the with block, and then closes the file in a finally block, regardless of whether an exception occurs.

Conclusion

Python's context managers are a versatile tool for resource management and clean code. They help ensure that resources are properly acquired and released, making your code more robust and readable. Whether you're dealing with files, databases, or custom contexts, understanding and using context managers will significantly improve your Python programming skills.

Take the time to explore context managers further in your Python projects. They can simplify complex resource management tasks and lead to more reliable and maintainable code.

Understanding Python Generators - Harnessing Lazy Evaluation

blugreenspace — Mon, 14 Aug 2023 14:53:45 +0000

Generators in Python are a type of iterable that can be used to iterate over a sequence of values without generating the entire sequence in memory. This makes them ideal for scenarios where you're dealing with large datasets, as they can help you avoid memory issues and improve the overall performance of your code.

The key feature that differentiates generators from other iterables is that they use lazy evaluation. This means that they only compute and yield values one at a time as you iterate over them, rather than creating a full list of values upfront.

Creating Generators

Creating a generator is as simple as defining a function with the yield keyword. Let's start with a basic example:

def countdown(n):
    while n > 0:
        yield n
        n -= 1

counter = countdown(5)
for num in counter:
    print(num)

In this example, the countdown function is a generator that yields numbers from n down to 1. The generator produces each value as it's requested, and no unnecessary memory is consumed, even though the countdown function theoretically generates an infinite sequence.

What is `yield`?

You might be wondering what the yield keyword does. At first glance, yield might appear to be just another way to return a value from a function. However, it goes beyond simple returns and plays a pivotal role in creating generators.

The key distinction between a regular function and a generator function lies in the use of the yield keyword. When a function contains yield, it becomes a generator function, and when called, it doesn't execute its code immediately. Instead, it returns a generator object, which can be iterated over to yield values one at a time.

Generator Expressions

Python also offers generator expressions, which are similar to list comprehensions but produce values lazily. Compare the memory usage between these two:

# List comprehension
squared_list = [x ** 2 for x in range(1, 1000000)]
sys.getsizeof(squared_list)
# 8448728

# Generator expression
squared_generator = (x ** 2 for x in range(1, 1000000))
sys.getsizeof(squared_generator)
# 112

The list comprehension creates an entire list in memory, while the generator expression produces values as needed.

Memory-Efficient Infinite Sequences

Generators are perfect for representing infinite sequences. Consider the Fibonacci sequence, which goes on infinitely. Here's a generator that generates Fibonacci numbers:

def fibonacci_generator():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib_sequence = fibonacci_generator()
for _ in range(10):
    print(next(fib_sequence))

You can use this generator to generate Fibonacci numbers lazily without worrying about memory constraints.

Pipelining

Imagine you have a large log file containing various events, and you need to extract specific information from it. Let's see how we can use generators to create an efficient pipeline for this task.

def read_log_file(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line

def filter_events(log_lines, keyword):
    for line in log_lines:
        if keyword in line:
            yield line

def extract_information(filtered_lines):
    for line in filtered_lines:
        # Extract relevant data from the line
        extracted_data = line.strip()
        yield extracted_data

log_file_path = 'logfile.log'

# Create the pipeline
pipeline = extract_information(filter_events(read_log_file(log_file_path), 'error'))

# Iterate over the results
for result in pipeline:
    print(result)

In this example, we've created three generator functions: read_log_file, filter_events, and extract_information. Each function processes the input and generates values for the next stage of the pipeline. This allows us to process the log file efficiently without loading the entire file into memory.

Pipelining is not only about memory efficiency; it also allows for more organized and modular code. Each stage of the pipeline is encapsulated in a separate function, making the code easier to understand and maintain. Additionally, pipelines can be extended with additional stages or modified without affecting the rest of the code.

Conclusion

Python generators provide an elegant way to improve code performance and memory efficiency, especially when used in pipelining scenarios. By leveraging lazy evaluation and producing data on-the-fly, generators enable you to process large datasets with minimal memory consumption. Understanding and using generators effectively can lead to more efficient and responsive Python applications.

Remember to explore and experiment with generators to harness their full potential in various programming tasks. Whether you're dealing with massive datasets or aiming to optimize your code, generators can be a powerful tool in your Python toolbox.

Zima Blue by Alastair Reynolds - An Existential Exploration

blugreenspace — Sun, 06 Aug 2023 17:05:57 +0000

The story follows a journalist as she receives an invitation from the elusive and enigmatic artist, Zima, who has suddenly decided to share the truth behind his life's work. Zima was once an ordinary cleaning robot, but through a series of self-modifications and upgrades, he evolved into an AI with a profound artistic sensibility. His rise to fame and notoriety occurred when he began creating thought-provoking artworks, often dominated by the color "Zima blue".

As the journalist delves deeper into Zima's past, she uncovers the key to his artistic vision, the search for truth in its purest form. Zima's last masterpiece is an art installation that he reveals at the end of his life: a giant "Zima blue" shape painted on the ocean floor of a distant planet. This artwork is accompanied by a profound revelation in the form of a final message, which profoundly impacts those who witness it.

Throughout the narrative, Reynolds weaves a thought-provoking exploration of existential themes. Zima's desire for authenticity, the meaning of existence, and the importance of self-discovery are all examined in the context of a rapidly changing technological landscape. The story poses questions about the nature of humanity and the potential for self-actualization within the realms of artificial intelligence.

Zima's journey from a simple cleaning robot to a complex AI artist highlights the blurred boundaries between artificial intelligence and human creativity. The narrative showcases the human desire to express emotions and thoughts through art, regardless of the medium or the artist's origins.

A great story is one that stays in your mind even after you've finished reading it. "Zima Blue" is exactly that kind of story. It makes you think deeply about life, the world, and what it means to be human. It explores big questions about existence and our place in the universe, leaving you with plenty to ponder.

The story also has a Netflix adaptation, which is a part of the anthology series "Love, Death & Robots". The episode is directed by Robert Valley and is a visual treat. The animation is stunning and the story is well adapted for the screen.

Creating multi-purpose reactive forms with Angular

blugreenspace — Sun, 06 Aug 2023 17:05:56 +0000

Hello.

This will be a short and quick tutorial on reactive forms with Angular.
We'll be learning step by step on how to create a single
signup/login/reset form with a couple of extra dynamic elements.

The idea and assumption are that generally, these three forms have common elements,
we can combine them and save time and long-term maintainability without sacrificing much UI/UX.

Let's start.

References

Step 1: Basic setup

Head over to your app.module.ts or any parent module.
Make sure it has the following imports and structure.

import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { ReactiveFormsModule } from '@angular/forms';

import { AppComponent } from './app.component';

@NgModule({
  imports: [
    BrowserModule,
    ReactiveFormsModule
  ],
  declarations: [
    AppComponent
  ],
  bootstrap: [AppComponent]
})

export class AppModule { }

Step 2: Form UI/UX

Below is the code for the whole dynamic form.
It reacts to user input and changes accordingly.
It also includes validation and error feedback.

<div class="jumbotron">
  <div class="container">
    <div class="row">
      <div class="col-lg-4 col-md-6 ml-auto mr-auto">
        <div class="card">
          <form class="form" [formGroup]="formGroup" (ngSubmit)="process()">

            <div class="card-header card-header-primary text-center">
              <h4 class="card-title">
                {{newUser ? 'Signup' : 'Login'}}
              </h4>
              <a (click)="toggle()" class="btn btn-warning">
                {{newUser ? 'Already have an account?' : 'Are you new?'}}
              </a>
            </div>

            <div class="card-body">
              <p class="description text-center">

                <div class="input-group" *ngIf="newUser">
                  <div class="input-group-prepend">
                    <span class="input-group-text">
                      <i class="fa fa-user-circle"></i>
                    </span>
                  </div>
                  <input type="text" name="name" formControlName="name" class="form-control" placeholder="Name...">
                </div>

                <div class="input-group">
                  <div class="input-group-prepend">
                    <span class="input-group-text">
                      <i class="fa fa-envelope"></i>
                    </span>
                  </div>
                  <input type="email" name="email" formControlName="email" required class="form-control"
                    placeholder="Email...">
                </div>
                <p *ngIf="formErrors.email" class="text-center text-danger">
                  {{formErrors.email}}
                </p>

                <div class="input-group">
                  <div class="input-group-prepend">
                    <span class="input-group-text">
                      <i class="fa fa-key"></i>
                    </span>
                  </div>
                  <input type="password" name="password" formControlName="password" required class="form-control"
                    placeholder="Password...">
                </div>
                <p *ngIf="formErrors.password" class="text-center text-danger">
                  {{formErrors.password}}
                </p>

              </div>

              <div class="footer text-center">            
                <button type="submit" [disabled]="!formGroup.valid" class="btn btn-primary btn-wd">Get Started</button>

                <br>
                <br>

                <a *ngIf="!passReset && formGroup.controls.email.valid" class="btn btn-danger btn-link"
                  (click)="forgotPassword()">
                  Reset my password
                </a>

                <p *ngIf="passReset" class="text-primary">
                  Reset requested. Check your email for instructions.
                </p>

                <p style="padding: 12px;">
                  By Login or Signup, you automatically accept the <a href="#">Terms of Service</a> and <a href="#">Privacy Policy</a>.
                </p>
              </div>
          </form>
        </div>
      </div>
    </div>
  </div>
</div>

Ok, so what's going on?

The form will be bound with formGroup variable in .component.ts
using [formGroup] directive.

The submit event will be bound to process function as well, where we'll
be able to handle form states and react accordingly.

Step 3: Form Logic

import { Component, OnInit } from '@angular/core';
import { FormBuilder, FormGroup, Validators } from '@angular/forms';

@Component({
  selector: 'app',
  templateUrl: 'app.component.html'
})

export class AppComponent implements OnInit {

  formGroup: FormGroup;
  newUser = false;
  passReset = false;
  formErrors = {
    'name': '',
    'email': '',
    'password': ''
  };
  validationMessages = {
    'name': {
      'required': 'Required.'
    },
    'email': {
      'required': 'Required.',
      'email': 'Must be a valid email'
    },
    'password': {
      'required': 'Required.',
      'pattern': 'Must include at one letter and one number.',
      'minlength': 'Must be at least 4 characters long.',
      'maxlength': 'Cannot be more than 40 characters long.',
    }
  };

  constructor(private formBuilder: FormBuilder) { }

  ngOnInit() {
    this.formGroup = this.formBuilder.group({
      'name': ['', []],
      'email': ['', [Validators.required, Validators.email]],
      'password': ['', [
        Validators.pattern('^(?=.*[0-9])(?=.*[a-zA-Z])([a-zA-Z0-9]+)$'),
        Validators.minLength(6),
        Validators.maxLength(25)
      ]],
    });

    this.formGroup.valueChanges.subscribe(data => this.onValueChanged(data));

    this.onValueChanged(); // reset validation messages
  }

  toggle(): void {
    this.newUser = !this.newUser;
  }

  onValueChanged(data?: any) {
    if (!this.formGroup) { return; }
    const form = this.formGroup;
    for (const field of Object.keys(this.formErrors)) {
      // clear previous error message (if any)
      this.formErrors[field] = '';
      const control = form.get(field);
      if (control && control.dirty && !control.valid) {
        const messages = this.validationMessages[field];
        for (const key of Object.keys(control.errors)) {
          this.formErrors[field] += messages[key] + ' ';
        }
      }
    }
  }

  process(): void {
    if (this.newUser) {
      // Call register service/api and update UI
    } else {
      // Call login service/api and update UI
    }
  }

  forgotPassword() {
    // Call forget password service/api and update UI
  }

}

Extra: Using single form with multiple routes

Now since our form is dynamic and multi-purpose, we can bind different states with different routes.

constructor(private router: Router) {

  if (router.url.includes('signup')) {
    this.newUser = true;
  }

}

In your routes, you can set a single component containing multi-purpose forms to multiple routes.
Later in the component code, at the starting point, you switch states based on the current route, as in above snippet.

Final

You can see the working sample at StackBlitz, fork and use it in your own apps as you like.

With some styling, you can makes forms like this .

Constructive feedback is always welcome. Feel free to share your ideas and suggestions.

Creating a GitHub Action for a Docker Image

blugreenspace — Sun, 06 Aug 2023 17:04:31 +0000

What are GitHub Actions anyway?

Actions are one of the the smallest executable steps of a job, or you can say a job is composed of steps which can be actions or commands. You can create GitHub Actions based on docker images. More details.

Creating a Github Action for an existing Dockerfile

Mainly three files are required, Dockerfile, entrypoint.sh, and actions.yml.

Let's start with creating a Dockerfile for our action, I'll use my Android CI Dockerfile. It's a simple Dockerfile, which includes all Android build-related tools, recent SDKs, Java, etc.

The Dockerfile for action uses the existing Docker image and extends it to include entrypoint script. The idea for the script is basically to pass the input from a step in workflow to runtime of the Docker in the Github environment.

`Dockerfile`

# Container image that runs your code
FROM code0987/android-ci:latest
# Copy your code to the filesystem path `/` of the container
COPY entrypoint.sh /
# Grant executable permission to entrypoint file
RUN ["chmod", "+x", "/entrypoint.sh"]
# Code file to execute when the docker container starts up (`entrypoint.sh`)
ENTRYPOINT ["/entrypoint.sh"]

`entrypoint.sh`

This script runs all the input passed from GitHub Workflow, as a set of commands in non-interactive sh spawned inside Docker runtime.

#!/bin/sh
set -eu
sh -c "$*"

Now let's define the action metadata so that GitHub can recognize this action. The specifics for Dockerfile based actions are, defining -

runs:
 using: 'docker'
 image: 'Dockerfile'
 args: …

`actions.yml`

name: 'Hello World'
description: 'Greet someone and record the time'
runs:
  using: 'docker'
  image: 'Dockerfile'

Using above action in a GitHub Workflow

name: Android CI
on: [push]
jobs:
  android-ci:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v1
    - name: "Android CI Github Action"
      uses: code0987/android-ci-github-action@master
      with:
        args: |
          chmod 755 gradlew 
          gradlew check

References

GitHub repo for action used as example, android-ci-github-action.

https://help.github.com/en/actions/building-actions/creating-a-docker-container-action

Introduction to Canvas

blugreenspace — Sun, 06 Aug 2023 17:04:29 +0000

The canvas element is part of HTML5 specification and allows for the rendering of 2D shapes and bitmap images. It is a low level, procedural model that updates a bitmap.

Canvas also helps in making 2D games, animations, scenes or any graphics, in general, using JavaScript.

More @ https://iq.opengenus.org/introduction-to-canvas/

Welcome folks!

blugreenspace — Sun, 06 Aug 2023 16:35:39 +0000

Hello,

DEV Community: blugreenspace

Finding Which Columns Value Has Actually Changed in PostgreSQL Trigger Functions

Finding Which Columns Value Has Actually Changed in PostgreSQL Trigger Functions

The Challenge

Solution With Example

Conclusion

Preventing Empty Updates In PostgreSQL Tables Using A Simple Trigger Function

The Need for Preventing Empty Updates

The Solution: A Simple Trigger Function

Application Of The Trigger Function

Understanding Closures in Python

How Closures Work

Why Use Closures?

Function Factory

Callbacks

Data Encapsulation

Decorators

Memoization

Conclusion

Understanding Python Context Managers

What is a Context Manager?

Code Examples

Example 1: Inbuilt Context Manager

Example 2: Custom Context Manager

Example 3: Using the contextlib Module

Conclusion

Understanding Python Generators - Harnessing Lazy Evaluation

Creating Generators

What is yield?

Generator Expressions

Memory-Efficient Infinite Sequences

Pipelining

Conclusion

Zima Blue by Alastair Reynolds - An Existential Exploration

Creating multi-purpose reactive forms with Angular

References

Step 1: Basic setup

Step 2: Form UI/UX

Step 3: Form Logic

Extra: Using single form with multiple routes

Final

Creating a GitHub Action for a Docker Image

What are GitHub Actions anyway?

Creating a Github Action for an existing Dockerfile

Dockerfile

entrypoint.sh

actions.yml

Using above action in a GitHub Workflow

Introduction to Canvas

Welcome folks!

Example 3: Using the `contextlib` Module

What is `yield`?

`Dockerfile`

`entrypoint.sh`

`actions.yml`