La signification des éléments de configuration dans le fichier de configuration Hive est expliquée en détail

Presque tous les éléments de configuration de la ruche sont répertoriés dans ce document. La question suivante ne mentionne que les fonctions de plusieurs éléments de configuration. Pour plus d'informations, vous pouvez afficher le contenu
Guide des questions:
1. Quel est l'élément de configuration du format de sortie de la ruche?
2. Comment configurer la ruche pour être appelée par différentes langues?
3. Le travail est-il soumis par Hive in Hive ou Hadoop?
4. La sortie de la dernière tâche de mappage / réduction d'une requête est-elle compressée? Quel élément de configuration est passé?
5. Lorsque l'utilisateur personnalise UDF ou SerDe, les jars de ces plug-ins doivent être placés dans ce répertoire, via quel élément de configuration?
6. La taille de chaque réducteur est par défaut de 1G. Si le fichier d'entrée est de 10G, il y aura 10 réducteurs, quel élément de configuration peut être configuré?
7. Le groupe par opération permet-il d'incliner les données, à travers quelle configuration d'élément de configuration?
8. Comment configurer l'utilisation de la mémoire de la carte / réduire en mode local?
9. Le nombre de lignes mises en cache en mémoire lors de la jointure de table, la valeur par défaut est 25 000, quel élément de configuration peut être modifié?
10. L'optimisation de la jointure de l'inclinaison des données est-elle activée? Quel élément de configuration peut être optimisé?
11. Lorsque le fonctionnement en parallèle est activé, combien de travaux sont autorisés à être calculés en même temps, la valeur par défaut est 8. Comment modifier cet élément de configuration?

Configuration de la ruche:

hive.ddl.output.format: le format de sortie de l'instruction hive ddl, la valeur par défaut est le format texte, texte brut et json. Il s'agit d'une nouvelle configuration publiée après 0.90;
hive.exec.script.wrapper: le wrapper lorsque hive appelle le script. La valeur par défaut est null. Si elle est définie sur python, l'instruction deviendra python <commande de script> lors de l'opération d'appel de script. S'il est nul, il exécutera directement la <commande de script>;
hive.exec.plan: le chemin du fichier du plan d'exécution de la ruche, la valeur par défaut est null, il sera automatiquement défini à l'exécution, comme hdfs: // xxxx / xxx / xx;
hive .exec.scratchdir: hive est utilisé pour stocker différents Le répertoire de la map / réduire le plan d'exécution de la scène, et stocke également les résultats de sortie intermédiaires. La valeur par défaut est /tmp/<user.name>/hive. Nous allons en fait distinguer par groupe, puis créez un répertoire tmp pour le stockage dans le groupe;
hive .exec.submitviachild: en mode non local, décidez si hive doit exécuter map / reduction dans un jvm séparé; la valeur par défaut est false, ce qui signifie que le le travail de mappage / réduction par défaut est soumis sur le jvm de la ruche;
hive.exec .script.maxerrsize: lorsque l'utilisateur appelle transformer ou mapper ou réduire pour exécuter un script, le nombre maximal d'erreurs de sérialisation, la valeur par défaut est 100000, généralement pas besoin à modifier;
hive.exec.compress.output: la sortie de la dernière tâche de mappage / réduction d'une requête L'indicateur indiquant s'il faut compresser, la valeur par défaut est false, mais il est généralement activé comme vrai. Si c'est avantageux , économisez de l'espace et augmentez io lorsque la pression du processeur n'est pas prise en compte;
hive.exec.compress.intermediate: similaire au précédent, en un Indique si la sortie de la tâche de mappage / réduction au milieu de la requête doit être compressée, la valeur par défaut c'est faux,
hive.jar.path: lorsque vous utilisez un jvm indépendant pour soumettre un travail, l'emplacement de hive_cli.jar n'a pas de valeur par défaut;
hive.aux.jars.path: lorsque l'utilisateur personnalise UDF ou SerDe, les fichiers jar de ces plug-ins doit être placé Dans ce répertoire, il n'y a pas de valeur par défaut;
hive.partition.pruning: lorsque le compilateur trouve qu'une table de partition est utilisée dans une instruction de requête mais ne fournit aucun prédicat de partition pour la requête, une erreur est générée pour protéger le table de partition, la valeur par défaut est non stricte; (à affiner après la lecture du code source, il y a très peu d'informations sur Internet)
hive.map.aggr: si l'agrégation côté carte est activée, elle est activée par défaut;
hive. join.emit.interval: le paramètre du nombre de lignes mises en cache pour l'opération la plus à droite de la jointure avant d'émettre le résultat de la jointure Ensemble, la valeur par défaut est 1000; il y a un correctif dans hive jira qui définit la valeur trop petite;
hive.map .aggr.hash.percentmemory: le pourcentage de mémoire occupée par la table de hachage lors de l'agrégation côté carte, la valeur par défaut est 0,5, ceci est activé sur l'agrégation côté carte Pour une utilisation ultérieure,
hive.default.fileformat: le format de fichier par défaut de l'instruction CREATE TABLE, la valeur par défaut est TextFile et les autres options sont SequenceFile, RCFile et Orc;
hive.merge.mapfiles: fusionne les petits fichiers à la fin du travail de mappage uniquement, par défaut Enable true;
hive.merge.mapredfiles : fusion de petits fichiers après la fin d'un travail de mappage / réduction, false n'est pas activé par défaut;
hive.merge.size.per.task: la taille des fichiers fusionnés à la fin du travail, par défaut 256 Mo;
hive.merge.smallfiles.avgsize: lorsque le fichier de sortie de la tâche est plus petit que cette valeur, une tâche de mappage / réduction supplémentaire est lancée pour fusionner les petits fichiers en fichiers volumineux. Le seuil de base pour les petits fichiers. La définition d'un point plus grand peut réduire le nombre de petits fichiers. mapfiles et mapredfiles sont vrais, la valeur par défaut est 16 Mo;
mapred.reduce.tasks: le nombre de tâches de réduction pour chaque travail, la valeur par défaut est la configuration du client hadoop 1;
hive.exec.reducers.bytes .per.reducer: chaque réducteur La taille, la valeur par défaut est 1G, si le fichier d'entrée est 10G, alors 10 réducteurs seront
créés ; hive.exec.reducers.max: le nombre maximum de réducteurs, si le mapred.reduce.tasks est défini sur une valeur négative, alors la ruche prendra Cette valeur est utilisée comme valeur maximale possible des réducteurs. Bien sûr, cela dépend également de la taille obtenue par (taille du fichier d'entrée / hive.exec.reducers.bytes.per.reducer), et la valeur la plus petite est utilisée comme nombre de réducteurs. La valeur par défaut de hive est 999;
hive .fileformat.check: charger le fichier de données S'il faut vérifier le format de fichier, la valeur par défaut est true;
hive.groupby.skewindata: si le groupe par opération autorise le biais des données, la valeur par défaut est false, lorsqu'il est défini sur true, le plan d'exécution générera deux tâches de mappage / réduction, le premier MR Le résultat de la mappe sera distribué aléatoirement pour réduire afin d'atteindre l'objectif de l'équilibrage de charge pour résoudre le biais de données.
hive.groupby.mapaggr.checkinterval: lorsque le côté de la carte effectue l'agrégation , le nombre de lignes de données autorisé par la clé du groupe dépasse cette valeur. Fractionné, la valeur par défaut est 100 000;
hive.mapred.local.mem: en mode local, l'utilisation de la mémoire de map / Reduce, la valeur par défaut est 0, ce qui signifie illimité;
hive.mapjoin.followby.map.aggr.hash.percentmemory: la mémoire de la table de hachage pendant agrégation côté carte Ce paramètre limite le groupe à être effectué après la jointure de la carte, sinon utilisez hive.map.aggr.hash.percentmemory pour confirmer le pourcentage de mémoire, la valeur par défaut est 0,3;
hive.map.aggr.hash.force.flush .memeory.threshold: mémoire maximale disponible de la table de hachage lors de l'agrégation de la carte. Si cette valeur est dépassée, les données seront vidées. La valeur par défaut est 0,9;
hive.map.aggr.hash.min.reduction: si le ratio de la capacité de la table de hachage au nombre de lignes d'entrée dépasse cette valeur Nombre, alors l'agrégation de hachage du côté de la carte sera désactivée, la valeur par défaut est 0,5, définie sur 1 pour garantir que l'agrégation de hachage ne sera jamais désactivée;
hive.optimize.groupby: s'il faut faire un groupe de compartiments en effectuant une requête de partition et de table, la valeur par défaut est true;
Hive.multigroupby.singlemr: sortie plusieurs groupes de bys dans un seul plan de tâches de mappage / réduction, bien sûr, la contrainte est que le group by a la même clé, la valeur par défaut est false;
hive.optimize.cp: recadrage de colonnes, la valeur par défaut est true lors d'une requête ne lisant que les colonnes utilisées, c'est une optimisation utile;
hive.optimize.index.filter: utilise automatiquement l'index, la valeur par défaut n'est pas open false;
hive.optimize.index.groupby: s'il faut utiliser un index clusterisé pour optimiser le groupe par requête, false est fermé par défaut;
hive.optimize.ppd: s'il faut prendre en charge le refoulement du prédicat, qui est activé par défaut; le soi-disant refoulement du prédicat, déplace le prédicat dans la clause WHERE du bloc de requête externe dans le bloc de requête inférieur (tel que la vue) contenu dans afin de pouvoir procéder plus tôt au filtrage des données et à une meilleure utilisation possible des index.
hive.optimize.ppd.storage: lorsque le refoulement du prédicat est activé, que le prédicat soit poussé vers le gestionnaire de stockage, il est activé par défaut et ne fonctionne pas lorsque le
refoulement du prédicat est désactivé; hive.ppd.recognizetransivity: si l'origine est répétée sous la condition d'égalité de jointure Le filtre de prédicat est activé par défaut:
hive.join.cache.size: le nombre de lignes mises en cache en mémoire lors d'une jointure de table, la valeur par défaut est 25000;
hive.mapjoin.bucket. cache.size: chaque clé du cache mémoire pendant mapjoin Combien de valeurs à stocker, la valeur par défaut est 100;
hive.optimize.skewjoin: s'il faut activer l'optimisation de la jointure du biais de données, la valeur par défaut n'est pas d'activer false;
hive .skewjoin.key: le seuil pour juger le biais des données, si la même clé est trouvée dans la jointure pour dépasser cette valeur La valeur est considérée comme étant une clé de jointure asymétrique, la valeur par défaut est 100000;
hive.skewjoin.mapjoin. map.tasks: le nombre de cartes de la jointure de carte lorsque les données sont inclinées jointure, la valeur par défaut est 10000;
hive.skewjoin.mapjoin.min. split: La taille minimale de division de la tâche de carte de la jointure de carte lorsque les données sont jointure asymétrique, la valeur par défaut est 33554432, ce paramètre doit être utilisé en conjonction avec les paramètres ci-dessus pour un contrôle précis;
hive.mapred.mode: Le mode lorsque l'opération de la ruche est exécutée, la valeur par défaut est le mode non strict non strict, s'il s'agit du mode strict, de nombreuses requêtes risquées seront interdites, telles que la jointure de produit cartésienne et la partition dynamique;
ruche. exec.script .maxerrsize: nombre maximal d'octets qu'une tâche de mappage / réduction est autorisée à imprimer en erreur standard. Afin d'empêcher le script de remplir le journal de partition, la valeur par défaut est 100000;
hive.exec.script.allow. partial.consumption: si la ruche autorise les scripts non Il se termine avec succès après la lecture de tout contenu de l'entrée standard, et false est fermé par défaut;
hive.script.operator.id.env.var: lorsque l'utilisateur utilise la fonction de transformation pour personnaliser la carte / réduire, la variable d'environnement qui stocke l'identifiant de script unique Name, par défaut HIVE_SCRIPT_OPERATOR_ID;
hive.exec.compress.output: contrôle si la sortie du résultat de la requête de la ruche est compressée, la méthode de compression est configurée dans mapred.output.compress de Hadoop et le la valeur par défaut n'est pas compressée false;
hive.exec.compress.intermediate: control Si les résultats intermédiaires des requêtes Hive sont compressés, comme la configuration ci-dessus, la valeur par défaut n'est pas de compresser false;
hive.exec.parallel: si l'exécution de les travaux hive sont exécutés en parallèle, la valeur par défaut n'est pas d'activer false, dans de nombreuses opérations telles que la jointure, il n'y a pas de sous-requêtes L'association peut s'exécuter indépendamment. Dans ce cas, l'activation de l'opération parallèle peut considérablement accélérer;
hvie.exec .parallel.thread.number: lorsque le fonctionnement parallèle est activé, le nombre de travaux autorisés à être calculés en même temps, la valeur par défaut est 8;
hive.exec.rowoffset: Indique s'il faut fournir une colonne virtuelle pour le décalage de ligne, la valeur par défaut est false et non fournie, Hive a deux colonnes virtuelles: l'une est INPUT__FILE__NAME, ce qui signifie le chemin du fichier d'entrée, et l'autre est BLOCK__OFFSET__INSIDE__FILE, ce qui signifie qu'il est enregistré dans le fichier Offset de bloc, ce qui est très utile pour dépanner les requêtes qui ne répondent pas aux attentes ou aux résultats nuls;
hive.task.progress: contrôle si Hive met régulièrement à jour le compteur de progression de la tâche pendant l'exécution . Activation de cette configuration peut aider le travail Le tracker surveille mieux l'exécution des tâches, mais il entraînera une certaine perte de performances. Lorsque l'indicateur de partition dynamique hive.exec.dynamic.partition est activé, cette configuration est automatiquement activée;
hive.exec.pre .hooks: conditions préalables à l'exécution, une liste de classes Java séparées par des virgules qui implémentent l'interface org.apache.hadoop.hive.ql.hooks.ExecuteWithHookContext. Une fois la configuration configurée, le hook de pré-exécution doit être exécuté avant chaque tâche ruche est exécuté. La valeur par défaut est vide;
hive.exec.post.hooks: comme ci-dessus, hooks après exécution, la valeur par défaut est vide;
hive.exec.failure.hooks: même que ci-dessus, hooks quand anormal, s'exécute quand une exception se produit dans le programme, la valeur par défaut est vide;
hive.mergejob. maponly: tentative de générer une tâche de mappage uniquement pour la fusion, à condition que CombineHiveInputFormat soit pris en charge et que la valeur par défaut soit true;
hive.mapjoin.smalltable.filesize: le seuil de mapjoin du fichier de table d'entrée, si la taille du fichier d'entrée est inférieure à cette valeur, il essaiera de fusionner la jointure normale est convertie en mapjoin, la valeur par défaut est 25 Mo;
hive.mapjoin.localtask.max.memory.usage: quantité maximale de clé / valeur dans la table de hachage lorsque la tâche locale mapjoin est exécutée. Si cette valeur est dépassée, la tâche locale se fermera automatiquement. La valeur par défaut est 0,9;
ruche .mapjoin.followby.gby.localtask .max.memory.usage: similaire à ce qui précède, sauf que s'il y a un groupe après mapjoin, cette configuration contrôle la limite supérieure de la capacité de mémoire locale d'une requête comme celle-ci, la valeur par défaut est 0,55;
hive.mapjoin.check.memory.rows: in La vérification de l'utilisation de la mémoire est effectuée après le calcul du nombre de lignes, la valeur par défaut est 100000;
hive.heartbeat.interval: l'intervalle de temps pour l'envoi des pulsations, utilisé dans les opérations de mapjoin et de filtrage , la valeur par défaut est 1000;
hive.auto.convert.join: selon la taille du fichier d'entrée Décidez s'il faut convertir une jointure normale en une optimisation de mapjoin, et false n'est pas activé par défaut;
hive.cript.auto.progress : Si le script de transformation / mappage / réduction de la ruche est exécuté ou non, envoie automatiquement les informations de progression à TaskTracker pour éviter les tâches qui ne répondent pas. Il a été tué par erreur. À l'origine, lorsque le script était sorti en erreur standard, les informations de progression étaient envoyées, mais après l'activation cette option, la sortie en erreur standard ne provoquera pas l'envoi des informations, donc cela peut entraîner une boucle infinie du script, mais TaskTracker ne vérifie pas La boucle continue;
hive.script.serde: contrainte SerDe lorsque le script utilisateur se convertit entrée à sortie, la valeur par défaut est org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe;
hive.script.recordreader: le lecteur par défaut lors de la lecture des données du script, la valeur par défaut est org.apache.hadoop.hive.ql.exec.TextRecordReader;
hive.script.recordwriter: l'écrivain par défaut lors de l'écriture des données dans le script, le la valeur par défaut est org. apache.hadoop.hive.ql.exec.TextRecordWriter;
hive.input.format: format d'entrée, la valeur par défaut est org.apache.hadoop.hive.ql.io.CombineHiveInputFormat, s'il y a un problème, vous pouvez utilisez plutôt org.apache.hadoop. hive.ql.io.HiveInputFormat;
hive.udtf.auto.progress: si la ruche envoie des informations de progression à TaskTracker lorsque UDTF est exécuté, la valeur par défaut est false;
hive.mapred.reduce.tasks.speculative .execution: La réduction de l'exécution spéculative de la tâche est activée, la valeur par défaut est true;
hive.exec.counters.pull.interval: l'intervalle de temps auquel le travail interroge le JobTracker pendant l'exécution, un petit paramètre affectera la charge du JobTracker, et un paramètre important peut ne pas afficher les informations de la tâche en cours d'exécution. Balance, la valeur par défaut est 1000;
Hive.enforce.bucketing: si le compartimentage des données est appliqué, la valeur par défaut est false, s'il est activé, le compartimentage sera démarré lors de l'écriture des données de table,

hive.enforce.sorting: lorsque le tri forcé est activé, l'insertion de données dans la table se poursuivra Tri obligatoire, la valeur par défaut est false;

hive.optimize.reducededuplication: Si les données ont été agrégées selon la même clé, supprimez les tâches redondantes de mappage / réduction. Cette configuration est la configuration recommandée du document, il est recommandé d'ouvrir, la valeur par défaut est true;

hive. exec.dynamic.partition: s'il faut prendre en charge la partition dynamique en DML / DDL, la valeur par défaut est false;

hive.exec.dynamic.partition.mode: default strict, en mode strict, l'utilisation de la partition dynamique doit être confirmée par une partition statique , les autres partitions peuvent être dynamiques;

Hive.exec.max.dynamic.partitions: la limite supérieure des partitions dynamiques, la valeur par défaut est 1000;

hive.exec.max.dynamic.partitions.pernode: le nombre maximum de partitions dynamiques que chaque mappeur / reducer node peut créer, la valeur par défaut est 100;

hive. exec.max.created.files: Le nombre maximum de fichiers HDFS pouvant être créés par une tâche mapreduce, la valeur par défaut est 100000;

hive.exec.default.partition.name : Lorsque le partitionnement dynamique est activé, si la colonne de données contient des chaînes nulles ou vides, les données seront insérées dans cette partition, le nom par défaut est __HIVE_DEFAULT_PARTITION__;

hive.fetch.output.serde: le SerDe requis lorsque FetchTask sérialise la sortie de récupération, le la valeur par défaut est org.apache.hadoop.hive.serde2.DelimitedJSONSerDe;

hive.exec .mode.local.auto: si Hive décide de s'exécuter automatiquement en mode local, la valeur par défaut est false,

hive.exec.drop.ignorenoneexistent: si la table ou la vue n'existe pas lors de la suppression d'une table ou d'une vue, si une erreur est signalée, la valeur par défaut est true;

hive.exec.show.job.failure.debug.info: s'il faut fournissez-en un lorsque le travail échoue Informations de débogage de la tâche, la valeur par défaut est true;


hive.auto.progress.timeout: l'intervalle de temps pour exécuter le progresseur automatique, la valeur par défaut est 0, ce qui équivaut à forever;


hive.table.parameters.default : la valeur par défaut du champ attributaire de la nouvelle table, la valeur par défaut est vide;


Hive.variable.substitute: s'il faut prendre en charge la substitution de variable, si elle est activée, prend en charge la syntaxe telle que $ {var} $ {system: var} et $ { env.var}, la valeur par défaut est true;

hive.error.on.empty.partition: Indique s'il faut signaler une erreur lors de la rencontre d'une partition dynamique avec un résultat vide, la valeur par défaut est false;

hive.exim.uri.scheme.whitelist: Une liste blanche fournie lors de l'importation et de l'exportation de données, les éléments de la liste sont séparés par des virgules, le hdfs par défaut, pfile;

hive.limit.row.max.size: la signification littérale est la quantité minimale de données de ligne garantie lors de l'utilisation de limite pour le sous-ensemble requête de données, la valeur par défaut est 100000;

hive.limit.optimize.limit.file: limite facile à utiliser Lors de l'interrogation d'un sous-ensemble de données, le nombre maximum de fichiers pouvant être échantillonnés, la valeur par défaut est 10;

hive.limit.optimize.enable: s'il faut activer l'option d'optimisation lors de l'utilisation de la limite simple pour échantillonner des données, la valeur par défaut est false. En ce qui concerne le problème d'optimisation de la limite, il est expliqué dans le livre de programmation hive que cette fonctionnalité présente un inconvénient, et l'incertitude de l'échantillonnage reçoit l'avertissement de risque;

hive.limit.optimize.fetch.max: nombre maximum de lignes de données échantillonnées en utilisant une simple limite autorisée par défaut 50000 requêtes la requête est limitée, insérer non affectée;

hive.rework.mapredwork: si refaire mapreduce, la valeur par défaut est false;

hive.sample.seednumber: le numéro utilisé pour distinguer l'échantillon, la valeur par défaut est 0;

hive.io.exception.handlers: la liste des gestionnaires d'exceptions io, la valeur par défaut est vide, lorsque le lecteur d'enregistrement io exception se produit, ces gestionnaires Pour gérer les exceptions;

hive.autogen.columnalias.prefix.label: Lorsque le préfixe des alias de colonne est automatiquement généré lors de l'exécution, lorsque les fonctions d'agrégation comme count fonctionnent, si count (a) as xxx n'est pas explicitement spécifié , puis la valeur par défaut. Elle sera ajoutée à partir du numéro de la position de la colonne. Par exemple, le résultat du premier décompte sera précédé du nom de colonne _c0, etc. La valeur par défaut est _c. Beaucoup de gens auraient dû voir ceci pendant le processus de développement des données Alias;

hive.autogen.columnalias.prefix.includefuncname: Indique s'il faut inclure le nom de la fonction lors de la génération automatique d'alias de colonne, la valeur par défaut est false;

hive.exec.perf.logger: nom de la classe de journal responsable de l'enregistrement des indicateurs de performance du client. Il doit s'agir d'une sous-classe de org.apache.hadoop.hive.ql.log.PerfLogger. La valeur par défaut est org.apache.hadoop. hive.ql. log.PerfLogger;

hive.start.cleanup.scratchdir: Indique s'il faut effacer le répertoire de travail de la ruche lors du démarrage du service de la ruche, la valeur par défaut est false;

hive.output.file.extension: l'extension du fichier de sortie, la valeur par défaut est vide;

hive.insert.into .multilevel.dirs: s'il faut insérer dans un répertoire à plusieurs niveaux, la valeur par défaut est false;

hive.files.umask.value: la valeur dfs.umask lorsque hive crée un dossier, la valeur par défaut est 0002;

hive.metastore.local: contrôlez si la ruche est connectée à un Le serveur de métastore distant ouvre toujours un client local jvm, la valeur par défaut est true, Hive0.10 a annulé cet élément de configuration;

javax.jdo.option.ConnectionURL: chaîne de connexion JDBC, jdbc par défaut: derby:; databaseName = metastore_db; create = true;

javax.jdo.option.ConnectionDriverName: pilote JDBC, par défaut org.apache.derby.jdbc.EmbeddedDriver;

javax.jdo.PersisteneManagerFactoryClass: le nom de la classe qui implémente JDO PersistenceManagerFactory, par défaut org.datanucleus.jdo.JDOPersistenceManagerFactory; javax.jdo.option.DetachAllOnCommit

: détacher tous les objets soumis après la soumission de la transaction, la valeur par défaut est true;

javax. jdo.option.NonTransactionalRead: s'il faut autoriser la lecture non transactionnelle, la valeur par défaut est true;

javax.jdo.option.ConnectionUserName: nom d'utilisateur, l'application par défaut;

javax.jdo.option.ConnectionPassword: mot de passe, le mien par défaut;

javax.jdo .option.Multithread: s'il faut prendre en charge le métastore d'accès simultané, la valeur par défaut est true;

datanucleus.connectionPoolingType: utilisez le pool de connexions pour accéder au métastore JDBC, la valeur par défaut est DBCP;

datanucleus.validateTables: vérifiez s'il existe un schéma de table, la valeur par défaut est false;

datanucleus.validateColumns: vérifiez s'il existe un schéma de colonne, la valeur par défaut est false;

Datanucleus.validateConstraints: vérifiez s'il existe un schéma de contrainte, la valeur par défaut est false;

datanucleus.stroeManagerType: le type de stockage des métadonnées, la valeur par défaut est rdbms ;

datanucleus.autoCreateSchema: s'il faut créer automatiquement le schéma nécessaire lorsqu'il n'existe pas, la valeur par défaut est true;

datanucleus.aotuStartMechanismMode: si la table de métadonnées est incorrecte, une exception est levée, la valeur par défaut est vérifiée;

datanucleus.transactionIsolation: la transaction par défaut niveau d'isolement, la valeur par défaut est read-commit;

datanucleus.cache.level2: utilisez le cache de second niveau, la valeur par défaut est false;

datanucleus.cache.level2.type: le type du cache de second niveau, il existe deux types, SOFT: référence souple, FAIBLE: référence faible, la valeur par défaut est SOFT;

Datanucleus.identifierFactory: le nom de la table de production id factory et le nom de la colonne, la valeur par défaut est datanucleus;

datanucleus.plugin.pluginRegistryBundleCheck: le comportement lorsque le plugin est trouvé et répété, la valeur par défaut est LOG;

hive.metastroe.warehouse.dir: l'emplacement de l'entrepôt de données, la valeur par défaut est / user / hive / entrepôt;

hive.metastore.execute.setugi: mode non sécurisé, défini sur true, le metastore fonctionnera Opérations DFS avec les autorisations utilisateur et groupe du client, la valeur par défaut est false, cet attribut nécessite le serveur et Le client est défini en même temps;

hive.metastore.event.listeners: une liste d'écouteurs d'événements pour le métastore, séparés par virgules et vide par défaut;

hive.metastore.partition.inherit.table.properties: la liste de clés qui est automatiquement héritée lors de la création d'une nouvelle partition, la valeur par défaut est vide;

hive.metastore.end.function.listeners: la liste des écouteurs à la fin du métastore exécution de la fonction, la valeur par défaut est vide;

hive.metastore.event.expiry.duration: l'heure d'expiration de l'événement dans la table des événements, la valeur par défaut est 0;

hive.metastore.event.clean.freq: la période d'exécution de la minuterie pour le nettoyage des événements expirés dans le métastore, la valeur par défaut est 0;

hive. metastore.connect.retries: le nombre de tentatives lors de la création d'une connexion au métastore, la valeur par défaut est 5;

hive.metastore.client.connect.retry.delay: l'heure le client attend une nouvelle tentative de connexion continue, la valeur par défaut est 1;

hive.metastore. client.socket.timeout: délai d'expiration du socket client, la valeur par défaut est de 20 secondes;

hive.metastore.rawstore.impl: la classe d'implémentation de stockage du métastore d'origine, la valeur par défaut est org.apache.hadoop.hive.metastore.ObjectStore;

hive.metastore.batch .retrieve.max: dans une acquisition par lots, le nombre maximal d'enregistrements pouvant être récupérés à partir du métastore, la valeur par défaut est 300;

ruche. metastore.ds.connection.url.hook: le nom du hook lors de la recherche de l'url de connexion JDO, la valeur par défaut est javax.jdo.option.ConnectionURL;

hive.metastore.ds.retry.attempts: le nombre de fois pour réessayer la connexion lorsqu'une erreur de connexion se produit, la valeur par défaut est 1;

hive.metastore.ds.retry.interval: l'intervalle de temps pour le métastore pour réessayer la connexion, le la valeur par défaut est de 1000 millisecondes;

hive. metastore.server.min.threads: le nombre minimum de threads de travail dans le pool de services d'épargne, la valeur par défaut est 200;

hive.metastore.server.max.threads: le nombre maximum de threads, la valeur par défaut est 100000;

hive.metastore.server.tcp.keepalive: indique si le serveur de métastore est ouvert pour de longues connexions. Les longues connexions peuvent empêcher l'accumulation de semi-connexions. La valeur par défaut est true;

hive.metastore.sasl.enabled: la politique de sécurité de l'interface d'économie de métastore. Lorsqu'elle est activée, l'interface de chiffrement SASL est utilisée. Le client doit utiliser Kerberos. Authentification par mécanisme, la valeur par défaut n'est pas d'activer false;

hive.metastore.kerberos.keytab.file: Après avoir ouvert sasl, le keytab kerberos chemin de stockage du fichier, la valeur par défaut est vide;

hive.metastore.kerberos.principal: Kerberos principal, la partie _HOST sera le remplacement dynamique, la valeur par défaut est hive-metastore/[email protected];

hive.metastore.cache.pinobjtypes: la prise en charge les types d'objet metastore dans le cache, séparés par des virgules, la valeur par défaut est Table, StorageDescriptor, SerDeInfo, Partition, Database, Type, FieldSchema, Order;

hive.metastore.authorization.storage.checks: lorsque vous effectuez des opérations similaires à supprimer une partition, si le métastore doit authentifier les autorisations, la valeur par défaut est false;

hive.metastore.schema.verification: force la cohérence du schéma du métastore, si elle est activée, elle sera vérifiée dans le métastore. La version des informations qui y sont stockées est cohérente avec la version du package jar de la ruche, et la migration automatique du schéma est désactivée. L'utilisateur doit mettre à niveau manuellement la ruche et migrer le schéma. Si elle est désactivé, il ne donnera un avertissement que lorsque la version est incohérente. La valeur par défaut est false.;

Hive.index.compact.file.ignore.hdfs: L'adresse hdfs stockée dans le fichier d'index sera ignorée lors de l'exécution, si elle est activé; si les données sont migrées, le fichier d'index est toujours disponible, la valeur par défaut est false;

hive.optimize .index.filter.compact.minsize: La taille d'entrée minimale appliquée automatiquement par l'index compressé, la valeur par défaut est 5368709120;

ruche .optimize.index.filter.compact.maxsize: Idem que ci-dessus, sens inverse, si une valeur négative représente l'infini positif, la valeur par défaut est- 1;

hive.index.compact.query.max.size: La quantité maximale de données qui peut être récupérée par une requête à l'aide d'un index compressé, la valeur par défaut est 10737418240 octets; une valeur négative représente l'infini;

hive.index.compact.query.max.entries: le nombre maximal d'éléments d'index pouvant être lus lors de l'utilisation d'un requête d'index, la valeur par défaut est 10000000; une valeur négative représente l'infini;

hive.index.compact.binary.search: s'il faut activer la recherche binaire dans la table d'index pour la requête d'élément d'index, la valeur par défaut est true ；

hive.exec.concatenate.check.index: Si défini sur true, une erreur sera générée lors de l'exécution d'ALTER TABLE tbl_name CONCATENATE sur une table / partition (avec index); cela peut aider les utilisateurs à éviter la suppression et la reconstruction d'index;

hive. stats .dbclass: la base de données qui stocke les statistiques temporaires de la ruche, la valeur par défaut est jdbc: derby;

hive.stats.autogather: collecte automatiquement les statistiques lors de la commande d'insertion de réécriture, la valeur par défaut est true;

hive.stats.jdbcdriver: la base de données stocke temporairement les statistiques de la ruche le pilote jdbc;

hive.stats.dbconnectionstring: chaîne de connexion des statistiques de base de données temporaire, la valeur par défaut jdbc: Derby: the databaseName = TempStatsStore; = Create to true;

hive.stats.defaults.publisher: jdbc or not if dbclass HBase, then use this par défaut Pour publier, il doit implémenter l'interface StatsPublisher, qui est vide par défaut;

hive.stats.defaults.aggregator: Si la dbclass n'est pas jdbc ou hbase, utilisez cette classe pour l'agrégation et nécessite l'implémentation de l'interface StatsAggregator , qui est vide par défaut;

hive.stats.jdbc.timeout: La configuration du délai d'expiration de la connexion jdbc, la valeur par défaut est de 30 secondes;

hive.stats.retries.max: le nombre maximum de tentatives lorsqu'une exception se produit lorsque les statistiques sont publiées et agrégé dans la base de données de mise à jour, la valeur par défaut est 0, aucune nouvelle tentative;

hive.stats.retries.wait: la fenêtre d'attente entre le nombre de tentatives, la valeur par défaut est de 3000 millisecondes;

hive.client.stats.publishers: la liste des classes de publication de statistiques pour les jobs de comptage, séparées par des virgules, la valeur par défaut est vide ; requis Implémenter l'interface org.apache.hadoop.hive.ql.stats.ClientStatsPublisher;

hive.client.stats.counters: inutile ~~~

hive.security.authorization.enabled: si le client de la ruche est authentifié, la valeur par défaut est false ;

hive.security .authorization.manager: classe de gestion pour l'authentification du client ruche, la valeur par défaut est org.apache.hadoop.hive.ql.security.authorization.DefaultHiveAuthorizationProvider; défini par l'utilisateur doit implémenter org.apache.hadoop.hive.ql .security.authorization. HiveAuthorizationProvider;

hive.security.authenticator.manager: Classe de gestion des autorisations client Hive, la valeur par défaut est org.apache.hadoop.hive.ql.security.HadoopDefaultAuthenticator; besoins définis par l'utilisateur pour implémenter org.apache.hadoop. hive.ql.security .HiveAuthenticatorProvider;

hive.security.authorization.createtable.user.grants: autorise automatiquement l'utilisateur lors de la création de la table, la valeur par défaut est vide;

hive.security.authorization.createtable.group.grants: comme ci-dessus, automatiquement autorisé aux groupes, la valeur par défaut est vide;

hive.security.authorization.createtable.role.grants: comme ci-dessus, automatiquement autorisé aux rôles, la valeur par défaut est vide ;

hive.security. authorisation.createtable.owner.grants: comme ci-dessus, automatiquement autorisé au propriétaire, la valeur par défaut est vide;

hive.security.metastore.authorization.manager: classe de gestion d'authentification Metastore, la valeur par défaut est org.apache. hadoop.hive.ql. security.authorization.StorageBasedAuthorizationProvider interface, utilisez les autorisations HDFS Contrôlez l'authentification au lieu de l'approche basée sur les subventions de Hive;

hive.security.metastore.authenticator.manager: Classe de gestion des autorisations Metastore, la valeur par défaut est org.apache.hadoop.hive.ql.security.HadoopDefaultMetastoreAuthenticator, les utilisateurs personnalisés doivent implémenter org.apache.hadoop.hive.ql.security.HiveAuthenticator Interface ;

hive.metastore.pre.event.listeners: une liste de classes d'écouteurs d'événements exécutées avant que le métastore n'effectue des opérations sur la base de données;

fs.har.impl: les classes d'implémentation pour accéder aux archives Hadoop, qui sont incompatibles avec les versions inférieures à hadoop 0.20, default Il s'agit de org.apache.hadoop.hive.shims.HiveHarFileSystem;

hive.archive.enabled: s'il faut autoriser les opérations d'archivage, la valeur par défaut est false;

hive.archive.har.parentdir.settable: lors de la création de fichiers HAR, il doit y avoir un répertoire parent, qui est requis Réglage manuel, il sera pris en charge dans la nouvelle version de hadoop, la valeur par défaut est false;

hive.support.concurrency: si la ruche prend en charge la concurrence, la valeur par défaut est false, si vous prenez en charge le verrouillage en lecture-écriture, vous doit démarrer

zookeeper ; hive.lock.mapred.only.operation: contrôle s'il faut verrouiller pendant la requête, la valeur par défaut est false;

hive.lock.numretries: le nombre de tentatives tentées lors de l'acquisition du verrou, la valeur par défaut est 100;

hive.lock .sleep.between.retries: le temps de sommeil entre les tentatives, la valeur par défaut est de 60 secondes;

hive.zookeeper.quorum: liste d'adresses zk, la valeur par défaut est vide;

hive.zookeeper.client.port: le port de connexion du serveur zk, la valeur par défaut est 2181;

hive.zookeeper.session.timeout: le délai d'expiration de la session client zk, la valeur par défaut est 600000;

Hive.zookeeper.namespace: le nœud parent une fois tous les nœuds zk créés, la valeur par défaut est hive_zookeeper_namespace;

hive.zookeeper.clean.extra.nodes: effacez tous les nœuds supplémentaires à la fin de la session;

hive.cluster.delegation.token.store. class: classe d'implémentation de stockage du jeton proxy. La valeur par défaut est org.apache.hadoop.hive.thrift.MemoryTokenStore, qui peut être définie sur org.apache.hadoop.hive.thrift .ZooKeeperTokenStore pour les clusters d'équilibrage de charge;

hive.cluster.delegation.token .store.zookeeper.connectString: chaîne de connexion de stockage de jetons de zk, la valeur par défaut est localhost: 2181;

hive.cluster.delegation.token.store.zookeeper.znode: le nœud et chemin du stockage des jetons, la valeur par défaut est / hive / cluster / délégation;

hive.cluster.delegation.token.store.zookeeper.acl: ACL pour le stockage des jetons, la valeur par défaut est sasl: hive/[email protected]: cdrwa, sasl: hive/[email protected]: cdrwa;

hive.use .input .primary.region: lors de la création d'une table à partir d'une table d'entrée, créez cette table dans la région principale de la table d'entrée, la valeur par défaut est true;

hive.default.region.name: le nom de la région par défaut, la valeur par défaut est la valeur par défaut;

hive.region.properties: Le système de fichiers et le suivi des travaux par défaut de la région, la valeur par défaut est vide;

hive.cli.print.header: demande s'il faut imprimer le nom et la colonne lors de la sortie, la valeur par défaut est false;
hive. cli.print.current.db: si dans l'invite de hive Contient la base de données actuelle, la valeur par défaut est false;

hive.hbase.wal.enabled: s'il faut forcer l'écriture du journal wal lors de l'écriture dans hbase, la valeur par défaut est true ;

hive.hwi.war.file: le chemin du fichier war utilisé par hive sur l'interface web, La valeur par défaut est lib / hive-hwi-xxxx (version) .war;

hive.hwi.listen.host: l'adresse de l'hôte sur lequel hwi écoute, la valeur par défaut est 0.0.0.0;

hive.hwi.listen.port: le port sur lequel hwi écoute, la valeur par défaut est 9999;

hive.test.mode: si la ruche s'exécute en mode test, la valeur par défaut c'est faux;

hive.test.mode.prefi x: lors de l'exécution en mode test, la chaîne de préfixe de la table, la valeur par défaut est test_;

hive.test.mode.samplefreq: si la ruche s'exécute en mode test et que la table n'est pas regroupée, que est la fréquence d'échantillonnage, La valeur par défaut est 32;

hive.test.mode.nosamplelist: la liste des tables qui ne seront pas échantillonnées lorsque le mode de test est en cours d'exécution, la valeur par défaut est vide;