Creates a {Schemas::Pipeline} schema.

 @param subschemas [Array<schema>] The schemas to be pipelined together,
   in order.
 @return [Schemas::Pipeline]

 @example (see Schemas::Pipeline)
554149
def pipeline(*subschemas)
      subschemas = subschemas.map { |ss| inconvenience(ss) }
      Schemas::Pipeline.new(subschemas)
    end
998292
function Schema(registry, definition, opt_depth) {
  this._allowUnknownProperties = false;
  this._registry = registry;

  this.id = undefined;
  this.type = TYPES.UNKNOWN;
  this.depth = opt_depth || registry.depth;

  // possible primitive values or array elements
  this.enum = undefined;
  this.ordered = false;

  // object property schemas
  this.properties = undefined;
  this.propertiesList = [];
  this.wildcard = undefined;

  // single schema for all array elements
  this.content = undefined;

  this.value = undefined;
  this.min = undefined;
  this.max = undefined;
  this.pattern = undefined;

  // schema value can be null
  this.allowNullValue = false;

  return this._configure(definition);
}
653031
def build_schema(**args)
      if Helper.collection?(object)
        build_collection_schema(args)
      else
        Surrealist.build_schema(instance: self, **args)
      end
    end
539420
function subHeader(schema, concat) {
      colspan = Object.keys(schema.tree).reduce(function(memo, key){
        return memo+addToHeader(key, path+concat+key, schema.tree[key], level+1)
      }, 0);
      if (typeof schema.options.strict === 'boolean' && !schema.options.strict) {
        colspan += 1;
        // add special column for mixed objects
        headers[level+1].push({name: name+concat+'*', colspan: 1, nested:false, path: name+concat+'*'})
      }
      nested = true;
      return colspan;
    }
1156908
def build_schema(
    source: Union[str, Source],
    assume_valid=False,
    assume_valid_sdl=False,
    no_location=False,
    experimental_fragment_variables=False,
) -> GraphQLSchema:
    """"""
    return build_ast_schema(
        parse(
            source,
            no_location=no_location,
            experimental_fragment_variables=experimental_fragment_variables,
        ),
        assume_valid=assume_valid,
        assume_valid_sdl=assume_valid_sdl,
    )
1275019
public void deploySchema(String generatedProtobufName, RemoteCache<String, String> protobufCache, SchemaCapture schemaCapture, SchemaOverride schemaOverrideService,
			URL schemaOverrideResource) {
		// user defined schema
		if ( schemaOverrideService != null || schemaOverrideResource != null ) {
			cachedSchema = new SchemaValidator( this, schemaOverrideService, schemaOverrideResource, generatedProtobufName ).provideSchema();
		}

		// or generate them
		generateProtoschema();

		try {
			protobufCache.put( generatedProtobufName, cachedSchema );
			String errors = protobufCache.get( generatedProtobufName + ".errors" );
			if ( errors != null ) {
				throw LOG.errorAtSchemaDeploy( generatedProtobufName, errors );
			}
			LOG.successfulSchemaDeploy( generatedProtobufName );
		}
		catch (HotRodClientException hrce) {
			throw LOG.errorAtSchemaDeploy( generatedProtobufName, hrce );
		}
		if ( schemaCapture != null ) {
			schemaCapture.put( generatedProtobufName, cachedSchema );
		}
	}
737358
def autoschema(self, objects, **kwargs):
        '''  '''
        return autoschema(objects=objects, exclude_keys=self.RESTRICTED_KEYS,
                          **kwargs)
525666
public Schema schema(TableSchema schema) {
		tableSchema.clear();
		lastField = null;
		for (int i = 0; i < schema.getFieldCount(); i++) {
			field(schema.getFieldName(i).get(), schema.getFieldType(i).get());
		}
		return this;
	}
666772
public static Builder newSchema(GraphQLSchema existingSchema) {
        return new Builder()
                .query(existingSchema.getQueryType())
                .mutation(existingSchema.getMutationType())
                .subscription(existingSchema.getSubscriptionType())
                .codeRegistry(existingSchema.getCodeRegistry())
                .clearAdditionalTypes()
                .clearDirectives()
                .additionalDirectives(existingSchema.directives)
                .additionalTypes(existingSchema.additionalTypes);
    }
772172
public static Schema.Field[] flatSchema(Schema s) {
    List<Schema.Field> fields = s.getFields();
    Schema.Field[] flatSchema = new Schema.Field[fields.size()];
    int cnt = 0;
    for (Schema.Field f : fields) {
      if (isSupportedSchema(f.schema())) {
        flatSchema[cnt] = f;
        cnt++;
      }
    }
    // Return resized array
    return cnt != flatSchema.length ? Arrays.copyOf(flatSchema, cnt) : flatSchema;
  }
938298
public static Schema mapOf(Schema keySchema, Schema valueSchema) {
    return new Schema(Type.MAP, null, null, keySchema, valueSchema, null, null, null);
  }
1121728
def add_schema(self, schema):
        

        # serialize instances of SchemaNode before parsing
        if isinstance(schema, SchemaNode):
            schema = schema.to_schema()

        for subschema in self._get_subschemas(schema):
            # delegate to SchemaType object
            schema_generator = self._get_generator_for_schema(subschema)
            schema_generator.add_schema(subschema)

        # return self for easy method chaining
        return self
907022
function Schema(options, descriptors) {

    if (!descriptors) {
        descriptors = options;
        options = null;
    }

    function opt(name, type) {
        var value = options[name];
        if (value !== undefined) {
            if (typeof value === type) return value;
            else throw new TypeError(current + 'options : ' + name + ': "' +
                value + '" is not of type [' + type + ']');
        }
        else return false;
    }

    var current = 'Schema: arguments: ',
        defaults = { required: false };

    if (hasValue(options)) {
        if (type(options) === 'object') {
            defaults.required = opt('required', 'boolean');
            if (opt('validator', 'function')) defaults.validator = options.validator;
        }
        else throw new TypeError(current + 'options: must be of type [object]');
    }

    current += 'descriptors: ';
    if (typeof descriptors !== 'object')
        throw new TypeError(current + 'must be of type [object]');
    if (!Array.isArray(descriptors)) {
        descriptors = this.toDescriptors(descriptors, defaults);
    }
    if (options && options.extends instanceof Schema) {
        descriptors = this.extendDescriptors(descriptors, options.extends.descriptors);
    }
    if (!descriptors.length)
        throw new TypeError(current + 'contains no values');
    else if (!(descriptors[0] instanceof Descriptor)) {
        throw new TypeError(current + 'must be instances of Descriptor class');
    }
    var instance = this;
    this.descriptors = descriptors;

}
1146048
function createSubset(keywords, doc) {

    if (!keywords || Object.prototype.toString.call(keywords) !== '[object Array]') {
      return doc;
    }

    var lookup = createLookUp(keywords);

    return traverseThroughObject(lookup, doc);

  }
1318105
private List<SchemaDescriptor> createSchemas(Catalog catalog, Store store) throws IOException {
        List<SchemaDescriptor> schemaDescriptors = new ArrayList<>();
        Map<String, ColumnTypeDescriptor> columnTypes = new HashMap<>();
        Map<Column, ColumnDescriptor> allColumns = new HashMap<>();
        Set<ForeignKey> allForeignKeys = new HashSet<>();
        for (Schema schema : catalog.getSchemas()) {
            SchemaDescriptor schemaDescriptor = store.create(SchemaDescriptor.class);
            schemaDescriptor.setName(schema.getName());
            // Tables
            createTables(catalog, schema, schemaDescriptor, columnTypes, allColumns, allForeignKeys, store);
            // Sequences
            createSequences(catalog.getSequences(schema), schemaDescriptor, store);
            // Procedures and Functions
            createRoutines(catalog.getRoutines(schema), schemaDescriptor, columnTypes, store);
            schemaDescriptors.add(schemaDescriptor);
        }
        // Foreign keys
        createForeignKeys(allForeignKeys, allColumns, store);
        return schemaDescriptors;
    }
1066684
function (schema) {
            if (!this.rowConfig.options) { this.rowConfig.options = {}; }
            this.rowConfig.options.schema = schema || this.options.rowSchema || this.rowSchema;
            return this;
        }
451185
public static org.apache.avro.Schema toAvroSchema(Schema pangoolSchema) {
		List<org.apache.avro.Schema.Field> avroFields = new ArrayList<org.apache.avro.Schema.Field>();

		for(Field pangoolField : pangoolSchema.getFields()) {
			org.apache.avro.Schema.Type avroFieldType = null;
			org.apache.avro.Schema.Field avroField = null;
			org.apache.avro.Schema avroFieldSchema=null;
			switch(pangoolField.getType()){
				case INT: 
				case FLOAT: 
				case DOUBLE: 
				case LONG: 
				case BOOLEAN: 
				case STRING:  
				case BYTES:
					avroFieldType = org.apache.avro.Schema.Type.valueOf(pangoolField.getType().toString());
					avroFieldSchema =org.apache.avro.Schema.create(avroFieldType); 
					avroField = new org.apache.avro.Schema.Field(pangoolField.getName(),avroFieldSchema
							,null,null);
				break;
				case OBJECT: 
					avroFieldType = org.apache.avro.Schema.Type.BYTES; 
					avroFieldSchema = org.apache.avro.Schema.create(avroFieldType);
					avroField = new org.apache.avro.Schema.Field(pangoolField.getName(),avroFieldSchema
							,null,null);
					avroField.addProp(Field.METADATA_BYTES_AS_OBJECT,"true");
					
				break;
				case ENUM: 
					avroFieldType = org.apache.avro.Schema.Type.ENUM;
					Object[] enumValues = pangoolField.getObjectClass().getEnumConstants();
					List<String> values=new ArrayList<String>();
					for (Object e : enumValues){
						values.add(e.toString());
					}
					avroFieldSchema = org.apache.avro.Schema.createEnum(pangoolField.getName(),null,null, values);
					avroField = new org.apache.avro.Schema.Field(pangoolField.getName(),avroFieldSchema
							,null,null);
					break;
				default:
					throw new PangoolRuntimeException("Not avro conversion from Pangool Schema type:" + pangoolField.getType());
				
			}
			if (pangoolField.getObjectClass() != null){
				avroField.addProp(Field.METADATA_OBJECT_CLASS, pangoolField.getObjectClass().getName());
			}
			if (pangoolField.getObjectSerialization() != null){
				avroField.addProp(Field.METADATA_OBJECT_SERIALIZATION,pangoolField.getObjectSerialization().getName());
			}
			for (Map.Entry<String,String> property : pangoolField.getProps().entrySet()){
				avroField.addProp(property.getKey(),property.getValue());
			}
			avroFields.add(avroField);
		}
		org.apache.avro.Schema avroSchema = org.apache.avro.Schema.createRecord(pangoolSchema.getName(), null, null, false);
		avroSchema.setFields(avroFields);
		return avroSchema;
	}