// This is an example of a AND query where different query strings can be used in a search across
            // different fields within a table.  This requires first configuring a Simple query for each query
            // string along with the fields to be searched 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 a another query
            // string against the "first" field.  Each of these queries are referred to as a querylet.  We will
            // apply a higher weight to the "last" field querylet and apply a the "nicknames" thesuaurs to the
            // "first" field querylet treating the related terms within the thesaurus as equivalent. We will also
            // set the empty score on the "first" field querylet to .2 meaning that if the "first" field of the
            // names table is is empty then use a score of .2 rather than 0.0 for this 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 using the defaults
                        NetricsSearchOpts opts = new NetricsSearchOpts();
                        // 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 Simple query
                        query = "den";
                        fieldNames[0] = "first";
                        nqs[1] = NetricsQuery.Simple(query, fieldNames, null);
                        // Use the nicknames thesaurus for this querylet associated with "first" field search
                        // and with the weight of 1.0 to treat related terms or synonyms the same.
                        // i.e. "Den" is equivalent to "Dennis"
                        nqs[1].useThesaurus("nicknames", 1.0);
                        // Set the empty score on the "first" field querylet to .2 meaning if the "first" field
                        // is empty then use a score of .2 rather thsan 0.0.
                        nqs[1].setEmptyScore(.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");
                    }
               }
            }