Articles

SQL (Structured Query Language) is a powerful and widely-used language for managing and manipulating data stored in relational databases. However, it’s important to be aware of common mistakes that can lead to bugs, security vulnerabilities, and poor performance in your SQL code. In this article, we’ll explore some of the most common mistakes made when writing SQL code and how to avoid them.

1. Not Properly Sanitizing User Input

One common mistake made when writing SQL code is not properly sanitizing user input. This can lead to security vulnerabilities such as SQL injection attacks, where malicious users can inject harmful code into your database.

Source de l’article sur DZONE

Database sharding is the process of dividing data into smaller pieces called « shards. » Sharding is typically introduced when there’s a need to scale writes. During the lifespan of a successful application, the database server will hit the maximum number of writes it can perform either at the processing or capacity level. Slicing the data into multiple shards—each one on its own database server—reduces the stress on each individual node, effectively increasing the write capacity of the overall database. This is what database sharding is.

Distributed SQL is the new way to scale relational databases with a sharding-like strategy that’s fully automated and transparent to applications. Distributed SQL databases are designed from the ground up to scale almost linearly. In this article, you’ll learn the basics of distributed SQL and how to get started.

Source de l’article sur DZONE

Microservices today are often deployed on a platform such as Kubernetes, which orchestrates the deployment and management of containerized applications. Microservices, however, don’t exist in a vacuum. They typically communicate with other services, such as databases, message brokers, or other microservices. Therefore, an application usually consists of multiple services that form a complete solution.

But, as a developer, how do you develop and test an individual microservice that is part of a larger system? This article examines some common inner-loop development cycle challenges and shows how Quarkus and other technologies help solve some of these challenges.

Source de l’article sur DZONE

With the advent of microservices in Kubernetes, individual developer teams now manage their own data, middleware, and databases. Automated tests and CI/CD pipelines must be revisited to include these new requirements.

This session demonstrates how to use Kustomize and Tekton to provide Kube-Native automated workflows taking into account new parameters such as database operators, StorageClass, and PVC.

Source de l’article sur DZONE


Context

  • 1: Is choosing a database easy?
  • 2: What are the different categories of databases?
    • 2.1: What are Relational Databases?
      • Relational Databases – OLTP – Online Transaction Processing
        • Cloud SQL
        • Cloud Spanner
        • Cloud SQL vs Cloud Spanner
      • Relational Database – OLAP – Online Analytics Processing
        • BigQuery – Modern Data warehouse
    • 2.2: What are NoSQL Databases?
      • Cloud Datastore and Firestore
      • Cloud BigTable
      • Choosing between Cloud Firestore, Datastore vs Cloud BigTable
    • 2.3: What are In-memory Databases?
  • 3: Let’s get a quick summary

Is Choosing a Database Easy?Datacenters

Choosing a database for your use case is not easy. A few factors you would need to consider:

  • 1: Do you want a fixed schema? Do you want flexibility in defining and changing your schema? Do you want to go schemaless?
  • 2: What level of transaction properties do you need? (atomicity and consistency)
  • 3: What kind of latency do you want? (seconds, milliseconds or microseconds)
  • 4: How many transactions do you expect? (hundreds or thousands or millions of transactions per second)
  • 5: How much data will be stored? (MBs or GBs or TBs or PBs)

Before we get into the details, let’s explore the different categories of databases:

Source de l’article sur DZONE

A few months ago, we wrote a blog post on finding and terminating long-running operations in MongoDB. To help make it even easier for MongoLab users* to quickly identify the cause behind database unresponsiveness, we’ve integrated the currentOp() and killOp() methods into our management portal.

* currentOp and killOp functionality is not available on our free Sandbox databases because they run on multi-tenanted mongod processes.

Source de l’article sur DZONE

It’s hard to operate stateful distributed systems at scale and Redis is no exception. Managed databases make life easier by taking on much of the heavy lifting. But you still need a sound architecture and apply best practices both on the server (Redis) as well as the client (application).

This blog covers a range of Redis-related best practices, tips and tricks including cluster scalability, client-side configuration, integration, metrics etc. Although I will be citing Amazon MemoryDB and ElastiCache for Redis from time to time, most (if not all) will be applicable to Redis clusters in general.

Source de l’article sur DZONE

This article is part of a series. For the previous article, see Moving an App Connect Flow Using MQ onto Containers. 

One of the most common integration points is a database, and App Connect is well suited to connecting to a significant variety of datastores. One of the most common protocols used to connect to databases is ODBC, so that is the example that we will work through in this post. 

Source de l’article sur DZONE


Introduction

Nestjs is a cutting-edge Node.js framework for developing server-side applications that are efficient, dependable, and scalable. It is simple to integrate with NoSQL and SQL databases such as MongoDB, Yugabyte, SQLite, Postgres, MySQL, and others. It supports popular object-relational mappers such as TypeORM Sequelize and Mongoose.

In this tutorial, we’ll create an e-commerce application with SQLite and TypeORM. We’ll also look at Arctype, a powerful SQL client and database management tool.

Source de l’article sur DZONE

Many software developers can attest that some of the most significant issues in their applications arise from database performance. Though many developers prefer to use a relational database for enterprise applications, typical logging and monitoring solutions provide limited signals to detect database performance issues. Rooting out common bad practices such as chatty interactions between the application code and the database is non-trivial.

As developers, we need to understand how our database is performing from the context of user transactions. Ideally, we would have a common tool that can monitor the performance of both the application and the database concerning user transactions. OpenTelemetry has emerged as a popular tool for application monitoring, but it can also be extended for monitoring databases.

Source de l’article sur DZONE