DocumentDB SQL – Funciones definidas por el usuario

DocumentDB SQL proporciona soporte para funciones definidas por el usuario (UDF). Las UDF son solo otro tipo de función de JavaScript que puede escribir y funcionan aproximadamente como espera. Puede crear funciones personalizadas para ampliar el lenguaje de consulta con lógica empresarial personalizada a la que puede hacer referencia en sus consultas.

La sintaxis SQL de DocumentDB se ha ampliado para admitir la lógica de aplicación personalizada utilizando estas UDF. Las UDF se pueden registrar con DocumentDB y luego hacer referencia a ellas como parte de una consulta SQL.

Considere los siguientes tres documentos para este ejemplo.

AndersenFamilia el documento tiene este aspecto.

{ 
   "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 
}

SmithFamily el documento tiene este aspecto.

{ 
   "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 
} 

WakefieldFamilia el documento tiene este aspecto.

{ 
   "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 
} 

Echemos un vistazo a un ejemplo en el que creamos algunas UDF simples.

A continuación se muestra la implementación CreateUserDefinedFunctions

private async static Task CreateUserDefinedFunctions(DocumentClient client) { 
   Console.WriteLine(); 
   Console.WriteLine("**** Create User Defined Functions ****"); 
   Console.WriteLine();  
	
   await CreateUserDefinedFunction(client, "udfRegEx");  
}

Tenemos un udfRegEx y en CreateUserDefinedFunction obtenemos su código JavaScript de nuestro archivo local. Creamos un objeto de definición para una nueva UDF y llamamos a CreateUserDefinedFunctionAsync con el objeto SelfLink y udfDefinition de la colección como se muestra en el siguiente código.

private async static Task<UserDefinedFunction>
CreateUserDefinedFunction(DocumentClient client, string udfId) { 
   var udfBody = File.ReadAllText(@"....Server" + udfId + ".js"); 
	
   var udfDefinition = new UserDefinedFunction { 
      Id = udfId, 
      Body = udfBody 
   }; 
   
   var result = await client
    .CreateUserDefinedFunctionAsync(_collection.SelfLink, udfDefinition); 
   var udf = result.Resource; 
	
   Console.WriteLine("Created user defined function {0}; RID: {1}", 
      udf.Id, udf.ResourceId);  
		
   return udf; 
}

Devolvemos la nueva UDF de la propiedad del recurso de resultado y se la devolvemos al llamador. Para mostrar una UDF existente, siga estos pasos. ViewUserDefinedFunctions… Llamamos CreateUserDefinedFunctionQuery y omítalas como de costumbre.

private static void ViewUserDefinedFunctions(DocumentClient client) { 
   Console.WriteLine(); 
   Console.WriteLine("**** View UDFs ****"); 
   Console.WriteLine(); 
	
   var udfs = client  
    .CreateUserDefinedFunctionQuery(_collection.UserDefinedFunctionsLink) 
    .ToList();  
		
   foreach (var udf in udfs) { 
      Console.WriteLine("User defined function {0}; RID: {1}", udf.Id, udf.ResourceId); 
   }
}

DocumentDB SQL no proporciona ninguna funcionalidad incorporada para encontrar subcadenas o expresiones regulares, por lo que la siguiente pequeña línea completa ese espacio, que es una función de JavaScript.

function udfRegEx(input, regex) { 
   return input.match(regex); 
}

Dada la cadena de entrada en el primer parámetro, use el soporte de expresiones regulares incorporado de JavaScript pasando la cadena de coincidencia de patrones en el segundo parámetro a.partido… Podemos ejecutar una consulta de subcadena para encontrar todas las tiendas que tienen la palabra Andersen. apellido propiedad.

private static void Execute_udfRegEx(DocumentClient client) { 
   var sql = "SELECT c.name FROM c WHERE udf.udfRegEx(c.lastName, 'Andersen') != null";
	
   Console.WriteLine(); 
   Console.WriteLine("Querying for Andersen"); 
	
   var documents = client.CreateDocumentQuery(_collection.SelfLink, sql).ToList();  
   Console.WriteLine("Found {0} Andersen:", documents.Count); 
	
   foreach (var document in documents) { 
      Console.WriteLine("Id: {0}, Name: {1}", document.id, document.lastName); 
   } 
}

Tenga en cuenta que tenemos que calificar cada enlace UDF con el prefijo udf… Acabamos de pasar el SQL CreateDocumentQuery como cualquier solicitud normal. Finalmente, llamemos a las consultas anteriores desde CreateDocumentClient una tarea

private static async Task CreateDocumentClient() { 
   // Create a new instance of the DocumentClient 
	
   using (var client = new DocumentClient(new Uri(EndpointUrl), AuthorizationKey)){ 
      database = client.CreateDatabaseQuery("SELECT * FROM c WHERE 
         c.id = 'myfirstdb'").AsEnumerable().First();
      collection = client.CreateDocumentCollectionQuery(database.CollectionsLink, 
         "SELECT * FROM c WHERE c.id = 'Families'").AsEnumerable().First();
			 
      await CreateUserDefinedFunctions(client);
   
      ViewUserDefinedFunctions(client);
   
      Execute_udfRegEx(client); 
   } 
}

Cuando se ejecuta el código anterior, da el siguiente resultado.

**** Create User Defined Functions ****  
Created user defined function udfRegEx; RID: kV5oANVXnwAlAAAAAAAAYA==  
**** View UDFs ****  
User defined function udfRegEx; RID: kV5oANVXnwAlAAAAAAAAYA==  
Querying for Andersen 
Found 1 Andersen: 
 Id: AndersenFamily, Name: Andersen

🚫