Creates a field containing a Pangool Tuple.

@param name   Field's name
@param schema The schema of the field
@return the field
@deprecated Use {@link Field#createTupleField(String, Schema)} instead}
974882
public static Field createTupleField(String name, Schema schema) {
    return Field.createTupleField(name, schema);
  }
772591
private void createSchemaOnDb() {
        StringBuilder sql = new StringBuilder();
        sql.append(topology.getSqlgGraph().getSqlDialect().createSchemaStatement(this.name));
        if (this.sqlgGraph.getSqlDialect().needsSemicolon()) {
            sql.append(";");
        }
        if (logger.isDebugEnabled()) {
            logger.debug(sql.toString());
        }
        Connection conn = this.sqlgGraph.tx().getConnection();
        try (Statement stmt = conn.createStatement()) {
            stmt.execute(sql.toString());
        } catch (SQLException e) {
            logger.error("schema creation failed " + this.sqlgGraph.toString(), e);
            throw new RuntimeException(e);
        }
    }
890836
public function clone_with_new_schema(NamedSchema $schema)
    {
        $name = $schema->fullname();
        if (Schema::is_valid_type($name)) {
            throw new SchemaParseException(
                sprintf('Name "%s" is a reserved type name', $name));
        } else if ($this->has_name($name)) {
            throw new SchemaParseException(
                sprintf('Name "%s" is already in use', $name));
        }
        $schemata = new NamedSchemata($this->schemata);
        $schemata->schemata[$name] = $schema;
        return $schemata;
    }
848123
public static Builder newBuilder(String name, LegacySQLTypeName type, Field... subFields) {
    return new Builder().setName(name).setType(type, subFields);
  }
395488
public static <T> Schema<T> createFrom(MappedSchema<T> ms, 
            Instantiator<T> instantiator, 
            Factory vf, 
            Predicate.Factory pf, 
            String ... args)
    {
        return vf.create(ms.typeClass, ms.fields, ms.fieldsByNumber, 
                ms.fieldsByName, instantiator, pf, args);
    }
656455
public FieldTemplate getFieldTemplate(final String name) {
        for ( int idx = 0; idx < this.fields.length; idx++ ) {
            if ( this.fields[idx].getName().equals( name ) ) {
                return this.fields[idx];
            }
        }
        return null;
    }
880458
public Schema mapper(String field, Mapper mapper) {
        if (mappers == null) {
            mappers = new LinkedHashMap<>();
        }
        mappers.put(field, mapper);
        return this;
    }
365546
public static <T> Schema<T> createFrom(RuntimeSchema<T> ms,
            Instantiator<T> instantiator,
            Factory vf,
            Predicate.Factory pf,
            String... args)
    {
        return vf.create(ms, instantiator, pf, args);
    }
789936
public void addTupleInput(Path path, Schema targetSchema, TupleMapper<ITuple, NullWritable> tupleMapper) {
		addInput(path, new TupleInputFormat(targetSchema), tupleMapper);
	}
757688
public static <F extends PField> MappedField<F> withColumn(String name, F field) {
        return new MappedField<>(name, field);
    }
1199737
public function addSchema(string $name, Schema $schema): self
    {
        $this->schemas[$name] = $schema;

        return $this;
    }
554811
public FieldNode getField(String name) {
        ClassNode node = this;
        while (node != null) {
            FieldNode fn = node.getDeclaredField(name);
            if (fn != null) return fn;
            node = node.getSuperClass();
        }
        return null;
    }
1149374
public void declareRequestedFieldname(String name) {
        if (name.endsWith(".*")) {
            stringSetValues.put(name, new HashMap<>());
            stringSetPrefixes.put(name.substring(0, name.length() - 1), name);
        }
    }
105651
@Override
	public Tuple createTuple(EntityKeyMetadata entityKeyMetadata, OperationContext operationContext) {
		Tuple tuple = null;
		CreateTuple createTuple = new CreateTupleImpl( entityKeyMetadata );

		try {
			tuple = super.createTuple( entityKeyMetadata, operationContext );
		}
		catch (Exception e) {
			handleException( createTuple, e );
		}

		handleAppliedOperation( createTuple );
		return tuple;
	}
107688
public static Schema superSetOf(Schema schema, Field... newFields) {
		return superSetOf("superSetSchema" + (COUNTER++), schema, newFields);
	}
815210
private JMFType findTupleChildByName(JSTuple tup, String name) {
    for (int i = 0; i < tup.getFieldCount(); i++) {
      JMFType theField = getEffectiveType(tup.getField(i));
      String fieldName = theField.getFeatureName();
      if (fieldName != null && fieldName.equals(name))
        return theField;
    }
    return null;
  }
204762
public void ensureNamespace(String schema)
    {
        try {
            // If the table schema is not "default" and the namespace does not exist, create it
            if (!schema.equals(DEFAULT) && !connector.namespaceOperations().exists(schema)) {
                connector.namespaceOperations().create(schema);
            }
        }
        catch (AccumuloException | AccumuloSecurityException e) {
            throw new PrestoException(UNEXPECTED_ACCUMULO_ERROR, "Failed to check for existence or create Accumulo namespace", e);
        }
        catch (NamespaceExistsException e) {
            // Suppress race condition between test for existence and creation
            LOG.warn("NamespaceExistsException suppressed when creating " + schema);
        }
    }