protected virtual QueryNode VisitMatches(MatchesNode node, AzureQueryOptimizerState state)
        {
            QueryNode regexOptions = (QueryNode)null;
            QueryNode leftNode     = this.Visit(node.LeftNode, state);
            QueryNode rightNode    = this.Visit(node.RightNode, state);

            if (node.RegexOptions != null)
            {
                regexOptions = this.Visit(node.RegexOptions, state);
            }
            return((QueryNode) new MatchesNode(leftNode, rightNode, regexOptions, state.Boost));
        }
        protected QueryBase VisitMatches(MatchesNode node, ElasticQueryMapperState state)
        {
            // TODO: Move these 3 lines to separate method for reuse?
            var fieldName = GetFormattedFieldName(node);
            var valueNode = node.GetValueNode <string>();
            var value     = ValueFormatter.FormatValueForIndexStorage(valueNode.Value, fieldName);

            // TODO: RegexOptions - does Elastic support this?
            return(new RegexpQuery
            {
                Field = fieldName,
                Value = value.ToStringOrEmpty(),
                Boost = node.Boost
            });
        }
        /// <summary>
        /// Regex query not currently supported in NEST, and there's no straightforward way to append raw query text to any parsed queries.
        /// </summary>
        /// <param name="node"></param>
        /// <param name="state"></param>
        /// <returns></returns>
        protected virtual BaseQuery HandleMatches(MatchesNode node, ElasticSearchQueryMapperState state)
        {
            //var fieldName = GetFormattedFieldName(node);
            //var valueNode = QueryHelper.GetValueNode<string>(node);
            //var formattedValue = ValueFormatter.FormatValueForIndexStorage(valueNode.Value);

            //using (var sw = new StringWriter())
            //{
            //	using (var jw = new JsonTextWriter(sw))
            //	{
            //		jw.WriteStartObject();
            //			jw.WritePropertyName("regexp");
            //			jw.WriteStartObject();
            //				jw.WritePropertyName(fieldName);
            //				jw.WriteStartObject();
            //					jw.WritePropertyName("value");
            //					jw.WriteValue(formattedValue);
            //					if (Math.Abs(node.Boost - 1f) > float.Epsilon)
            //					{
            //						jw.WritePropertyName("boost");
            //						jw.WriteValue(node.Boost);
            //					}
            //				jw.WriteEndObject();
            //				if (node.RegexOptions != null && !string.IsNullOrEmpty(node.RegexOptions.ToString()))
            //				{
            //					jw.WritePropertyName("flags");
            //					jw.WriteValue(node.RegexOptions);
            //				}
            //			jw.WriteEndObject();
            //		jw.WriteEndObject();
            //	}

            //	var rawQuery = sw.ToString();
            //	return rawQuery;
            //}

            //rawQuery = "{\"regexp\" : { \"" + fieldName + "\" : { \"value\" : \"" + formattedValue + "\", \"flags\" : \"" + node.RegexOptions + "\" } }";

            throw new NotImplementedException("Matches expression is not implemented (i.e. no regex queries)");
        }