Java 17 Pattern Matching in Switch and Yield

 In Java switch statements are used instead of multiple if-else statements. Something like below

switch (day) {
case "Monday" -> System.out.println("Today is an monday");
case "Tuesday" -> System.out.println("Today is an tuesday");
case "Wednesday" -> System.out.println("Today is an wednesday");
case "Thursday" -> System.out.println("Today is an thursday");
case "Friday" -> System.out.println("Today is an friday");
case "Saturday" -> System.out.println("Today is an saturday");
case "Sunday" -> System.out.println("Today is an sunday");
default -> System.out.println("Invalid date");
}

There are multiple advantages of this we dont' need to write multiple nested if-else block

if ("Monday".equals(day)) {
System.out.println("Today is an monday");
}
else if ("Tuesday".equals(day)) {
System.out.println("Today is an tuesday");
}
......
else {
System.out.println("Invalid date");
}

Switch statements are there in java for a long back. over time it has evolved. Earlier Switch expressions are supposed to be numbers or enums. Case statements used to start with : and break need to be added to stop the overflow

switch (day) {
case "Monday": System.out.println("Today is an monday"); break;
case "Tuesday": System.out.println("Today is an Tuesday"); break;
.....
}

In Java 17 switch is enhanced. Before Java 17 switch started supporting string as expression type. In 17 the case key word can be followed with -> so that we dont need break any more.

case "Saturday" -> System.out.println("Today is an saturday");

we can have multiple levels in case.

case "Saturday", "Sunday" -> System.out.println("Its weekend");

We can return value from the case using yield

int dayOfTheWeek = switch (day) {
case "Monday" -> {
yield 1;
}
case "Tuesday" -> {
yield 2;
}
default -> {
yield -1;
}
};

In case expression we can try an instance of the operator or null check also

Object x = 0;
switch (x) {
case null -> System.out.println("x is null");
case Integer i -> System.out.println("x is an integer");
default -> System.out.println("x is of type "+x.getClass().getName());
}

These are still preview features to try this we need to enable it in our java env

java --enable-preview --source 17 <filename.java>

Please let me know your thoughts about this topic.

Reference

https://docs.oracle.com/en/java/javase/17/language/pattern-matching-switch-expressions-and-statements.html#GUID-E69EEA63-E204-41B4-AA7F-D58B26A3B232

OCI function in golang connecting to autonomous database over TLS

 In this post we will discuss how to connect oracle cloud infrastructure function implemented in golang connect to the autonomous database. We will configure the adb on TLS, so that we don't need the client credential wallet for connection. If we need to connect over mtls still this post will give some idea but we need to stage the client credential in the function runtime container, this I may discuss in a different post. 

1. Configure ADB for TLS

We need to enable TLS connection in the autonomous database detail page. (More details).  

a) In adb detail page under the Network section enable the access control list, here I configured the allow-only ip addresses of a particular vcn should able to connect the adb.

 b) Set Mutual TLS authentication to not required, so that TLS connection will be allowed. 

2. Create a oracle function appliaction in the same VCN, which we configured  in above step (1. a), if we wish to run the function in private subnet then few more things we need to take care, details can be found here

3. Go lang function which will connect to ADB. 

we will use godror library to connect to ADB. A standalone golang program connecting ADB will be found here, the same concept we will use to write our function code. 

/**

* @Author Pallab (pallab.rath@gmail.com)

*/

package main

import (

"context"

"database/sql"

"encoding/json"

"fmt"

"io"

fdk "github.com/fnproject/fdk-go"

_ "github.com/godror/godror"

)

func main() {

fdk.Handle(fdk.HandlerFunc(myHandler))

}

func myHandler(ctx context.Context, in io.Reader, out io.Writer) {

db_user := "<db-user>"

db_pwd := "<db-pwd>"

db_host := "<db-host>"

db_port := "<db-port>>"

db_srvc := "<db-service>"

db_details := fmt.Sprintf(`user="%s" password="%s" connectString="tcps://%s:%s/%s"`, db_user, db_pwd,

db_host, db_port, db_srvc)

db, err := sql.Open("godror", db_details)

if err != nil {

fmt.Println(err)

return

}

defer db.Close()

rows, err := db.Query("select sysdate from dual")

if err != nil {

fmt.Println("Error running query")

fmt.Println(err)

return

}

defer rows.Close()

var resData string

for rows.Next() {

rows.Scan(&resData)

}

json.NewEncoder(out).Encode(&resData)

}

In this program, we need to provide db user, pwd, host, port, and service name. we can find the host port and service name from tls connect string. The tls connection string can be found on the Database Connection page.

4. Building and publishing the above function.

To build this function we need godror dependency, and this requires gcc compile to be present in build time env. So I created my custom build environment where gcc is installed, instead of the default fnproject/go:1.15-dev build image.

a) Create the build image docker definition (gofn_build.Dockerfile)

FROM oraclelinux:8

RUN yum -y install golang && yum -y clean all && rm -rf /var/cache

Then build this image using the below command

$ docker build -f gofn_build.Dockerfile -t gofn_build .

b) Create the runtime image docker definition (gofn_runtime.Dockerfile), in the runtime container godror need oracle instant client.

FROM oraclelinux:8

WORKDIR /function

RUN curl https://download.oracle.com/otn_software/linux/instantclient/217000/oracle-instantclient-basiclite-21.7.0.0.0-1.el8.x86_64.rpm --output oracle-instantclient-basiclite-21.7.0.0.0-1.el8.x86_64.rpm

RUN yum -y install oracle-instantclient-basiclite-21.7.0.0.0-1.el8.x86_64.rpm && yum -y clean all && rm -rf /var/cache

RUN rm -f oracle-instantclient-basiclite-21.7.0.0.0-1.el8.x86_64.rpm

Then build this image using the below comman

$ docker build -f gofn_build.Dockerfile -t gofn_runtime

c) Create the custom Dockerfile with below content, where we use build go function in the build conatiner we just created in above steps and create a image of our runtime image and the executable function.

FROM gofn_build as build-stage

WORKDIR /function

WORKDIR /go/src/func/

ENV GO111MODULE=on

COPY . .

RUN cd /go/src/func/ && go build -o func

FROM gofn_runtime

WORKDIR /function

COPY --from=build-stage /go/src/func/func /function/

ENTRYPOINT ["./func"]

d) Finally change the func.yaml with below content

schema_version: 20180708

name: function-adb

version: 0.0.26

runtime: docker

$ fn deploy -verbose <ap-name>

Then fn deploy should do the job for us.

$ fn invoke <ap-name>

"2022-09-04T17:56:09Z"

All these source code would be found in https://github.com/pallabrath/myexpjava/tree/master/function-adb

How to measure elapsed time of a method in Java

There are times we need to compute how much time is elapsed while executing a certain task. To compute elapsed time we can think something like below.

public class ElapsedTimeDemo {

public static void main(String[] args) {

long startTime = System.currentTimeMillis();

doSomething();

long endTime = System.currentTimeMillis();

System.out.println("Elapsed time = "+ (endTime - startTime));

}

public void doSomething() {

}

}

This code keeps track of start time of function execution and end time once the execution is complete. The difference between start time and end time gives us the elapsed time. This looks good. The only problem is that for start time and end time we are depending upon the system clock. Because of the clock skew system clock tends to drift away from the actual time. To make the system clock sync usual practice is computer connects to a time server and adjusts its own clock. While adjusting the system clock it may be set forward or backward based on the drift. This can cause some issues in the above program. If the clock is getting adjusted while the method execution of doSomething(), we will get the end time which can be either before or after the real end time. This makes the elapsed time calculation faulty.

To make the correct elapsed time calculation consider the below program.

public class ElapsedTimeDemo {

public static void main(String[] args) {

long startTime = System.nanoTime();

doSomething();

long endTime = System.nanoTime();

System.out.println("Elapsed time = "+ (endTime - startTime));

}

public void doSomething() {

}

}

Here instead of currentTimeMillis() we are using nanoTime(), Nano time comes from a JVM monotonic clock. A monotonic clock means it starts with a fixed origin, let's assume it's a counter that starts from 0 when JVM starts it keeps on incrementing. At any point in time counter value will not make much sense in absolute terms. In elapsed time calculation this is useful. And this doesn't get adjusted like a system clock. 

References

Clock Skew

System.currentTimeMillis()

System.nanoTime()