public bool Run(CommonScriptCursor cursor)
        {
            int index = -1;

            if (_single)
            {
                index = cursor.Value.IndexOf(_char, cursor.Index);
            }
            else
            {
                for (int i = cursor.Index; i < cursor.Length; i++)
                {
                    if (_chars.IndexOf(cursor.Value[i]) == -1)
                    {
                        continue;
                    }

                    index = i;
                    break;
                }
            }

            if (index == -1)
            {
                return(false);
            }

            cursor.Index = index;
            return(true);
        }
Esempio n. 2
0
        public bool Run(CommonScriptCursor cursor)
        {
            int index = cursor.Index - 1;

            while ((index = cursor.Value.IndexOf(_quote, index + 1)) >= 0)
            {
                if (_backslashEscape && index > cursor.Index && cursor.Value[index - 1] == '\\')
                {
                    continue;
                }

                if (index + 1 < cursor.Value.Length && cursor.Value[index + 1] == _quote)
                {
                    index++;
                    continue;
                }

                break;
            }

            if (index == -1)
            {
                return(false);
            }

            cursor.Index = index;
            return(true);
        }
Esempio n. 3
0
        public bool Run(CommonScriptCursor cursor)
        {
            int count      = cursor.Length - cursor.Index;
            int breakIndex = -1;

            foreach (var breakChar in _breakChars)
            {
                int index = cursor.Value.IndexOf(breakChar, cursor.Index, count);

                if (index == -1)
                {
                    continue;
                }

                breakIndex = index;
                count      = breakIndex - cursor.Index + 1;
            }

            if (breakIndex == -1)
            {
                cursor.Index = cursor.Length - 1;
            }
            else
            {
                cursor.Index = breakIndex - 1;
            }

            return(true);
        }
Esempio n. 4
0
        protected override QsiScriptType GetSuitableType(CommonScriptCursor cursor, IReadOnlyList <Token> tokens, Token[] leadingTokens)
        {
            if (leadingTokens.Length >= 1 && cursor.Value[leadingTokens[0].Span].EqualsIgnoreCase("VALUES"))
            {
                return(QsiScriptType.Select);
            }

            return(base.GetSuitableType(cursor, tokens, leadingTokens));
        }
Esempio n. 5
0
        public bool Run(CommonScriptCursor cursor)
        {
            int index = cursor.Value.IndexOf(_keyword, cursor.Index, StringComparison.Ordinal);

            if (index == -1)
            {
                return(false);
            }

            cursor.Index = index + _keyword.Length - 1;
            return(true);
        }
        public bool Run(CommonScriptCursor cursor)
        {
            var match = _regex.Match(cursor.Value, cursor.Index);

            if (!match.Success)
            {
                return(false);
            }

            cursor.Index = match.Index + match.Length - 1;
            return(true);
        }
Esempio n. 7
0
        public bool Run(CommonScriptCursor cursor)
        {
            for (int i = cursor.Index; i < cursor.Length; i++)
            {
                if (char.IsWhiteSpace(cursor.Value[i]))
                {
                    continue;
                }

                cursor.Index = i - 1;
                return(true);
            }

            cursor.Index = cursor.Length - 1;
            return(true);
        }
Esempio n. 8
0
        protected override QsiScriptType GetSuitableType(CommonScriptCursor cursor, IReadOnlyList <Token> tokens, Token[] leadingTokens)
        {
            if (leadingTokens.Length >= 1)
            {
                if (Exec.EqualsIgnoreCase(cursor.Value[leadingTokens[0].Span]))
                {
                    return(QsiScriptType.Execute);
                }

                if (Merge.EqualsIgnoreCase(cursor.Value[leadingTokens[0].Span]))
                {
                    return(QsiScriptType.MergeInto);
                }
            }

            return(base.GetSuitableType(cursor, tokens, leadingTokens));
        }
        public bool Run(CommonScriptCursor cursor)
        {
            for (int i = cursor.Index; i < cursor.Length; i++)
            {
                var c = cursor.Value[i];

                if ('A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' || c == '_')
                {
                    continue;
                }

                cursor.Index = i - 1;
                return(true);
            }

            cursor.Index = cursor.Length - 1;
            return(true);
        }
Esempio n. 10
0
        protected override bool TryParseToken(CommonScriptCursor cursor, out Token token)
        {
            if (!base.TryParseToken(cursor, out token))
            {
                return(false);
            }

            if (token.Type is TokenType.MultiLineComment or TokenType.SingeLineComment)
            {
                var(offset, length) = token.Span.GetOffsetAndLength(cursor.Length);
                ReadOnlySpan <char> span = cursor.Value.AsSpan(offset, length);

                if (ImpalaUtility.IsCommentPlanHint(span))
                {
                    token = new Token(TokenType.Fragment, token.Span);
                }
            }

            return(true);
        }