Column

column

Free Copy of Apache Iceberg the Definitive Guide
Free Apache Iceberg Crash Course
Iceberg Lakehouse Engineering Video Playlist In the first post of this series, we introduced the Apache Parquet file format and touched upon one of its key features—columnar storage. Now, we’ll take a deeper dive into what this columnar storage model is, how it works, and why it’s so efficient for big data analytics. Understanding Parquet's columnar architecture is key to leveraging its full potential in optimizing data storage and query performance. What is Columnar Storage? Columnar storage means that instead of storing rows of data together, the data for each column is stored separately. This might seem counterintuitive at first, but it has major benefits for certain types of workloads, particularly those where you’re analyzing or aggregating specific columns rather than accessing entire rows. In a row-based format like CSV or JSON, data is written and read one row at a time. Each row stores all fields together in sequence. On the other hand, in a columnar format like Parquet, all values for a single column are stored together. For instance, if you have a dataset with columns for Name, Age, and Salary, all the values for the Name column are stored in one block, all the values for the Age column are stored in another, and so on. Why is Columnar Storage Efficient? The efficiency of columnar storage becomes clear when we consider the type of operations typically performed on large datasets in analytics. Let’s break down the advantages. 1. Faster Query Performance Columnar storage shines when your queries focus on a subset of columns. For example, if you want to calculate the average salary of employees in a large dataset, Parquet allows you to scan just the Salary column without reading the entire dataset. In a row-based format, even though you're only interested in one column, the system has to read all the data in every row to retrieve the values for that column. This results in a lot of unnecessary I/O operations, slowing down query performance. With Parquet, only the columns you need are read, making queries significantly faster. 2. Better Compression Parquet's columnar structure also improves compression. Since similar data types are stored together, compression algorithms can be applied more effectively. For example, if a column contains repeated values or data that follows a consistent pattern (such as dates or integers), it can be compressed more efficiently. By grouping similar values together, columnar formats enable algorithms like dictionary encoding or run-length encoding to achieve high compression ratios. This leads to smaller file sizes, which means reduced storage costs and faster data transfers. 3. Efficient Aggregation Columnar storage is ideal for aggregation queries, such as calculating sums, averages, or counts. These types of operations often focus on specific columns. With Parquet, only the relevant columns need to be read into memory, which not only improves query speed but also reduces the overall resource usage. 4. Batch Processing and Parallelization Another benefit of Parquet’s columnar model is that it enables better parallel processing. Since columns are stored independently, data processing engines like Apache Spark can read different columns in parallel, further speeding up query execution. This makes Parquet a great fit for distributed computing environments, where parallelism is key to achieving high performance. How Parquet Organizes Data Understanding how Parquet organizes data internally can help you fine-tune how you store and query your datasets. Columns and Row Groups: Parquet organizes data into row groups, which contain chunks of column data. A row group contains all the data for a subset of rows, but the data for each column is stored separately. This allows for efficient I/O when reading subsets of rows or columns.
Pages: Within each column chunk, data is further divided into pages. Parquet uses pages to store column data more granularly, which helps optimize compression and read performance. Each page is typically a few megabytes in size, and Parquet stores statistics about the data in each page, making it easier to skip irrelevant pages during query execution. Use Cases for Columnar Storage Columnar storage formats like Parquet are most effective in the following scenarios: Analytics-Heavy Workloads: If your workload involves a lot of analytical queries (e.g., calculating averages, filtering by certain columns), columnar formats will provide significant performance gains.
Big Data Environments: Parquet is commonly used in distributed data environments where large datasets are stored in cloud data lakes (e.g., AWS S3, Google Cloud Storage). It works seamlessly with frameworks like Apache Spark and Presto, which are built to process data at scale.
Data Warehousing: When designing data warehouses, storing data in Parquet allows you to run complex analytical queries efficiently while reducing storage costs due to Parquet’s high compression. When Not to Use Columnar Storage While columnar storage offers significant advantages for read-heavy, analytical workloads, it may not be the best option for all use cases. For example, transactional systems that involve frequent, small updates to data (like an online store's transaction log) may perform better with row-based formats, which are optimized for write-heavy operations. In such cases, the overhead of reading and writing data in columnar format may outweigh its benefits. Conclusion Parquet’s columnar storage model is what makes it a powerful tool for big data analytics. By organizing data by columns, Parquet allows for faster query performance, better compression, and more efficient aggregation. It’s designed to excel in environments where read-heavy workloads dominate and when your queries often target specific columns rather than entire datasets. In the next blog post, we’ll dive deeper into the file structure of Parquet, exploring how data is organized into row groups, pages, and columns to optimize both storage and retrieval. Stay tuned for part 3: Parquet File Structure: Pages, Row Groups, and Columns. Free Copy of Apache Iceberg the Definitive Guide Free Apache Iceberg Crash Course Iceberg Lakehouse Engineering Video Playlist Free Copy of Apache Iceberg the Definitive Guide Free Copy of Apache Iceberg the Definitive Guide Free Apache Iceberg Crash Course Free Apache Iceberg Crash Course Iceberg Lakehouse Engineering Video Playlist Iceberg Lakehouse Engineering Video Playlist In the first post of this series, we introduced the Apache Parquet file format and touched upon one of its key features—columnar storage. Now, we’ll take a deeper dive into what this columnar storage model is, how it works, and why it’s so efficient for big data analytics. Understanding Parquet's columnar architecture is key to leveraging its full potential in optimizing data storage and query performance. What is Columnar Storage? Columnar storage means that instead of storing rows of data together, the data for each column is stored separately. This might seem counterintuitive at first, but it has major benefits for certain types of workloads, particularly those where you’re analyzing or aggregating specific columns rather than accessing entire rows. In a row-based format like CSV or JSON, data is written and read one row at a time. Each row stores all fields together in sequence. On the other hand, in a columnar format like Parquet, all values for a single column are stored together. For instance, if you have a dataset with columns for Name , Age , and Salary , all the values for the Name column are stored in one block, all the values for the Age column are stored in another, and so on. Name Age Salary Name Age Why is Columnar Storage Efficient? The efficiency of columnar storage becomes clear when we consider the type of operations typically performed on large datasets in analytics. Let’s break down the advantages. 1. Faster Query Performance Faster Query Performance Columnar storage shines when your queries focus on a subset of columns. For example, if you want to calculate the average salary of employees in a large dataset, Parquet allows you to scan just the Salary column without reading the entire dataset. Salary In a row-based format, even though you're only interested in one column, the system has to read all the data in every row to retrieve the values for that column. This results in a lot of unnecessary I/O operations, slowing down query performance. With Parquet, only the columns you need are read, making queries significantly faster. 2. Better Compression Better Compression Parquet's columnar structure also improves compression. Since similar data types are stored together, compression algorithms can be applied more effectively. For example, if a column contains repeated values or data that follows a consistent pattern (such as dates or integers), it can be compressed more efficiently. By grouping similar values together, columnar formats enable algorithms like dictionary encoding or run-length encoding to achieve high compression ratios. This leads to smaller file sizes, which means reduced storage costs and faster data transfers. dictionary encoding run-length encoding 3. Efficient Aggregation Efficient Aggregation Columnar storage is ideal for aggregation queries, such as calculating sums, averages, or counts. These types of operations often focus on specific columns. With Parquet, only the relevant columns need to be read into memory, which not only improves query speed but also reduces the overall resource usage. 4. Batch Processing and Parallelization Batch Processing and Parallelization Another benefit of Parquet’s columnar model is that it enables better parallel processing. Since columns are stored independently, data processing engines like Apache Spark can read different columns in parallel, further speeding up query execution. This makes Parquet a great fit for distributed computing environments, where parallelism is key to achieving high performance. How Parquet Organizes Data Understanding how Parquet organizes data internally can help you fine-tune how you store and query your datasets. Columns and Row Groups: Parquet organizes data into row groups, which contain chunks of column data. A row group contains all the data for a subset of rows, but the data for each column is stored separately. This allows for efficient I/O when reading subsets of rows or columns. Pages: Within each column chunk, data is further divided into pages. Parquet uses pages to store column data more granularly, which helps optimize compression and read performance. Each page is typically a few megabytes in size, and Parquet stores statistics about the data in each page, making it easier to skip irrelevant pages during query execution. Columns and Row Groups : Parquet organizes data into row groups , which contain chunks of column data. A row group contains all the data for a subset of rows, but the data for each column is stored separately. This allows for efficient I/O when reading subsets of rows or columns. Columns and Row Groups row groups Pages : Within each column chunk, data is further divided into pages . Parquet uses pages to store column data more granularly, which helps optimize compression and read performance. Each page is typically a few megabytes in size, and Parquet stores statistics about the data in each page, making it easier to skip irrelevant pages during query execution. Pages pages Use Cases for Columnar Storage Columnar storage formats like Parquet are most effective in the following scenarios: Analytics-Heavy Workloads: If your workload involves a lot of analytical queries (e.g., calculating averages, filtering by certain columns), columnar formats will provide significant performance gains. Big Data Environments: Parquet is commonly used in distributed data environments where large datasets are stored in cloud data lakes (e.g., AWS S3, Google Cloud Storage). It works seamlessly with frameworks like Apache Spark and Presto, which are built to process data at scale. Data Warehousing: When designing data warehouses, storing data in Parquet allows you to run complex analytical queries efficiently while reducing storage costs due to Parquet’s high compression. Analytics-Heavy Workloads : If your workload involves a lot of analytical queries (e.g., calculating averages, filtering by certain columns), columnar formats will provide significant performance gains. Analytics-Heavy Workloads Big Data Environments : Parquet is commonly used in distributed data environments where large datasets are stored in cloud data lakes (e.g., AWS S3, Google Cloud Storage). It works seamlessly with frameworks like Apache Spark and Presto, which are built to process data at scale. Big Data Environments Data Warehousing : When designing data warehouses, storing data in Parquet allows you to run complex analytical queries efficiently while reducing storage costs due to Parquet’s high compression. Data Warehousing When Not to Use Columnar Storage While columnar storage offers significant advantages for read-heavy, analytical workloads, it may not be the best option for all use cases. For example, transactional systems that involve frequent, small updates to data (like an online store's transaction log) may perform better with row-based formats, which are optimized for write-heavy operations. In such cases, the overhead of reading and writing data in columnar format may outweigh its benefits. transactional systems Conclusion Parquet’s columnar storage model is what makes it a powerful tool for big data analytics. By organizing data by columns, Parquet allows for faster query performance, better compression, and more efficient aggregation. It’s designed to excel in environments where read-heavy workloads dominate and when your queries often target specific columns rather than entire datasets. In the next blog post, we’ll dive deeper into the file structure of Parquet, exploring how data is organized into row groups, pages, and columns to optimize both storage and retrieval. file structure Stay tuned for part 3: Parquet File Structure: Pages, Row Groups, and Columns . Parquet File Structure: Pages, Row Groups, and Columns

 All About Parquet Part 02 - Parquet's Columnar Storage Model

When building your application, one of the first questions you will probably ask yourself is: what database should I use to store my users' data? If you look up this question on the Internet, you will find not only that there are hundreds of different database management systems, but also that there are different categories of databases, such as SQL and NoSQL databases, key/value databases, row and column databases. In this article, you will learn what columnar databases are, when to use them, and their advantages and disadvantages. What Are Column-Oriented Databases? Columnar (or column-oriented) databases store tables of data by column rather than by row. They're often used in online analytical processing (OLAP) environments. For example, here's a simple table containing some information about usernames, their country, and their account status. | ID |  Name  | Active |  Country  |
|----|--------|--------|-----------|
|  1 | Andrii |      1 | UK        |
|  2 | Tom    |      0 | US        |
|  3 | Jack   |      1 | Canada    |
|  4 | Scott  |      1 | Australia | For columnar databases, the data would be stored as: 1234;AndriiTomJackScott;1011;UKUSCanadaAustralia; While traditional row-oriented databases present such tables as: 1Andrii1UK;2Tom0US;3Jack1Canada;4Scott1Australia Storing data differently drastically improves the performance of read operations. For example, performing aggregation functions such as averaging or summing will be many times faster on columnar databases. At the same time, a row-oriented database would perform better for write operations. Especially when inserting rows one at a time. They are perfect for transactional processing (OLTP). For example, consider a scenario where you want to create an analytical sales report. If you are using a row-oriented database, all the rows (chunks of data) have to be brought into memory and processed. Even if you select a particular column, the DBMS will first have to access a row such as 1Andrii1UK and then extract the required column from it. A column-oriented database would present data in chunks of columns, like AndriiTomJackScott, allowing much faster processing and read operations. Row-oriented databases prioritize transactional integrity and data normalization, while columnar databases focus on fast-read operations and data aggregation. Use Cases for Columnar Databases Columnar databases are perfect for reading and processing billions of data points. Here are some of the more common use cases: Log analysis Server logs are usually a pain to analyze, especially when there is a lot of information being logged from different processes. Columnar databases can store logs and later aggregate information such as the most common errors or their patterns. Business Analysis & Time Series Data Columnar databases are perfect for processing analytical data and building aggregated reports, and this is probably their most common use case. Columnar OLAPs are also commonly used in IoT applications and monitoring systems, which often deal with time-series data. Examples of Columnar DBMSs Many column-oriented databases share similarities, such as distributed processing, aggregation capabilities, and so on. However, many of them are designed for different purposes. Clickhouse Clickhouse is one of the most popular open-source real-time OLAP databases. Its speed and aggregation capabilities make it ideal for analytical purposes and it's used by organizations such as CERN, Akamai, and Bytedance. DuckDB DuckDB is an open-source in-process columnar DBMS. It also features fast reads and extensive aggregation functions, and has been described as the "SQLite of columnar databases." It’s perfect for applications dealing with logs or parsing CSV files. It’s also great for embedded programming, as it’s relatively small in size and fast. QuestDB QuestDB is also an open-source columnar database with a focus on efficient processing and aggregation of time series data. Final Thoughts There are dozens of different types of database management systems, and each one is tailored to specific use cases. Choosing the right database for your application is a good long-term solution that can save you the headache of migrating later. For example, if you're building analytical or log-processing applications, it's a good idea to opt for column-oriented databases, even if you don't store that much data initially. When building your application, one of the first questions you will probably ask yourself is: what database should I use to store my users' data? If you look up this question on the Internet, you will find not only that there are hundreds of different database management systems, but also that there are different categories of databases, such as SQL and NoSQL databases, key/value databases, row and column databases. In this article, you will learn what columnar databases are, when to use them, and their advantages and disadvantages. What Are Column-Oriented Databases? Columnar (or column-oriented) databases store tables of data by column rather than by row. They're often used in online analytical processing (OLAP) environments. For example, here's a simple table containing some information about usernames, their country, and their account status. | ID |  Name  | Active |  Country  |
|----|--------|--------|-----------|
|  1 | Andrii |      1 | UK        |
|  2 | Tom    |      0 | US        |
|  3 | Jack   |      1 | Canada    |
|  4 | Scott  |      1 | Australia | | ID |  Name  | Active |  Country  |
|----|--------|--------|-----------|
|  1 | Andrii |      1 | UK        |
|  2 | Tom    |      0 | US        |
|  3 | Jack   |      1 | Canada    |
|  4 | Scott  |      1 | Australia | For columnar databases, the data would be stored as: 1234;AndriiTomJackScott;1011;UKUSCanadaAustralia; 1234;AndriiTomJackScott;1011;UKUSCanadaAustralia; While traditional row-oriented databases present such tables as: 1Andrii1UK;2Tom0US;3Jack1Canada;4Scott1Australia 1Andrii1UK;2Tom0US;3Jack1Canada;4Scott1Australia Storing data differently drastically improves the performance of read operations. For example, performing aggregation functions such as averaging or summing will be many times faster on columnar databases. At the same time, a row-oriented database would perform better for write operations. Especially when inserting rows one at a time. They are perfect for transactional processing (OLTP). For example, consider a scenario where you want to create an analytical sales report. If you are using a row-oriented database, all the rows (chunks of data) have to be brought into memory and processed. Even if you select a particular column, the DBMS will first have to access a row such as 1Andrii1UK and then extract the required column from it. 1Andrii1UK A column-oriented database would present data in chunks of columns, like AndriiTomJackScott , allowing much faster processing and read operations. AndriiTomJackScott Row-oriented databases prioritize transactional integrity and data normalization, while columnar databases focus on fast-read operations and data aggregation. Use Cases for Columnar Databases Columnar databases are perfect for reading and processing billions of data points. Here are some of the more common use cases: Log analysis Server logs are usually a pain to analyze, especially when there is a lot of information being logged from different processes. Columnar databases can store logs and later aggregate information such as the most common errors or their patterns. Business Analysis & Time Series Data Columnar databases are perfect for processing analytical data and building aggregated reports, and this is probably their most common use case. Columnar OLAPs are also commonly used in IoT applications and monitoring systems, which often deal with time-series data. Examples of Columnar DBMSs Many column-oriented databases share similarities, such as distributed processing, aggregation capabilities, and so on. However, many of them are designed for different purposes. Clickhouse Clickhouse is one of the most popular open-source real-time OLAP databases. Its speed and aggregation capabilities make it ideal for analytical purposes and it's used by organizations such as CERN, Akamai, and Bytedance. DuckDB DuckDB is an open-source in-process columnar DBMS. It also features fast reads and extensive aggregation functions, and has been described as the "SQLite of columnar databases." It’s perfect for applications dealing with logs or parsing CSV files. It’s also great for embedded programming, as it’s relatively small in size and fast. QuestDB QuestDB is also an open-source columnar database with a focus on efficient processing and aggregation of time series data. Final Thoughts There are dozens of different types of database management systems, and each one is tailored to specific use cases. Choosing the right database for your application is a good long-term solution that can save you the headache of migrating later. For example, if you're building analytical or log-processing applications, it's a good idea to opt for column-oriented databases, even if you don't store that much data initially.

What Are Columnar Databases and When Do You Need to Use Them?

Auto-Increment Columns in Databases: A Simple Trick That Makes a Big Difference

Introduction In Python, you can use the pandas library to work with tabular data, and the core data type in pandas is the DataFrame. Sometimes, when working with DataFrame , you may need to convert rows to columns or columns to rows. Here is a simple example demonstrating how to achieve this using the pandas library. data Create Table First, let’s create a new example DataFrame. import pandas as pd

# create a new DataFrame
df = pd.DataFrame({
    'name': ['John', 'Mary', 'Peter'],
    'math': [80, 90, 70],
    'english': [70, 85, 90],
    'science': [75, 95, 80]
})

print(df)

# output:
    name  math  english  science
0   John    80       70       75
1   Mary    90       85       95
2  Peter    70       90       80 Convert Rows to Columns # Use the melt function to convert rows to columns
df_melt = pd.melt(df, id_vars=['name'], var_name='subject', value_name='score')

print(df_melt) In the code above, we simply use the function to transform each student's subject grades into a column, which gives us the following output. melt name  subject  score
0   John     math     80
1   Mary     math     90
2  Peter     math     70
3   John  english     70
4   Mary  english     85
5  Peter  english     90
6   John  science     75
7   Mary  science     95
8  Peter  science     80 Convert Columns to Rows Column-to-row transformation, also known as data unpivoting, can be achieved using the function in the pandas library. Here is an example code: pivot # Use the pivot function to pivot rows to columns.
df_pivot = df_meld.pivot(index='name', columns='subject', values='score')
print(df_pivot) subject  english  math  science
name
John          70    80       75
Mary          85    90       95
Peter         90    70       80 Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on or (@Luca_DataTeam). You can also catch glimpses of my personal life on , Happy exploring!👋 LinkedIn X Instagram

How to Convert Rows to Columns and Columns to Rows in Pandas DataFrame using Python

Slow query times in large datasets are a common headache in database management. offers a neat way out of this. It's a columnar storage engine that significantly speeds up data analytics. Typically, you can improve query performance in relational databases by adding appropriate indexes. MariaDB ColumnStore However, maintaining indexes is hard, especially with ad-hoc queries where you don't really know where indexes are going to be needed. ColumnStore eases this pain. It's as if you had an index on each column but without the hassle of creating and updating them. The price to pay? Well, inserts are not as fast as with , so this is not the best option for operational/transactional databases but rather for analytical ones. are very fast, though. InnoDB Bulk inserts There's plenty of about ColumnStore, so I won't go through all the details on how it works or how to deploy it on production. Instead, in this article, I'll show you how to try MariaDB ColumnStore on your computer using . online documentation Docker Prerequisites You'll need: The command line tool mariadb Docker Setting up MariaDB ColumnStore Run a container with MariaDB + ColumnStore: docker run -d -p 3307:3306 -e PM1=mcs1 --hostname=mcs1 --name mcs1 mariadb/columnstore This command runs a new Docker container using the official ColumnStore image with several specified options: : Starts a new Docker container. docker run : Runs the container in detached mode (in the background). -d : Maps port 3307 on the host (your computer) to port 3306 inside the container. This makes the database accessible on port on the host machine. -p 3307:3306 3307 : The environment variable specifies the primary database node ( ). -e PM1=mcs1 PM1 PM1 mcs1 : Sets the hostname of the container to . --hostname=mcs1 mcs1 : Names the container . --name mcs1 mcs1 : Specifies the Docker image to use, in this case, an image for MariaDB with the ColumnStore storage engine. mariadb/columnstore Provision ColumnStore: docker exec -it mcs1 provision mcs1 The command is used to interact with a running Docker container. This is what each option does: docker exec : Executes a command in a running container. docker exec : This option ensures the command is run in interactive mode with a terminal. -it (first occurrence): This is the name of the Docker container in which the command is to be executed. mcs1 This is the specific command being executed inside the container. is a script included in the Docker image that initializes and configures the MariaDB ColumnStore environment within the container. The argument is passed to the command to specify the host for the MariaDB server within the Docker container. provision mcs1 provision mcs1 provision Connect to the MariaDB server using the default credentials defined in the MariaDB ColumnStore Docker image: mariadb -h 127.0.0.1 -P 3307 -u admin -p'C0lumnStore!' Check that ColumnStore is available as a storage engine by running the following SQL sentence: SHOW ENGINES; Setting up a demo database Create the database and its InnoDB tables: operations CREATE DATABASE operations;

CREATE TABLE operations.doctors(
    id SERIAL PRIMARY KEY,
    name VARCHAR(200) NOT NULL CHECK(TRIM(name) != '')
) ENGINE=InnoDB;

CREATE TABLE operations.appointments(
    id SERIAL PRIMARY KEY,
    name VARCHAR(200) NOT NULL CHECK(TRIM(name) != ''),
    phone_number VARCHAR(15) NOT NULL CHECK(phone_number RLIKE '[0-9]+'),
    email VARCHAR(254) NOT NULL CHECK(TRIM(email) != ''),
    time DATETIME NOT NULL,
    reason ENUM('Consultation', 'Follow-up', 'Preventive', 'Chronic') NOT NULL,
    status ENUM ('Scheduled', 'Canceled', 'Completed', 'No Show'),
    doctor_id BIGINT UNSIGNED NOT NULL,
    CONSTRAINT fk_appointments_doctors FOREIGN KEY (doctor_id) REFERENCES doctors(id)
) ENGINE=InnoDB; Create the database and its ColumnStore table: analytics CREATE DATABASE analytics;

CREATE TABLE analytics.appointments(
    id BIGINT UNSIGNED NOT NULL,
    name VARCHAR(200) NOT NULL,
    phone_number VARCHAR(15) NOT NULL,
    email VARCHAR(254) NOT NULL,
    time DATETIME NOT NULL,
    reason VARCHAR(15) NOT NULL,
    status VARCHAR(10) NOT NULL,
    doctor_id BIGINT UNSIGNED NOT NULL
) ENGINE=ColumnStore; You can use the same database (or schema. They are in MariaDB) for both the InnoDB and ColumnStore tables if you prefer. Use a different name for the ColumnStore table if you opt for this alternative. synonyms Inserting demo data Insert a few doctors: INSERT INTO operations.doctors(name)
VALUES ("Maria"), ("John"), ("Jane"); Create a new file with the name with the following content: test_data_insert.py import random
import os
import subprocess
from datetime import datetime, timedelta

# Function to generate a random date within a given range
def random_date(start, end):
    return start + timedelta(days=random.randint(0, int((end - start).days)))

# Function to execute a given SQL command using MariaDB
def execute_sql(sql):
    # Write the SQL command to a temporary file
    with open("temp.sql", "w") as file:
        file.write(sql)
    # Execute the SQL command using the MariaDB client
    subprocess.run(["mariadb", "-h", "127.0.0.1", "-P", "3307", "-u", "admin", "-pC0lumnStore!", "-e", "source temp.sql"])
    # Remove the temporary file
    os.remove("temp.sql")

print("Generating and inserting data...")

# Total number of rows to be inserted
total_rows = 4000000
# Number of rows to insert in each batch
batch_size = 10000

# Possible values for the 'reason' column and their associated weights for random selection
reasons = ["Consultation", "Follow-up", "Preventive", "Chronic"]
reason_weights = [0.5, 0.15, 0.25, 0.1]

# Possible values for the 'status' column and their associated weights for random selection
statuses = ["Scheduled", "Canceled", "Completed", "No Show"]
status_weights = [0.1, 0.15, 0.7, 0.05]

# Possible values for the 'doctor_id' column and their associated weights for random selection
doctors = [1, 2, 3]
doctors_weights = [0.4, 0.35, 0.25]

# List of patient names
names = [f"Patient_{i}" for i in range(total_rows)]

# Insert data in batches
for batch_start in range(0, total_rows, batch_size):
    batch_values = []

    # Generate data for each row in the batch
    for i in range(batch_start, min(batch_start + batch_size, total_rows)):
        name = names[i]
        phone_number = f"{random.randint(100, 999)}-{random.randint(100, 999)}-{random.randint(1000, 9999)}"
        email = f"patient_{i}@example.com"
        time = random_date(datetime(2023, 1, 1), datetime(2024, 1, 1)).strftime("%Y-%m-%d %H:%M:%S")
        reason = random.choices(reasons, reason_weights)[0]
        status = random.choices(statuses, status_weights)[0]
        doctor_id = random.choices(doctors, doctors_weights)[0]

        # Append the generated row to the batch
        batch_values.append(f"('{name}', '{phone_number}', '{email}', '{time}', '{reason}', '{status}', {doctor_id})")

    # SQL command to insert the batch of data into the 'appointments' table
    sql = "USE operations;\nINSERT INTO appointments (name, phone_number, email, time, reason, status, doctor_id) VALUES " + ", ".join(batch_values) + ";"
    # Execute the SQL command
    execute_sql(sql)
    # Print progress
    print(f"Inserted up to row {min(batch_start + batch_size, total_rows)}")

print("Data insertion complete.") Insert 4 million appointments by running the Python script: python3 test_data_insert.py Populate the ColumnStore table by connecting to the database and running: INSERT INTO analytics.appointments (
    id,
    name,
    phone_number,
    email,
    time,
    reason,
    status,
    doctor_id
)
SELECT
    appointments.id,
    appointments.name,
    appointments.phone_number,
    appointments.email,
    appointments.time,
    appointments.reason,
    appointments.status,
    appointments.doctor_id
FROM operations.appointments; Run cross-engine SQL queries MariaDB ColumnStore is designed to run in a cluster of multiple servers. It is there where you see massive performance gains in analytical queries. However, we can also see this in action with the single-node setup of this article. Run the following query and pay attention to the time it needs to complete (make sure it queries the database): operations SELECT doctors.name, status, COUNT(*) AS count
FROM operations.appointments -- use the InnoDB table
JOIN doctors ON doctor_id = doctors.id
WHERE status IN (
    'Scheduled',
    'Canceled',
    'Completed',
    'No Show'
)
GROUP BY doctors.name, status
ORDER BY doctors.name, status; On my machine, it took around 3 seconds. Now modify the query to use the ColumnStore table instead (in the database): analytics SELECT doctors.name, status, COUNT(*) AS count
FROM analytics.appointments -- use the ColumnStore table
JOIN doctors ON doctor_id = doctors.id
WHERE status IN (
    'Scheduled',
    'Canceled',
    'Completed',
    'No Show'
)
GROUP BY doctors.name, status
ORDER BY doctors.name, status; It takes less than a second. Of course, you can speed up the first query by adding an index in this simplistic example, but imagine the situation in which you have hundreds of tables—it will become harder and harder to manage indexes. ColumnStore removes this complexity. Also published . here

Optimizing Database Performance with MariaDB ColumnStore

Strategies for Implementing Columnar Compression in Large PostgreSQL Databases

বড় পোস্টগ্রেএসকিউএল ডেটাবেসে কলামার কম্প্রেশন বাস্তবায়নের কৌশল

Strategien zur Implementierung der Spaltenkomprimierung in großen PostgreSQL-Datenbanken

Estrategias para implementar la compresión de columnas en grandes bases de datos PostgreSQL

Stratégies d'implémentation de la compression en colonnes dans les grandes bases de données PostgreSQL

बड़े PostgreSQL डेटाबेस में कॉलमर कम्प्रेशन लागू करने की रणनीतियाँ

大規模な PostgreSQL データベースに列圧縮を実装するための戦略

대규모 PostgreSQL 데이터베이스에서 열 형식 압축을 구현하기 위한 전략

Estratégias para implementar compactação colunar em grandes bancos de dados PostgreSQL

Стратегии реализации столбчатого сжатия в больших базах данных PostgreSQL

Büyük PostgreSQL Veritabanlarında Sütun Sıkıştırmasını Uygulama Stratejileri

Các chiến lược thực hiện nén cột trong cơ sở dữ liệu PostgreSQL lớn

在大型 PostgreSQL 数据库中实现列压缩的策略

https://www.youtube.com/watch?v=lQrpYlBHdlY&embedable=true&transcript=true Become a tech influencer with onboarding process! ! HackerNoon's 3-step Publish your technology story today Listen to the with , the COO of . full episode of Inside Startup Investing Linh Dao Smooke HackerNoon

How Do You Become a Technology Columnist? 

আপনি কিভাবে একটি প্রযুক্তি কলামিস্ট হয়ে উঠবেন?

Wie wird man Technologiekolumnist?

¿Cómo convertirse en columnista de tecnología?

Comment devenir chroniqueur technologique ?

आप एक प्रौद्योगिकी स्तंभकार कैसे बनें?

テクノロジーコラムニストになるにはどうすればよいですか?

기술 칼럼니스트가 되려면 어떻게 해야 하나요?

Como você se torna um colunista de tecnologia?

Как стать обозревателем технологий?

Nasıl Teknoloji Yazarı Olursunuz?

Làm thế nào để bạn trở thành một nhà báo chuyên mục công nghệ?

如何成为一名技术专栏作家？

How to become a Lightning Calculator by Anonymous is part of the HackerNoon Books Series. You can jump to any chapter in this book . How to Add Two Columns at Once. here How to Add Two Columns at Once. To the inexperienced it will be a difficult task to add two columns at once, but many of those who have daily practice in addition find it about as easy to add two columns as one. Say 99 and 50 are 149, and 6 are 155, and 10 and 50 are 215 and 3 are 218, and 12 are 230. Carry 2, and say 33 and 12 are 45, and 20 are 65, and 6 are 71, and 30 are 101, and 2 are 103, and 23 are 126. Much of the information here contained is compiled from W. D. Rowland’s valuable little volume, entitled “How to become expert with figures.” You can get this handy book by sending 25 cents in stamps to American Nation Co., Boston. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Anonymous (2021). How to become a lightning calculator. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/65078/pg65078-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

How to Add Two Columns at Once.

Hello! I wrote a blog on finding the a couple of months ago. Since then, I have found a better, faster, and easier method, which works in . last non-empty rows most cases Find the Last Row & Column You can copy and paste one of the following functions as per your needs. is meant for a bound script, is very easy to implement, and works on the currently active worksheet. FindLastRowNColBoundScript(), should be used with an independent script. The given code is very simple. You can modify this function and pass variables such as ID and Worksheet names as parameters to make this function more dynamic. FindLastRowNColIndependentScript() /**
 * Function should be used for bound script.
 * Function use getDataRange().getValues() method to 
 * find lastRow and LastColumn of that Spreadhseet.
 */
function findLastRowNColBoundScript() {
  const sheet = SpreadsheetApp.getActiveSheet();

  const data = sheet.getDataRange().getValues();
  const lastRow = data.length;
  const lastCol = data[0].length;

  console.log(lastRow);
  console.log(lastCol);

  return [lastRow, lastCol];
}

/**
 * Function should be used for independent script.
 * Function use getDataRange().getValues() method to 
 * find lastRow and LastColumn of that Spreadhseet
 */
function findLastRowNColIndependentScript() {
  const ss = SpreadsheetApp.openById("<Your Spreadsheet's ID>");
  const sheet = ss.getSheetByName("<Name of the worksheet>");

  const data = sheet.getDataRange().getValues();
  const lastRow = data.length;
  const lastCol = data[0].length;

  console.log(lastRow);
  console.log(lastCol);

  return [lastRow, lastCol];
}


/**
 * This script is for finding last non empty rows and columns in a spreadsheet. 
 * This works in most cases but not in some cases such as columns with checkboxes
 * It is created in such a way that it only works with bound script.
 *
 * Created by: Nibesh Khadka.
 * linkedin: https://www.linkedin.com/in/nibesh-khadka/
 * website: https://nibeshkhadka.com
 */ This strategy of using () to find the last row and columns works in most cases but few such as columns filled with checkboxes on their entire rows. DataRange Thank You for Your Time My name is Nibesh Khadka, and as a freelance automation expert, I specialize in automating Google products with Apps Script. If you need my services, let me . know Don’t forget to like and share this blog. Also published . here

How to Get the Last Non-empty Row of a Column of a Spreadsheet Accurately

Welcome to this very short daily blog where I give a very simple script to automate Google Products. In this chapter, we'll create a custom menu that'll delete empty rows and columns in current active spreadsheets. Delete Empty/Extra Rows and Column The following script will do three things: bound Create a custom menu in your spreadsheets tabs with the title . Custom Menu After you call to select the custom menu, It will check all the extra rows and columns after the last rows and columns with data. Then delete all those extra rows and columns. function deleteExteriorRowsNColumns() {
// get sheets and data
const sheet = SpreadsheetApp.getActiveSheet();
const data = sheet.getDataRange().getValues();

// determine last row and column
const lastRow = data.length;
const lastCol = Math.max(...data.map((arr) => arr.length));

// get maximum rows and columns sheets
const maxRows = sheet.getMaxRows();
const maxCols = sheet.getMaxColumns();

// only remove rows and columns if there are empty rows or columns beyond last row and columns
if (maxRows > lastRow) {
  sheet.deleteRows(lastRow + 1, maxRows - lastRow);
  }
if (maxCols > lastCol) {
  sheet.deleteColumns(lastCol + 1, maxCols - lastCol);
  }

}

/**
OnOpen trigger that creates menu
@param {Dictionary} e
*/
function onOpen(e) {
createCustomMenu();
}

/**

Menu creates menu UI in spreadsheet.
*/
function createCustomMenu() {
let menu = SpreadsheetApp.getUi().createMenu("Custom Menu");

menu.addItem("Delete Empty Rows and Columns", "deleteExteriorRowsNColumns");
menu.addToUi();
} How To Add Apps Script Code To a Spreadsheet? If you don't know how to add this script to your sheet, then just click the tab and then as shown in the image below. Extensions Apps Script Now, similar to the , you can now just: previous blogs Save the code. Reload the spreadsheet, where you'll see the custom menu as shown below And execute the function from the custom menu as shown in the image below Thank You for Your Time My name is Nibesh Khadka, and as a freelance automation expert, I specialize in automating Google products with Apps Script. So let's get started! If you need my services let me . know Don’t forget to like and share this blog. Also published . here

How to Delete Empty Rows and Columns in Google Sheets

In this blog, I will be sharing a script that allows you to easily select a column in a Google Sheets spreadsheet and copy it to another spreadsheet while ensuring that the values are aligned in the same rows. Whether you're a Google Apps Script Developer or just someone looking to streamline their workflow, this script will be a helpful tool for you. This is Nibesh Khadka. I am a freelance Google Apps Script Developer and Content Creator. Referencing Columns Before Copying Copying a column from one sheet to another can be challenging if we don't have a unique column as a reference to put the values in the correct column. We can use columns like ID, Email, or any other column that exists in both sheets as a reference. In this article, we'll create a spreadsheet with two sheets and use the "ID" column as a reference to copy the "Name" column from to . Sheet1 Sheet2 You can just download and use this sheet or create your own. You can either follow the steps or download the complete code from the git . repository Script Editor Now this is the bound script. So, open the spreadsheet you want to use for this project and open the script editor from there. HTML Form For this project, unlike in the one, we'll be using with HTML instead of UI prompts because we'll need multiple input boxes for this project. previous Custom Dialog Boxes Create a new file in your script editor. Then copy and paste the following codes HTML <!DOCTYPE html>
<html>
<head>
  <base target="_top">
  
</head>

<body>
  <form onsubmit="formSubmitHandler(event)">
    <h2>Source Sheet</h2>
    <label for="sourceSheet">Source Sheet Name:</label><br>
    <input type="text" id="sourceSheet" name="sourceSheet"><br>
    <label for="referenceColumn">Reference Column Name</label><br>
    <input type="text" id="referenceColumn" name="referenceColumn"><br>
    <label for="sourceColumn">Source Column To Copy From:</label><br>
    <input type="text" id="sourceColumn" name="sourceColumn"><br>
    <hr>
    <h2>Target Sheet</h2><br>
    <label for="targetSheet">Target Sheet Name:</label><br>
    <input type="text" id="targetSheet" name="targetSheet"><br>
    <label for="targetReferenceColumn">Reference Column Name</label><br>
    <input type="text" id="targetReferenceColumn" name="targetReferenceColumn"><br>
    <label for="targetColumn">Target Column To Copy To:*</label><br>
    <input type="text" id="targetColumn" name="targetColumn"><br>
    

    <input type="submit" value="Submit" />

  </form>

  <script>
    function formSubmitHandler(event) {

      const sourceSheet = event.target['sourceSheet'].value;
      const referenceColumn = event.target['referenceColumn'].value;
      const sourceColumn = event.target['sourceColumn'].value;
      const targetSheet = event.target['targetSheet'].value;
      const targetReferenceColumn = event.target['targetReferenceColumn'].value;
      const targetColumn = event.target['targetColumn'].value ?? "";
      const data = [sourceSheet, referenceColumn, sourceColumn, targetSheet, targetReferenceColumn, targetColumn];

      // call server side function
     google.script.run.withSuccessHandler(closeDialog).setTargetColumns(data);

      event.preventDefault();

    }

    function closeDialog() { google.script.host.close() }
  </script>
</body>
</html> There are two to notice here. script runners is used to link the function in the form in the front-end to the function in the backend(script) code during operation success, in this case, is the backend function we're using. withSuccessHandler() setTargetColumns() which is used to close the dialog box. We are using it with to call the backend and then close the dialog box. close() withSuccessHandler() When rendered the Form looks like this: Feel free to style the HTML Form to make it more beautiful. In this HTML form you'll have to provide six pieces of information: The name of the Source Worksheet. The name of the Reference Column in the source sheet. The name of the Source Column in the source sheet whose value is to be copied. The name of the Target Worksheet where the value is to be copied. The name of the Reference Column in the target sheet. The name of the Target Column in the target sheet, that will hold the copied value. Copy Column to Different Sheet Now let's write the script to copy the values from one column to another. function renderForm() {
  const html = HtmlService.createHtmlOutputFromFile('form')
    .setWidth(400)
    .setHeight(600);// play with dimension to fit your need
  SpreadsheetApp.getUi() 
    .showModalDialog(html, "Copy Column With Reference");
}

//["Sheet1", "ID", "Name", "Sheet2", "ID", "Name"]
function setTargetColumns(data) {
  try {
    const sourceSheetName = data[0];
    const referenceColumnName = data[1];
    const sourceColumnName = data[2];
    const targetSheetName = data[3];
    const targetReferenceColumnName = data[4];
    const targetColumnName = data[5];

    // get sheet and data
    const sheet = SpreadsheetApp.getActiveSpreadsheet();
    const sourceSheet = sheet.getSheetByName(sourceSheetName);

    const sourceSheetData = sourceSheet.getDataRange().getValues();
    const sourceSheetLastRow = sourceSheetData.length;
    const sourceSheetLastColumn = sourceSheetData[0].length;
    // get header column of source sheet
    const sourceSheetHeader = sourceSheet.getRange(1, 1, 1, sourceSheetLastColumn).getValues().flat();

    // find the index of the given column names
    const referenceColumnIndex = sourceSheetHeader.indexOf(referenceColumnName.trim());
    if (referenceColumnIndex === -1) throw "Reference Column Not Found";

    const sourceColumnIndex = sourceSheetHeader.indexOf(sourceColumnName.trim());
    if (sourceColumnIndex === -1) throw "Source Column Not Found"; // if the name is not found then throw error

    const sourceSheetData2 = [sourceSheet.getRange(2, referenceColumnIndex + 1, sourceSheetLastRow, 1).getValues().flat(), sourceSheet.getRange(2, sourceColumnIndex + 1, sourceSheetLastRow, 1).getValues().flat()]


    const targetSheet = sheet.getSheetByName(targetSheetName);
    const targetSheetData = targetSheet.getDataRange().getValues();
    const targetSheetLastRow = targetSheetData.length;


    const targetReferenceColumnIndex = sourceSheetHeader.indexOf(targetReferenceColumnName.trim());
    if (targetReferenceColumnIndex === -1) throw "Target Sheets Reference Column Not Found";

    const targetColumnIndex = sourceSheetHeader.indexOf(targetColumnName.trim());
    if (targetColumnIndex === -1) throw "Target Sheet's Target Column Not Found";

    const targetSheetRefData = targetSheet.getRange(2, targetReferenceColumnIndex + 1, targetSheetLastRow - 1, 1).getValues().flat();
    const targetSheetColData = targetSheet.getRange(2, targetColumnIndex + 1, targetSheetLastRow - 1, 1).getValues();


    for (let i = 0; i < sourceSheetData2[0].length; i++) {
      for (let j = 0; j < targetSheetRefData.length; j++) {
        if (targetSheetRefData[j] === sourceSheetData2[0][i]) {
          targetSheetColData[j] = [sourceSheetData2[1][i]];
          break;
        }
        continue;
      }
    }
    // set new values 
    targetSheet.getRange(2, targetColumnIndex + 1, targetSheetLastRow - 1, 1).setValues(targetSheetColData);

  } catch (e) {
    // alert error
    SpreadsheetApp.getUi().alert(`Error: ${e}`)
  }
}


/**
 * Menu creates menu UI in the document it's bound to.
 */
function createCustomMenu() {
  const menu = SpreadsheetApp.getUi().createMenu("Copy Columns");

  menu.addItem("Copy Column", "renderForm");
  menu.addToUi();
}


/**
 * OnOpen trigger that creates menu
 * @param {Dictionary} e
 */
function onOpen(e) {
  createCustomMenu();
}

/**
 * This script is for safely and accurately copying one column to 
 * another column in two sheets while properly aliging with other
 * rows.
 * It is created in such a way that it only works with bound script.
 *
 * Created by: Nibesh Khadka.
 * linkedin: https://www.linkedin.com/in/nibesh-khadka/
 * website: https://nibeshkhadka.com
 */ Now, similar to the , you can now just: previous blogs Save the code. Reload the spreadsheet. Where you'll see the custom menu as shown below And execute the function. After this, you'll see a menu like the image below in the spreadsheet. Error In case you leave any input box empty or you gave the wrong names to the boxes, you'll see the error alert like the image below. Thank You for Your Time My name is Nibesh Khadka, and as a freelance automation expert, I specialize in automating Google products with Apps Script. So let's get started! If you need my services let me . know Don’t forget to like and share this blog. Also published . here

How to Copy a Column From One Sheet to Another in Google Sheets Easily 

Auto-increment is a feature in databases that automatically generates a unique number for each new row added to a table. This number is usually used as a primary key to uniquely identify each row in the table. The system automatically assigns the next available number to each new row, saving the user from having to manually manage the primary key values. This simplifies the process of adding new rows and ensures that each row has a unique identifier. database Below we explore how tables are created with an auto-increment column in different RDBMS SQLite CREATE TABLE example_table (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   name VARCHAR(50),
   age INT
); In this example, the id column is defined as an integer data type with the AUTOINCREMENT keyword. It is also set as the primary key of the table. MySQL and MariaDB CREATE TABLE example_table (
   id INT AUTO_INCREMENT PRIMARY KEY,
   name VARCHAR(50),
   age INT
); In this example, the id column is defined as an auto-increment column with the AUTO_INCREMENT keyword. It is also set as the primary key of the table. SQL Server CREATE TABLE example_table (
   id INT IDENTITY(1,1) PRIMARY KEY,
   name VARCHAR(50),
   age INT
); In this example, the id column is defined as an identity column with the IDENTITY keyword. It is also set as the primary key of the table. The numbers 1,1 specify the starting value and increment value of an auto-incrementing column. For example, we can start numbering with 100 and add 10 (100, 110, 120, 130...) to each next row by replacing IDENTITY(1,1) with IDENTITY(100, 10). Moreover, negative numbers can be used as a sequence start and step. Try it yourself here Oracle CREATE SEQUENCE example_table_seq;

CREATE TABLE example_table (
   id NUMBER DEFAULT example_table_seq.nextval PRIMARY KEY,
   name VARCHAR2(50),
   age NUMBER
); In this example, a sequence is created first with the CREATE SEQUENCE statement. Then the id column is defined as a number data type with a default value of the next value of the sequence. It is also set as the primary key of the table. The sequence started with 1 and step 1. When we need to customize it we can use and parameters: example_table_seq INCREMENT BY START WITH CREATE SEQUENCE example_table_seq 
    INCREMENT BY 10
    START WITH 10; PostgreSQL PostgreSQL has several options for defining the auto-increment column. The most popular is keyword SERIAL CREATE TABLE example_table (
   id SERIAL PRIMARY KEY,
   name VARCHAR(50),
   age INT
); In this example, the id column is defined as a serial data type, which is equivalent to an auto-increment column in other DBMS. It is also set as the primary key of the table. Also, you can use both and syntax in PostgreSQL to create an auto-increment column. IDENTITY SEQUENCE Here are the examples of creating an auto-increment column using IDENTITY and SEQUENCE syntax in PostgreSQL CREATE TABLE example_table (
   id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
   name VARCHAR(50),
   age INT
); CREATE SEQUENCE example_table_seq;

CREATE TABLE example_table (
   id INT DEFAULT nextval('example_table_seq') PRIMARY KEY,
   name VARCHAR(50),
   age INT
); To insert a new row into the table with an auto-increment column, we can use the INSERT INTO statement, specifying all columns except auto-increment: INSERT INTO example_table (name, age) VALUES ('John Smith', 30); Most SQL dialects allow us to insert several rows in a single query. INSERT INTO example_table (name, age)
VALUES
  ('Jane Doe', 25),
  ('Bob Johnson', 40),
  ('Alice Brown', 35); SQLite, MySQL & MariaDB allows us to insert arbitrary values into the auto-increment column and update the sequence. INSERT INTO example_table (id, name, age) VALUES (11, 'John Smith', 30);

INSERT INTO example_table (name, age)
VALUES
  ('Jane Doe', 25),
  ('Bob Johnson', 40),
  ('Alice Brown', 35);

SELECT * FROM example_table; In the above example, we insert 'John Smith' with id = 11 and the next records inserts uses next sequence values 12, 13, 14. +====+=============+=====+
| id | name        | age |
+====+=============+=====+
| 11 | John Smith  | 30  |
| 12 | Jane Doe    | 25  |
| 13 | Bob Johnson | 40  |
| 14 | Alice Brown | 35  |
+----+-------------+-----+ MS SQL Server does not allow such voluntarism by default. So if we need to insert a value in the identity column we must set on our table: IDENTITY_INSERT SET IDENTITY_INSERT example_table ON
INSERT INTO example_table (id, name, age) VALUES (11, 'John Smith', 30)
SET IDENTITY_INSERT example_table OFF; The above query inserts the record with id = 11 and moves up the identity counter for the next records. What about Oracle? It allows us to insert values in the id column, without the sequence being affected. So, we can insert a row with an arbitrary id, but this can cause a collision like in the next example: CREATE SEQUENCE example_table_seq;

CREATE TABLE example_table (
   id NUMBER DEFAULT example_table_seq.nextval PRIMARY KEY,
   name VARCHAR2(50),
   age NUMBER
);
-- insert row with id = 3
INSERT INTO example_table (id, name, age) VALUES (3, 'John Smith', 30);

-- next to queries will add records with id 1 and 2
INSERT INTO example_table (name, age) VALUES ('Jane Doe', 25); -- 1
INSERT INTO example_table (name, age) VALUES ('Bob Johns', 40); -- 2

-- below query cause to error OCIStmtExecute: ORA-00001: unique constraint (0c7690dacb6b.SYS_C009760) violated 
INSERT INTO example_table (name, age) VALUES ('Alice Brown', 35); 

SELECT * FROM example_table; PostgreSQL with or syntax for the auto-increment column shows us the same behavior as Oracle (row inserted, sequence not updated, error on duplicate). But, when we use syntax insert row with an arbitrary id it is not allowed. SERIAL SEQUENCE IDENTITY This restriction can be forced by like in the next example, but again it is not updating the sequence and collision may ensue. OVERRIDING SYSTEM VALUE CREATE TABLE example_table (
   id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
   name VARCHAR(50),
   age INT
);

INSERT INTO example_table (id, name, age) OVERRIDING SYSTEM VALUE VALUES (3, 'John Smith', 30);

INSERT INTO example_table (name, age) VALUES ('Jane Doe', 25);
INSERT INTO example_table (name, age) VALUES ('Bob Johnson', 40);
INSERT INTO example_table (name, age) VALUES ('Alice Brown', 35);

SELECT * FROM example_table; Let’s move on! How to change an auto-increment value In SQLite, you can reset the auto-increment value for a table by using the table. The table is an internal table used by SQLite to keep track of the next auto-increment value for each table in a database. sqlite_sequence sqlite_sequence Each row in the table represents a table in the database, and the seq column stores the next auto-increment value for that table. sqlite_sequence So when we need to change it just try next: UPDATE sqlite_sequence SET seq = 100 WHERE name = 'example_table';

INSERT INTO example_table (name, age) VALUES ('John Gold', 30); The above code will move the auto-increment value to 100 and the next inserted row will get = 101; id We can delete auto-increment with next query: DELETE FROM sqlite_sequence WHERE name = 'example_table'; or set it as less than the maximal value in the auto-incremented column but after the next row,  the inserted sqlite_sequence will be fixed with the right value. Just look next code snippet: CREATE TABLE example_table (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   name VARCHAR(50),
   age INT
);

INSERT INTO example_table (name, age)
VALUES
  ('Jane Doe', 25),
  ('Bob Johnson', 40),
  ('Alice Brown', 35);

SELECT * FROM sqlite_sequence WHERE name = 'example_table'; After the table is created and filled we see: +===============+=====+
| name          | seq |
+===============+=====+
| example_table | 3   |
+---------------+-----+ We can drop it and make sure that value disappeared DELETE FROM sqlite_sequence WHERE name = 'example_table';

SELECT * FROM sqlite_sequence WHERE name = 'example_table'; After the next record of the inserted value, the sequence will be restored as well. Try it here MySQL & MariaDB also allows changing of the auto-increment using query but it can not be less than the maximal value in the auto-incremented column: ALTER TABLE ALTER TABLE example_table AUTO_INCREMENT = 100; In Oracle, it is possible to alter a sequence using the ALTER SEQUENCE statement. This statement allows you to change the characteristics of a sequence, such as its minimum and maximum values, its increment, and its starting value. If you need to make more significant changes to a sequence, such as changing its data type or dropping it entirely, then you may need to drop and re-create the sequence. DROP SEQUENCE example_table_seq;
CREATE SEQUENCE example_table_seq INCREMENT BY 1 START WITH 100; Note that in Oracle, there is no conflict checking between the new sequence value and existing records. Therefore, it is important to exercise caution and use this feature responsibly to avoid unintended consequences. In PostgreSQL, it doesn't matter how your auto-increment column is created (SERIAL, GENERATED ALWAYS AS IDENTITY, or using CREATE SEQUENCE) because you can use the ALTER SEQUENCE statement to modify the sequence. However, this DBMS does not guarantee the absence of conflicts after the sequence is modified, so it is important to exercise caution. ALTER SEQUENCE example_table_id_seq RESTART WITH 100; Conclusion Auto-increment is a feature in databases that generates a unique number for each new row added to a table, saving the user from manually managing the primary key values. This feature is supported by most RDBMS and can be easily implemented using different syntax in each database. SQLite, MySQL, and MariaDB all support auto-increment columns, as well as PostgreSQL and Oracle, which also allow for more advanced options like sequences and serial data types. Although each database has its own syntax for implementing and managing auto-increment. Overall, the auto-increment feature greatly simplifies the process of adding new rows and ensures that each row has a unique identifier, which is essential for many database operations. If you want to practice creating tables with auto-increment columns and executing SQL statements, you can try using an online SQL editor like SQLize.online, which allows you to create tables, insert data, and run SQL queries on a live database. Also published here.

How to Navigate Auto-Increment Columns in Relational Databases

Intro I am writing this short blog to share a solution to a problem that has been bugging me for a while, which is to find the last row in a column . accurately Problem Usually, when you use google apps script and want to find the last non-empty row we use something similar to the following code. //...... 
// after certain codes
//last row
let lastRow = sheet
      .getRange(1, 1)
      .getNextDataCell(SpreadsheetApp.Direction.DOWN)
      .getRow(); If you've used this code then you know that this doesn't always work. Helper Function But first, a function to get all columns in a spreadsheet. function getColumnNames() {
  let spreadsheet = SpreadsheetApp.openById(SPRD_ID);
  let activeSheet = spreadsheet.getSheetByName(SHEET_NAME);
  let lastCol = sheet
    .getRange(1, 1)
    .getNextDataCell(SpreadsheetApp.Direction.NEXT)
    .getColumn();

 // find the corrent index of url column
  let columns = activeSheet.getRange(1, 1, 1, lastCol).getValues().flat();
  console.log(columns)
  return columns;
} Solution So, solution in stack overflow suggests using the logic of finding the last non-empty row starting from the bottom. I have modified this code to suit my needs. this Then the following code can calculate the last row of a column. function getUrlColumnNRowNumber(colName = "Email") {

  try {
    let spreadsheet = SpreadsheetApp.openById(SPRD_ID);
    let activeSheet = spreadsheet.getSheetByName(SHEET_NAME);

    // find the corrent index of url column
    let columns = getColumnNames();
    let ind = columns.findIndex((val) => val.toLowerCase().trim() === colName.toLowerCase().trim());

    // check if -1 is returned else increase index by 1 to match with index system of spreadsheet
    let colIndex = ind === -1 ? null : ind + 1;
    if (colIndex === null) throw { "error": "No Column Name Found" };

    let maxRows = activeSheet.getMaxRows();
    // ger all the values with emtpy rows
    let columnRaw = activeSheet
      .getRange(2, colIndex, maxRows, 1)
      .getValues()
      .flat();

    let columnRawReverse = [...columnRaw].reverse();
    // find first non empty value  in the list 
    let firstNonEmptyCell = columnRawReverse.findIndex((el) => el !== "");

    // subtract it with maxrows and add 1 becuase range started from 2.
    //  if all rows are empty then return 2 
    let lastRowInCol = firstNonEmptyCell !== -1 ? maxRows - firstNonEmptyCell + 1 : 2;
    console.log([colIndex, lastRowInCol]);
    return [colIndex, lastRowInCol];
  }
  catch (e) {
    if (e.error === "No Column Name Found") {
      console.log("No column found");
      return [null, null]
    }

  }
} If you've understood the code then no need to read further. Explanation Let's go over some minor details: // find the corrent index of url column
    let columns = getColumnNames();
    let ind = columns.findIndex((val) => val.toLowerCase().trim() === colName.toLowerCase().trim());

   // check if -1 is returned else increase index by 1 to match with index system of spreadsheet
    let colIndex = ind === -1 ? null : ind + 1;
    if (colIndex === null) throw { "error": "No Column Name Found" }; Here, we get column names , the first row from the spreadsheet. Then, on the second line, we check if the column name exists in the spreadsheet if not we are throwing an error, however, if it exists then we return the column index. i.e let maxRows = activeSheet.getMaxRows();
    // ger all the values with emtpy rows
    let columnRaw = activeSheet
      .getRange(2, colIndex, maxRows, 1)
      .getValues()
      .flat();

    let columnRawReverse = [...columnRaw].reverse(); Now, we get the max number of rows in the current spreadsheet. Get the values in the column we're checking. The reverse is done to implement the method next. Remember we're fetching values from the second row so, if the column is empty we have to consider this as well. findIndex() // find first non empty value  in the list 
    let firstNonEmptyCell = columnRawReverse.findIndex((el) => el !== ""); Here, we use the method to find the first non-empty value in the reversed list. findIndex() // subtract it with maxrows and add 1 becuase range started from 2.
    //  if all rows are empty then return 2 
    let lastRowInCol = firstNonEmptyCell !== -1 ? maxRows - firstNonEmptyCell + 1 : 2; The returns -1 if the condition is not satisfied and if so then, we'll return 2 as the last row. Else, just subtract the returned, with max rows, and then add 1( ). findIndex() index because we fetched the value from the second row Thank You This is Nibesh Khadka from Khadka's Coding Lounge. Find my blogs . Please do like and share if you like my work. Also, subscribe to get notified about the next upload. here I can make Google Add-Ons and  also write Google Apps Scripts for you. If you need my services let me know. Thank you for your time. Also Published Here

How to Find the Last Non-Empty Row in a Column with Google Apps Script Accurately

How to Change Django Code during Seamless Deployment to Production Server Depending on the environment, working with Django is not always as easy as it is shown in tutorials. It may seem simple – if you need to add a column, add a field to a model, create a migration, run it and the column is ready. And, if you need to delete it, then everything is just as simple: delete the field, create a migration, run it and it is done. However, it does not always work that way in production. When you have several servers or containers running on Prod, and migrations are published before the code is published, then it becomes important not to break the seamless deployment. That is, you need to maintain the consistency of a database and code, and even more. In a previous article, I wrote about . Let's move on to the details. how to deploy Django model changes to Production Deleting Column on Production Depending on the deployment architecture, to delete a column on production, you can use several methods. Performing migrations after deploying the code to all pods in one deployment. Performing migrations with the second deployment, immediately after the first one in which the code was deployed. Performing migrations with a separate deployment after deploying the code but with a possible delay and even other deployments. And now, let us look at this in more detail. Let us take the Airport list model as an example. class Airport(models.Model):
    iata = models.CharField(max_length=3, unique=True)
    name = models.CharField(max_length=30, unique=True) If you delete the ‘name’ column from the model and do not create or perform migrations, nothing bad will happen. But if you try to start creating migrations, a migration will be added with the removal of this field: python manage.py makemigrations Nevertheless, keeping an extra unused field in a database is not the best idea.
Therefore, it seems logical to create a migration and then execute it, thereby removing this field from the table in the database. As a result, a test on a local machine shows that everything is working. But when we started to deploy to Prod, a bunch of errors appears. So, everything is different on Prod. When pods with new code are deployed, the following most often happens. Initialization is performed before each deployment, which includes the execution of migrations: python manage.py migrate After that, pods are created, one at a time. Once a pod is created, one of the old pods is destroyed. Now imagine that the migrations have been completed, but the old code is still working. And it will keep working for a while depending on the number and complexity of pods, sometimes for a few seconds, and sometimes for a few minutes or even tens of minutes. So, after the migration is completed, until the replacement of the last pod, almost any request to the Airport model will throw an exception. For example: Airport.objects.first() will throw an exception like: ProgrammingError: column avia_airport.name does not exist
LINE 1: SELECT "avia_airport"."id", "avia_airport"."iata", "avia_airport"."name" Solutions The first solution suggests that you have two types of migration: the one performed before the code is deployed and the one performed after that. If you have this in , then everything is simple. Adding a column, creating a model, and so on must be done before deployment, and deleting must be performed after that. CI / CD The second solution is only possible if you are completely sure that you can perform two deployments in a row without a break and during this time, no one will deploy or change anything. Then you create a migration as usual. After that, you first deploy only code, and then you run the migration. The model class for the previous two methods will look as follows: class Airport(models.Model):
    iata = models.CharField(max_length=3, unique=True) And the migration will look as follows: migrations.RemoveField(
    model_name='avia_airport',
    name='name',
) And  finally, the third solution is for those cases where you cannot guarantee that two versions will be deployed in a row without any interference. In this case, you need to create a "fake" migration. For this, state_operations is used. For example: migrations.RunSQL(
    sql=migrations.RunSQL.noop, 
    reverse_sql=migrations.RunSQL.noop, 
    state_operations=[
        migrations.RemoveField(
            model_name='avia_airport',
            name='name',
        ),
    ]
) This way you inform Django that this migration is completed. And when you run the command, Django will not add the migration with the 'name' field deletion. However, this migration will not delete this field from the table in the database. So, your first deployment will contain the removal of the field from the model in the code and the ‘fake’ migration. makemigrations Then, the second deployment will have to contain the column removal code. But since Django thinks the column was removed in the previous migration, it will have to be deleted using SQL commands. migrations.RunSQL(
    sql="ALTER TABLE public.avia_airport DROP COLUMN name CASCADE",
    reverse_sql=migrations.RunSQL.noop
) If you are not sure what to write in SQL, then create an original migration and run the command: sqlmigrate python manage.py sqlmigrate avia You will see the needed SQL command which you can copy. By the way, I highly recommend specifying in every manual migration. If you have a specific migration rollback script, then should run it. If you do not have it, then use for the migration or for migrations – an empty migration. This will help avoid an exception in case you need to roll back the migration. reverse_sql reverse_sql migrations.RunSQL.noop RunSQL migrations.RunPython.noop RunPython Conclusion Always keep in mind that there are several Django instances running on production, which are updated to a new version sequentially. Also, remember that there is a period of time between performing a migration and updating the code in which users can see an error. This can cause reputational and financial damage. Therefore, use multi-step deployments when changing the database.

Deleting a Column from a Django Model on Production

If you’ve used Notion for recurring activities like daily habits, or routine checklists, then this blog is for you. I have been using notion to track my habits for over 2 years. I used to use the column-based habit tracker, but I recently switched over to something different. A Column-based habit tracker is where you have all your habits as columns (properties on a page) when using a database table view.  Column-based habit trackers are great for beginners because they're easy to understand, but they have some limitations. For example, if you have columns for “wake up” and “get dressed,” you can't perform aggregations on individual daily entries using columns. For example, it's difficult to know how many habits you've completed today. Also, using a formula would mean using the exact words on the column. Luckily if you change the name of the habit, Notion would also update the formula—but how about when you add new ones or delete a habit column? At that point, you've lost your correct values for the previous days or months. Habits are great. They help you meet your goals, but they can also be a big waste of time. We've all had the experience of getting into a habit and then realizing that we've spent so long doing it that it's become boring or tedious. Most tracked habits should have an expiry that is the date when the habit would no longer be actively tracked. Understanding this, while using a Column-based tracker, I created multiple habit databases per quarter using the column model. I revise my habits every month and quarter, introducing new ones and doing away with ones that are now part of me like waking up early, meditating and going to the gym. Although this worked well on a month-to-month basis, I lost the advantage of using a master database table that is using the table footer actions for calculations like getting the frequency of when I missed a habit, the average time I got out of bed or how many times I indulged in a bad habit. Something different How about we use a Relation Property instead? The Relation Property is a great option for tracking habits because, instead of using a single property to hold all selected habits, it supports them in separate databases. This allows you to calculate the percentage changed on a single day without affecting the calculations or scores of previous months. It also allows you to leverage a master database (a journal, habit entries, daily logs, etc) so that all of your habits are kept together and easily accessible. Here, each habit would be a database and each day in the journal would have a relation to habits, thereby using a single property to hold all selected habits. The downside to this, compared to a Column-based style is that you lose the ability to easily check off habits when using database views however, you become more intentional about your habits. With this, you are able to revisit the pieces of information associated with individual habits and recall why they exist in the first place by navigating into the page contents. While searching for a new way to track my habits, I needed  something that would give me these sets of features Calculate the percentage changed on a single day Skipping a habit should also count toward the overall checked score Supporting habits that can expire by adding and removing a habit column shouldn’t affect the calculations/score of the previous months. Leverage a master database (a journal, habit entries, daily logs, etc) Setting up habits that expire Since I will be introducing new habits every month and quarter (i.e about 30 to 90 days). Every month, I'm going to add a set of habits I plan to track, link those up to the daily entry, and make a comparison between the habits performed today and the habits I have set out to perform using the habit IDs. This can be done using a regex ( ) defined ! Regular Expressions here Getting progress on each daily entry can easily be done by setting an ID on individual habits, rolling up the IDs to the daily database and using the regex formula to derive the numeric difference between the planned and the executed habits. For example, in the image above, Aug 03 has two habits executed out of the 4 planned habits in August. The Daily Log will have a roll-up of all the planned habit IDs from August, and as we add executed habits for the day, we compare the executed against the planned to get a 0.5 execution score. Want to see checkmarks for every habit? Easy! Simply add a formula that results in true or false. For example . You can also delete or update this column and it doesn't change the progress or the data saved in the previous months and days. 👏🏾 contains(props("Selected Habit IDs"), <habit id>) The only disadvantage when using this method is that when you’ve accumulated habits over months and years say 20 habits, updating the habit log property can be a pain because for a relational property; Notion gives you a filter bar and scrollable suggestions. You either have to search or scroll through the list of habits suggested to you. But… it makes habit tracking intentional. To make tracking easier, since the daily entry is a Notion page, we can create two table views filtered by the current page; one for pending and the other for completed. By dragging pending habits between views, Notion will automatically update the page’s habit log relation property with the dragged habit. THE END Leave a comment below if you want to know how I achieve my goals using habits on Notion. Get this Free Template here Also Published here

How to Setup a Better Column-based Habit Tracker in Notion

While working on a Rails application, we all have had to in some way. You can change the and the , as well as changing the column with the . change the database column column name column type type conversion Changing the Column Name Before we can change a column, we have to create it. Let's start with for profiles. creating a model create_table t.references t.string t.string , < ActiveRecord::Migration class CreateProfiles def change :profiles do |t| :user :avatar :name null: false end end end Once you run the profiles data will be migrated to the database. Then we decided to change the . rake db:migrate column name How can we do this? There are 3 different ways to achieve that: Making a migration. new Fixing the migration. existing Making a migration in order to the table. change Be sure to run rake db :migrate at the end of all the examples, so the changes will be saved in the database. Making a New Migration to Change the Column Name First, you need to create a : new migration g migration rename_profile_name_to_full_name rails Then, add a in the newly generated file, specifying which table and what column you want to change: rename_column rename_column , , < ActiveRecord::Migration class RenameProfileNameToFullName def change :profiles :name :full_name end end And you are done! Fixing an Existing Migration Before we start, you should that you want to fix. Depending on the migration was made you can do it in the following ways: rollback the migration when The last migration: rake rollback db: Calling the migration version: rake down VERSION=YOUR_MIGRATION_VERSION db: migrate: Once the rollback has been completed you are free to edit the model. create_table t.references t.string t.string , < ActiveRecord::Migration class CreateProfiles def change :profiles do |t| :user :avatar :full_name null: false end end end Making a New Migration to Change the Table You should only use this option when adding multiple changes to the table at once. Start by creating a new migration: g migration change_profiles rails After the file has been created, specifying which column you want to change by adding a type on its place: rename change_table t.references t.string t.rename , < ActiveRecord::Migration class ChangeProfiles def change :profiles do |t| :user :avatar :name :full_name # t.string -> t.rename end end end Always run your after each change to the database to make it sure everything is working as intended. Also, please be careful with reserved names in Rails or SQL when renaming a column. Here is a list of to help you. RSpec tests reserved words Changing the Column Type This is a common change that encounters - you start with a having an attribute of one and then you realize it needs to be another. At first, you might think that you should store a as a text when it should actually be a string. every programmer model type profile name You can easily fix this by generating a : Don't worry! new migration rails g migration change ame to be string rofiles _n _ _ _ _ in _p Now, open up and edit it in the following way: the migration file change_column , , < ActiveRecord::Migration class ChangeNameToBeStringInProfiles def change :profiles :name :string end end Note that . It will cause an error if you try to rollback. To prevent this, modify the usual change method in the migration to use two separate like this: change_column is an irreversible migration up and down methods change_column , , change_column , , < ActiveRecord::Migration class ChangeNameToBeStringInProfiles def up :profiles :name :string end def down :profiles :name :text end end Start by creating a and change the to a string. Test this out! profile factory name type Changing the Column Type - Errors There are times when simply changing the column type will not work. When you try to write a migration that converts a string column to an integer: change_column , , :profile :age :integer Your database will complain and raise an error: PG::DatatypeMismatch: ERROR: "age" cannot be automatically HINT:  Specify a expression the . column cast to type integer USING to perform conversion To solve this, we will follow the hint and specify in our migration how data should be converted. There are two ways to do this: change_column , , :profile :age 'integer USING CAST(age AS integer)' change_column , , , :profile :age :integer using: 'age::integer' That's it! Hope these steps helped you to change the database columns to your liking. Previously published at kolosek.com/rails-change-database-column/

Changing Database Column in Rails 5

Responsive web pages are websites that adjust to different screen sizes. Audi.com, in 2001 was one of the websites to adopt this design. Bootstrap is one of the most popular CSS frameworks for building responsive web pages. It has a simple way of organizing, positioning and displaying elements using column reordering, which I discovered when working on my project . As the name implies, the concept allows you to reorder columns based on the screen size of the device used to view the page. HTML & CSS capstone at microverse In this publication, I am going to show how to reorder columns using bootstrap. At the time of writing, the current version of bootstrap was 4.1, hence refer to the implementation of this concept in the version of bootstrap you are using to achieve the desired results. To start, by default, all columns have an order value of 0 but I assigned class “order-1” to the desired columns. This if omitted will still display columns based on their appearance in the code. See code and output below: As seen, I did not use any order class, hence the columns appeared in the order in which they appeared in the code. Now let’s see what happens when we alter their order. It can be seen that the columns that did not have order classes were given precedence over those that had, and those that had order classes appeared according to the order value assigned to them. Now let’s reorder the columns based on screen size: The above snippet shows that on medium-sized screens (MD) the columns are displayed based on the order value assigned to them. This means if it is required that the order changes on let’s say large screens, then will be assigned to the various columns. order-lg-[value] Protip: column reordering only works on bootstrap columns: col-[xx], container or container-fluid, not rows The image below shows a practical example of column reordering where I built an online sneaker shop that required column reordering on different screens sizes. the big shoe moves to the top on small screens due to column reordering. In conclusion, column reordering makes arranging content easy and allows the designer to bring into focus the main item when necessary.

How to Achieve Column Reordering with Bootstrap 4

One of the oldest is to keep line width 80, and many of us follow it blindly but have you ever thought why we have this practice in the first place? coding practice I believe it was to make your code more readable in the age of small monitors so that whole content can fit in the screen, or it might have originated from the age of punch card, which was used to be 80 columns wide. This sounds reasonable when we think about those old days but do you think this rule makes sense in 2019? We are now living in the age where most of the developers have got , which can show up to 180 characters, It also makes your code unnecessary long, then it actually is. large monitors doesn’t this is wastage of precious monitor space? I first come to know about line wrapping at 80, while reading Oracle Code Conventions for the , which was last revised at April 20, 1999, which under indentation says Java Programming Language 4.1 Line Length Avoid lines longer than 80 characters, since they’re not handled well by many terminals and tools. Note: Examples for use in documentation should have a shorter line length-generally no more than 70 characters. source: http://www.oracle.com/technetwork/java/javase/documentation/codeconventions-136091.html#248 If I understood correctly (I may be wrong), one goal of this rule is .I used to think that 80 was silly, but being able to go through source code written by a dozen different teams over last 7 years and not needing to re-size my window is a really nice thing. Consistent column width helps with the pace of reading code. consistency Since I mostly worked with large monitors, like with Screen Split, I also realize that we are wasting lots of precious space. The consistent column width of 80 is simply too little. LG 32MP58HQ-P 32-Inch IPS Monitor I personally use 120 unless the project I work already finalized a column width, in that case, I go for consistency. One more reason people give for still using a column with of 80 is that nowadays they are working with multiple files at once, mostly in or in their IDEs like or . VIM Eclipse IntelliJ IDEA For example, if you use standard column width you can fit a couple of files across a reason and can compare them line by line, which I believe is a real benefit. You can even do a three-way merge inspection on one screen without scrolling sideways. By the way, this should not be done at the cost of excessive wrapping. I understand that consistent columns make it easier to scan and read through text but it doesn’t matter whether it’s 80 or 120. On a closing note, I would say that consistency is nice and you must go for it but 80 or even 100 is too short. Many developers could probably live with 120 or even 150 though. Our modern widescreen high definition can easily handle more. LCD monitors It is more readable than the excessive wrapping because I personally find it much harder to read a wrapped line than just seeing the whole thing in one line. Of course, this is just preference and others will feel different. So, what do you guys think, does this rule still hold or you have already moved on? Other you may like Programming Articles The 2019 Web Developer RoadMap 10 Data Structure and Algorithms Courses to Crack Programming Interview 10 Things Java Programmer Should Learn in 2019 10 Programming languages You can Learn in 2019 10 Tools Every Java Developer Should Know 10 Reasons to Learn Java Programming languages 10 Frameworks Java and Web Developer should learn in 2019 10 Tips to become a better Java Developer in 2019 Top 5 Java Frameworks to Learn in 2019 10 Reasons to Learn Python in 2019 10 Testing Libraries Every Java Developer Should Know Thanks for reading this article so far till the end. If you like this article then please consider following me on medium ( ). if you’d like to be notified for every new post and don’t forget to follow on Twitter! javinpaul javarevisited

Stories, News & Mentions about COLUMN

Column’s Stories on HackerNoon