@Override public Optional<Long> sizeIfKnown() { Optional<Long> optionalUnslicedSize = ByteSource.this.sizeIfKnown(); if (optionalUnslicedSize.isPresent()) { long unslicedSize = optionalUnslicedSize.get(); long off = Math.min(offset, unslicedSize); return Optional.of(Math.min(length, unslicedSize - off)); } return Optional.absent(); }
private static void changeColumnDefinitionPosition(final ColumnFirstPositionSegment columnFirstPositionSegment, final List<ColumnMetaData> columnMetaDataList) { Optional<ColumnMetaData> columnMetaData = find(columnFirstPositionSegment.getColumnName(), columnMetaDataList); if (columnMetaData.isPresent()) { columnMetaDataList.remove(columnMetaData.get()); columnMetaDataList.add(0, columnMetaData.get()); } }
/** * Parse order by. * * @param selectStatement select statement */ public final void parse(final SelectStatement selectStatement) { if (!lexerEngine.skipIfEqual(DefaultKeyword.ORDER)) { return; } List<OrderItem> result = new LinkedList<>(); lexerEngine.skipIfEqual(OracleKeyword.SIBLINGS); lexerEngine.accept(DefaultKeyword.BY); do { Optional<OrderItem> orderItem = parseSelectOrderByItem(selectStatement); if (orderItem.isPresent()) { result.add(orderItem.get()); } } while (lexerEngine.skipIfEqual(Symbol.COMMA)); selectStatement.getOrderByItems().addAll(result); }
private SelectItem getAggregationDistinctSelectItem(final SelectStatement selectStatement, final AggregationType aggregationType, final int beginPosition, final int endPosition, final String innerExpression) { Optional<String> alias = aliasExpressionParser.parseSelectItemAlias().isPresent() ? aliasExpressionParser.parseSelectItemAlias() : Optional.of(DerivedAlias.AGGREGATION_DISTINCT_DERIVED.getDerivedAlias(selectStatement.getAggregationDistinctSelectItems().size())); AggregationDistinctSelectItem result = new AggregationDistinctSelectItem( aggregationType, innerExpression, alias, getDistinctColumnName(innerExpression)); selectStatement.getSQLTokens().add(new AggregationDistinctToken(beginPosition, endPosition - 1, result.getDistinctColumnName(), alias)); return result; }
@Override public void fill(final TableSegment sqlSegment, final SQLStatement sqlStatement, final String sql, final ShardingRule shardingRule, final ShardingTableMetaData shardingTableMetaData) { boolean fill = false; String tableName = sqlSegment.getName(); if (shardingRule.contains(tableName) || shardingRule.isBroadcastTable(tableName) || shardingRule.findBindingTableRule(tableName).isPresent() || shardingRule.getShardingDataSourceNames().getDataSourceNames().contains(shardingRule.getShardingDataSourceNames().getDefaultDataSourceName())) { fill = true; } else { if (!(sqlStatement instanceof SelectStatement) && sqlStatement.getTables().isEmpty()) { fill = true; } } if (fill) { sqlStatement.getTables().add(new Table(sqlSegment.getName(), sqlSegment.getAlias())); sqlStatement.getSQLTokens().add(sqlSegment.getToken()); } } }
/** * Extract expression. * * @param placeholderIndexes place holder index * @param expressionNode expression node * @return expression segment */ public Optional<? extends ExpressionSegment> extract(final Map<ParserRuleContext, Integer> placeholderIndexes, final ParserRuleContext expressionNode) { Optional<ParserRuleContext> subqueryNode = ExtractorUtils.findFirstChildNode(expressionNode, RuleName.SUBQUERY); return subqueryNode.isPresent() ? new SubqueryExtractor().extract(subqueryNode.get()) : Optional.of(extractExpression(placeholderIndexes, expressionNode)); }
private static void changeColumnDefinitionPosition(final ColumnAfterPositionSegment columnAfterPositionSegment, final List<ColumnMetaData> columnMetaDataList) { Optional<ColumnMetaData> columnMetaData = find(columnAfterPositionSegment.getColumnName(), columnMetaDataList); Optional<ColumnMetaData> afterColumnMetaData = find(columnAfterPositionSegment.getAfterColumnName(), columnMetaDataList); if (columnMetaData.isPresent() && afterColumnMetaData.isPresent()) { columnMetaDataList.remove(columnMetaData.get()); columnMetaDataList.add(columnMetaDataList.indexOf(afterColumnMetaData.get()) + 1, columnMetaData.get()); } }
private Optional<OrConditionSegment> buildCondition(final ParserRuleContext node, final Map<ParserRuleContext, Integer> placeholderIndexes) { Optional<ParserRuleContext> exprNode = ExtractorUtils.findFirstChildNode(node, RuleName.EXPR); return exprNode.isPresent() ? predicateSegmentExtractor.extractCondition(placeholderIndexes, exprNode.get()) : Optional.<OrConditionSegment>absent(); } }
@Override public Optional<SubqueryConditionSegment> extract(final ParserRuleContext ancestorNode) { Collection<ParserRuleContext> suQueryNodes = ExtractorUtils.getAllDescendantNodes(ancestorNode, RuleName.SUBQUERY); SubqueryConditionSegment result = new SubqueryConditionSegment(); FromWhereExtractor fromWhereExtractor = new FromWhereExtractor(); for (ParserRuleContext each : suQueryNodes) { Optional<FromWhereSegment> condition = fromWhereExtractor.extract(each, ancestorNode); if (condition.isPresent()) { result.getOrConditions().add(condition.get().getConditions()); } } return Optional.of(result); } }
/** * Find actual default data source name. * * <p>If use master-slave rule, return master data source name.</p> * * @return actual default data source name */ public Optional<String> findActualDefaultDataSourceName() { String defaultDataSourceName = shardingDataSourceNames.getDefaultDataSourceName(); if (Strings.isNullOrEmpty(defaultDataSourceName)) { return Optional.absent(); } Optional<String> masterDefaultDataSourceName = findMasterDataSourceName(defaultDataSourceName); return masterDefaultDataSourceName.isPresent() ? masterDefaultDataSourceName : Optional.of(defaultDataSourceName); }