Create a {@code this.substring(beginIndex)} expression

@param beginIndex inclusive start index
@return this.substring(beginIndex)
@see java.lang.String#substring(int)
511241
public StringExpression substring(Expression<Integer> beginIndex) {
        return Expressions.stringOperation(Ops.SUBSTR_1ARG, mixin, beginIndex);
    }
494806
public String remove(String expression) {
    if (expression == null || expression.length() == 0) { return null; }
    String property = next(expression);
    if (expression.length() == property.length()) { return null; }
    int start = property.length();
    if (expression.charAt(start) == Nested) start++;
    return expression.substring(start);
  }
25096
public String substring(int beginIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = size() - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? toString() : new String(buf, toInternalId(beginIndex), subLen);
    }
672458
public static String executeSubstring(String text, String parseExpression) {
        LOGGER.debug("substring抽取函数之前：" + text);
        String parameter = parseExpression.replace("substring(", "");
        parameter = parameter.substring(0, parameter.length() - 1);
        String[] attr = parameter.split(",");
        if (attr != null && attr.length == 2) {
            int beginIndex = Integer.parseInt(attr[0]);
            int endIndex = Integer.parseInt(attr[1]);
            text = text.substring(beginIndex, endIndex);
        }
        LOGGER.debug("substring抽取函数之后：" + text);
        return text;
    }
1236542
public Expression<String> between(String startValue, String endValue) {
		String valueString = "'" + startValue + "' AND '" + endValue + "'";
		return new Expression<String>(this, Operation.between, valueString);
	}
532000
private static List<String> splitExpression(String expression) {
        List<String> tokens = new ArrayList<String>();
        int lastStart = -1;
        boolean isQuoted = false;
        for (int i = 0; i < expression.length(); i++) {
            if ( lastStart == -1 ) {
                if ( !isQuoted && Character.isJavaIdentifierStart( expression.charAt(i) ) ) {
                    lastStart = i;
                }
            } else if ( !Character.isJavaIdentifierPart( expression.charAt(i) ) ) {
                tokens.add(expression.subSequence(lastStart, i).toString());
                lastStart = -1;
            }
            if (expression.charAt(i) == '"' || expression.charAt(i) == '\'') {
                if (i == 0 || expression.charAt(i-1) != '\\') {
                    isQuoted = !isQuoted;
                }
                if (isQuoted) {
                    lastStart = -1;
                }
            }
        }
        if (lastStart != -1) {
            tokens.add( expression.subSequence( lastStart, expression.length() ).toString() );
        }
        return tokens;
    }
1274136
public String between(int leftIndex, int rightIndex) {
		String result = this.target4Sub.substring(reviseL(leftIndex), reviseR(rightIndex));
		return isResetMode ? result : (this.target4Sub = result);
	}
996527
public static Expression position(String expression, String substring) {
        return position(x(expression), substring);
    }
212654
public String substring(int start, int end) {

    return new String(this.buffer, this.initialOffset + start, end - start);
  }
806641
public static Expression substr(Expression expression, int position, int length) {
        return x("SUBSTR(" + expression.toString() + ", " + position + ", " + length + ")");
    }
484066
public static String subst(final String from, final String to,
            final String string)
   {
      return subst(new StringBuffer(), from, to, string);
   }
693088
public SubString substring(int start) {
		JcNumber sub = new JcNumber(start, this, OPERATOR.Common.COMMA_SEPARATOR);
		SubString ret = new SubString(null, sub,
				new FunctionInstance(FUNCTION.String.SUBSTRING, 2));
		QueryRecorder.recordInvocationConditional(this, "substring", ret, QueryRecorder.literal(start));
		return ret;
	}
240824
public LinkedList<Map.Entry<String, V>> commonPrefixSearchWithValue(char[] chars, int begin)
    {
        LinkedList<Map.Entry<String, V>> result = new LinkedList<Map.Entry<String, V>>();
        StringBuilder sb = new StringBuilder();
        BaseNode branch = this;
        for (int i = begin; i < chars.length; ++i)
        {
            char aChar = chars[i];
            branch = branch.getChild(aChar);
            if (branch == null || branch.status == Status.UNDEFINED_0) return result;
            sb.append(aChar);
            if (branch.status == Status.WORD_MIDDLE_2 || branch.status == Status.WORD_END_3)
            {
                result.add(new AbstractMap.SimpleEntry<String, V>(sb.toString(), (V) branch.value));
            }
        }

        return result;
    }
1018693
SubString getParenSubString(int i)
    {
        if (parens != null && i < parens.length) {
            SubString parsub = parens[i];
            if (parsub != null) {
                return parsub;
            }
        }
        return new SubString();
    }
625329
public static <T> List<T> subList(List<T> input, int startIndex, int count) {
        int fromIndex = startIndex - 1;
        int toIndex = fromIndex + count;
        if (toIndex >= input.size()) {
            toIndex = input.size();
        }
        if (fromIndex >= toIndex) {
            return Collections.emptyList();
        }
        return input.subList(fromIndex, toIndex);
    }
779574
public int getParentExpressionIndex(int index) {
    if (index == 0) {
      return -1;
    } else {
      int[] parts = findSubexpression(index);
      int parentIndex = subexpressions.get(parts[0]).getParentExpressionIndex(parts[1]);
      
      if (parentIndex == -1) {
        // index refers to a child of this expression.
        return 0;
      } else {
        // Return the index into this expression of the chosen child,
        // plus the index into that expression.
        return parentIndex + parts[2]; 
      }
    }
  }
1076132
public static String insert(final String value, final String substr, final int index) {
        validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
        validate(substr, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
        if (index > value.length()) {
            return value;
        }
        return append(value.substring(0, index), substr, value.substring(index));
    }