HIVE 中的数据类型检查器 -- ObjectInspector 源码详解

朴灿烈づ我的快乐病毒、 2023-10-04 19:01 14阅读 0赞

### HIVE 中的数据类型检查器 ###

#### 内容目录 ####

*   *  HIVE 中的数据类型检查器
     *   *  一、PRIMITIVE
         *  二、LIST
         *   *  ListObjectInspector
             *  StandardListObjectInspector
         *  三、MAP
         *   *  MapObjectInspector
             *  StandardMapObjectInspector
         *  四、STRUCT
         *  五、UNION
         *  六、Factory和Utils
         *   *  Factory
             *  Utils

> HIVE中的ObjectInspector，类似于数据类型检查器，告诉hive变量的类型是怎么样的。类似于Hadoop中的Text、IntWritable等这些类型一样。

> hive认为，一个复杂的对象可以由一对ObjectInspector和JavaObject表示。 ObjectInspector不仅告诉我们对象的结构，而且还提供了访问对象内部字段的方法。ObjectInspector只记录类型并且可以直接返回，另外提供了一个获取实例的方法，该方法的参数是一个Object对象，即本身不存储具体的数据，而是根据传入的对象，利用自己的类型来转换成具有类型的对象。

HIVE中的数据类型分为了几种：

PRIMITIVE, LIST, MAP, STRUCT, UNION;

看源码可以看到。

public interface ObjectInspector extends Cloneable {
        
        String getTypeName();
    
        ObjectInspector.Category getCategory();
    
        public static enum Category {
        
            PRIMITIVE,  -- hive原始类型
            LIST,  -- 列表类型
            MAP,  -- map类型
            STRUCT,  -- 结构类型
            UNION;  -- 组合类型
    
            private Category() {
        
            }
        }
    }

#### 一、PRIMITIVE ####

PrimitiveObjectInspector

PrimitiveCategory：

VOID,
    BOOLEAN,
    BYTE,
    SHORT,
    INT,
    LONG,
    FLOAT,
    DOUBLE,
    STRING,
    DATE,
    TIMESTAMP,
    BINARY,
    DECIMAL,
    VARCHAR,
    CHAR,
    INTERVAL_YEAR_MONTH,
    INTERVAL_DAY_TIME,
    UNKNOWN;

#### 二、LIST ####

主要有几种方面理解：

1.  获取一个LIST类型的对象检查器
2.  获取LIST指定下标的元素对象实例
3.  可以获取长度
4.  可以返回一个LIST实例

主要的实现和常用到的实现接口和类如下：

##### ListObjectInspector #####

StandardListObjectInspector

其中接口ListObjectInspector中的getList方法也可以返回一个List类型

public interface ListObjectInspector extends ObjectInspector {
        
        ObjectInspector getListElementObjectInspector();
    
        Object getListElement(Object var1, int var2);
    
        int getListLength(Object var1);
    
        List<?> getList(Object var1);
    }

##### StandardListObjectInspector #####

是一个十分中要的实现类，源码是这样的：

// 一个list的检查器
    public class StandardListObjectInspector implements SettableListObjectInspector {
        
        private ObjectInspector listElementObjectInspector;
    
        protected StandardListObjectInspector() {
        
        }
    
        protected StandardListObjectInspector(ObjectInspector listElementObjectInspector) {
        
            this.listElementObjectInspector = listElementObjectInspector;
        }
    
        public final Category getCategory() {
        
            return Category.LIST;
        }
    
        public ObjectInspector getListElementObjectInspector() {
        
            return this.listElementObjectInspector;
        }
    
        public Object getListElement(Object data, int index) {
        
            
            xxx xxx  -- 省略 ...
            return index >= 0 && index < list.size() ? list.get(index) : null;
            }
        }
    
        public int getListLength(Object data) {
        
            -- 省略 ... 
            return list.size();
        }
    
        public List<?> getList(Object data) {
        
            -- 省略 ... 
            List<?> list = (List)data;
            return list;
        }
    
        public String getTypeName() {
        
            return "array<" + this.listElementObjectInspector.getTypeName() + ">";
        }
    
        public Object create(int size) {
        
            List<Object> a = new ArrayList(size);
    
            -- 省略 ... 
    
            return a;
        }
    
        public Object resize(Object list, int newSize) {
        
            List a = (List)list;
    
            -- 省略 ... 
    
            return a;
        }
    
        public Object set(Object list, int index, Object element) {
        
            List<Object> a = (List)list;
            a.set(index, element);
            return a;
        }
    }

#### 三、MAP ####

主要有几个方面：

1.  获取key和value的检查器
2.  获取key和value的实例
3.  获取一个map实例
4.  获取map的size

以下也是很重要的接口和实现类

##### MapObjectInspector #####

源码如下：

public interface MapObjectInspector extends ObjectInspector {
        
        ObjectInspector getMapKeyObjectInspector();
    
        ObjectInspector getMapValueObjectInspector();
    
        Object getMapValueElement(Object var1, Object var2);
    
        Map<?, ?> getMap(Object var1);
    
        int getMapSize(Object var1);
    }

##### StandardMapObjectInspector #####

是一个十分重要的实现类，看下源码：

public class StandardMapObjectInspector implements SettableMapObjectInspector {
        
        // 分别key和value的检查器
        private ObjectInspector mapKeyObjectInspector;
        private ObjectInspector mapValueObjectInspector;
    
        protected StandardMapObjectInspector() {
        
        }
        // key和value构造器
        protected StandardMapObjectInspector(ObjectInspector mapKeyObjectInspector, ObjectInspector mapValueObjectInspector) {
        
            this.mapKeyObjectInspector = mapKeyObjectInspector;
            this.mapValueObjectInspector = mapValueObjectInspector;
        }
    
        // 返回key的检查器
        public ObjectInspector getMapKeyObjectInspector() {
        
            return this.mapKeyObjectInspector;
        }
    
        // 返回value的检查器
        public ObjectInspector getMapValueObjectInspector() {
        
            return this.mapValueObjectInspector;
        }
    
        // 获取key的value
        public Object getMapValueElement(Object data, Object key) {
        
            if (data != null && key != null) {
        
                Map<?, ?> map = (Map)data;
                return map.get(key);
            } else {
        
                return null;
            }
        }
    
        // 获取map大小
        public int getMapSize(Object data) {
        
            if (data == null) {
        
                return -1;
            } else {
        
                Map<?, ?> map = (Map)data;
                return map.size();
            }
        }
    
        // 返回一个map
        public Map<?, ?> getMap(Object data) {
        
            if (data == null) {
        
                return null;
            } else {
        
                Map<?, ?> map = (Map)data;
                return map;
            }
        }
    
        public final Category getCategory() {
        
            return Category.MAP;
        }
    
        public String getTypeName() {
        
            return "map<" + this.mapKeyObjectInspector.getTypeName() + "," + this.mapValueObjectInspector.getTypeName() + ">";
        }
    
        // 创建一个新的map
        public Object create() {
        
            Map<Object, Object> m = new HashMap();
            return m;
        }
    
        public Object clear(Object map) {
        
            Map<Object, Object> m = (HashMap)map;
            m.clear();
            return m;
        }
    
        // 往map里放数据
        public Object put(Object map, Object key, Object value) {
        
            Map<Object, Object> m = (HashMap)map;
            m.put(key, value);
            return m;
        }
    
        public Object remove(Object map, Object key) {
        
            Map<Object, Object> m = (HashMap)map;
            m.remove(key);
            return m;
        }
    }

看一个源码中的实现类例子：

mapOI = (MapObjectInspector) arguments[0];
    // 得到一个map的key类型检查器
    ObjectInspector mapKeyOI = mapOI.getMapKeyObjectInspector();
    // 返回map类型
    return ObjectInspectorFactory.getStandardListObjectInspector(mapKeyOI);

// MapObjectInspector类型
    private transient MapObjectInspector mapOI;
    Object mapObj = arguments[0].get();
    // 转换为map
    Map<?,?> mapVal = mapOI.getMap(mapObj);

#### 四、STRUCT ####

STRUCT比较特殊，没有接口，直接使用的抽象类

public abstract class StructObjectInspector implements ObjectInspector {
        
        public StructObjectInspector() {
        
        }
    
        public abstract List<? extends StructField> getAllStructFieldRefs();
    
        public abstract StructField getStructFieldRef(String var1);
    
        public abstract Object getStructFieldData(Object var1, StructField var2);
    
        public abstract List<Object> getStructFieldsDataAsList(Object var1);
    
        public boolean isSettable() {
        
            return false;
        }
    
        public String toString() {
        
            StringBuilder sb = new StringBuilder();
            List<? extends StructField> fields = this.getAllStructFieldRefs();
            sb.append(this.getClass().getName());
            sb.append("<");
    
            for(int i = 0; i < fields.size(); ++i) {
        
                if (i > 0) {
        
                    sb.append(",");
                }
    
                sb.append(((StructField)fields.get(i)).getFieldObjectInspector().toString());
            }
    
            sb.append(">");
            return sb.toString();
        }
    }

#### 五、UNION ####

组合数据类型检查器

#### 六、Factory和Utils ####

工厂和工具类

##### Factory #####

工厂一般创建新的检查器不是直接new一个实例，而是通过工厂类造出来一个

有两个可供使用的工厂：

PrimitiveObjectInspectorFactory  -- 用于原始类型
    ObjectInspectorFactory  -- java类型

##### Utils #####

工具类中有大量的经常用到的工具可以使用，全类名：

org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorUtils