public override void Visit(TermNode node) {
            // using a field not in the free list
            if (node.Field != null && !_freeFields.Contains(node.Field.Field))
                UsesPremiumFeatures = true;

            // using all fields search
            if (node.Field == null || String.IsNullOrEmpty(node.Field.Field))
                UsesPremiumFeatures = true;

            if (node.Field != null && node.Field.Field.StartsWith("data.")) {
                string term = node.Term ?? node.TermMin ?? node.TermMax;
                string termType = "s";
                bool boolResult;
                DateTime dateResult;
                if (Boolean.TryParse(term, out boolResult))
                    termType = "b";
                else if (term.IsNumeric())
                    termType = "n";
                else if (DateTime.TryParse(term, out dateResult))
                    termType = "d";

                UsesDataFields = true;
                node.Field.Field = "idx." + node.Field.Field.ToLower().Substring(5) + "-" + termType;
            }

            base.Visit(node);
        }
        public TermNode CopyTo(TermNode target) {
            if (Field != null)
                target.Field = Field;

            if (TermMin != null)
                target.TermMin = TermMin;

            if (TermMax != null)
                target.TermMax = TermMax;

            if (MinInclusive.HasValue)
                target.MinInclusive = MinInclusive;

            if (MaxInclusive.HasValue)
                target.MaxInclusive = MaxInclusive;

            if (Term != null)
                target.Term = Term;

            target.IsQuotedTerm = IsQuotedTerm;

            if (Boost.HasValue)
                target.Boost = Boost;

            if (Prefix != null)
                target.Prefix = Prefix;

            if (Proximity.HasValue)
                target.Proximity = Proximity;

            return target;
        }
        public override void Visit(TermNode node) {
            _builder.Append(node.Prefix);

            if (node.Field != null)
                node.Field.Accept(this, false);

            if (node.MinInclusive.HasValue)
                _builder.Append(node.MinInclusive.Value ? "[" : "{");

            _builder.Append(node.TermMin);

            if (!String.IsNullOrEmpty(node.TermMin) && !String.IsNullOrEmpty(node.TermMax))
                _builder.Append(node.TermDelimiter ?? " TO ");

            _builder.Append(node.TermMax);

            if (node.MaxInclusive.HasValue)
                _builder.Append(node.MaxInclusive.Value ? "]" : "}");

            _builder.Append(node.IsQuotedTerm ? "\"" + node.Term + "\"" : node.Term);

            if (node.Boost.HasValue)
                _builder.Append("^" + node.Boost);

            if (node.Proximity.HasValue)
                _builder.Append("~" + (node.Proximity.Value != Double.MinValue ? node.Proximity.ToString() : String.Empty));
        }
        public TermNode CopyTo(TermNode target)
        {
            if (Field != null)
            {
                target.Field = Field;
            }

            if (TermMin != null)
            {
                target.TermMin = TermMin;
            }

            if (TermMax != null)
            {
                target.TermMax = TermMax;
            }

            if (MinInclusive.HasValue)
            {
                target.MinInclusive = MinInclusive;
            }

            if (MaxInclusive.HasValue)
            {
                target.MaxInclusive = MaxInclusive;
            }

            if (Term != null)
            {
                target.Term = Term;
            }

            target.IsQuotedTerm = IsQuotedTerm;

            if (Boost.HasValue)
            {
                target.Boost = Boost;
            }

            if (Prefix != null)
            {
                target.Prefix = Prefix;
            }

            if (Proximity.HasValue)
            {
                target.Proximity = Proximity;
            }

            return(target);
        }
        public override void Visit(TermNode node) {
            _writer.WriteLine("Term: ");
            _writer.Indent++;
            _writer.WriteLineIf(node.Prefix != null, "Prefix: {0}", node.Prefix);
            _writer.WriteLineIf(node.Term != null, "Term: {0}", node.Term);
            _writer.WriteLineIf(node.TermMax != null, "TermMax: {0}", node.TermMax);
            _writer.WriteLineIf(node.TermMin != null, "TermMin: {0}", node.TermMin);
            _writer.WriteLineIf(node.Boost.HasValue, "Boost: {0}", node.Boost);
            _writer.WriteLineIf(node.MinInclusive.HasValue, "MinInclusive: {0}", node.MinInclusive);
            _writer.WriteLineIf(node.MaxInclusive.HasValue, "MaxInclusive: {0}", node.MaxInclusive);
            _writer.WriteLineIf(node.Proximity.HasValue, "Proximity: {0}", node.Proximity);
            
            if (node.Field != null)
                node.Field.Accept(this, false);

            _writer.Indent--;
        }
        public override void Visit(TermNode node) {
            // using all fields search
            if (String.IsNullOrEmpty(node.Field?.Field))
                UsesPremiumFeatures = true;

            if (node.Field != null) {
                // using a field not in the free list
                if (!_freeFields.Contains(node.Field.Field))
                    UsesPremiumFeatures = true;

                if (node.Field.Field.StartsWith("data.")) {
                    UsesDataFields = true;
                    string termType = GetTermType(node.TermMin, node.TermMax, node.Term);
                    node.Field.Field = "idx." + node.Field.Field.ToLower().Substring(5) + "-" + termType;
                }
            }

            base.Visit(node);
        }
 public virtual void Visit(TermNode node) {}
        public void Visit(TermNode node)
        {
            // using all fields search
            if (String.IsNullOrEmpty(node.Field)) {
                UsesPremiumFeatures = true;
                return;
            }

            node.Field = GetCustomFieldName(node.Field, node.Term) ?? node.Field;
        }