remove unused helper methods in SqlType

Signed-off-by: varun-edachali-dbx <varun.edachali@databricks.com>

Author: varun-edachali-dbx

src/databricks/sql/backend/sea/conversion.py

@@ -55,50 +55,6 @@ class SqlType:
     NULL = "null"
     USER_DEFINED_TYPE = "user_defined_type"
 
-    @classmethod
-    def is_numeric(cls, sql_type: str) -> bool:
-        """Check if the SQL type is a numeric type."""
-        return sql_type.lower() in (
-            cls.BYTE,
-            cls.SHORT,
-            cls.INT,
-            cls.LONG,
-            cls.FLOAT,
-            cls.DOUBLE,
-            cls.DECIMAL,
-        )
-
-    @classmethod
-    def is_boolean(cls, sql_type: str) -> bool:
-        """Check if the SQL type is a boolean type."""
-        return sql_type.lower() == cls.BOOLEAN
-
-    @classmethod
-    def is_datetime(cls, sql_type: str) -> bool:
-        """Check if the SQL type is a date/time type."""
-        return sql_type.lower() in (cls.DATE, cls.TIMESTAMP, cls.INTERVAL)
-
-    @classmethod
-    def is_string(cls, sql_type: str) -> bool:
-        """Check if the SQL type is a string type."""
-        return sql_type.lower() in (cls.CHAR, cls.STRING)
-
-    @classmethod
-    def is_binary(cls, sql_type: str) -> bool:
-        """Check if the SQL type is a binary type."""
-        return sql_type.lower() == cls.BINARY
-
-    @classmethod
-    def is_complex(cls, sql_type: str) -> bool:
-        """Check if the SQL type is a complex type."""
-        sql_type = sql_type.lower()
-        return (
-            sql_type.startswith(cls.ARRAY)
-            or sql_type.startswith(cls.MAP)
-            or sql_type.startswith(cls.STRUCT)
-            or sql_type == cls.USER_DEFINED_TYPE
-        )
-
 
 class SqlTypeConverter:
     """

tests/unit/test_conversion.py

@@ -12,84 +12,6 @@
 from databricks.sql.backend.sea.conversion import SqlType, SqlTypeConverter
 
 
-class TestSqlType:
-    """Test suite for the SqlType class."""
-
-    def test_is_numeric(self):
-        """Test the is_numeric method."""
-        assert SqlType.is_numeric(SqlType.BYTE)
-        assert SqlType.is_numeric(SqlType.SHORT)
-        assert SqlType.is_numeric(SqlType.INT)
-        assert SqlType.is_numeric(SqlType.LONG)
-        assert SqlType.is_numeric(SqlType.FLOAT)
-        assert SqlType.is_numeric(SqlType.DOUBLE)
-        assert SqlType.is_numeric(SqlType.DECIMAL)
-
-        # Test with uppercase
-        assert SqlType.is_numeric("INT")
-        assert SqlType.is_numeric("DECIMAL")
-
-        # Test non-numeric types
-        assert not SqlType.is_numeric(SqlType.STRING)
-        assert not SqlType.is_numeric(SqlType.BOOLEAN)
-        assert not SqlType.is_numeric(SqlType.DATE)
-
-    def test_is_boolean(self):
-        """Test the is_boolean method."""
-        assert SqlType.is_boolean(SqlType.BOOLEAN)
-        assert SqlType.is_boolean("BOOLEAN")
-
-        # Test non-boolean types
-        assert not SqlType.is_boolean(SqlType.STRING)
-        assert not SqlType.is_boolean(SqlType.INT)
-
-    def test_is_datetime(self):
-        """Test the is_datetime method."""
-        assert SqlType.is_datetime(SqlType.DATE)
-        assert SqlType.is_datetime(SqlType.TIMESTAMP)
-        assert SqlType.is_datetime(SqlType.INTERVAL)
-        assert SqlType.is_datetime("DATE")
-        assert SqlType.is_datetime("TIMESTAMP")
-
-        # Test non-datetime types
-        assert not SqlType.is_datetime(SqlType.STRING)
-        assert not SqlType.is_datetime(SqlType.INT)
-
-    def test_is_string(self):
-        """Test the is_string method."""
-        assert SqlType.is_string(SqlType.STRING)
-        assert SqlType.is_string(SqlType.CHAR)
-        assert SqlType.is_string("STRING")
-        assert SqlType.is_string("CHAR")
-
-        # Test non-string types
-        assert not SqlType.is_string(SqlType.INT)
-        assert not SqlType.is_string(SqlType.BOOLEAN)
-
-    def test_is_binary(self):
-        """Test the is_binary method."""
-        assert SqlType.is_binary(SqlType.BINARY)
-        assert SqlType.is_binary("BINARY")
-
-        # Test non-binary types
-        assert not SqlType.is_binary(SqlType.STRING)
-        assert not SqlType.is_binary(SqlType.INT)
-
-    def test_is_complex(self):
-        """Test the is_complex method."""
-        assert SqlType.is_complex(SqlType.ARRAY)
-        assert SqlType.is_complex(SqlType.MAP)
-        assert SqlType.is_complex(SqlType.STRUCT)
-        assert SqlType.is_complex(SqlType.USER_DEFINED_TYPE)
-        assert SqlType.is_complex("ARRAY<int>")
-        assert SqlType.is_complex("MAP<string,int>")
-        assert SqlType.is_complex("STRUCT<name:string,age:int>")
-
-        # Test non-complex types
-        assert not SqlType.is_complex(SqlType.STRING)
-        assert not SqlType.is_complex(SqlType.INT)
-
-
 class TestSqlTypeConverter:
     """Test suite for the SqlTypeConverter class."""