import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
public MongoRecordReader(
    MongoSubScan.MongoSubScanSpec subScanSpec,
    List<SchemaPath> projectedColumns,
    FragmentContext context,
    MongoStoragePlugin plugin) {

  fields = new BasicDBObject();
  // exclude _id field, if not mentioned by user.
  fields.put(DrillMongoConstants.ID, Integer.valueOf(0));
  setColumns(projectedColumns);
  fragmentContext = context;
  this.plugin = plugin;
  filters = new BasicDBObject();
  Map<String, List<BasicDBObject>> mergedFilters = MongoUtils.mergeFilters(
      subScanSpec.getMinFilters(), subScanSpec.getMaxFilters());
  buildFilters(subScanSpec.getFilter(), mergedFilters);
  enableAllTextMode = fragmentContext.getOptions().getOption(ExecConstants.MONGO_ALL_TEXT_MODE).bool_val;
  readNumbersAsDouble = fragmentContext.getOptions().getOption(ExecConstants.MONGO_READER_READ_NUMBERS_AS_DOUBLE).bool_val;
  init(subScanSpec);
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
private boolean fieldSelected(MaterializedField field) {
  // TODO - not sure if this is how we want to represent this
  // for now it makes the existing tests pass, simply selecting
  // all available data if no columns are provided
  if (isStarQuery()) {
    return true;
  }

  int i = 0;
  for (SchemaPath expr : getColumns()) {
    if ( field.matches(expr)) {
      columnsFound[i] = true;
      return true;
    }
    i++;
  }
  return false;
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
public ProjectPushInfo(List<SchemaPath> columns, ImmutableList<DesiredField> desiredFields) {
  super();
  this.columns = columns;
  this.desiredFields = desiredFields;

  this.fieldNames = Lists.newArrayListWithCapacity(desiredFields.size());
  this.types = Lists.newArrayListWithCapacity(desiredFields.size());
  IntIntOpenHashMap oldToNewIds = new IntIntOpenHashMap();

  int i =0;
  for (DesiredField f : desiredFields) {
    fieldNames.add(f.name);
    types.add(f.field.getType());
    oldToNewIds.put(f.origIndex, i);
    i++;
  }
  this.rewriter = new InputRewriter(oldToNewIds);
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
public static CompareFunctionsProcessor process(FunctionCall call, boolean nullComparatorSupported) {
  String functionName = call.getName();
  LogicalExpression nameArg = call.args.get(0);
  LogicalExpression valueArg = call.args.size() >= 2 ? call.args.get(1) : null;
  CompareFunctionsProcessor evaluator = new CompareFunctionsProcessor(functionName);

  if (valueArg != null) { // binary function
    if (VALUE_EXPRESSION_CLASSES.contains(nameArg.getClass())) {
      LogicalExpression swapArg = valueArg;
      valueArg = nameArg;
      nameArg = swapArg;
      evaluator.functionName = COMPARE_FUNCTIONS_TRANSPOSE_MAP.get(functionName);
    }
    evaluator.success = nameArg.accept(evaluator, valueArg);
  } else if (nullComparatorSupported && call.args.get(0) instanceof SchemaPath) {
    evaluator.success = true;
    evaluator.path = (SchemaPath) nameArg;
  }

  return evaluator;
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
public HiveTextRecordReader(Table table, Partition partition, InputSplit inputSplit, List<SchemaPath> projectedColumns, FragmentContext context) throws ExecutionSetupException {
  super(table, partition, inputSplit, projectedColumns, context, null);
  String d = table.getSd().getSerdeInfo().getParameters().get("field.delim");
  if (d != null) {
    delimiter = d.getBytes()[0];
  } else {
    delimiter = (byte) 1;
  }
  assert delimiter > 0;
  List<Integer> ids = Lists.newArrayList();
  for (int i = 0; i < tableColumns.size(); i++) {
    if (selectedColumnNames.contains(tableColumns.get(i))) {
      ids.add(i);
    }
  }
  columnIds = ids;
  numCols = tableColumns.size();
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
@Test
public void testNullableFilter() throws Exception {
  final List<QueryDataBatch> result = testSqlWithResults(
      "select count(wr_return_quantity) as row_count from dfs.`/tmp/web_returns` where wr_return_quantity = 1");
  assertEquals("Only expected one batch with data, and then the empty finishing batch.", 2, result.size());
  final RecordBatchLoader loader = new RecordBatchLoader(getDrillbitContext().getAllocator());

  final QueryDataBatch b = result.get(0);
  loader.load(b.getHeader().getDef(), b.getData());

  final VectorWrapper vw = loader.getValueAccessorById(
      BigIntVector.class,
      loader.getValueVectorId(SchemaPath.getCompoundPath("row_count")).getFieldIds()
  );
  assertEquals(3573l, vw.getValueVector().getAccessor().getObject(0));
  b.release();
  loader.clear();
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
private void initFieldWriters() throws IOException {
  fieldConverters = Lists.newArrayList();
  try {
    int fieldId = 0;
    for (VectorWrapper w : batch) {
      if (w.getField().getPath().equals(SchemaPath.getSimplePath(WriterPrel.PARTITION_COMPARATOR_FIELD))) {
        continue;
      }
      FieldReader reader = w.getValueVector().getReader();
      FieldConverter converter = getConverter(recordWriter, fieldId++, w.getField().getLastName(), reader);
      fieldConverters.add(converter);
    }
  } catch(Exception e) {
    logger.error("Failed to create FieldWriter.", e);
    throw new IOException("Failed to initialize FieldWriters.", e);
  }
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
public TestBuilder(BufferAllocator allocator, String query, UserBitShared.QueryType queryType, Boolean ordered,
                   boolean approximateEquality, Map<SchemaPath, TypeProtos.MajorType> baselineTypeMap,
                   String baselineOptionSettingQueries, String testOptionSettingQueries, boolean highPerformanceComparison,
                   int expectedNumBatches) {
  this(allocator);
  if (ordered == null) {
    throw new RuntimeException("Ordering not set, when using a baseline file or query you must explicitly call the ordered() or unOrdered() method on the " + this.getClass().getSimpleName());
  }
  this.query = query;
  this.queryType = queryType;
  this.ordered = ordered;
  this.approximateEquality = approximateEquality;
  this.baselineTypeMap = baselineTypeMap;
  this.baselineOptionSettingQueries = baselineOptionSettingQueries;
  this.testOptionSettingQueries = testOptionSettingQueries;
  this.highPerformanceComparison = highPerformanceComparison;
  this.expectedNumBatches = expectedNumBatches;
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
@Test
public void testMaterializingLateboundField(final @Injectable RecordBatch batch) throws SchemaChangeException {
  final SchemaBuilder builder = BatchSchema.newBuilder();
  builder.addField(getField(2, "test", bigIntType));
  final BatchSchema schema = builder.build();

  new NonStrictExpectations() {
    {
      batch.getValueVectorId(new SchemaPath("test", ExpressionPosition.UNKNOWN));
      result = new TypedFieldId(Types.required(MinorType.BIGINT), -5);
    }
  };

  ErrorCollector ec = new ErrorCollectorImpl();
  LogicalExpression expr = ExpressionTreeMaterializer.materialize(new FieldReference("test",
      ExpressionPosition.UNKNOWN), batch, ec, registry);
  assertEquals(bigIntType, expr.getMajorType());
  assertFalse(ec.hasErrors());
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
public MongoGroupScan(String userName, MongoStoragePlugin storagePlugin,
    MongoScanSpec scanSpec, List<SchemaPath> columns) throws IOException {
  super(userName);
  this.storagePlugin = storagePlugin;
  this.storagePluginConfig = storagePlugin.getConfig();
  this.scanSpec = scanSpec;
  this.columns = columns;
  this.storagePluginConfig.getConnection();
  init();
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
@VisibleForTesting
public DrillConfig(Config config, boolean enableServerConfigs) {
  super(config);
  logger.debug("Setting up DrillConfig object.");
  logger.trace("Given Config object is:\n{}",
               config.root().render(ConfigRenderOptions.defaults()));
  mapper = new ObjectMapper();

  if (enableServerConfigs) {
    SimpleModule deserModule = new SimpleModule("LogicalExpressionDeserializationModule")
      .addDeserializer(LogicalExpression.class, new LogicalExpression.De(this))
      .addDeserializer(SchemaPath.class, new SchemaPath.De());

    mapper.registerModule(deserModule);
    mapper.enable(SerializationFeature.INDENT_OUTPUT);
    mapper.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
    mapper.configure(JsonGenerator.Feature.QUOTE_FIELD_NAMES, true);
    mapper.configure(Feature.ALLOW_COMMENTS, true);
    mapper.registerSubtypes(LogicalOperatorBase.getSubTypes(this));
    mapper.registerSubtypes(StoragePluginConfigBase.getSubTypes(this));
    mapper.registerSubtypes(FormatPluginConfigBase.getSubTypes(this));
  }

  RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
  this.startupArguments = ImmutableList.copyOf(bean.getInputArguments());
  logger.debug("DrillConfig object initialized.");
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
@Override
public Integer getIdIfValid(String name) {
  SchemaPath schemaPath = SchemaPath.getSimplePath(name);
  int id = partitionColumns.indexOf(schemaPath);
  if (id == -1) {
    return null;
  }
  return id;
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
@Test
  public void twoKeyAgg(@Injectable final DrillbitContext bitContext, @Injectable UserClientConnection connection) throws Throwable {
    SimpleRootExec exec = doTest(bitContext, connection, "/agg/twokey.json");

    while(exec.next()) {
      final IntVector key1 = exec.getValueVectorById(SchemaPath.getSimplePath("key1"), IntVector.class);
      final BigIntVector key2 = exec.getValueVectorById(SchemaPath.getSimplePath("key2"), BigIntVector.class);
      final BigIntVector cnt = exec.getValueVectorById(SchemaPath.getSimplePath("cnt"), BigIntVector.class);
      final NullableBigIntVector total = exec.getValueVectorById(SchemaPath.getSimplePath("total"), NullableBigIntVector.class);
      final Integer[] keyArr1 = {Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE};
      final long[] keyArr2 = {0,1,2,0,1,2};
      final long[] cntArr = {34,34,34,34,34,34};
      final long[] totalArr = {0,34,68,0,34,68};

      for(int i = 0; i < exec.getRecordCount(); i++) {
//        System.out.print(key1.getAccessor().getObject(i));
//        System.out.print("\t");
//        System.out.print(key2.getAccessor().getObject(i));
//        System.out.print("\t");
//        System.out.print(cnt.getAccessor().getObject(i));
//        System.out.print("\t");
//        System.out.print(total.getAccessor().getObject(i));
//        System.out.println();
        assertEquals((Long) cntArr[i], cnt.getAccessor().getObject(i));
        assertEquals(keyArr1[i], key1.getAccessor().getObject(i));
        assertEquals((Long) keyArr2[i], key2.getAccessor().getObject(i));
        assertEquals((Long) totalArr[i], total.getAccessor().getObject(i));
      }
    }

    if(exec.getContext().getFailureCause() != null){
      throw exec.getContext().getFailureCause();
    }
    assertTrue(!exec.getContext().isFailed());

  }
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
@Override
public Set<SchemaPath> visitUnknown(LogicalExpression e, Void value) {
  Set<SchemaPath> paths = Sets.newHashSet();
  for (LogicalExpression ex : e) {
    paths.addAll(ex.accept(this, null));
  }
  return paths;
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
@Override
public boolean isStarQuery() {
  if(settings.isUseRepeatedVarChar()) {
    return super.isStarQuery() || Iterables.tryFind(getColumns(), new Predicate<SchemaPath>() {
      @Override
      public boolean apply(@Nullable SchemaPath path) {
        return path.equals(RepeatedVarCharOutput.COLUMNS);
      }
    }).isPresent();
  }
  return super.isStarQuery();
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
@Override
public PhysicalOperator getPhysicalOperator(PhysicalPlanCreator creator) throws IOException {
  Prel child = (Prel) this.getInput();

  PhysicalOperator childPOP = child.getPhysicalOperator(creator);
  FlattenPOP f = new FlattenPOP(childPOP, (SchemaPath) getFlattenExpression(new DrillParseContext(PrelUtil.getSettings(getCluster()))));
  return creator.addMetadata(this, f);
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
public boolean isStarQuery() {
  for (SchemaPath column : columns) {
    if (column.getRootSegment().getPath().startsWith("*")) {
      return true;
    }
  }
  return false;
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
@Test
public void testSchemaExpression(final @Injectable RecordBatch batch) throws Exception {
  final TypedFieldId tfid = new TypedFieldId(Types.optional(MinorType.BIGINT), false, 0);

  new Expectations() {
    {
      batch.getValueVectorId(new SchemaPath("alpha", ExpressionPosition.UNKNOWN));
      result = tfid;
      // batch.getValueVectorById(tfid); result = new Fixed4(null, null);
    }

  };
  System.out.println(getExpressionCode("1 + alpha", batch));

}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
@Test
public void testMaterializingLateboundTree(final @Injectable RecordBatch batch) throws SchemaChangeException {
  new NonStrictExpectations() {
    {
      batch.getValueVectorId(SchemaPath.getSimplePath("test"));
      result = new TypedFieldId(Types.required(MinorType.BIT), -4);
      batch.getValueVectorId(SchemaPath.getSimplePath("test1"));
      result = new TypedFieldId(Types.required(MinorType.BIGINT), -5);
    }
  };

  ErrorCollector ec = new ErrorCollectorImpl();


  LogicalExpression elseExpression = new IfExpression.Builder().setElse(new ValueExpressions.LongExpression(1L, ExpressionPosition.UNKNOWN))
      .setIfCondition(new IfExpression.IfCondition(new ValueExpressions.BooleanExpression("true", ExpressionPosition.UNKNOWN),
          new FieldReference("test1", ExpressionPosition.UNKNOWN)))
      .build();

  LogicalExpression expr = new IfExpression.Builder()
      .setIfCondition(new IfExpression.IfCondition(new FieldReference("test", ExpressionPosition.UNKNOWN), new ValueExpressions.LongExpression(2L, ExpressionPosition.UNKNOWN)))
      .setElse(elseExpression).build();

  LogicalExpression newExpr = ExpressionTreeMaterializer.materialize(expr, batch, ec, registry);
  assertTrue(newExpr instanceof IfExpression);
  IfExpression newIfExpr = (IfExpression) newExpr;
  //assertEquals(1, newIfExpr.conditions.size());
  IfExpression.IfCondition ifCondition = newIfExpr.ifCondition;
  assertTrue(newIfExpr.elseExpression instanceof IfExpression);
  //assertEquals(1, newIfExpr.conditions.size());
  //ifCondition = newIfExpr.conditions.get(0);
  assertEquals(bigIntType, ifCondition.expression.getMajorType());
  assertEquals(true, ((ValueExpressions.BooleanExpression) ((IfExpression)(newIfExpr.elseExpression)).ifCondition.condition).value);
  if (ec.hasErrors()) {
    System.out.println(ec.toErrorString());
  }
  assertFalse(ec.hasErrors());
}
 

import org.apache.drill.common.expression.SchemaPath; //导入依赖的package包/类
@Override
public ExprNode visitSchemaPath(SchemaPath path, Void value) throws RuntimeException {
  String field = path.getAsUnescapedPath().toUpperCase();
  if (field.equals(SCHS_COL_SCHEMA_NAME)
      || field.equals(SHRD_COL_TABLE_NAME)
      || field.equals(SHRD_COL_TABLE_SCHEMA)) {
    return new FieldExprNode(field);
  }

  return visitUnknown(path, value);
}