Hello Everyone,

In this post, I am going to present some of the basic syntax and example of MongoDB to get started with it. For basic detail of NoSQL db visit this link.

What is MongoDB?

Mongo db is an open source, cross-platform NoSql database. It is a document-oriented db which is written in C++.

Mongo db stores its data on the filesystem. It stores all the data in BSON (Binary JSON). The format of BSON documents is very similar to the Object Oriented Programming. In MongoDB we can store complete information in one document rather than creating different tables for them and then define a relationship between them.

Let’s take a brief look at terms which mongo db uses to store the data:

• Collections: You need to create collections in each Database. Each DB can contain multiple collections.
• Documents: Each Collection contains multiple Documents.
• Fields: Each Document contains multiple Fields.

Now get started with the commands:

Database:

• Create db or Use db: There is no command to create a db in Mongo. Whenever we want to create a new db use following command.
  • Syntax: use <dbname>
  • Example: use customerdb
• Show current db : This is very simple and small command
  • Syntax: db
• Show db : This command will return the existing dbs only if it contains at least one collection.
  • Syntax: show dbs

At this time we did show dbs it will return only a default db. For this, we need to add a collection to it. We will see how to add collection in collection section. But for now, presenting an example:

• • Example: db.customer({first_name:”Robin”}
  • show dbs

Now we can see our db customerdb in the list.

• Drop db: To drop database following is the command. Before deleting database first select the db.
  • Syntax: db.dropDatabase()
  • Example: use customerdb
    db.dropDatabase()

Collections

• Create collection : Mongo db normally we do not need to create collection explicitly. When we write a command to insert the document it will create the collection if does not exist. But there is a way to create collection explicitly an define it as expected:
  • Syntax: db.createCollection(<collectionName>, option)
    db.createCollection(<name>, { capped: <boolean>,
    autoIndexId: <boolean>,
    size: <number>,
    max: <number>,
    storageEngine: <document>,
    validator: <document>,
    validationLevel: <string>,
    validationAction: <string>,
    indexOptionDefaults: <document>,
    viewOn: <string>,
    pipeline: <pipeline>,
    collation: <document> } )
  • Example: db.createCollection(customer)

Collection name’s type is String and option type is Document.
Some of the important fields I am describing below:

• Drop Collection: We can drop a collection by using the following index but before dropping any collection we should be in the same db.
  • Syntax: db.<collectionName>.drop()
  • Example: use customerdb
    db.customer.drop()

CRUD Operations:

Mongo db provides very flexibility for CRUD operations. We can insert or update document on the fly.

• Insert Document:
  • Syntax: db.<collectionName>.insert(<documents>)
  • Example:  db.customer.insert([{first_name:”Robin”, last_name:”Desosa”}, {first_name:“Kanika”, last_name:”Bhatnagar”},{first_name:”Rakesh”, last_name:”Sharma”, gender:”male”}]);

In the above example we are adding 3 document, first 2 are having the same fields but the third document has an additional field gender. Mongo db provides a functionality to insert the non structural data.
When you insert a document mongo db will automatically create a unique Id for each document.

• Update Document:
  • Syntax: db.<collectionName>.update({<documentIdentifier>}, {$set:{<update value>}})
  • Example: db.customer.update({first_name:”Robin”},  {$set:{gender:”male”}});
    db.customer.update({first_name:”Kanika”},  {$set:{gender:”female”}});db.customer.update({first_name:”Rakesh”}, {$set:{age:”25”}})The above example will add a new field in corresponding document.
• Update or Insert: Upsert command updates the document if it already exists or inserts a new one.
  • Syntax: db.<collectionName>.upsert({<docIdentifier>}, {<document>}, {upsert:true})
  • Example: db.customer({first_name:”Amita”}, {first_name:” Amita”, last_name:”Jain”, gender:”female”}, {upsert: true});
• Rename Field in Document: We can rename field of a specific document by using $rename in update command.
  • Syntax: db.<collectionName>. update({<documentIdentifier>}, {$rename:{<update value>}})
  • Example: db.customer.update({first_name:”Rakesh”}, {$rename:{“gender”:”sex”}});After this we renamed the gender field to sex only for the document whose first_name is “Rakesh”.
• Remove a field: To remove a field $unset needs to be used in update command.
  • Syntax: db.<collectionName>.update({<documentIdentifier >}, {$unset:{<field:1>}})
  • Example: Db.customer.update({first_name:”Rakesh”}, {$unset:{age:1}});
• Remove Document:
  • Syntax: db.<collectionName>.remove({<documentIdentifier >})
  • Example: db.customer.remove({first_name:”Amita”});
    (If we have multiple entries with first_name Amita and want to remove 1.)
    db.customer.remove({first_name:”Amita”}, {justOne:true});
• Find Document: We can find the document in collection by using following command. The output of that command is an object in json form.
  • Syntax: db.<collectionName>.find()
  • Example: db.customer.find();

The output of the above command will be all the json object stored in that collection.
To see it in a formatted way like each object and field in new line we can use pretty on find.

Example: db.customer.find().pretty();

• Find Specific: By passing the documentIdentifier value in find method.
  • Syntax: db.<collectionName>.find({<documentIdentifier >})
  • Example: db.customer.find({first_name:”Kanika”});
• Or condition: 
  • Example: db.customer.find({$or:[{first_name:”Kanika”}, {first_name:”Robin”}]});

In the above example we have a document in find as parameter, and in that document we have give an array of first_name. $or is defining the operation which is going to be performed on the array.

• Greater than, Less than: We can directly jump on the example of the greater than and less than.

Example:

• db.customer.find({age:{$gt:26}});
  In the above example $gt defines that > operation need to be perform on age. It will find and print all the documents who has this field age and age >26.
• db.customer.find({age:{$lt:26}});
  In the same way this $lt will help us to find all documents which have age field and age < 26.
• db.customer.find({age:{$gte:26}});
  We can perform >= or <= operations as well by using $gte and $lte.

Following are some more example on features provided by Mongo db:

• Sort:
  • db.customer.find().sort({first_name:1}); //descending order
    db.customer.find().sort({first_name:-1}); //ascending order
• Count:
  • db.customer.find().count();
• ForEach:
  • db.customer.find().forEach(function(doc){print(“Customer Name:”+ doc.first_name)});

These all are the basic syntax for getting started with MongoDb.

Hi Everyone,

Today we gonna discuss delegates in kotlin.

The Delegation pattern has proven to be a good alternative to implementation inheritance, and kotlin supports it natively requiring zero boilerplate code.

Property delegates don’t have to implement any interface, but they have to provide a getValue() and setValue() function.

let’s see an example, that mention in Kotlin ref docs. going to define Delegate class with getValue and setValue function.

class Delegate {

    operator fun getValue(thisRef : Any?, property : KProperty<*>) : String
    {
        return "${thisRef?.javaClass?.name}, thank you for delegating '${property.name}' to me!"
    }

    operator fun setValue(thisRef : Any?, property : KProperty<*>,value : String)
    {
        println("$value has been assigned to '${property.name}' in ${thisRef?.javaClass?.name}.")
    }
}

now creating another class.

class Example {
     var p : String by Delegate()
}

call Example class

fun main(args : Array)
{
    var example = Example()
    println(example.p)
    example.p = "delegate world"
}
//output:

com.delegated.Example, thank you for delegating 'p' to me!
delegate world has been assigned to 'p' in com.delegated.Example.

kotlin provides few delegated properties build into the language – Lazy properties, Observable properties, and properties storing in the map.

Lazy Properties: lazy is a function that takes a lambda and returns and returns an instance of Lazy which can serve as a delegate.

let’s create an example class.

class Example {
     val lazyValue: String by lazy {
          println("computed!") 
          "Hello"
     }
}

fun main(args : Array)
{
    println(example.lazyValue)
}
//output:
computed!
Hello

Observable properties: Observable takes two arguments: the initial value and a handle for modifications. the handler gets called every time we assign the property. it has three parameters: a property being assigned to, the old value and the new one.

let’s create an example class

class Example {
     
     var name: String by Delegates.observable("") {
          prop, old, new ->
          println("$old -> $new")
     }
}

fun main(args : Array)
{
    var example = Example()

    example.name = "first"
    example.name = "second"
}
//output:
 -> first
first -> second

Properties storing in the map: One common use case is storing the values of properties in a map. This comes up often in applications like parsing JSON or doing other “dynamic” things. In this case, you can use the map instance itself as the delegate for a delegated property.

let’s create an example class.

class User(val map: Map<String, Any?>) {
    val name:String by map
    val age: Int by map
}

fun main(args : Array)
{
    var user = User(mapOf("name" to "Ritesh pathak", "age" to 23))
    println(user.name)
    println(user.age)
}
//output:
Ritesh pathak
27

Ref – Kotlin docs.

Hope you like this. Thanks for reading 🙂

Follow @nikeshpathak

Hello Everyone,

In this post, we will see object-oriented syntex and features in Kotlin. for other basic detail please visit the part-1 tutorial to make yourself comfortable.

let’s jump into code!

#using class

Java

class Customer {
}

Kotlin

class Customer {
}
//or if the class has no body then curley braces can be omitted
class Customer

#using constructor including primary and secondary 

Java

class Customer {

    String name;

    Customer() {}

    Customer(String name)
    {
        //TODO
    }
}

Kotlin

class Customer() {

    lateinit var name: String

    constructor(name: String) : this()
    {
        //TODO
    }
}

#using instance of class

Java

Customer customer = new Customer();
//or
Customer customer1 = new Customer("Test");

Kotlin

val customer  = Customer()
//or
val customer1 = Customer("Test")

#using inheritance 

Java

public class Base {

    Base(int p)
    {
        //TODO
    }
}

public class Derived extends Base{

    Derived(int p) {
        super(p);
    }
}

Kotlin

open class Base(p: Int)

class Derived(p: Int) : Base(p)

#using method overriding

Java

public class Base {

   final void v() {}
   void nv() {}
}

public class Derived extends Base{

    @Override
    void nv() {
        super.nv();
    }
}

Kotlin

open class Base {
    open fun v() {}
    fun nv() {}
}

class Derived() : Base() {
    override fun v() {}
}

#using static methods

Java

class Customer {

   static String name = "Test";
}

Kotlin

class Customer {

    companion object {
         var name : String = "Test"
    }
}

Thanks for reading 🙂

Follow @nikeshpathak