ballerina-platform/module-ballerinax-postgresql ballerina-platform/module-ballerinax-postgresql

  • Stars
    star
    116
  • Rank 303,894 (Top 6 %)
  • Language Ballerina
  • License
    Apache License 2.0
  • Created almost 4 years ago
  • Updated 8 months ago
Twitter logo Share LinkedIn logo Share Facebook logo Share
ballerina-platform/module-ballerinax-postgresql
github

ballerina-platform

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Ballerina PostgreSQL DB module

Ballerina PostgreSQL Library

Build codecov Trivy GraalVM Check GitHub Last Commit Github issues

This library provides the functionality required to access and manipulate data stored in a PostgreSQL database.

Prerequisite

Add the PostgreSQL driver as a dependency to the Ballerina project.

Note: ballerinax/postgresql supports PostgrSQL driver versions above 42.2.18.

You can achieve this by importing the ballerinax/postgresql.driver module,

import ballerinax/postgresql.driver as _;

ballerinax/postgresql.driver package bundles the latest PostgreSQL driver JAR.

Tip: GraalVM native build is supported when ballerinax/postgresql is used along with the ballerinax/postgresql.driver

If you want to add a PostgreSQL driver of a specific version, you can add it as a dependency in Ballerina.toml. Follow one of the following ways to add the JAR in the file:

  • Download the JAR and update the path

    [[platform.java17.dependency]]
path = "PATH"

  • Add JAR with a maven dependency params

    [[platform.java17.dependency]]
groupId = "org.postgresql"
artifactId = "postgresql"
version = "42.2.20"

Client

To access a database, you must first create a postgresql:Client object. The examples for creating a PostgreSQL client can be found below.

Tip: The client should be used throughout the application lifetime.

Create a client

This example shows the different methods of creating a postgresql:Client.

When the database is in the default username, the client can be created with an empty constructor, and thereby, the client will be initialized with the default properties.

postgresql:Client|sql:Error dbClient = new ();

The postgresql:Client receives the host, username, password, database, and port. Since the properties are passed in the same order as they are defined in the postgresql:Client, you can pass them without named parameters.

postgresql:Client|sql:Error dbClient2 = 
                                new ("localhost", "postgres", "postgres", 
                                     "postgres", 5432);

In the sample below, the postgresql:Client uses named parameters to pass the attributes since it is skipping some parameters in the constructor. Further, the postgresql:Options property is passed to configure the connection timeout in the PostgreSQL client.

postgresql:Options postgresqlOptions = {
  connectTimeout: 10
};
postgresql:Client|sql:Error dbClient = 
                                new (username = "postgres", password = "postgres", 
                                     database = "test", options = postgresqlOptions);

Similarly in the sample below, the postgresql:Client uses named parameters and it provides an unshared connection pool of the type of sql:ConnectionPool to be used within the client. For more details about connection pooling, see the sql library.

postgresql:Client|sql:Error dbClient4 = 
                                new (username = "postgres", password = "postgres",
                                     connectionPool = {maxOpenConnections: 5});

Using SSL

To connect to the PostgreSQL server using an SSL connection, you must add the SSL configurations to the postgresql:Options when creating the postgresql:Client. For the SSL Mode, you can select one of the following modes: postgresql:PREFERRED, postgresql:REQUIRED, postgresql:DISABLE, or postgresql:ALLOW, postgresql:VERIFY_CA, or postgresql:VERIFY_IDENTITY according to the requirement. The key files must be provided in the .p12 format.

string clientStorePath = "/path/to/keystore.p12";

postgresql:Options postgresqlOptions = {
    ssl: {
        mode: postgresql:ALLOW,
        key: {
            path: clientStorePath,
            password: "ballerina"
        }
    }
};

Connection pool handling

All database libraries share the same connection pooling concept and there are three possible scenarios for connection pool handling. For its properties and possible values, see the sql:ConnectionPool.

Note: Connection pooling is used to optimize opening and closing connections to the database. However, the pool comes with an overhead. It is best to configure the connection pool properties as per the application need to get the best performance.

  1. Global, shareable, default connection pool

    If you do not provide the connectionPool field when creating the database client, a globally-shareable pool will be created for your database unless a connection pool matching with the properties you provided already exists.

    postgresql:Client|sql:Error dbClient = 
                                new (username = "postgres", password = "postgres", 
                                     database = "test");

  2. Client-owned, unsharable connection pool

    If you define the connectionPool field inline when creating the client with the sql:ConnectionPool type, an unsharable connection pool will be created.

    postgresql:Client|sql:Error dbClient = 
                                new (username = "postgres", password = "postgres", 
                                     database = "test", 
                                     connectionPool = { maxOpenConnections: 5 });

  3. Local, shareable connection pool

    If you create a record of the sql:ConnectionPool type and reuse that in the configuration of multiple clients, for each set of clients that connects to the same database instance with the same set of properties, a shared connection pool will be used.

    sql:ConnectionPool connPool = {maxOpenConnections: 5};

postgresql:Client|sql:Error dbClient1 =
                                new (username = "postgres", password = "postgres", 
                                database = "test", connectionPool = connPool);
postgresql:Client|sql:Error dbClient2 = 
                                new (username = "postgres", password = "postgres", 
                                database = "test", connectionPool = connPool);
postgresql:Client|sql:Error dbClient3 = 
                                new (username = "postgres", password = "postgres",
                                database = "example", connectionPool = connPool);

For more details about each property, see the postgresql:Client.

The postgresql:Client references sql:Client and all the operations defined by the sql:Client will be supported by the postgresql:Client as well.

Close the client

Once all the database operations are performed, you can close the client you have created by invoking the close() operation. This will close the corresponding connection pool if it is not shared by any other database clients.

Note: The client must be closed only at the end of the application lifetime (or closed for graceful stops in a service).

error? e = dbClient.close();

or

check dbClient.close();

Database operations

Once the client is created, database operations can be executed through that client. This library defines the interface and common properties that are shared among multiple database clients. It also supports querying, inserting, deleting, updating, and batch updating data.

Parameterized query

The sql:ParameterizedQuery is used to construct the SQL query to be executed by the client. You can create a query with constant or dynamic input data as follows.

Query with constant values

sql:ParameterizedQuery query = `SELECT * FROM students 
                                WHERE id < 10 AND age > 12`;

Query with dynamic values

int[] ids = [10, 50];
int age = 12;
sql:ParameterizedQuery query = `SELECT * FROM students 
                                WHERE id < ${ids[0]} AND age > ${age}`;

Moreover, the SQL package has sql:queryConcat() and sql:arrayFlattenQuery() util functions which make it easier to create a dynamic/constant complex query.

The sql:queryConcat() is used to create a single parameterized query by concatenating a set of parameterized queries. The sample below shows how to concatenate queries.

int id = 10;
int age = 12;
sql:ParameterizedQuery query = `SELECT * FROM students`;
sql:ParameterizedQuery query1 = ` WHERE id < ${id} AND age > ${age}`;
sql:ParameterizedQuery sqlQuery = sql:queryConcat(query, query1);

A query with the IN operator can be created using the sql:ParameterizedQuery as shown below. Here you need to flatten the array and pass each element separated by a comma.

int[] ids = [1, 2, 3];
sql:ParameterizedQuery query = `SELECT count(*) as total FROM DataTable 
                                WHERE row_id IN (${ids[0]}, ${ids[1]}, ${ids[2]})`;

The sql:arrayFlattenQuery() util function is used to make the array flattening easier. It makes the inclusion of varying array elements into the query easier by flattening the array to return a parameterized query. You can construct the complex dynamic query with the IN operator by using both functions as shown below.

int[] ids = [1, 2];
sql:ParameterizedQuery sqlQuery = 
                         sql:queryConcat(`SELECT * FROM DataTable WHERE id IN (`, 
                                          sql:arrayFlattenQuery(ids), `)`);

Create tables

This sample creates a table with three columns. The first column is a primary key of type int while the second column is of type int and the other is of type varchar. The CREATE statement is executed via the execute remote method of the client.

// Create the ‘Students’ table with the ‘id’, ’name’, and ’age’ fields.
sql:ExecutionResult result = 
                check dbClient->execute(`CREATE TABLE student (
                                           id INT AUTO_INCREMENT,
                                           age INT, 
                                           name VARCHAR(255), 
                                           PRIMARY KEY (id)
                                         )`);
// A value of the `sql:ExecutionResult` type is returned for the `result`.

Insert data

These samples show the data insertion by executing an INSERT statement using the execute remote method of the client.

In this sample, the query parameter values are passed directly into the query statement of the execute remote method.

sql:ExecutionResult result = check dbClient->execute(`INSERT INTO student(age, name)
                                                        VALUES (23, 'john')`);

In this sample, the parameter values, which are assigned to local variables are used to parameterize the SQL query in the execute remote method. This type of parameterized SQL query can be used with any primitive Ballerina type such as string, int, float, or boolean and in that case, the corresponding SQL type of the parameter is derived from the type of the Ballerina variable that is passed.

string name = "Anne";
int age = 8;

sql:ParameterizedQuery query = `INSERT INTO student(age, name)
                                  VALUES (${age}, ${name})`;
sql:ExecutionResult result = check dbClient->execute(query);

In this sample, the parameter values are passed as an sql:TypedValue to the execute remote method. Use the corresponding subtype of the sql:TypedValue such as sql:VarcharValue, sql:CharValue, sql:IntegerValue, etc., when you need to provide more details such as the exact SQL type of the parameter.

sql:VarcharValue name = new ("James");
sql:IntegerValue age = new (10);

sql:ParameterizedQuery query = `INSERT INTO student(age, name)
                                  VALUES (${age}, ${name})`;
sql:ExecutionResult result = check dbClient->execute(query);

Insert data with auto-generated keys

This sample demonstrates inserting data while returning the auto-generated keys. It achieves this by using the execute remote method to execute the INSERT statement.

int age = 31;
string name = "Kate";

sql:ParameterizedQuery query = `INSERT INTO student(age, name)
                                  VALUES (${age}, ${name})`;
sql:ExecutionResult result = check dbClient->execute(query);

//Number of rows affected by the execution of the query.
int? count = result.affectedRowCount;

//The integer or string generated by the database in response to a query execution.
string|int? generatedKey = result.lastInsertId;

Query data

These samples show how to demonstrate the different usages of the query operation to query the database table and obtain the results as a stream.

Note: When processing the stream, make sure to consume all fetched data or close the stream.

This sample demonstrates querying data from a table in a database. First, a type is created to represent the returned result set. This record can be defined as an open or a closed record according to the requirement. If an open record is defined, the returned stream type will include both defined fields in the record and additional database columns fetched by the SQL query which are not defined in the record. Note the mapping of the database column to the returned record's property is case-insensitive if it is defined in the record (i.e., the ID column in the result can be mapped to the id property in the record). Additional column names are added to the returned record as in the SQL query. If the record is defined as a closed record, only the fields defined in the record are returned or gives an error when additional columns are present in the SQL query. Next, the SELECT query is executed via the query remote method of the client. Once the query is executed, each data record can be retrieved by iterating through the result set. The stream returned by the SELECT operation holds a pointer to the actual data in the database, and it loads data from the table only when it is accessed. This stream can be iterated only once.

// Define an open record type to represent the results.
type Student record {
    int id;
    int age;
    string name;
};

// Select the data from the database table. The query parameters are passed 
// directly. Similar to the `execute` samples, parameters can be passed as
// sub types of `sql:TypedValue` as well.
int id = 10;
int age = 12;
sql:ParameterizedQuery query = `SELECT * FROM students
                                WHERE id < ${id} AND age > ${age}`;
stream<Student, sql:Error?> resultStream = dbClient->query(query);

// Iterating the returned table.
check from Student student in resultStream
    do {
       // Can perform operations using the `student` record of type `Student`.
    };

Defining the return type is optional and you can query the database without providing the result type. Hence, the above sample can be modified as follows with an open record type as the return type. The property name in the open record type will be the same as how the column is defined in the database.

// Select the data from the database table. The query parameters are passed 
// directly. Similar to the `execute` samples, parameters can be passed as 
// sub types of `sql:TypedValue` as well.
int id = 10;
int age = 12;
sql:ParameterizedQuery query = `SELECT * FROM students
                                WHERE id < ${id} AND age > ${age}`;
stream<record{}, sql:Error?> resultStream = dbClient->query(query);

// Iterating the returned table.
check from record{} student in resultStream
    do {
        // Can perform operations using the `student` record.
        io:println("Student name: ", student.value["name"]);
    };

There are situations in which you may not want to iterate through the database and in that case, you may decide to use the queryRow() operation. If the provided return type is a record, this method returns only the first row retrieved by the query as a record.

int id = 10;
sql:ParameterizedQuery query = `SELECT * FROM students WHERE id = ${id}`;
Student retrievedStudent = check dbClient->queryRow(query);

The queryRow() operation can also be used to retrieve a single value from the database (e.g., when querying using COUNT() and other SQL aggregation functions). If the provided return type is not a record (i.e., a primitive data type) , this operation will return the value of the first column of the first row retrieved by the query.

int age = 12;
sql:ParameterizedQuery query = `SELECT COUNT(*) FROM students WHERE age < ${age}`;
int youngStudents = check dbClient->queryRow(query);

Update data

This sample demonstrates modifying data by executing an UPDATE statement via the execute remote method of the client.

int age = 23;
sql:ParameterizedQuery query = `UPDATE students SET name = 'John' WHERE age = ${age}`;
sql:ExecutionResult result = check dbClient->execute(query);

Delete data

This sample demonstrates deleting data by executing a DELETE statement via the execute remote method of the client.

string name = "John";
sql:ParameterizedQuery query = `DELETE from students WHERE name = ${name}`;
sql:ExecutionResult result = check dbClient->execute(query);

Batch update data

This sample demonstrates how to insert multiple records with a single INSERT statement that is executed via the batchExecute remote method of the client. This is done by creating a table with multiple records and parameterized SQL query as same as the above execute operations.

// Create the table with the records that need to be inserted.
var data = [
  { name: "John", age: 25 },
  { name: "Peter", age: 24 },
  { name: "jane", age: 22 }
];

// Do the batch update by passing the batches.
sql:ParameterizedQuery[] batch = from var row in data
                                 select `INSERT INTO students ('name', 'age')
                                           VALUES (${row.name}, ${row.age})`;
sql:ExecutionResult[] result = check dbClient->batchExecute(batch);

Execute stored procedures

This sample demonstrates how to execute a stored procedure with a single INSERT statement that is executed via the call remote method of the client.

int uid = 10;
sql:IntegerOutParameter insertId = new;

sql:ProcedureCallResult result = 
                         check dbClient->call(`call InsertPerson(${uid}, ${insertId})`);
stream<record{}, sql:Error?>? resultStr = result.queryResult;
if resultStr is stream<record{}, sql:Error?> {
    check from record{} result in resultStr
        do {
            // Can perform operations using the `result` record.
        };
}
check result.close();

Note: Once the results are processed, the close method on the sql:ProcedureCallResult must be called.

Note: The default thread pool size used in Ballerina is: the number of processors available * 2. You can configure the thread pool size by using the BALLERINA_MAX_POOL_SIZE environment variable.

Issues and projects

Issues and Projects tabs are disabled for this repository as this is part of the Ballerina Standard Library. To report bugs, request new features, start new discussions, view project boards, etc, visit the Ballerina Standard Library parent repository.

This repository only contains the source code for the package.

Building from the source

Set up the prerequisites

  1. Download and install Java SE Development Kit (JDK) version 11 (from one of the following locations).

  2. Download and install Docker.

  3. Export your Github Personal access token with the read package permissions as follows.

     export packageUser=<Username>
 export packagePAT=<Personal access token>

Building the source

Execute the commands below to build from the source.

  1. To build the library:

     ./gradlew clean build

  2. To run the integration tests:

     ./gradlew clean test

  3. To build the package without tests:

     ./gradlew clean build -x test

  4. To run only specific tests:

     ./gradlew clean build -Pgroups=<Comma separated groups/test cases>

    Tip: The following groups of test cases are available.

    Groups Test Cases
    connection connection-init
    pool pool
    execute execute-basic
    execute-params
    batch-execute batch-execute
    query query
    query-simple-params
    procedures procedures
    functions functions

  5. To disable some specific groups during the test:

     ./gradlew clean build -Pdisable-groups=<Comma separated groups/test cases>

  6. To debug the tests:

     ./gradlew clean build -Pdebug=<port>

  7. To debug the package with the Ballerina language:

     ./gradlew clean build -PbalJavaDebug=<port>

  8. Publish ZIP artifact to the local .m2 repository:

    ./gradlew clean build publishToMavenLocal

  9. Publish the generated artifacts to the local Ballerina central repository:

    ./gradlew clean build -PpublishToLocalCentral=true

Contribute to Ballerina

As an open source project, Ballerina welcomes contributions from the community.

For more information, go to the contribution guidelines.

Code of conduct

All contributors are encouraged to read the Ballerina Code of Conduct.

Useful links

More Repositories

1

ballerina-lang

The Ballerina Programming Language
Ballerina
3,286
star
2

lsp4intellij

This language client library provides language server protocol support for IntelliJ IDEA and other Jetbrains IDEs.
Java
413
star
3

ballerina-spec

Ballerina Language and Platform Specifications
HTML
171
star
4

ballerina-dev-website

Dev version of the ballerina.io website
HTML
163
star
5

module-ballerina-graphql

The Ballerina GraphQL module is part of the Ballerina Standard Library. It is a spec-compliant, production-ready GraphQL implementation for writing GraphQL APIs in Ballerina.
Ballerina
144
star
6

nballerina

Ballerina compiler that generates native executables.
Ballerina
142
star
7

ballerina-library

The Ballerina Library
Ballerina
137
star
8

module-ballerina-jwt

Ballerina JWT module.
Ballerina
130
star
9

openapi-tools

Ballerina OpenApi-Tool
Java
129
star
10

module-ballerina-grpc

Ballerina gRPC Module
Ballerina
128
star
11

ballerina-release

Ballerina release scripts
Python
126
star
12

openapi-connectors

Generate Ballerina connector with OpenAPI definition
Ballerina
126
star
13

module-ballerina-http

Ballerina HTTP Module
Java
124
star
14

module-ballerinax-nats

Ballerina NATS Module.
Ballerina
124
star
15

ballerina-platform.github.io

ballerina-platform.github.io - Github pages based ballerina.io website
HTML
124
star
16

ballerina-action

Dockerfile
124
star
17

module-ballerina-io

Ballerina io Module
Ballerina
123
star
18

module-ballerina-tcp

Ballerina socket module
Java
122
star
19

module-ballerina-oauth2

Ballerina OAuth2 Module
Ballerina
122
star
20

module-ballerina-websocket

Ballerina WebSocket Module
Java
121
star
21

module-ballerina-websub

Ballerina Websub module.
Ballerina
120
star
22

module-ballerina-mime

Ballerina MIME Module
Java
119
star
23

plugin-intellij

Ballerina extension for IntelliJ IDEA.
Java
119
star
24

module-ballerinax-mysql

Ballerina mysql Module
Ballerina
119
star
25

module-ballerina-auth

Ballerina Auth Module
Java
119
star
26

module-ballerina-sql

Ballerina SQL Module
Java
119
star
27

module-ballerina-email

Ballerina module to send and receive emails
Java
119
star
28

module-ballerinax-kafka

Ballerina Kafka Module.
Ballerina
119
star
29

module-ballerina-udp

Ballerina UDP module enables transport layer communication over UDP protocol.
Java
118
star
30

module-ballerinax-java.jdbc

Ballerina JDBC Module
Ballerina
118
star
31

module-ballerina-cache

Ballerina cache Module
Ballerina
118
star
32

module-ballerina-log

Ballerina log Module
Ballerina
118
star
33

module-ballerina-c2c

Ballerina Code2Cloud implementation
Java
118
star
34

module-ballerinax-slack

Ballerina slack module
Ballerina
118
star
35

module-ballerinax-azure-cosmosdb

Ballerina
118
star
36

plugin-vscode-compiler-toolkit

Compiler tools for Ballerina developers
TypeScript
118
star
37

ballerina-dev-tools

Ballerina Developer Tooling
Java
118
star
38

module-ballerinax-stan

Ballerina NATS Streaming Module.
Java
117
star
39

module-ballerina-crypto

Ballerina crypto Module
Ballerina
117
star
40

module-ballerina-websubhub

This modules includes a bunch of APIs to facilitate writing different WebSub Hub implementations
Ballerina
116
star
41

module-ballerinax-googleapis.calendar

Connector repository for Google Calendar API.
Ballerina
116
star
42

module-ballerina-xmldata

Ballerina xml utils Module
Ballerina
116
star
43

module-ballerinax-java.jms

Ballerina
116
star
44

module-ballerina-file

Ballerina File Module
Ballerina
116
star
45

module-ballerinax-azure-service-bus

Ballerina
116
star
46

module-ballerinax-aws.dynamodb

This is to keep the Amazon DynamoDB connector for Ballerina.
Ballerina
116
star
47

module-ballerinax-aws.s3

Ballerina
116
star
48

module-ballerina-task

Ballerina task Module
Java
116
star
49

module-ballerina-time

Ballerina time Module
Ballerina
116
star
50

module-ballerinax-azure.functions

The implementation of Azure Functions compiler extension for Ballerina.
Java
116
star
51

module-ballerinax-datamapper

A compiler extension to extract abstract representation of Ballerina connector actions and their associated types
Java
116
star
52

module-ballerina-uuid

Ballerina UUID Module
Ballerina
116
star
53

module-ballerinax-netsuite

The Ballerina connector to perform operations on Netsuite integrate cloud system.
Ballerina
116
star
54

module-ballerinax-twitter

This repo is to keep Ballerina Twitter connector implementation for Ballerina
Ballerina
116
star
55

ballerina-update-tool

Ballerina Update Tool implementation to manage Ballerina versions
Java
116
star
56

module-ballerinax-ai.agent

Ballerina ReAct type Agent module using Large language models (LLMs)
Ballerina
115
star
57

module-ballerina-os

Ballerina system Module
Java
115
star
58

module-ballerinax-jaeger

Ballerina Jaeger Observability Extension Module
Java
115
star
59

module-ballerinax-aws.sqs

Ballerina
115
star
60

module-ballerinax-mssql

Ballerina MSSQL DB module
Ballerina
115
star
61

module-ballerinax-aws.lambda

Java
115
star
62

module-ballerina-serdes

This is the Ballerina SerDes package, which is a part of the Ballerina Language Standard Library
Java
115
star
63

module-ballerinax-oracledb

Oracle Database Connector for Ballerina
Ballerina
115
star
64

module-ballerina-xslt

Ballerina xslt module
Java
115
star
65

module-ballerina-url

Ballerina encoding module.
Ballerina
115
star
66

module-ballerinax-rabbitmq

Ballerina RabbitMQ Module.
Ballerina
115
star
67

module-ballerinax-prometheus

Ballerina Prometheus Observability Extension Module
Java
115
star
68

module-ballerinai-transaction

Ballerina internal module of transaction implementation
Ballerina
115
star
69

module-ballerinax-mysql.driver

Ballerina Azure MySQL Module
Ballerina
115
star
70

module-ballerinax-azure-storage-service

Ballerina
115
star
71

graphql-tools

Maintain the source code for GraphQL related tools.
Java
115
star
72

module-ballerina-jballerina.java.arrays

Ballerina Java Array Module
Ballerina
114
star
73

module-ballerina-constraint

Ballerina Constraint Module
Ballerina
114
star
74

module-ballerinax-choreo

Ballerina Choreo Observability Extension Module
Java
114
star
75

ballerina-performance-cloud

Ballerina Performance Tests in Cloud
Shell
114
star
76

module-ballerinax-azure.eventhub

Azure Eventhub connector
Ballerina
114
star
77

module-ballerina-regex

Ballerina Regex Module
Ballerina
114
star
78

plugin-gradle

Ballerina Gradle plugin
Groovy
114
star
79

module-ballerinax-mssql.driver

Ballerina MSSQL DB Driver
Ballerina
114
star
80

module-ballerina-random

Ballerina Random Library
Ballerina
114
star
81

module-ballerinax-health.fhir.templates

FHIR Ballerina templates
Ballerina
114
star
82

module-ballerinax-persist.sql

SQL database support of Ballerina Persist
Ballerina
114
star
83

module-ballerinax-microsoft.onedrive

The Ballerina connector to perform operations on the files, which is stored on OneDrive
Ballerina
114
star
84

ballerina-custom-jre

Generates platform-specific custom Java runtime images to be bundled with Ballerina platform distributions, which contains only the required modules for Ballerina runtime.
114
star
85

asyncapi-tools

This repository is the code base for the ballerina async-api tool
Java
114
star
86

persist-tools

Ballerina persist tools
Ballerina
113
star
87

module-ballerinax-cdata.connect

Manage Ballerina CData connector modules centrally.
Java
113
star
88

module-ballerina-persist

Ballerina Persist module
Java
113
star
89

module-ballerinax-peoplehr

Ballerina connector for People HR
Ballerina
113
star
90

module-ballerinax-aws.ses

The Ballerina connector to perform operations on Amazon Simple Email Service(Amazon SES).
Ballerina
113
star
91

module-ballerinax-googleapis.people

Repository for Google People API Connector
Ballerina
113
star
92

module-ballerinax-microsoft.teams

The Ballerina Microsoft Teams Connector for teamwork and intelligent communications.
Ballerina
113
star
93

module-ballerinax-googleapis.drive

Repository for Google Drive module.
Ballerina
113
star
94

module-ballerinax-microsoft.excel

The Ballerina connector to perform operations on Excel workbooks stored in Microsoft OneDrive.
Ballerina
113
star
95

asyncapi-triggers

This repo will contain the trigger source code generated through ballerina async api tool
Ballerina
113
star
96

module-ballerinax-aws.simpledb

This is to keep the Amazon SimpleDB connector for Ballerina.
Ballerina
112
star
97

module-ballerinax-aws.sns

This repo is to keep the newly written Amazon SNS connector for Ballerina.
Ballerina
112
star
98

module-ballerina-toml

Ballerina TOML Parser
Ballerina
112
star
99

edi-tools

This library provides the functionality required to process EDI files and implement EDI integrations.
Ballerina
112
star
100

module-ballerinax-health.fhir.r4

FHIR R4 Ballerina modules
Ballerina
112
star