Author: alien

  • Khóa học miễn phí DocumentDB SQL – Aliasing nhận dự án làm có lương

    DocumentDB SQL – Aliasing



    In relational databases, SQL aliases are used to temporarily rename a table or a column heading. Similarly, in DocumentDB, aliases are used to temporarily rename a JSON document, sub-document, object or any field.

    The renaming is a temporary change and the actual document does not change. Basically, aliases are created to make field/document names more readable. For aliasing, AS keyword is used which is optional.

    Let’s consider three similar documents from the ones used in previous examples.

    Following is the AndersenFamily document.

    {
       "id": "AndersenFamily",
       "lastName": "Andersen",
    
       "parents": [
          { "firstName": "Thomas", "relationship":  "father" },
          { "firstName": "Mary Kay", "relationship":  "mother" }
       ],
    
       "children": [
          {
             "firstName": "Henriette Thaulow",
             "gender": "female",
             "grade": 5,
             "pets": [ { "givenName": "Fluffy", "type":  "Rabbit" } ]
          }
       ],
    
       "location": { "state": "WA", "county": "King", "city": "Seattle" },
       "isRegistered": true
    }
    

    Following is the SmithFamily document.

    {
       "id": "SmithFamily",
    
       "parents": [
          { "familyName": "Smith", "givenName": "James" },
          { "familyName": "Curtis", "givenName": "Helen" }
       ],
    
       "children": [
          {
             "givenName": "Michelle",
             "gender": "female",
             "grade": 1
          },
    
          {
             "givenName": "John",
             "gender": "male",
             "grade": 7,
    
             "pets": [
                { "givenName": "Tweetie", "type": "Bird" }
             ]
          }
       ],
    
       "location": {
          "state": "NY",
          "county": "Queens",
          "city": "Forest Hills"
       },
    
       "isRegistered": true
    }
    

    Following is the WakefieldFamily document.

    {
       "id": "WakefieldFamily",
    
       "parents": [
          { "familyName": "Wakefield", "givenName": "Robin" },
          { "familyName": "Miller", "givenName": "Ben" }
       ],
    
       "children": [
          {
             "familyName": "Merriam",
             "givenName": "Jesse",
             "gender": "female",
             "grade": 6,
    
             "pets": [
                { "givenName": "Charlie Brown", "type": "Dog" },
                { "givenName": "Tiger", "type": "Cat" },
                { "givenName": "Princess", "type": "Cat" }
             ]
          },
    
          {
             "familyName": "Miller",
             "givenName": "Lisa",
             "gender": "female",
             "grade": 3,
    
             "pets": [
                { "givenName": "Jake", "type": "Snake" }
             ]
          }
       ],
    
       "location": { "state": "NY", "county": "Manhattan", "city": "NY" },
       "isRegistered": false
    }
    

    Let’s take a look at an example to discuss the aliases.

    Aliase

    Following is the query which will join the root to children subdocument. We have aliases such as f.id AS familyName, c.givenName AS childGivenName, and c.firstName AS childFirstName.

    SELECT
       f.id AS familyName,
       c.givenName AS childGivenName,
       c.firstName AS childFirstName
    FROM Families f
    JOIN c IN f.children
    

    When the above query is executed, it produces the following output.

    [
       {
          "familyName": "WakefieldFamily",
          "childGivenName": "Jesse"
       },
    
       {
          "familyName": "WakefieldFamily",
    	  "childGivenName": "Lisa"
       },
    
       {
          "familyName": "SmithFamily",
          "childGivenName": "Michelle"
       },
    
       {
          "familyName": "SmithFamily",
          "childGivenName": "John"
       },
    
       {
          "familyName": "AndersenFamily",
          "childFirstName": "Henriette Thaulow"
       }
    ]
    

    The above output shows that the filed names are changed, but it is a temporary change and the original documents are not modified.


    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí DocumentDB SQL – Iteration nhận dự án làm có lương

    DocumentDB SQL – Iteration



    In DocumentDB SQL, Microsoft has added a new construct which can be used with IN keyword to provide support for iterating over JSON arrays. The support for iteration is provided in the FROM clause.

    We will consider similar three documents from the previous examples again.

    Following is the AndersenFamily document.

    {
       "id": "AndersenFamily",
       "lastName": "Andersen",
    
       "parents": [
          { "firstName": "Thomas", "relationship":  "father" },
          { "firstName": "Mary Kay", "relationship":  "mother" }
       ],
    
       "children": [
          {
             "firstName": "Henriette Thaulow",
             "gender": "female",
             "grade": 5,
             "pets": [ { "givenName": "Fluffy", "type":  "Rabbit" } ]
          }
       ],
    
       "location": { "state": "WA", "county": "King", "city": "Seattle" },
       "isRegistered": true
    }
    

    Following is the SmithFamily document.

    {
       "id": "SmithFamily",
    
       "parents": [
          { "familyName": "Smith", "givenName": "James" },
          { "familyName": "Curtis", "givenName": "Helen" }
       ],
    
       "children": [
          {
             "givenName": "Michelle",
             "gender": "female",
             "grade": 1
          },
    
          {
             "givenName": "John",
             "gender": "male",
             "grade": 7,
    
             "pets": [
                { "givenName": "Tweetie", "type": "Bird" }
             ]
          }
       ],
    
       "location": {
          "state": "NY",
          "county": "Queens",
          "city": "Forest Hills"
       },
    
       "isRegistered": true
    }
    

    Following is the WakefieldFamily document.

    {
       "id": "WakefieldFamily",
    
       "parents": [
          { "familyName": "Wakefield", "givenName": "Robin" },
          { "familyName": "Miller", "givenName": "Ben" }
       ],
    
       "children": [
          {
             "familyName": "Merriam",
             "givenName": "Jesse",
             "gender": "female",
             "grade": 6,
    
             "pets": [
                { "givenName": "Charlie Brown", "type": "Dog" },
                { "givenName": "Tiger", "type": "Cat" },
                { "givenName": "Princess", "type": "Cat" }
             ]
          },
    
          {
             "familyName": "Miller",
             "givenName": "Lisa",
             "gender": "female",
             "grade": 3,
    
             "pets": [
                { "givenName": "Jake", "type": "Snake" }
             ]
          }
       ],
    
       "location": { "state": "NY", "county": "Manhattan", "city": "NY" },
       "isRegistered": false
    }
    

    Let’s take a look at a simple example without IN keyword in FROM clause.

    Iteration

    Following is the query which will return all the parents from the Families collection.

    SELECT *
    FROM Families.parents
    

    When the above query is executed, it produces the following output.

    [
       [
          {
             "familyName": "Wakefield",
             "givenName": "Robin"
          },
    
          {
             "familyName": "Miller",
             "givenName": "Ben"
          }
       ],
    
       [
          {
             "familyName": "Smith",
             "givenName": "James"
          },
    
          {
             "familyName": "Curtis",
             "givenName": "Helen"
          }
       ],
    
       [
          {
             "firstName": "Thomas",
             "relationship": "father"
          },
    
          {
             "firstName": "Mary Kay",
             "relationship": "mother"
          }
       ]
    ]
    

    As can be seen in the above output, the parents of each family is displayed in a separate JSON array.

    Let’s take a look at the same example, however this time we will use the IN keyword in FROM clause.

    Iterations

    Following is the query which contains the IN keyword.

    SELECT *
    FROM c IN Families.parents
    

    When the above query is executed, it produces the following output.

    [
       {
          "familyName": "Wakefield",
          "givenName": "Robin"
       },
    
       {
          "familyName": "Miller",
          "givenName": "Ben"
       },
    
       {
          "familyName": "Smith",
          "givenName": "James"
       },
    
       {
          "familyName": "Curtis",
          "givenName": "Helen"
       },
    
       {
          "firstName": "Thomas",
          "relationship": "father"
       },
    
       {
          "firstName": "Mary Kay",
          "relationship": "mother"
       }
    
       {
          "id": "WakefieldFamily",
          "givenName": "Jesse",
          "grade": 6
       }
    ]
    

    In the above example, it can be seen that with iteration, the query that performs iteration over parents in the collection has different output array. Hence, all the parents from each family are added into a single array.


    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí DocumentDB SQL – Value Keyword nhận dự án làm có lương

    DocumentDB SQL – Value Keyword



    When you know you”re only returning a single value, then the VALUE keyword can help produce a leaner result set by avoiding the overhead of creating a full-blown object. The VALUE keyword provides a way to return JSON value.

    Let’s take a look at a simple example.

    Value KeyWord

    Following is the query with VALUE keyword.

    SELECT VALUE "Hello World, this is DocumentDB SQL Tutorial"
    

    When this query is executed, it returns the scalar “Hello World, this is DocumentDB SQL Tutorial”.

    [
       "Hello World, this is DocumentDB SQL Tutorial"
    ]
    

    In another example, let’s consider the three documents from the previous examples.

    Following is the AndersenFamily document.

    {
       "id": "AndersenFamily",
       "lastName": "Andersen",
    
       "parents": [
          { "firstName": "Thomas", "relationship":  "father" },
          { "firstName": "Mary Kay", "relationship":  "mother" }
       ],
    
       "children": [
          {
             "firstName": "Henriette Thaulow",
             "gender": "female",
             "grade": 5,
             "pets": [ { "givenName": "Fluffy", "type":  "Rabbit" } ]
          }
       ],
    
       "location": { "state": "WA", "county": "King", "city": "Seattle" },
       "isRegistered": true
    }
    

    Following is the SmithFamily document.

    {
       "id": "SmithFamily",
    
       "parents": [
          { "familyName": "Smith", "givenName": "James" },
          { "familyName": "Curtis", "givenName": "Helen" }
       ],
    
       "children": [
          {
             "givenName": "Michelle",
             "gender": "female",
             "grade": 1
          },
    
          {
             "givenName": "John",
             "gender": "male",
             "grade": 7,
    
             "pets": [
                { "givenName": "Tweetie", "type": "Bird" }
             ]
          }
       ],
    
       "location": {
          "state": "NY",
          "county": "Queens",
          "city": "Forest Hills"
       },
    
       "isRegistered": true
    }
    

    Following is the WakefieldFamily document.

    {
       "id": "WakefieldFamily",
    
       "parents": [
          { "familyName": "Wakefield", "givenName": "Robin" },
          { "familyName": "Miller", "givenName": "Ben" }
       ],
    
       "children": [
          {
             "familyName": "Merriam",
             "givenName": "Jesse",
             "gender": "female",
             "grade": 6,
    
             "pets": [
                { "givenName": "Charlie Brown", "type": "Dog" },
                { "givenName": "Tiger", "type": "Cat" },
                { "givenName": "Princess", "type": "Cat" }
             ]
          },
    
          {
             "familyName": "Miller",
             "givenName": "Lisa",
             "gender": "female",
             "grade": 3,
    
             "pets": [
                { "givenName": "Jake", "type": "Snake" }
             ]
          }
       ],
    
       "location": { "state": "NY", "county": "Manhattan", "city": "NY" },
       "isRegistered": false
    }
    

    Following is the query.

    SELECT VALUE f.location
    FROM Families f
    

    When this query is executed, it return the returns the address without the location label.

    [
       {
          "state": "NY",
          "county": "Manhattan",
          "city": "NY"
       },
    
       {
          "state": "NY",
          "county": "Queens",
          "city": "Forest Hills"
       },
    
       {
          "state": "WA",
          "county": "King",
          "city": "Seattle"
       }
    ]
    

    If we now specify the same query without VALUE Keyword, then it will return the address with location label. Following is the query.

    SELECT f.location
    FROM Families f
    

    When this query is executed, it produces the following output.

    [
       {
          "location": {
             "state": "NY",
             "county": "Manhattan",
             "city": "NY"
          }
       },
    
       {
          "location": {
             "state": "NY",
             "county": "Queens",
             "city": "Forest Hills"
          }
       },
    
       {
          "location": {
             "state": "WA",
             "county": "King",
             "city": "Seattle"
          }
       }
    ]
    

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí DocumentDB SQL – Overview nhận dự án làm có lương

    DocumentDB SQL – Overview



    DocumentDB is Microsoft”s newest NoSQL document database platform that runs on Azure. In this tutorial, we will learn all about querying documents using the special version of SQL supported by DocumentDB.

    NoSQL Document Database

    DocumentDB is Microsoft”s newest NoSQL document database, however, when we say NoSQL document database, what precisely do we mean by NoSQL, and document database?

    • SQL means Structured Query Language which is a traditional query language of relational databases. SQL is often equated with relational databases.

    • It is really more helpful to think of a NoSQL database as a non-relational database, so NoSQL really means non-relational.

    There are different types of NoSQL databases which include key value stores such as −

    • Azure Table Storage
    • Column-based stores, like Cassandra
    • Graph databases, like NEO4
    • Document databases, like MongoDB and Azure DocumentDB

    Why SQL Syntax?

    This can sound strange at first, but in DocumentDB which is a NoSQL database, we query using SQL. As mentioned above, this is a special version of SQL rooted in JSON and JavaScript semantics.

    • SQL is just a language, but it”s also a very popular language that”s rich and expressive. Thus, it definitely seems like a good idea to use some dialect of SQL rather than come up with a whole new way of expressing queries that we would need to learn if you wanted to get documents out of your database.

    • SQL is designed for relational databases, and DocumentDB is a non-relational document database. DocumentDB team has actually adapted the SQL syntax for the non-relational world of document databases, and this is what is meant by rooting SQL in JSON and JavaScript.

    • The language still reads as familiar SQL, but the semantics are all based on schemafree JSON documents rather than relational tables. In DocumentDB, we will be working with JavaScript data types rather than SQL data types. We will be familiar with SELECT, FROM, WHERE, and so on, but with JavaScript types, which are limited to numbers and strings, objects, arrays, Boolean, and null are far fewer than the wide range of SQL data types.

    • Similarly, expressions are evaluated as JavaScript expressions rather than some form of T-SQL. For example, in a world of denormalized data, we”re not dealing with the rows and columns, but schema-free documents with hierarchal structures that contain nested arrays and objects.

    How does SQL Work?

    The DocumentDB team has answered this question in several innovative ways. Few of them are listed as follows −

    • First, assuming you”ve not changed the default behavior to automatically index every property in a document, you can use dotted notation in your queries to navigate a path to any property no matter how deeply nested it may be within the document.

    • You can also perform an intra-document join in which nested array elements are joined with their parent element within a document in a manner very similar to the way a join is performed between two tables in the relational world.

    • Your queries can return documents from the database as it is, or you can project any custom JSON shape you want based on as much or as little of the document data that you want.

    • SQL in DocumentDB supports many of the common operators including −

      • Arithmetic and bitwise operations

      • AND and OR logic

      • Equality and range comparisons

      • String concatenation

    • The query language also supports a host of built-in functions.


    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí DocumentDB SQL – Order By Clause nhận dự án làm có lương

    DocumentDB SQL – Order By Clause



    Microsoft Azure DocumentDB supports querying documents using SQL over JSON documents. You can sort documents in the collection on numbers and strings using an ORDER BY clause in your query. The clause can include an optional ASC/DESC argument to specify the order in which results must be retrieved.

    We will consider the same documents as in the previous examples.

    Following is the AndersenFamily document.

    {
       "id": "AndersenFamily",
       "lastName": "Andersen",
    
       "parents": [
          { "firstName": "Thomas", "relationship":  "father" },
          { "firstName": "Mary Kay", "relationship":  "mother" }
       ],
    
       "children": [
          {
             "firstName": "Henriette Thaulow",
             "gender": "female",
             "grade": 5,
             "pets": [ { "givenName": "Fluffy", "type":  "Rabbit" } ]
          }
       ],
    
       "location": { "state": "WA", "county": "King", "city": "Seattle" },
       "isRegistered": true
    }
    

    Following is the SmithFamily document.

    {
       "id": "SmithFamily",
    
       "parents": [
          { "familyName": "Smith", "givenName": "James" },
          { "familyName": "Curtis", "givenName": "Helen" }
       ],
    
       "children": [
          {
             "givenName": "Michelle",
             "gender": "female",
             "grade": 1
          },
    
          {
             "givenName": "John",
             "gender": "male",
             "grade": 7,
    
             "pets": [
                { "givenName": "Tweetie", "type": "Bird" }
             ]
          }
       ],
    
       "location": {
          "state": "NY",
          "county": "Queens",
          "city": "Forest Hills"
       },
    
       "isRegistered": true
    }
    

    Following is the WakefieldFamily document.

    {
       "id": "WakefieldFamily",
    
       "parents": [
          { "familyName": "Wakefield", "givenName": "Robin" },
          { "familyName": "Miller", "givenName": "Ben" }
       ],
    
       "children": [
          {
             "familyName": "Merriam",
             "givenName": "Jesse",
             "gender": "female",
             "grade": 6,
    
             "pets": [
                { "givenName": "Charlie Brown", "type": "Dog" },
                { "givenName": "Tiger", "type": "Cat" },
                { "givenName": "Princess", "type": "Cat" }
             ]
          },
    
          {
             "familyName": "Miller",
             "givenName": "Lisa",
             "gender": "female",
             "grade": 3,
    
             "pets": [
                { "givenName": "Jake", "type": "Snake" }
             ]
          }
       ],
    
       "location": { "state": "NY", "county": "Manhattan", "city": "NY" },
       "isRegistered": false
    }
    

    Let’s take a look at a simple example.

    Order By Clause

    Following is the query which contains the ORDER BY keyword.

    SELECT  f.id, f.children[0].givenName,f.children[0].grade
    FROM Families f
    ORDER BY f.children[0].grade
    

    When the above query is executed, it produces the following output.

    [
       {
          "id": "SmithFamily",
          "givenName": "Michelle",
          "grade": 1
       },
    
       {
          "id": "AndersenFamily",
          "grade": 5
       },
    
       {
          "id": "WakefieldFamily",
          "givenName": "Jesse",
          "grade": 6
       }
    ]
    

    Let’s consider another simple example.

    Order By Clauses

    Following is the query which contains the ORDER BY keyword and DESC optional keyword.

    SELECT f.id, f.parents[0].familyName
    FROM Families f
    ORDER BY f.parents[0].familyName DESC
    

    When the above query is executed, it will produce the following output.

    [
       {
          "id": "WakefieldFamily",
          "familyName": "Wakefield"
       },
    
       {
          "id": "SmithFamily",
          "familyName": "Smith"
       },
    
       {
          "id": "AndersenFamily"
       }
    ]
    

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí DocumentDB SQL – Operators nhận dự án làm có lương

    DocumentDB SQL – Operators



    An operator is a reserved word or a character used primarily in an SQL WHERE clause to perform operation(s), such as comparisons and arithmetic operations. DocumentDB SQL also supports a variety of scalar expressions. The most commonly used are binary and unary expressions.

    The following SQL operators are currently supported and can be used in queries.

    SQL Comparison Operators

    Following is a list of all the comparison operators available in DocumentDB SQL grammar.

    S.No. Operators & Description
    1

    =

    Checks if the values of two operands are equal or not. If yes, then condition becomes true.

    2

    !=

    Checks if the values of two operands are equal or not. If values are not equal then condition becomes true.

    3

    <>

    Checks if the values of two operands are equal or not. If values are not equal then condition becomes true.

    4

    >

    Checks if the value of left operand is greater than the value of right operand. If yes, then condition becomes true.

    5

    <

    Checks if the value of left operand is less than the value of right operand. If yes, then condition becomes true.

    6

    >=

    Checks if the value of left operand is greater than or equal to the value of right operand. If yes, then condition becomes true.

    7

    <=

    Checks if the value of left operand is less than or equal to the value of right operand. If yes, then condition becomes true.

    SQL Logical Operators

    Following is a list of all the logical operators available in DocumentDB SQL grammar.

    S.No. Operators & Description
    1

    AND

    The AND operator allows the existence of multiple conditions in an SQL statement”s WHERE clause.

    2

    BETWEEN

    The BETWEEN operator is used to search for values that are within a set of values, given the minimum value and the maximum value.

    3

    IN

    The IN operator is used to compare a value to a list of literal values that have been specified.

    4

    OR

    The OR operator is used to combine multiple conditions in an SQL statement”s WHERE clause.

    5

    NOT

    The NOT operator reverses the meaning of the logical operator with which it is used. For example, NOT EXISTS, NOT BETWEEN, NOT IN, etc. This is a negate operator.

    SQL Arithmetic Operators

    Following is a list of all the arithmetic operators available in DocumentDB SQL grammar.

    S.No. Operators & Description
    1

    +

    Addition − Adds values on either side of the operator.

    2

    Subtraction − Subtracts the right hand operand from the left hand operand.

    3

    *

    Multiplication − Multiplies values on either side of the operator.

    4

    /

    Division − Divides the left hand operand by the right hand operand.

    5

    %

    Modulus − Divides the left hand operand by the right hand operand and returns the remainder.

    We will consider the same documents in this example as well. Following is the AndersenFamily document.

    {
       "id": "AndersenFamily",
       "lastName": "Andersen",
    
       "parents": [
          { "firstName": "Thomas", "relationship":  "father" },
          { "firstName": "Mary Kay", "relationship":  "mother" }
       ],
    
       "children": [
          {
             "firstName": "Henriette Thaulow",
             "gender": "female",
             "grade": 5,
             "pets": [ { "givenName": "Fluffy", "type":  "Rabbit" } ]
          }
       ],
    
       "location": { "state": "WA", "county": "King", "city": "Seattle" },
       "isRegistered": true
    }
    

    Following is the SmithFamily document.

    {
       "id": "SmithFamily",
    
       "parents": [
          { "familyName": "Smith", "givenName": "James" },
          { "familyName": "Curtis", "givenName": "Helen" }
       ],
    
       "children": [
          {
             "givenName": "Michelle",
             "gender": "female",
             "grade": 1
          },
    
          {
             "givenName": "John",
             "gender": "male",
             "grade": 7,
    
             "pets": [
                { "givenName": "Tweetie", "type": "Bird" }
             ]
          }
       ],
    
       "location": {
          "state": "NY",
          "county": "Queens",
          "city": "Forest Hills"
       },
    
       "isRegistered": true
    }
    

    Following is the WakefieldFamily document.

    {
       "id": "WakefieldFamily",
    
       "parents": [
          { "familyName": "Wakefield", "givenName": "Robin" },
          { "familyName": "Miller", "givenName": "Ben" }
       ],
    
       "children": [
          {
             "familyName": "Merriam",
             "givenName": "Jesse",
             "gender": "female",
             "grade": 6,
    
             "pets": [
                { "givenName": "Charlie Brown", "type": "Dog" },
                { "givenName": "Tiger", "type": "Cat" },
                { "givenName": "Princess", "type": "Cat" }
             ]
          },
    
          {
             "familyName": "Miller",
             "givenName": "Lisa",
             "gender": "female",
             "grade": 3,
    
             "pets": [
                { "givenName": "Jake", "type": "Snake" }
             ]
          }
       ],
    
       "location": { "state": "NY", "county": "Manhattan", "city": "NY" },
       "isRegistered": false
    }
    

    Let’s take a look at a simple example in which a comparison operator is used in WHERE clause.

    Comparison Operator

    In this query, in WHERE clause, the (WHERE f.id = “WakefieldFamily”) condition is specified, and it will retrieve the document whose id is equal to WakefieldFamily.

    SELECT *
    FROM f
    WHERE f.id = "WakefieldFamily"
    

    When the above query is executed, it will return the complete JSON document for WakefieldFamily as shown in the following output.

    [
       {
          "id": "WakefieldFamily",
          "parents": [
             {
                "familyName": "Wakefield",
                "givenName": "Robin"
             },
    
             {
                "familyName": "Miller",
                "givenName": "Ben"
             }
          ],
    
          "children": [
             {
                "familyName": "Merriam",
                "givenName": "Jesse",
                "gender": "female",
                "grade": 6,
    
                "pets": [
                   {
                      "givenName": "Charlie Brown",
                      "type": "Dog"
                   },
    
                   {
                      "givenName": "Tiger",
                      "type": "Cat"
                   },
    
                   {
                      "givenName": "Princess",
                      "type": "Cat"
                   }
                ]
    
             },
    
             {
                "familyName": "Miller",
                "givenName": "Lisa",
                "gender": "female",
                "grade": 3,
    
                "pets": [
                   {
                      "givenName": "Jake",
                      "type": "Snake"
                   }
                ]
             }
          ],
    
          "location": {
             "state": "NY",
             "county": "Manhattan",
             "city": "NY"
          },
    
          "isRegistered": false,
          "_rid": "Ic8LAJFujgECAAAAAAAAAA==",
          "_ts": 1450541623,
          "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgECAAAAAAAAAA==/",
          "_etag": ""00000500-0000-0000-0000-567582370000"",
          "_attachments": "attachments/"
       }
    ]
    

    Let’s take a look at another example in which the query will retrieve the children data whose grade is greater than 5.

    SELECT *
    FROM Families.children[0] c
    WHERE (c.grade > 5)
    

    When the above query is executed, it will retrieve the following sub document as shown in the output.

    [
       {
          "familyName": "Merriam",
          "givenName": "Jesse",
          "gender": "female",
          "grade": 6,
    
          "pets": [
             {
                "givenName": "Charlie Brown",
                "type": "Dog"
             },
    
             {
                "givenName": "Tiger",
                "type": "Cat"
             },
    
             {
                "givenName": "Princess",
                "type": "Cat"
             }
          ]
       }
    ]
    

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí DocumentDB SQL – Home nhận dự án làm có lương

    DocumentDB SQL Tutorial

    DocumentDB SQL Tutorial







    DocumentDB is Microsoft”s newest NoSQL document database platform that runs on Azure. DocumentDB is designed keeping in mind the requirements of managing data for latest applications. This tutorial talks about querying documents using the special version of SQL supported by DocumentDB with illustrative examples.

    Audience

    This tutorial is designed for developers who want to get acquainted with how to query DocumentDB using a familiar Structured Query Language (SQL).

    Prerequisites

    It is an elementary tutorial that explains the basics of DocumentDB and there are no prerequisites as such. However, it will certainly help if you have some prior exposure to NoSQL technologies.

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí DocumentDB SQL – From Clause nhận dự án làm có lương

    DocumentDB SQL – From Clause



    In this chapter, we will cover the FROM clause, which works nothing like a standard FROM clause in regular SQL.

    Queries always run within the context of a specific collection and cannot join across documents within the collection, which makes us wonder why we need a FROM clause. In fact, we don”t, but if we don”t include it, then we won”t be querying documents in the collection.

    The purpose of this clause is to specify the data source upon which the query must operate. Commonly the whole collection is the source, but one can specify a subset of the collection instead. The FROM <from_specification> clause is optional unless the source is filtered or projected later in the query.

    Let’s take a look at the same example again. Following is the AndersenFamily document.

    {
       "id": "AndersenFamily",
       "lastName": "Andersen",
    
       "parents": [
          { "firstName": "Thomas", "relationship":  "father" },
          { "firstName": "Mary Kay", "relationship":  "mother" }
       ],
    
       "children": [
          {
             "firstName": "Henriette Thaulow",
             "gender": "female",
             "grade": 5,
             "pets": [ { "givenName": "Fluffy", "type":  "Rabbit" } ]
          }
       ],
    
       "location": { "state": "WA", "county": "King", "city": "Seattle" },
       "isRegistered": true
    }
    

    Following is the SmithFamily document.

    {
       "id": "SmithFamily",
    
       "parents": [
          { "familyName": "Smith", "givenName": "James" },
          { "familyName": "Curtis", "givenName": "Helen" }
       ],
    
       "children": [
          {
             "givenName": "Michelle",
             "gender": "female",
             "grade": 1
          },
    
          {
             "givenName": "John",
             "gender": "male",
             "grade": 7,
    
             "pets": [
                { "givenName": "Tweetie", "type": "Bird" }
             ]
          }
       ],
    
       "location": {
          "state": "NY",
          "county": "Queens",
          "city": "Forest Hills"
       },
    
       "isRegistered": true
    }
    

    Following is the WakefieldFamily document.

    {
       "id": "WakefieldFamily",
    
       "parents": [
          { "familyName": "Wakefield", "givenName": "Robin" },
          { "familyName": "Miller", "givenName": "Ben" }
       ],
    
       "children": [
          {
             "familyName": "Merriam",
             "givenName": "Jesse",
             "gender": "female",
             "grade": 6,
    
             "pets": [
                { "givenName": "Charlie Brown", "type": "Dog" },
                { "givenName": "Tiger", "type": "Cat" },
                { "givenName": "Princess", "type": "Cat" }
             ]
          },
    
          {
             "familyName": "Miller",
             "givenName": "Lisa",
             "gender": "female",
             "grade": 3,
    
             "pets": [
                { "givenName": "Jake", "type": "Snake" }
             ]
          }
       ],
    
       "location": { "state": "NY", "county": "Manhattan", "city": "NY" },
       "isRegistered": false
    }
    
    WakefieldFamily

    In the above query, “SELECT * FROM c” indicates that the entire Families collection is the source over which to enumerate.

    Sub-documents

    The source can also be reduced to a smaller subset. When we want to retrieve only a subtree in each document, the sub-root could then become the source, as shown in the following example.

    Sub-documents

    When we run the following query −

    SELECT * FROM Families.parents
    

    The following sub-documents will be retrieved.

    [
       [
          {
             "familyName": "Wakefield",
             "givenName": "Robin"
          },
    
          {
             "familyName": "Miller",
             "givenName": "Ben"
          }
       ],
    
       [
          {
             "familyName": "Smith",
             "givenName": "James"
          },
    
          {
             "familyName": "Curtis",
             "givenName": "Helen"
          }
       ],
    
       [
          {
             "firstName": "Thomas",
             "relationship": "father"
          },
    
          {
             "firstName": "Mary Kay",
             "relationship": "mother"
          }
       ]
    ]
    

    As a result of this query, we can see that only the parents sub-documents are retrieved.


    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí DocumentDB SQL – In Keyword nhận dự án làm có lương

    DocumentDB SQL – In Keyword



    The IN keyword can be used to check whether a specified value matches any value in a list. The IN operator allows you to specify multiple values in a WHERE clause. IN is equivalent to chaining multiple OR clauses.

    The similar three documents are considered as done in earlier examples. Following is the AndersenFamily document.

    {
       "id": "AndersenFamily",
       "lastName": "Andersen",
    
       "parents": [
          { "firstName": "Thomas", "relationship":  "father" },
          { "firstName": "Mary Kay", "relationship":  "mother" }
       ],
    
       "children": [
          {
             "firstName": "Henriette Thaulow",
             "gender": "female",
             "grade": 5,
             "pets": [ { "givenName": "Fluffy", "type":  "Rabbit" } ]
          }
       ],
    
       "location": { "state": "WA", "county": "King", "city": "Seattle" },
       "isRegistered": true
    }
    

    Following is the SmithFamily document.

    {
       "id": "SmithFamily",
    
       "parents": [
          { "familyName": "Smith", "givenName": "James" },
          { "familyName": "Curtis", "givenName": "Helen" }
       ],
    
       "children": [
          {
             "givenName": "Michelle",
             "gender": "female",
             "grade": 1
          },
    
          {
             "givenName": "John",
             "gender": "male",
             "grade": 7,
    
             "pets": [
                { "givenName": "Tweetie", "type": "Bird" }
             ]
          }
       ],
    
       "location": {
          "state": "NY",
          "county": "Queens",
          "city": "Forest Hills"
       },
    
       "isRegistered": true
    }
    

    Following is the WakefieldFamily document.

    {
       "id": "WakefieldFamily",
    
       "parents": [
          { "familyName": "Wakefield", "givenName": "Robin" },
          { "familyName": "Miller", "givenName": "Ben" }
       ],
    
       "children": [
          {
             "familyName": "Merriam",
             "givenName": "Jesse",
             "gender": "female",
             "grade": 6,
    
             "pets": [
                { "givenName": "Charlie Brown", "type": "Dog" },
                { "givenName": "Tiger", "type": "Cat" },
                { "givenName": "Princess", "type": "Cat" }
             ]
          },
    
          {
             "familyName": "Miller",
             "givenName": "Lisa",
             "gender": "female",
             "grade": 3,
    
             "pets": [
                { "givenName": "Jake", "type": "Snake" }
             ]
          }
       ],
    
       "location": { "state": "NY", "county": "Manhattan", "city": "NY" },
       "isRegistered": false
    }
    

    Let’s take a look at a simple example.

    In KeyWord

    Following is the query which will retrieve the data whose familyName is either “Smith” or Wakefield.

    SELECT *
    FROM Families.parents[0] f
    WHERE f.familyName IN (''Smith'', ''Wakefield'')
    

    When the above query is executed, it produces the following output.

    [
       {
          "familyName": "Wakefield",
          "givenName": "Robin"
       },
    
       {
          "familyName": "Smith",
          "givenName": "James"
       }
    ]
    

    Let’s consider another simple example in which all family documents will be retrieved where the id is one of “SmithFamily” or “AndersenFamily”. Following is the query.

    SELECT *
    FROM Families
    WHERE Families.id IN (''SmithFamily'', ''AndersenFamily'')
    

    When the above query is executed, it produces the following output.

    [
       {
          "id": "SmithFamily",
          "parents": [
             {
                "familyName": "Smith",
                "givenName": "James"
             },
    
             {
                "familyName": "Curtis",
                "givenName": "Helen"
             }
          ],
    
          "children": [
             {
                "givenName": "Michelle",
                "gender": "female",
                "grade": 1
             },
    
             {
                "givenName": "John",
                "gender": "male",
                "grade": 7,
    
                "pets": [
                   {
                      "givenName": "Tweetie",
                      "type": "Bird"
                   }
                ]
             }
          ],
    
          "location": {
             "state": "NY",
             "county": "Queens",
             "city": "Forest Hills"
          },
    
          "isRegistered": true,
          "_rid": "Ic8LAJFujgEDAAAAAAAAAA==",
          "_ts": 1450541623,
          "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgEDAAAAAAAAAA==/",
          "_etag": ""00000600-0000-0000-0000-567582370000"",
          "_attachments": "attachments/"
       },
    
       {
          "id": "AndersenFamily",
          "lastName": "Andersen",
    
          "parents": [
             {
                "firstName": "Thomas",
                "relationship": "father"
             },
    
             {
                "firstName": "Mary Kay",
                "relationship": "mother"
             }
          ],
    
          "children": [
             {
                "firstName": "Henriette Thaulow",
                "gender": "female",
                "grade": 5,
    
                "pets": [
                   {
                      "givenName": "Fluffy",
                      "type": "Rabbit"
                   }
                ]
             }
          ],
    
          "location": {
             "state": "WA",
             "county": "King",
             "city": "Seattle"
          },
    
          "isRegistered": true,
          "_rid": "Ic8LAJFujgEEAAAAAAAAAA==",
          "_ts": 1450541624,
          "_self": "dbs/Ic8LAA==/colls/Ic8LAJFujgE=/docs/Ic8LAJFujgEEAAAAAAAAAA==/",
          "_etag": ""00000700-0000-0000-0000-567582380000"",
          "_attachments": "attachments/"
       }
    ]
    

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí DocumentDB – Between Keyword nhận dự án làm có lương

    DocumentDB SQL – Between Keyword



    The BETWEEN keyword is used to express queries against ranges of values like in SQL. BETWEEN can be used against strings or numbers. The main difference between using BETWEEN in DocumentDB and ANSI SQL is that you can express range queries against properties of mixed types.

    For example, in some document it is possible that you might have “grade” as a number and in other documents it might be strings. In these cases, a comparison between two different types of results is “undefined”, and the document will be skipped.

    Let us consider the three documents from the previous example. Following is the AndersenFamily document.

    {
       "id": "AndersenFamily",
       "lastName": "Andersen",
    
       "parents": [
          { "firstName": "Thomas", "relationship":  "father" },
          { "firstName": "Mary Kay", "relationship":  "mother" }
       ],
    
       "children": [
          {
             "firstName": "Henriette Thaulow",
             "gender": "female",
             "grade": 5,
             "pets": [ { "givenName": "Fluffy", "type":  "Rabbit" } ]
          }
       ],
    
       "location": { "state": "WA", "county": "King", "city": "Seattle" },
       "isRegistered": true
    }
    

    Following is the SmithFamily document.

    {
       "id": "SmithFamily",
    
       "parents": [
          { "familyName": "Smith", "givenName": "James" },
          { "familyName": "Curtis", "givenName": "Helen" }
       ],
    
       "children": [
          {
             "givenName": "Michelle",
             "gender": "female",
             "grade": 1
          },
    
          {
             "givenName": "John",
             "gender": "male",
             "grade": 7,
    
             "pets": [
                { "givenName": "Tweetie", "type": "Bird" }
             ]
          }
       ],
    
       "location": {
          "state": "NY",
          "county": "Queens",
          "city": "Forest Hills"
       },
    
       "isRegistered": true
    }
    

    Following is the WakefieldFamily document.

    {
       "id": "WakefieldFamily",
    
       "parents": [
          { "familyName": "Wakefield", "givenName": "Robin" },
          { "familyName": "Miller", "givenName": "Ben" }
       ],
    
       "children": [
          {
             "familyName": "Merriam",
             "givenName": "Jesse",
             "gender": "female",
             "grade": 6,
    
             "pets": [
                { "givenName": "Charlie Brown", "type": "Dog" },
                { "givenName": "Tiger", "type": "Cat" },
                { "givenName": "Princess", "type": "Cat" }
             ]
          },
    
          {
             "familyName": "Miller",
             "givenName": "Lisa",
             "gender": "female",
             "grade": 3,
    
             "pets": [
                { "givenName": "Jake", "type": "Snake" }
             ]
          }
       ],
    
       "location": { "state": "NY", "county": "Manhattan", "city": "NY" },
       "isRegistered": false
    }
    

    Let’s take a look at an example, where the query returns all family documents in which the first child”s grade is between 1-5 (both inclusive).

    Returns Family Documents

    Following is the query in which BETWEEN keyword is used and then AND logical operator.

    SELECT *
    FROM Families.children[0] c
    WHERE c.grade BETWEEN 1 AND 5
    

    When the above query is executed, it produces the following output.

    [
       {
          "givenName": "Michelle",
          "gender": "female",
          "grade": 1
       },
    
       {
          "firstName": "Henriette Thaulow",
          "gender": "female",
          "grade": 5,
    
          "pets": [
             {
                "givenName": "Fluffy",
                "type": "Rabbit"
             }
          ]
       }
    ]
    

    To display the grades outside the range of the previous example, use NOT BETWEEN as shown in the following query.

    SELECT *
    FROM Families.children[0] c
    WHERE c.grade NOT BETWEEN 1 AND 5
    

    When this query is executed. It produces the following output.

    [
       {
          "familyName": "Merriam",
          "givenName": "Jesse",
          "gender": "female",
          "grade": 6,
    
          "pets": [
             {
                "givenName": "Charlie Brown",
                "type": "Dog"
             },
    
             {
                "givenName": "Tiger",
                "type": "Cat"
             },
    
             {
                "givenName": "Princess",
                "type": "Cat"
             }
          ]
       }
    ]
    

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc