Retrieves a description of the user-defined types (UDTs) defined in a particular schema.
344263
@Override
    public ResultSet getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types) throws SQLException
    {
        checkClosed();
        throw SQLError.noSupport();
    }
730836
def get_definition(self):
        ''''''

        serialized = super(ComplexSchemaItem, self).serialize()
        # Adjust entries in the serialization
        del serialized['definition_name']
        serialized['title'] = self.definition_name

        properties = {}
        required_attr_names = []

        for attr_name in self._attributes:
            attr = getattr(self, attr_name)
            if attr and isinstance(attr, BaseSchemaItem):
                # Remove the attribute entry added by the base serialization
                del serialized[attr_name]
                properties[attr_name] = attr.serialize()
                properties[attr_name]['type'] = attr.__type__
                if attr.required:
                    required_attr_names.append(attr_name)
        if serialized.get('properties') is None:
            serialized['properties'] = {}
        serialized['properties'].update(properties)

        # Assign the required array
        if required_attr_names:
            serialized['required'] = required_attr_names
        return serialized
392833
def _get_inherited_field_types(class_to_field_type_overrides, schema_graph):
    """"""
    inherited_field_type_overrides = dict()
    for superclass_name, field_type_overrides in class_to_field_type_overrides.items():
        for subclass_name in schema_graph.get_subclass_set(superclass_name):
            inherited_field_type_overrides.setdefault(subclass_name, dict())
            inherited_field_type_overrides[subclass_name].update(field_type_overrides)
    return inherited_field_type_overrides
409043
def _schema_getter(self, db):
        """"""
        # Change DB connection if needed
        if self.database != db:
            self.change_db(db)
        schema_dict = {tbl: self.get_schema(tbl) for tbl in self.tables}

        schema_lst = []
        for table, schema in schema_dict.items():
            for col in schema:
                col.insert(0, table)
                schema_lst.append(col)
        return schema_lst
354360
def getschemas(cls):
        
        members = getmembers(cls, lambda member: isinstance(member, Schema))

        result = OrderedDict()

        for name, member in members:
            result[name] = member

        return result
723420
public static <E> Schema getWriterSchema(Class<E> type, Schema schema) {
    Schema writerSchema = schema;
    GenericData dataModel = getDataModelForType(type);
    if (dataModel instanceof AllowNulls) {
      // assume fields are non-null by default to avoid schema conflicts
      dataModel = ReflectData.get();
    }

    if (dataModel instanceof SpecificData) {
      writerSchema = ((SpecificData)dataModel).getSchema(type);
    }

    return writerSchema;
  }
680150
def _annotation_stmt(self, stmt: Statement, sctx: SchemaContext) -> None:
        """"""
        if not sctx.schema_data.if_features(stmt, sctx.text_mid):
            return
        dst = stmt.find1("description")
        self.annotations[(stmt.argument, sctx.default_ns)] = Annotation(
            DataType._resolve_type(stmt.find1("type", required=True), sctx),
            dst.argument if dst else None)
885036
def get_suggested_type_names(schema, output_type, field_name):
    """"""

    if isinstance(output_type, (GraphQLInterfaceType, GraphQLUnionType)):
        suggested_object_types = []
        interface_usage_count = OrderedDict()
        for possible_type in schema.get_possible_types(output_type):
            if not possible_type.fields.get(field_name):
                return

            # This object type defines this field.
            suggested_object_types.append(possible_type.name)

            for possible_interface in possible_type.interfaces:
                if not possible_interface.fields.get(field_name):
                    continue

                # This interface type defines this field.
                interface_usage_count[possible_interface.name] = (
                    interface_usage_count.get(possible_interface.name, 0) + 1
                )

        # Suggest interface types based on how common they are.
        suggested_interface_types = sorted(
            list(interface_usage_count.keys()),
            key=lambda k: interface_usage_count[k],
            reverse=True,
        )

        # Suggest both interface and object types.
        suggested_interface_types.extend(suggested_object_types)
        return suggested_interface_types

    # Otherwise, must be an Object type, which does not have possible fields.
    return []
168925
def get_type(t):
    
    if isinstance(t, UserDefinedType):
        if isinstance(t.type, Contract):
            return 'address'
    return str(t)
848600
private void readUDFTypes(FieldContainer mpxj, List<UDFAssignmentType> udfs)
   {
      for (UDFAssignmentType udf : udfs)
      {
         FieldType fieldType = m_fieldTypeMap.get(Integer.valueOf(udf.getTypeObjectId()));
         if (fieldType != null)
         {
            mpxj.set(fieldType, getUdfValue(udf));
         }
      }
   }
226466
def _get_dbal_column_type(self, type_):
        
        type_ = type_.lower()

        if type_ == "enum":
            return "string"

        return super(SQLiteSchemaGrammar, self)._get_dbal_column_type(type_)
230021
private String emitDataTypes() {
    StringBuilder dtDefs = new StringBuilder();
    while (emittedDatatypes.size() < datatypes.size()) {
      for (String dt : new HashSet<String>(datatypes)) {
        if (!emittedDatatypes.contains(dt)) {
          StructureDefinition sd = context.fetchResource(StructureDefinition.class,
              ProfileUtilities.sdNs(dt, null));
          // TODO: Figure out why the line below doesn't work
          // if (sd != null && !uniq_structures.contains(sd))
          if(sd != null && !uniq_structure_urls.contains(sd.getUrl()))
            dtDefs.append("\n").append(genShapeDefinition(sd, false));
          emittedDatatypes.add(dt);
        }
      }
    }
    return dtDefs.toString();
  }
425608
def _GetSqliteSchema(self, proto_struct_class, prefix=""):
    """"""
    schema = collections.OrderedDict()
    for type_info in proto_struct_class.type_infos:
      if type_info.__class__ is rdf_structs.ProtoEmbedded:
        schema.update(
            self._GetSqliteSchema(
                type_info.type, prefix="%s%s." % (prefix, type_info.name)))
      else:
        field_name = utils.SmartStr(prefix + type_info.name)
        schema[field_name] = Rdf2SqliteAdapter.GetConverter(type_info)
    return schema
1255942
def datatype(dbtype, description, cursor):
    """"""
    dt = cursor.db.introspection.get_field_type(dbtype, description)
    if type(dt) is tuple:
        return dt[0]
    else:
        return dt
1277273
def get_regular_properties(self, _type, *args, **kwargs):
        
        if not SchemaObjects.contains(_type):
            return _type
        schema = SchemaObjects.get(_type)
        if schema.schema_type == SchemaTypes.DEFINITION and not kwargs.get('definition'):
            return ''
        head = """.. csv-table::
    :delim: |
    :header: "Name", "Required", "Type", "Format", "Properties", "Description"
    :widths: 20, 10, 15, 15, 30, 25

"""
        body = []
        if schema.properties:
            for p in schema.properties:
                body.append('        {} | {} | {} | {} | {} | {}'.format(
                    p.get('name') or '',
                    'Yes' if p.get('required') else 'No',
                    self.get_type_description(p['type'], *args, **kwargs),
                    p.get('type_format') or '',
                    '{}'.format(p.get('type_properties') or ''),
                    p.get('description') or '')
                )
            body.sort()
        return (head + '\n'.join(body))
114054
def dbType(self, typ):
        
        return self.TypeMap.get(typ, self.TypeMap.get('Default'))
192630
def get_type(bind):
    
    types = bind.types + [bind.schema.get('format')]
    for type_name in ('date-time', 'date', 'decimal', 'integer', 'boolean',
                      'number', 'string'):
        if type_name in types:
            return type_name
    return 'string'