[Format][FlightSQL] Spec refers to "int" type (which seems Java specific) rather than "int32"

[appletreeisyellow]

Describe the bug, including details regarding any error messages, version, and platform.

While implement FlightSQL in our project, we found that the FlightSql.proto format reference refers to a type int

arrow/format/FlightSql.proto

Line 1370 in c03ca8f

* key_sequence: int not null,

What int means was slightly unclear as the Arrow spec refers to "Int" types with bitWidth of 8, 16, 32 or 64 but the rust implementation has Int8, Int16, Int32 and Int64.

arrow/format/Schema.fbs

Lines 145 to 148 in c03ca8f

	table Int {
	bitWidth: int; // restricted to 8, 16, 32, and 64 in v1
	is_signed: bool;
	}

Go uses Int32:

arrow/go/arrow/flight/flightsql/schema_ref/reference_schemas.go

Line 63 in c03ca8f

{Name: "key_sequence", Type: arrow.PrimitiveTypes.Int32, Nullable: false},

C++ uses Int32:

arrow/cpp/src/arrow/flight/sql/server.cc

Line 1144 in c03ca8f

field("key_sequence", int32(), false), field("fk_key_name", utf8(), true),

Java uses INT:

arrow/java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/FlightSqlProducer.java

Line 848 in c03ca8f

Field.notNullable("key_sequence", INT.getType()),

which is defined at:

arrow/java/adapter/jdbc/src/test/java/org/apache/arrow/adapter/jdbc/h2/JdbcToArrowDataTypesTest.java

Line 90 in c03ca8f

private static final String INT = "int";

According to The Java Language Specification from Section 4.2: Primitive Types and Values:

The integral types are byte, short, int, and long, whose values are 8-bit, 16-bit, 32-bit and 64-bit signed two's-complement integers, respectively, and char, whose values are 16-bit unsigned integers representing UTF-16 code units

Therefore, we can conclude that INT in arrow Java refers to 32-bit integer.

Proposal

I propose that we change the proto spec to be consistent and use int<bitwidth> to refer to integer types. So specifically, change int to int32 to match C++/Rust/Go as well as the convention in the rest of Flight.proto

Here is the reference to details of our discussion https://github.com/influxdata/influxdb_iox/pull/7546#discussion_r1165830088

Component(s)

Format

[alamb]

Also related to #35107

[appletreeisyellow]

There are more to change from int to int32 in the following part of the code

arrow/format/FlightSql.proto

Lines 1067 to 1112 in 00072f9

	* data_type: int not null (The SQL data type),
	* column_size: int (The maximum size supported by that column.
	* In case of exact numeric types, this represents the maximum precision.
	* In case of string types, this represents the character length.
	* In case of datetime data types, this represents the length in characters of the string representation.
	* NULL is returned for data types where column size is not applicable.),
	* literal_prefix: utf8 (Character or characters used to prefix a literal, NULL is returned for
	* data types where a literal prefix is not applicable.),
	* literal_suffix: utf8 (Character or characters used to terminate a literal,
	* NULL is returned for data types where a literal suffix is not applicable.),
	* create_params: list<utf8 not null>
	* (A list of keywords corresponding to which parameters can be used when creating
	* a column for that specific type.
	* NULL is returned if there are no parameters for the data type definition.),
	* nullable: int not null (Shows if the data type accepts a NULL value. The possible values can be seen in the
	* Nullable enum.),
	* case_sensitive: bool not null (Shows if a character data type is case-sensitive in collations and comparisons),
	* searchable: int not null (Shows how the data type is used in a WHERE clause. The possible values can be seen in the
	* Searchable enum.),
	* unsigned_attribute: bool (Shows if the data type is unsigned. NULL is returned if the attribute is
	* not applicable to the data type or the data type is not numeric.),
	* fixed_prec_scale: bool not null (Shows if the data type has predefined fixed precision and scale.),
	* auto_increment: bool (Shows if the data type is auto incremental. NULL is returned if the attribute
	* is not applicable to the data type or the data type is not numeric.),
	* local_type_name: utf8 (Localized version of the data source-dependent name of the data type. NULL
	* is returned if a localized name is not supported by the data source),
	* minimum_scale: int (The minimum scale of the data type on the data source.
	* If a data type has a fixed scale, the MINIMUM_SCALE and MAXIMUM_SCALE
	* columns both contain this value. NULL is returned if scale is not applicable.),
	* maximum_scale: int (The maximum scale of the data type on the data source.
	* NULL is returned if scale is not applicable.),
	* sql_data_type: int not null (The value of the SQL DATA TYPE which has the same values
	* as data_type value. Except for interval and datetime, which
	* uses generic values. More info about those types can be
	* obtained through datetime_subcode. The possible values can be seen
	* in the XdbcDataType enum.),
	* datetime_subcode: int (Only used when the SQL DATA TYPE is interval or datetime. It contains
	* its sub types. For type different from interval and datetime, this value
	* is NULL. The possible values can be seen in the XdbcDatetimeSubcode enum.),
	* num_prec_radix: int (If the data type is an approximate numeric type, this column contains
	* the value 2 to indicate that COLUMN_SIZE specifies a number of bits. For
	* exact numeric types, this column contains the value 10 to indicate that
	* column size specifies a number of decimal digits. Otherwise, this column is NULL.),
	* interval_precision: int (If the data type is an interval data type, then this column contains the value
	* of the interval leading precision. Otherwise, this column is NULL. This fields
	* is only relevant to be used by ODBC).

Go uses Int32:

arrow/go/arrow/flight/flightsql/schema_ref/reference_schemas.go

Lines 87 to 104 in 00072f9

	{Name: "data_type", Type: arrow.PrimitiveTypes.Int32, Nullable: false},
	{Name: "column_size", Type: arrow.PrimitiveTypes.Int32, Nullable: true},
	{Name: "literal_prefix", Type: arrow.BinaryTypes.String, Nullable: true},
	{Name: "literal_suffix", Type: arrow.BinaryTypes.String, Nullable: true},
	{Name: "create_params", Type: arrow.ListOfField(arrow.Field{Name: "item", Type: arrow.BinaryTypes.String, Nullable: false}), Nullable: true},
	{Name: "nullable", Type: arrow.PrimitiveTypes.Int32, Nullable: false},
	{Name: "case_sensitive", Type: arrow.FixedWidthTypes.Boolean, Nullable: false},
	{Name: "searchable", Type: arrow.PrimitiveTypes.Int32, Nullable: false},
	{Name: "unsigned_attribute", Type: arrow.FixedWidthTypes.Boolean, Nullable: true},
	{Name: "fixed_prec_scale", Type: arrow.FixedWidthTypes.Boolean, Nullable: false},
	{Name: "auto_increment", Type: arrow.FixedWidthTypes.Boolean, Nullable: true},
	{Name: "local_type_name", Type: arrow.BinaryTypes.String, Nullable: true},
	{Name: "minimum_scale", Type: arrow.PrimitiveTypes.Int32, Nullable: true},
	{Name: "maximum_scale", Type: arrow.PrimitiveTypes.Int32, Nullable: true},
	{Name: "sql_data_type", Type: arrow.PrimitiveTypes.Int32, Nullable: false},
	{Name: "datetime_subcode", Type: arrow.PrimitiveTypes.Int32, Nullable: true},
	{Name: "num_prec_radix", Type: arrow.PrimitiveTypes.Int32, Nullable: true},
	{Name: "interval_precision", Type: arrow.PrimitiveTypes.Int32, Nullable: true},

C++ uses int32:

arrow/cpp/src/arrow/flight/sql/server.cc

Lines 1186 to 1203 in 00072f9

	field("data_type", int32(), false),
	field("column_size", int32()),
	field("literal_prefix", utf8()),
	field("literal_suffix", utf8()),
	field("create_params", list(field("item", utf8(), false))),
	field("nullable", int32(), false),
	field("case_sensitive", boolean(), false),
	field("searchable", int32(), false),
	field("unsigned_attribute", boolean()),
	field("fixed_prec_scale", boolean(), false),
	field("auto_increment", boolean()),
	field("local_type_name", utf8()),
	field("minimum_scale", int32()),
	field("maximum_scale", int32()),
	field("sql_data_type", int32(), false),
	field("datetime_subcode", int32()),
	field("num_prec_radix", int32()),
	field("interval_precision", int32()),

Java uses INT:

arrow/java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/FlightSqlProducer.java

Lines 882 to 901 in 00072f9

	Field.notNullable("data_type", INT.getType()),
	Field.nullable("column_size", INT.getType()),
	Field.nullable("literal_prefix", VARCHAR.getType()),
	Field.nullable("literal_suffix", VARCHAR.getType()),
	new Field(
	"create_params", FieldType.nullable(LIST.getType()),
	singletonList(Field.notNullable("item", VARCHAR.getType()))),
	Field.notNullable("nullable", INT.getType()),
	Field.notNullable("case_sensitive", BIT.getType()),
	Field.notNullable("searchable", INT.getType()),
	Field.nullable("unsigned_attribute", BIT.getType()),
	Field.notNullable("fixed_prec_scale", BIT.getType()),
	Field.nullable("auto_increment", BIT.getType()),
	Field.nullable("local_type_name", VARCHAR.getType()),
	Field.nullable("minimum_scale", INT.getType()),
	Field.nullable("maximum_scale", INT.getType()),
	Field.notNullable("sql_data_type", INT.getType()),
	Field.nullable("datetime_subcode", INT.getType()),
	Field.nullable("num_prec_radix", INT.getType()),
	Field.nullable("interval_precision", INT.getType())

As mentioned in the above, INT in arrow Java refers to 32-bit integer.

[alamb]

There are more to change from int to int32 in the following part of the code

Note this was fixed in #35213 -- thanks @appletreeisyellow and @kou