You are viewing the documentation for a prerelease version.

View Latest

CREATE FUNCTION

    +
    The CREATE FUNCTION statement enables you to create a user-defined function.

    Purpose

    There are two types of user-defined function:

    • Inline functions are defined using N1QL expressions, including subqueries. They enable you to name and reuse complex or repetitive expressions, including subqueries, in order to simplify your queries.

    • External functions are defined using an external language. They enable you to create functions that may be difficult or impossible to define using built-in N1QL expressions. The only supported language is JavaScript.

    Global Functions and Scope Functions

    You can create user-defined functions at two different levels of the N1QL logical hierarchy.

    • A global function is created within a namespace, at the same level as the buckets within the namespace. When you call a global function, any partial keyspace references within the function definition are resolved against the function’s namespace, regardless of the current query context.

      For example, when you call a global function default:global() which contains the keyspace reference `travel-sample`, the keyspace reference is always resolved within the context of the function to the default:`travel-sample` bucket.

    • A scope function is created within a scope, at the same level as the collections within the scope. When you call a scope function, any partial keyspace references within the function definition are resolved against the function’s scope, regardless of the current query context.

      For example, when you call a scope function default:`travel-sample`.inventory.scope() which contains the keyspace reference route, the keyspace reference is always resolved within the context of the function to default:`travel-sample`.inventory.route.

    When you create a user-defined function, the current query context determines whether it is created as a global function or a scope function. If you want to create a user-defined function outside of the current query context, you must include the full path to the function when you specify the function name.

    Similarly, when you call a user-defined function, the current query context determines the path to the function. If you want to call a user-defined function outside of the current query context, you must include the full path to the function when you specify the function name.

    Finally, it is important to note that a global function is not the same as a scope function stored in the default scope in a bucket.

    Syntax

    The CREATE FUNCTION statement takes a different syntax depending on the type of function you are creating.

    create-function-inline | create-function-external

    Inline Functions

    There are two alternative syntaxes for defining an inline function: a syntax with braces {} and a syntax using the LANGUAGE keyword. The two syntaxes are synonymous.

    create-function-inline ::= CREATE [ OR REPLACE ] FUNCTION name '(' [ parameter ( ',' parameter )* ] ')' ( '{' expression '}' | LANGUAGE INLINE AS expression )
    'CREATE' ( 'OR' 'REPLACE' )? 'FUNCTION' name '(' (parameter (',' parameter)* )? ')' ( '{' expression '}' | 'LANGUAGE' 'INLINE' 'AS' expression )
    name

    The name of the function. It is recommended to use an unqualified identifier for the function name, such as func1 or `func-1`. In this case, the function is created as a global function or a scope function, depending on the current query context.

    To create a global function in a particular namespace, the function name must be a qualified identifier with a namespace, such as default:func1. Similarly, to create a scope function in a particular scope, the function name must be a qualified identifier with the full path to a scope, such as default:`travel-sample`.inventory.func1.

    If the function name is an unqualified identifier, it may not be the same as a reserved keyword. A function name with a specified namespace or scope may have the same name as a reserved keyword.

    parameter

    [Optional] The name of a function argument. If you specify named parameters for the function, then you must call the function with exactly the same number of arguments at execution time. If you specify no parameters, then you must call the function with no arguments. To create a variadic function, that is, a function which you can call with any number of arguments or none, specify ... as the only parameter.

    expression

    The N1QL expression that defines the function. You can use any valid expression. If you specified named parameters for the function, you can use these in the expression to represent arguments passed to the function at execution time. If you specified that the function is variadic, any arguments passed to the function at execution time are held in an array named args.

    • If the expression contains a parameter that has the same name as a field in the document, it will always refer to the parameter. To distinguish between the field and the parameter, prefix the field with the keyspace name, for example landmark.activity. To avoid this ambiguity, you should use unique parameter names that do not clash with document field names, such as vActivity.

    • Functions may return only one value, of any valid N1QL type. For inline functions, the result and type of the function are the result and type of the expression. If you need to return multiple values, construct an array.

    Replacing a Function

    The optional OR REPLACE keywords enable you to redefine a function. If these keywords are present, and a function with the same name already exists, the existing function is replaced.

    If these keywords are not present, and a function with the same name already exists, an error is generated.

    External Functions

    create-function-external ::= CREATE [ OR REPLACE ] FUNCTION name '(' [ parameter ( ',' parameter )* ] ')' LANGUAGE JAVASCRIPT AS object AT library
    'CREATE' ( 'OR' 'REPLACE' )? 'FUNCTION' name '(' (parameter (',' parameter)* )? ')' 'LANGUAGE' 'JAVASCRIPT' 'AS' object 'AT' library
    name

    The name of the function. It is recommended to use an unqualified identifier for the function name, such as func1 or `func-1`. In this case, the function is created as a global function or a scope function, depending on the current query context.

    To create a global function in a particular namespace, the function name must be a qualified identifier with a namespace, such as default:func1. Similarly, to create a scope function in a particular scope, the function name must be a qualified identifier with the full path to a scope, such as default:`travel-sample`.inventory.func1.

    If the function name is an unqualified identifier, it may not be the same as a reserved keyword. A function name with a specified namespace or scope may have the same name as a reserved keyword.

    parameter

    [Optional] The name of a function argument. If you specify named parameters for the function, then you must call the function with exactly the same number of arguments at execution time. If you specify no parameters, then you must call the function with no arguments. To create a variadic function, that is, a function which you can call with any number of arguments or none, specify ... as the only parameter.

    object

    The name of the JavaScript function that you want to use for the user-defined function. This parameter is a string and must be wrapped in quotes. The supported JavaScript syntax is the same as for the Eventing service. For details, refer to Language Constructs.

    library

    The name of the JavaScript library that contains the function you want to use. This parameter is a string and must be wrapped in quotes. You must create the JavaScript library and the JavaScript function using the N1QL Functions REST API. For details, refer to Functions REST API.

    Replacing a Function

    The optional OR REPLACE keywords enable you to redefine a function. If these keywords are present, and a function with the same name already exists, the existing function is replaced.

    If these keywords are not present, and a function with the same name already exists, an error is generated.

    Examples

    For simplicity, none of these examples implement any data validation or error checking.

    Example 1. Inline function with the LANGUAGE syntax

    This statement creates a function called celsius, which converts Fahrenheit to Celsius. The function is variadic. The expression converts the first argument supplied at execution time, which is stored in the first member in the args array.

    CREATE FUNCTION celsius(...) LANGUAGE INLINE AS (args[0] - 32) * 5/9;
    Test
    EXECUTE FUNCTION celsius(100);
    Result
    [
      37.77777777777778
    ]
    Example 2. Inline function with the braces syntax

    This statement creates a function called fahrenheit, which converts Celsius to Fahrenheit. The function is variadic. The expression converts the first argument supplied at execution time, which is stored in the first member in the args array.

    CREATE FUNCTION fahrenheit(...) { (args[0] * 9/5) + 32 };
    Test
    EXECUTE FUNCTION fahrenheit(100, "ignore this");
    Result
    [
      212
    ]

    As the function is variadic, you can use any number of arguments when you call the function. Arguments which are not used by the function expression are ignored.

    Example 3. Inline function with named parameters

    The following statement creates a function called lstr, which returns the specified number of characters from the left of a string. The expression expects two named arguments: vString, which is the string to work with, and vLen, which is the number of characters to return.

    CREATE FUNCTION lstr(vString, vLen) LANGUAGE INLINE AS SUBSTR(vString, 0, vLen);
    Test
    EXECUTE FUNCTION lstr("Couchbase", 5, "ignore this");
    Result
    [
      {
        "code": 10104,
        "msg": "Incorrect number of arguments supplied to function lstr - cause: lstr"
      }
    ]

    As the arguments were specified by the function definition, you must use the same number of arguments when you call the function. If you supply the wrong number of arguments, an error is generated.

    Example 4. Inline function with named parameters

    The following statement creates a function called rstr, which returns the specified number of characters from the right of a string. The expression expects two named arguments: vString, which is the string to work with, and vLen, which is the number of characters to return.

    CREATE FUNCTION rstr(vString, vLen) { SUBSTR(vString, LENGTH(vString) - vLen, vLen) };
    Test
    EXECUTE FUNCTION rstr("Couchbase", 4);
    Result
    [
      "base"
    ]
    Example 5. Inline function with subquery

    The following statement creates a function called locations, which selects name and address information from all documents with the specified activity in the landmark keyspace.

    CREATE FUNCTION locations(vActivity) { (
      SELECT id, name, address, city
      FROM `travel-sample`.inventory.landmark
      WHERE activity = vActivity) };
    Test
    EXECUTE FUNCTION locations("see");
    Result
    [
      [
        {
          "address": "Prince Arthur Road, ME4 4UG",
          "city": "Gillingham",
          "id": 10019,
          "name": "Royal Engineers Museum"
        },
        {
          "address": "84 rue Claude Monet",
          "city": "Giverny",
          "id": 10061,
          "name": "Monet's House"
        },
    ...
    Example 6. External function

    The following command registers a JavaScript function called add in a library called math.

    $ curl -v -X POST \
      http://localhost:8093/functions/v1/libraries/math/functions/add \
      -u Administrator:password \
      -H 'content-type: application/json' \
      -d '{"name": "add",
           "code": "function add(a, b) { let data = a + b; return data; }"
          }'

    The following statement creates a function called javaScriptAdd, which calls the JavaScript add function from the math library.

    CREATE FUNCTION javaScriptAdd(...) LANGUAGE JAVASCRIPT AS "add" AT "math";
    Test
    EXECUTE FUNCTION javaScriptAdd(2, 3);
    Result
    [
      5
    ]
    Example 7. Replace a function

    This statement creates a function which returns an approximation of π. The function takes no arguments.

    CREATE FUNCTION pi() { 22 / 7 };
    Test
    EXECUTE FUNCTION pi();
    Result
    [
      3.142857142857143
    ]

    The following statement redefines the function so that it returns a slightly better approximation of π.

    Replace
    CREATE OR REPLACE FUNCTION pi() { 355 / 113 };
    Test
    EXECUTE FUNCTION pi();
    Result
    [
      3.1415929203539825
    ]