Forem: Anisha Mohanty

GraphQL CRUD Java: Overview

Anisha Mohanty — Thu, 05 Nov 2020 14:54:31 +0000

What is GraphQL CRUD Java?

GraphQLCRUD java is an extensive framework built using the GraphQLCRUD spec which provides a specification for common operation on top of GraphQL. It provides numerous options for users to access and modify their data from any data sources they are connected to.

Common Features

Check specifications for patterns and pick only those that will really work for your specific database or business requirements.
It provides canonical versions and other variants giving you an overview of different approaches used in most schemas.
Focus on your business logic and data and generate GraphQL CRUD compliant schemas in any language of your choice.
It abstracts from large GraphQL vendors giving you flexibility, and the ability to migrate without rebuilding your clients and resolves.
It focuses on productivity by giving developers powerful query capabilities that are not specific to any GraphQL solution providers.

CRUD methods

GraphQL CRUD java defines different CRUD capabilities that represent various operations that can be executed on a set of objects:

Create: create an object
Update: update a specific object's properties
Delete: delete a specific object by its ID
Get: get a specific object by its ID
Find: find multiple objects

Capabilities

GraphQL CRUD java defines different capabilities that developers can enable to modify what queries can be made against the service. Examples of these capabilities include:

Pagination: Ability to paginate content
Filtering: Ability to perform filtering on specific fields
Countability: Ability to count the total number of objects
Consistency: Ability to verify whether a write operation is overriding data

How it works?

Take any database, the GraphQL CRUD java engine can automatically generate a GraphQL schema and process GraphQL queries and mutations. Here’s what the engine does under the hood.

The GraphQL CRUD java engine automatically generates GraphQL schema components and creates relationships between them.
It defines a GraphQL type definition for your database.
Provides Query with filter,order_by, and page arguments.
Provides Insert mutations with the input argument that supports insert operation.
Provides Update mutation with filter and input argument that supports bulk updates.
Provides Delete mutation with a filter argument that supports bulk deletes.

Example: Fetch list of all accounts

#Input
{
  accounts {
    account_id
    status
    ssn
    }
}

#Output
{
  "data": {
    "accounts": [
      {
        "account_id": "19980001",
        "status": "Personal",
        "ssn": "CST01002"
      },
      {
        "account_id": "19980002",
        "status": "Personal",
        "ssn": "CST01002"
      },
      {
        "account_id": "19980003",
        "status": "Personal",
        "ssn": "CST01003"
      }
    ]
  }
}

Example: Fetch an account using the primary key

#Input
{
  account(account_id: 19980001) {
    account_id
    ssn
    status
    type
  }
}

#Output
{
  "data": {
    "account": {
      "account_id": "19980001",
      "ssn": "CST01002",
      "status": "Personal",
      "type": "Active"
    }
  }
}

Example: Fetch a customer whose name is James

#Input
{
  customers(filter: {
    firstname: {
      eq: "James"
    }
  }) {
    firstname
    lastname
    ssn
    phone
  }
}

#Output
{
  "data": {
    "customers": [
      {
        "firstname": "James",
        "lastname": "Drew",
        "ssn": "CST01036",
        "phone": "(216)555-6523"
      }
    ]
  }
}

Example: Fetch 2 customers from the list of all customers, starting from first

#Input
{
  customers(page: {
    limit: 2
  }) {
    firstname
    lastname
    ssn
    phone
  }
}

#Output
{
  "data": {
    "customers": [
      {
        "firstname": "John",
        "lastname": "Doe",
        "ssn": "CST01002  ",
        "phone": "(646)555-1776"
      },
      {
        "firstname": "Bob",
        "lastname": "Smith",
        "ssn": "CST01003  ",
        "phone": "(412)555-4327"
      }
    ]
  }
}

Example: Fetch 2 customers from the list of all customers, starting from the 2nd customer

#Input
{
  customers(filter: {
    firstname: {
      startsWith: "J"
    }
  }, page: {
    limit: 2,
    offset: 2
  }) {
    firstname
    lastname
    ssn
    phone
  }
}

#Output
{
  "data": {
    "customers": [
      {
        "firstname": "Jack",
        "lastname": "Corby",
        "ssn": "CST01015  ",
        "phone": "(469)555-8023"
      },
      {
        "firstname": "James",
        "lastname": "Drew",
        "ssn": "CST01036  ",
        "phone": "(216)555-6523"
      }
    ]
  }
}

Example: Insert a new customer object and return the inserted customer object in the response

#Input
mutation {
  createCustomer(input: {
    firstname: "James",
    lastname: "Corners",
    ssn: "CST00989"
  }) {
    firstname
    lastname
    ssn
  }
}

#Output
{
  "data": {
    "createCustomer": {
      "firstname": "James",
      "lastname": "Corners",
      "ssn": "CST00989"
    }
  }
}

Example: Update a customer with the name Bob and return the updated customer object in the response

#Input
mutation {
  updateCustomer (input: {
    firstname: "Andrew",
    lastname: "Moore"
  }, filter: {
    firstname: {
      eq: "Bob"
    }
  }) {
    firstname
    lastname
    ssn
  }
}

#Output
{
  "data": {
    "updateCustomer": {
      "firstname": "Andrew",
      "lastname": "Moore",
      "ssn": "CST01003"
    }
  }
}

Example: Delete a customer where name is Andrew

#Input
mutation {
  deleteCustomer(filter: {
    firstname: {
      eq: "Andrew"
    }
  }) {
    firstname
    lastname
    ssn
    phone
  }
}

#Output
{
  "data": {
    "deleteCustomer": {
      "firstname": "Andrew",
      "lastname": "Moore",
      "ssn": "CST01003"
    }
  }
}

You can explore the entire schema and the available queries using the GraphiQL interface. You can expand the framework as per your needs to make it more robust.

To get a detailed understanding or to contribute check out the GitHub repository here and if you like the work drop a ⭐ in the repository.

Happy Reading! ❤️

Drop your Hacktoberfest 2020 projects! 🥳

Anisha Mohanty — Thu, 17 Sep 2020 09:47:01 +0000

Join the global community for the yearly celebration of open source software. Hacktoberfest is a monthlong celebration of open source software organized by DigitalOcean.

I am excited for Hacktoberfest 2020 and looking forward to contribute in some exciting projects. Drop your awesome github projects links and I will share the best ones as well. Looking forward to work with your exciting projects.

May the source be with you. ✨

Golang Learning Resources

Anisha Mohanty — Thu, 27 Aug 2020 15:39:08 +0000

Hey everyone, I have started learning Golang recently and in this article, I am going to list a few useful resources for beginners getting started with Golang.

🏷️ Online Resources

The Go Programming Language Tour
Go Essentials Training by Miki Tebeka on LinkedIn Learning
Effective Go
How to Write Go Code
Go Programming Language by GeeksForGeeks

🏷️ Books

The Go Programming Language by Alan A. A. Donovan and Brian W. Kernighan
Go Bootcamp by Matt Aimonetti

🏷️ Videos and Podcasts

Go in 5 Minitues
Gophercises by Jon Calhoun

🏷️ Editors and IDEs

GoLand by Jetbrains

🏷️ Community Resources

These are some of my recommendations, feel free to add more resources in the comments. Happy Learning! 🚀

Basic git commands

Anisha Mohanty — Mon, 24 Aug 2020 16:24:22 +0000

Working with Git on the command line can be messy. To help with that, I have listed together with some basic Git commands, what each one means, and how to use them.

Command: `git init`

Usage :

Used to create an empty Git repository or reinitialize an existing one. Also, you create a repository within a new directory by specifying the project name.

$ git init 

#initailize empty git repository with a name
$ git init <project-name>

Command: `git clone`

Usage :

Used to create a local working copy of an existing remote repository.

$ git clone <remote-repository>

Command: `git add`

Usage :

Adds files in the to the staging area for Git. Before a commit is made to a repository, the file needs to be added to the Git index.

#add all files
$ git add .

#add a specific file:
$ git add <file-name>

#add an entire directory:
$ git add <directory-name>

Command: `git rm`

Usage :

Remove files from the working tree and from the index.

#remove a file from the working index (cached)
$ git rm --cached <file-name>

#delete a file (force)
$ git rm -f <file-name>

Command: `git log`

Usage :

Show commit logs.

#show entire git log
$ git log

#show git log based on commit author
$ git log --<author>="Author Name"

Command: `git status`

Usage :

Show the working tree status.

$ git status

Command: `git branch`

Usage :

List, create or delete branches.

#create a new branch
$ git branch <branch-name>

#list all remote or local branches
$ git branch -a

#delete a branch
$ git branch -d <branch-name>

Command: `git checkout`

Usage :

Switch branches or restore working tree files.

#checkout an existing branch
$ git checkout <branch-name>

#checkout and create a new branch 
$ git checkout -b <new-branch>

Command: `git commit`

Usage :

Record changes to the repository.

#add a commit with a message
$ git commit -m "commit message in quotes"

Command: `git merge`

Usage :

Join two or more development histories together.

#merge changes into current branch
$ git merge <branch-name>

Command: `git fetch`

Usage :

Download objects and refs from another repository.

#fetch all of the branches from the repository
$ git fetch <remote-name>

#fetch the specified branch
$ git fetch <remote-name> <branch-name>

Command: `git pull`

Usage :

Fetch from and integrate with another repository or a local branch.

$ git pull <branch-name> <remote-name>

Command: `git push`

Usage :

Update remote refs along with associated objects.

$ git push <remote-name> <branch-name>

# push all local branches to a remote repository
$ git push —all

Command: `git remote`

Usage :

Used to connect a local repository with a remote repository.

#add remote repository
$ git remote <command> <remote-name> <remote-URL>

#list named remote repositories
$ git remote -v

Further Learning

There are plenty of more commands, here are few references that might be useful.

Thanks for reading, I hope you get git done. 🎉

How to create awesome illustrations?

Anisha Mohanty — Sat, 15 Aug 2020 20:11:46 +0000

Well well, this weekend I chose to do something new. Apart from writing code I enjoy gardening, painting and reading. But I did something interesting today. I used the Adobe Illustrator to design my first illustration. It is a very minimal and small planter.

My key learning was that patience is the ultimate goal to get started here. I really enjoyed doing this. ♥️

Any awesome resources to create and learn more of it? I wanna explore more here!

How to Install GO?

Anisha Mohanty — Sat, 15 Aug 2020 05:44:18 +0000

Go is a programming language that was developed by Google. The language is often referred to as Golang. It was designed to have three features available at the same time - fast compilation, ease of programming, and efficient execution in production.

This guide will help you through installing Go on your local machine and setting up a programming workspace via the command line.

Let's get started. 🚀

Installing and Setting Up Homebrew

Homebrew provides macOS with a free and open-source software package managing system that simplifies the installation of software on macOS.

$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Installing GO

You can use Homebrew to search for all available packages with the brew search command.

$ brew search golang

The terminal will output a list of what you can install.

golang  golang-migrate

Now, install golang with brew install command.

$ brew install golang

To check the version of Go that you installed use the following command.

$ go version

Creating Your Go Workspace

src: The directory that contains Go source files. A source file is a file that you write using the Go programming language. Source files are used by the Go compiler to create an executable binary file.
bin: The directory that contains executables built and installed by the Go tools. Executables are binary files that run on your system and execute tasks. These are typically the programs compiled by your source code or another downloaded Go source code.

The default directory for the Go workspace home directory with a go subdirectory, or $HOME/go.

Issue the following command to create the directory structure for your Go workspace:

$ mkdir -p $HOME/go/{bin,src}

First, open ~/.bash_profile with your preferred text editor and set up the $GOPATH.

export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin

Congratulations! You have a Go programming workspace set up on your local machine and can begin to write your first Go program. 🚀

Thanks for reading. Happy Learning! ❤️

Unit Testing with JUnit5

Anisha Mohanty — Thu, 13 Aug 2020 05:35:04 +0000

Unit testing is a type of software testing in which we test individual software components. It is done during the development of an application by the developers. It isolates a section of code and verify its correctness. A unit may be an individual function, method, procedure, module, or object.

Well here are a few advantages of Unit testing.

If unit tests are well-written, then with every build of our software with changed of code, we can notice any failures when we introduce new features.
It makes your code more reusable, as, for good unit tests, code components should be modular.
It acts like documentation as it describes the expected behavior for a piece of code to other developers.

Now that we have defined unit testing and why we use it, we are ready to move on to JUnit5.

JUnit is one of the most popular unit-testing frameworks in Java. JUnit5 is composed of several different modules from three different sub-projects namely JUnit Platform, JUnit Vintage, JUnit Jupiter.

Install JUnit5

For Maven, add the dependancy to Pom.xml:

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>{$version}</version>
    <scope>test</scope>
</dependency>

For Gradle, add to build.gradle:

testCompile group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: '$version'

JUnit Annotations

Annotations are the meta-tags that provides additional information about the methods and classes defined in our code structure.

Some commonly used annotations are listed here.

@Test - Represents a test method.
@BeforeEach - Represents the annotated method should be executed before each test method.
@AfterEach - Represents the annotated method should be executed after each test method.
@BeforeAll - Represents the annotated method should be executed before all test methods.
@AfterAll - Represents the annotated method should be executed after all test methods.
@DisplayName - Creates a custom display name for the test class or method.
@Tag - Creates tags for filtering tests.
@ExtendWith - Registers custom extensions.

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

class JUnit5Tests {

    @BeforeAll
    static void beforeAllTest() {
        log.info("Executed before all test methods.");
    }

    @BeforeEach
    void beforeEachTest() {
        log.info("Executed before each test method.");
    }

    @Test
    void test() {
        log.info("Executed test method.");
    }

    @AfterEach
    void afterEachTest() {
         log.info("Executed after all test methods");
    }

    @AfterAll
    static void afterAllTest() {
         log.info("Executed after all test methods");
    }
}

JUnit Assertions

Every test method must be evaluated against the condition to true using assertions so that the test can continue to execute. JUnit Jupiter assertions are kept in the org.junit.jupiter.api.Assertions class.

Here are some commonly used Assertions.

assertNull(actual value) - Fails when actual value is not null.
assertNotNull(actual value) - Fails when actual value is null.
assertEquals(expected value, actual value) - Fails when expected value does not equal actual value.
assertAll() - Groups a bunch of assertions and every assertion is executed even if one or more of them fails.
assertTrue(expression value) - Fails if expression is not true.
assertFalse(expression value) - Fails when the expression is not false.

import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;

import example.io.util.Customer;

class JUnit5Tests {

    private final Customer customer = new Customer("Ann", "Marie");

    @Test
    void standardAssertions() {
        assertEquals("Marie", customer.getLastName());
        assertNotNull(customer);
        assertTrue("Ann", customer.getFirstName());
    }

    @Test
    void groupedAssertions() {
        assertAll("customer",
         () -> assertEquals("Ann", customer.getFirstName()),
         () -> assertEquals("Marie", customer.getLastName())
        );
    }
}

JUnit5 Assumptions

Assumptions are static methods present inside the org.junit.jupiter.api.Assumptions class. These methods will execute a test only when the specified condition met otherwise the test will be aborted. The aborted test will not cause a build failure. Assumptions also understand lambda expressions.

Here are some commonly used Assumptions.

assumeTrue() - Execute the body when the positive condition hold else test will be skipped.
assumeFalse() - Execute the body when the negative condition hold else test will be skipped.
assumingThat() - Part of the test method will execute if an assumption holds true and everything after that will execute irrespective of the assumption in assumingThat() holds.

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
import static org.junit.jupiter.api.Assumptions.assumingThat;

import example.util.Calculator;

import org.junit.jupiter.api.Test;

class JUnit5Tests {

    private final Calculator calculator = new Calculator();

    @Test
    void simpleAssumeTest() {
        assumeTrue("DEV".equals(System.getenv("ENV")),
            () -> "Aborting test");
    }

    @Test
    void complexAssumeTest() {
        assumingThat("CI".equals(System.getenv("ENV")),
            () -> {
                assertEquals(21, calculator.add(14, 7));
            });
     }
}

Install docker on RHEL 8

Anisha Mohanty — Sat, 18 Jul 2020 15:15:51 +0000

Docker is a tool that allows you to easily build, test, and deploy applications smoothly and quickly using containers. It has gained widespread popularity in recent times due to the portability to run applications anywhere irrespective of the host operating system.

Let's get started on how to install Docker on CentOS / RHEL. 🚀

Docker is available in two editions, namely,

Community Edition (CE)
Enterprise Edition (EE)

Here, we will install Docker Comunity Edition (CE).

Prerequisites

Uninstall older versions of Dockers, named docker or docker-engine along with associated dependencies.

$ yum -y install lvm2 device-mapper device-mapper-persistent-data device-mapper-event device-mapper-libs device-mapper-event-libs

Add Docker Repository

Now let’s add the CE repository for the Docker installation.

$ curl https://download.docker.com/linux/centos/docker-ce.repo -o /etc/yum.repos.d/docker-ce.repo

Install Docker CE

$ yum install docker-ce

Output

Error:
 Problem: package docker-ce-3:19.03.5-3.el7.x86_64 requires containerd.io >= 1.2.2-3, but none of the providers can be installed
  - cannot install the best candidate for the job
  - package containerd.io-1.2.10-3.2.el7.x86_64 is excluded
  - package containerd.io-1.2.2-3.3.el7.x86_64 is excluded
  - package containerd.io-1.2.2-3.el7.x86_64 is excluded
  - package containerd.io-1.2.4-3.1.el7.x86_64 is excluded
  - package containerd.io-1.2.5-3.1.el7.x86_64 is excluded
  - package containerd.io-1.2.6-3.3.el7.x86_64 is excluded
(try to add '--skip-broken' to skip uninstallable packages or '--nobest' to use not only best candidate packages)

Install the Docker CE by skipping unavailable package

$ yum -y install docker-ce --nobest

Now you have Docker installed onto your machine, start the Docker service in case if it is not started automatically after the installation run these commands.

$ systemctl start docker

$ systemctl enable docker

Verify Docker Installation

$ docker run hello-world

And it's done! You have successfully installed docker on your RHEL / CentOS. Happy Learning! 🎉

GraphQL better than REST?

Anisha Mohanty — Tue, 07 Jul 2020 10:43:28 +0000

Well, after working with GraphQL for some time now I have understood quite well how amazing the tool is and the beauty of fetching the data. It's better than REST if you don't know already read my article here! 🤩

🔸 REST Overview

A REST API is an architectural standard for network-based software.
RESTful web services allow to access and manipulate the web resources using a predefined set of stateless operations like GET, POST, PUT, and DELETE.
The implementation of the client and server is independent of each other and does not affect each other's functionality.
One advantage of using REST is, it's scalable. The architecture decouples client and server which allows developers to scale products and applications indefinitely without much difficulty.
REST-based API requires multiple round trips. For example, if you wanted to retrieve data from two or more different endpoints, you’d have to send two or more separate requests to the REST API each time.
Using REST also arises over-fetching and under-fetching. For example, you need to display a list of twitter users with their names and followers. But you receive a JSON data structure with the user data having user’s name, tweets, email and, address.

🔸 GraphQL Overview

GraphQL is a query language, a specification, and a set of tools that operates over a single endpoint using HTTP.
It has been to optimize for performance and flexibility. It provides detailed insight into the data that’s requested on the backend.
GraphQL uses a strong type system to define the capabilities of an API. All the types that are exposed in an API are written down in a schema using the GraphQL Schema Definition Language (SDL).
The GraphQL schema serves as the path between the client and the server to define how a client can access the data.
GraphQL overcomes the problems of REST over-fetching and under-fetching in a smooth manner.
It enables rapid product development and a large open source community to work with.

Some big firms that use GraphQL :

🔸 Conclusion

Both REST and GraphQL are unique ways to design how an API will function and how applications will receive data from it. While REST had significantly simplified the work of developers with its standardized approach, it does have a few drawbacks. GraphQL, with its queries, schemas, and resolvers offers more flexibility, moreover, GraphQL can offer better performance. Analyze your application, data, and performance requirements, so that you can choose appropriately.

Thanks for Reading. Happy Learning! ❤️

How to create GraphQL schema dynamically?

Anisha Mohanty — Tue, 16 Jun 2020 10:27:12 +0000

Hey everyone. 🤩 I am writing this article to guide you through to a create a dynamic GraphQL schema programmatically as java code. We would be primarily using the graphql-java library for this.

GraphQL Schema

GraphQL has its type system that’s used to define the schema of an API. The syntax for writing schemas is called Schema Definition Language (SDL). We can either define the schema using SDL or define it programmatically as java code. But both of them are static ways of representation. In case you are building schema during runtime, it becomes difficult to recursively add new fields to your predefined definition.

SDL Schema Definition

type Customer {
   name : String
   address : String
   contact : Int 
}

Programmatic Schema Definition

GraphQLObjectType.Builder graphQLObjectType = GraphQLObjectType.newObject();
graphQLObjectType.name("Customer")
                 .field(newFieldDefinition()
                       .name("name")
                       .type(Scalars.GraphQLString))
                 .field(newFieldDefinition()
                       .name("address")
                       .type(Scalars.GraphQLString))
                 .field(newFieldDefinition()
                       .name("conatct")
                       .type(Scalars.GraphQLInt)
                 .build();

We will be focusing on how to extract the metadata of the data source to which you are connecting. Metadata characterizes your data and makes easier for anyone to understand and consume it. To put it simply, metadata is the data describing the data that is being stored in your data source. It generally includes the name, size and number of rows of each table present in a database, along with the columns in each table, their data types, precisions, etc.

Let's get started! 🚀

To read and store database meta data we will be using two interfaces DatabaseMetaData and ResultSet.The DatabaseMetaData interface is huge, containing hundreds of methods for reading capabilities of a DBMS. You can refer to Javadoc for the complete list of methods.

Obtaining DatabaseMetaData Instance

Here I am using jdbc-url for Teiid, you can choose others too. We obtain the DatabaseMetaData object from a Connection object, like this:

String URL = "jdbc:teiid:customer@mm://localhost:31000";
String USERNAME = "sa";
String PASSWORD = "sa";
Connection connection = DriverManager.getConnection(URL, USERNAME ,PASSWORD );
DatabaseMetaData databaseMetaData = connection.getMetaData();

Listing Database Tables

We can obtain a list of the defined tables in your database or data source with the help of DatabaseMetaData. Here is how that is done:

String table[] = {"TABLE"};

ResultSet resultSet = databaseMetaData.getTables(null,null,null,table);
ArrayList<String> tables = new ArrayList();

    while(resultSet.next()) {
        tables.add(resultSet.getString("TABLE_NAME"));
    }

Listing Database Columns

We can obtain the columns of a table via the DatabaseMetaData object in this manner :

ResultSet columns = databaseMetaData.getColumns(null,null, tableName, null);
     while(columns.next()) {
         String columnName = columns.getString("COLUMN_NAME");
         String datatype = columns.getString("DATA_TYPE");
         String columnsize = columns.getString("COLUMN_SIZE");

         System.out.println(columnName + "---" + datatype + "---" + columnsize);
      }

Creating Schema

Next step would be to create a schema using GraphQLObjectType object, store it's corresponding metadata in HashMap and read it's type from ReturnType class defined in the next section.

ResultSet resultSet = databaseMetaData.getColumns(null, null, (String) tableName, null);

     GraphQLObjectType objectType = null;
     GraphQLObjectType.Builder graphQLObjectType = GraphQLObjectType.newObject();

     System.out.println("-------Schema for Table " + tableName + "-------");
     HashMap <String,String> data  = new HashMap<>();

      while (resultSet.next()) {
           data.put(resultSet.getString("COLUMN_NAME"), resultSet.getString("TYPE_NAME"));

           for (Map.Entry<String, String> hm : data.entrySet()) {

                graphQLObjectType
                        .name(tableName)
                        .field(GraphQLFieldDefinition.newFieldDefinition()
                                .name(hm.getKey())
                                .type(ReturnType(hm.getValue())));
                objectType = graphQLObjectType.build();

            }
        }

Defining the Field Type in Schema

This class returns the type of field in each case, here I have defined only two types GraphQLLong and GraphQLString. You can define accordingly for other types.

public static GraphQLScalarType ReturnType(String type) {
      if(type.equals("long"))
           return Scalars.GraphQLLong;
      else if (type.equals("string"))
           return Scalars.GraphQLString;
      return null;
    }
}

Building and Printing Schema

To print schema is a defined manner we are using SchemaPrinter object which takes an object of GraphQLSchema type.

GraphQLSchema graphQLSchema = GraphQLSchema.newSchema()
                    .query(objectType)
                    .build();

SchemaPrinter schemaPrinter = new SchemaPrinter();
String printer = schemaPrinter.print(graphQLSchema);
System.out.println(printer);

Conclusion

There you have it! You have successfully connected to your data source to fetch database metadata and using the data you constructed your graphQL schema.

You can visit the Github Repo Schema Builder to view the source code. Also check GraphQL Java website to learn more.

You're learning. I'm learning. We're all learning. Let's continue to learn and get better together. Thank you. Happy Reading! 🎉

You can connect with me on Twitter and LinkedIn ❤️

Teiid : Introduction

Anisha Mohanty — Sat, 06 Jun 2020 08:05:08 +0000

Hey everyone, I have been working on a new data integration tool. This is a small introduction to new learning. 🤩

🏷️ Overview

Teiid is a cloud-based data virtualization platform. It is a flexible Java component that provides integrated access to multiple data sources through a single uniform API. Data can be accessed using standard JDBC, ODBC, OData, or REST, even if that data resides in more than one source or in sources that do not understand standard queries. Typically it is a view building tool. 🚀

To clear out things first, Teiid is not a database, it does not store any data. It acts as an interface or data gateway for accessing data from data sources in an optimal manner.

🏷️ Why Teiid?

Teiid offers interaction with very familiar interfaces like JDBC, ODBC, OData, and REST. It allows the capability to query from non-SQL data sources as well. Teiid is cheaper, better, and faster. It is easy to deploy and has several distributions including Teiid Spring Boot, Teiid Wildfly, Teiid Openshift, etc.

🏷️ Teiid Basics

Before getting started, here are some basic constructs of teiid.

📌 Schema

In teiid, schemas are used to define the entities and relationships between those entities, required to fully define the integration so that they may be accessed uniformly. There are pre-built translators in teiid for MySQL, Oracle, PostgreSQL, etc.

📌 Data Sources

Teiid provides the means (Translators and JEE connectors) to connect to various data sources, both relational and non-relational, for fetching required data.

📌 Virtual Database

A virtual database (or VDB) is a type of database that serves as a container to transparently view and query from several other databases through a uniform API that culls from multiple sources as if they were a single entity.

A VDB has multiple schema components known as models. Each schema contains the metadata. There are two different types of schemas :

Foreign schema
A foreign schema represents external or remote data sources, such as a relational database, such as Oracle, or MySQL; files, such as CSV, etc. It is also called a source or physical schema.
Virtual schema
A view layer or logical schema layer represents the structure and character to be exposed to applications.

📌 Translator

A translator converts a teiid specific command into its native command, executes, and returns a result to expected teiid types. It provides an abstraction layer between the Teiid Query Engine and the physical data source.

🏷️ Explore

There are other projects which might interest you.

Teiid Syndesis
Syndesis allows us to connect to data sources, define REST APIs, integrations (like cloud-based Camel/Fuse routes), and data virtualizations in minutes. Teiid Syndesis allows us to create views and expose data as OData or database protocols.
Teiid Operator
It is the job of the teiid operator to deploy Teiid on your OpenShift instance. The Operator also assists with the management of and updates to your Teiid instances.

🏷️ Futher Reading

Visit teiid repository on github. To contribute read the documentation here.

Thank you. Happy Reading! 🎉

You can connect with me on Twitter and LinkedIn ❤️

Forem: Anisha Mohanty

GraphQL CRUD Java: Overview

What is GraphQL CRUD Java?

Common Features

CRUD methods

Capabilities

How it works?

Example: Fetch list of all accounts

Example: Fetch an account using the primary key

Example: Fetch a customer whose name is James

Example: Fetch 2 customers from the list of all customers, starting from first

Example: Fetch 2 customers from the list of all customers, starting from the 2nd customer

Example: Insert a new customer object and return the inserted customer object in the response

Example: Update a customer with the name Bob and return the updated customer object in the response

Example: Delete a customer where name is Andrew

Drop your Hacktoberfest 2020 projects! 🥳

Golang Learning Resources

🏷️ Online Resources

🏷️ Books

🏷️ Videos and Podcasts

🏷️ Editors and IDEs

🏷️ Community Resources

Basic git commands

Command: git init

Usage :

Command: git clone

Usage :

Command: git add

Usage :

Command: git rm

Usage :

Command: git log

Usage :

Command: git status

Usage :

Command: git branch

Usage :

Command: git checkout

Usage :

Command: git commit

Usage :

Command: git merge

Usage :

Command: git fetch

Usage :

Command: git pull

Usage :

Command: git push

Usage :

Command: git remote

Usage :

Further Learning

How to create awesome illustrations?

How to Install GO?

Installing and Setting Up Homebrew

Installing GO

Creating Your Go Workspace

Unit Testing with JUnit5

Install JUnit5

JUnit Annotations

JUnit Assertions

JUnit5 Assumptions

Further Reading

Install docker on RHEL 8

Prerequisites

Add Docker Repository

Install Docker CE

Output

Install the Docker CE by skipping unavailable package

Verify Docker Installation

GraphQL better than REST?

🔸 REST Overview

🔸 GraphQL Overview

🔸 Conclusion

How to create GraphQL schema dynamically?

GraphQL Schema

SDL Schema Definition

Programmatic Schema Definition

Obtaining DatabaseMetaData Instance

Listing Database Tables

Command: `git init`

Command: `git clone`

Command: `git add`

Command: `git rm`

Command: `git log`

Command: `git status`

Command: `git branch`

Command: `git checkout`

Command: `git commit`

Command: `git merge`

Command: `git fetch`

Command: `git pull`

Command: `git push`

Command: `git remote`