// This is an example of using some search options with a multi-query using both a Simple and Predicate query.
             // This requires first configuring a Simple query using the query string along with the fields to be searched 
             // followed by configuring a Predicate query and then either "And" or "Or" them together.  
             //
             // In this we will query the "names" table using a query string against the "last" field and then configuring
             // the Predicate query to look for the year 2001 in the DOB field which is a date field.  If the DOB field contains
             // an invalid date we will assign a score of .2 by using the setInvalidScore method. Each of these queries are referred
             // to as a querylet.  We will apply a higher weight to the "last" field querylet.
             
             using System;
             using NetricsServerInterface;
             class MyClass
             {
                 private static NetricsServerInterface.NetricsServerInterface si = null;
                 public static void Main()
                 {
                     try
                     {
                         String host = "localhost";
                         int port = 5051;
                         si = new NetricsServerInterface.NetricsServerInterface(host, port);
                         // Table is the TIBCO Patterns Engine table to be search/matched against query
                         String table = "names";
                         // Going to use 2 NetricsQuery for the search configuration
                         NetricsQuery[] nqs = new NetricsQuery[2];
                         // Create NetricsSearchOpts object and then set some options
                         NetricsSearchOpts opts = new NetricsSearchOpts();
                         // Set the search to SYMMETRIC scoring mode
                         opts.scoreType((int)NetricsSearchOpts.score_types.SCORE_SYMMETRIC);
                         // Set cutoff to exact matches plus the next 3 highest similarity score
                         opts.useExactPlusScoreCutoff(3);
                         // Create the NetricsSearchCfg pointing to the table to be searched/matched against
                         NetricsSearchCfg tblCfg = new NetricsSearchCfg(table);
                         // Query will contain the query string for the first querylet which is "last
                         String query = "brown";
                         // FieldNames contain the fields within the table to be searhed/matched against.
                         // If fieldNames is set to null then all fields will be searched/matched against
                         String[] fieldNames = { "last" };
                         // Create a Simple query for the "last" names search
                         nqs[0] = NetricsQuery.Simple(query, fieldNames, null);
                         // Set up the second query of type Predicate
                         nqs[1] = NetricsQuery.Predicate("\"2001\" IN $\"DOB\"");
                         // Set the invalid score to .2 if the DOB field contains an invalid date
                         nqs[1].setInvalidScore(.2);
                         // QueryletWeights is an array that must be the same length as the number of querylets
                         // and is the weight applied to each querylet in the search which impacts the similarity
                         // scrore.  In this case there will be two querylets that will be ANDed together to create
                         // a single search configuration
                         double[] queryletWeights = { 1.0, .5 };
                         // Now AND the two Simple querys together to create the final NetricsQuery for the search
                         NetricsQuery nqAnded = NetricsQuery.And(queryletWeights, nqs);
                         // Set the NetricsSearchCfg;
                         tblCfg.setNetricsQuery(nqAnded);
                         // Perform the search/match using the NetricsSearchCfg and NetricsSearchOpts
                         NetricsSearchResponse resp = si.search(tblCfg, opts);
                         String s = "";
                         // Get the results of the search/match
                         NetricsSearchResult[] res = resp.getSearchResults();
                         // Create viables for result processing
                         String[] xfieldNames;
                         String[] xfields;
                         // Iterate through the result records
                         for (int i = 0; i < res.Length; i++)
                         {
                             // Get the fieldNames in the result record
                             xfieldNames = res[i].getFieldNames();
                             // Get the data for each fieldName in result record
                             xfields = res[i].getFields();
                             // Get the score for this result record
                             double score = res[i].getMatchScore();
                             // Build the printline for the result record
                             s = s + "Rank=" + i + ", Score=" + score.ToString();
                             for (int x = 0; x < xfields.Length; x++)
                             {
                                 s = s + ", " + xfieldNames[x] + "=" + xfields[x];
                             }
                             s = s + "\n";
                         }
                         Console.WriteLine(s);
                     }
                     catch (NetricsException e)
                     {
                         Console.Write(e.getErrorDescription() + "\n");
                     }
                 }
             }